#include <bits/stdc++.h>
using namespace std;
ifstream fin("xormax.in");
ofstream fout("xormax.out");
int n, nr_max_biti, v[100100], xorpart[100100], sol_value, sol_left, sol_right;

struct trie {
    trie *bit[2];
    int poz;

    trie() {
        bit[0] = bit[1] = nullptr;
    }

    trie(int p) {
        poz = p;
        bit[0] = bit[1] = nullptr;
    }
};

int calc_nr_max_biti(int x) {
    int nr_biti = 0;
    while (x) {
        nr_biti++;
        x >>= 1;
    }
    return max(1, nr_biti);
}

void add(trie *nod, int x, int nr_bit, int poz) {
    if (nr_bit == 0)
        return;
    for (int i = 0; i <= 1; i++) {
        if (((x & (1 << (nr_bit - 1))) > 0) == (bool)i) {
            /// bitul de pe pozitia "nr_bit - 1" este egal cu i (0 sau 1)
            if (nod->bit[i] == nullptr) {
                nod->bit[i] = new trie(poz);
            }
            add(nod->bit[i], x, nr_bit - 1, poz);
        }
    }
}

int find_best_poz(trie *nod, int nr_bit, int want) {
    if (nr_bit == 0)
        return nod->poz;
    bool want_bit = (bool)((want & (1 << (nr_bit - 1))) > 0);
    if (nod->bit[want_bit] == nullptr)
        return find_best_poz(nod->bit[!want_bit], nr_bit - 1, want);
    return find_best_poz(nod->bit[want_bit], nr_bit - 1, want);
}

int main() {
    fin >> n;
    for (int i = 1; i <= n; i++) {
        fin >> v[i];
        xorpart[i] = xorpart[i - 1] ^ v[i];
        nr_max_biti = max(nr_max_biti, calc_nr_max_biti(v[i]));
    }

    trie *root = new trie();
    for (int i = 1; i <= n; i++)
        add(root, xorpart[i], nr_max_biti, i);

    for (int i = 1; i <= n; i++)
        if (v[i] > sol_value) {
            sol_value = v[i];
            sol_left = sol_right = i;
        }

    for (int i = 1; i <= n; i++) {
        int best_poz = find_best_poz(root, nr_max_biti, (xorpart[i] ^ ((1 << nr_max_biti) - 1)));
        if (best_poz >= i)
            continue;
        int best_value = xorpart[i] ^ xorpart[best_poz];
        if (best_value > sol_value || best_value == sol_value && best_poz + 1 < sol_left) {
            sol_value = best_value;
            sol_left = best_poz + 1;
            sol_right = i;
        }
    }
    fout << sol_value << ' ' << sol_left << ' ' << sol_right << '\n';
    return 0;
}