#include <cstdio>
#include <cstdlib>
#include <cassert>
 
#define MAXN 100000
#define DIGITS 22
 
int N;
int V[MAXN];
int X[MAXN + 1];
 
void actsol(int max, int start, int stop,
            int& oldmax, int& oldstart, int& oldstop)
{
  if(max > oldmax ||
     (max == oldmax && stop < oldstop) ||
     (max == oldmax && stop == oldstop && start > oldstart))
  {
    oldmax = max;
    oldstart = start;
    oldstop = stop;
  }
}
 
void read()
{
  scanf("%d", &N);
  for(int i = 0; i < N; i++)
    scanf("%d", V + i);
}
 
struct node
{
  explicit node()
  {
    next[0] = next[1] = NULL;
    ep = -1;
  }
 
  void add(int x, int bit_pos, int end_pos)
  {
    if(bit_pos == -1)
      ep = end_pos;
    else
    {
      int bit = (((1 << bit_pos) & x) != 0);
      if(next[bit] == NULL)
        next[bit] = new node();
      next[bit]->add(x, bit_pos - 1, end_pos);
    }
  }
 
  int get_best_ep(int current_xor, int bit_pos)
  {
    if(bit_pos == -1)
      return ep;
    else
    {
      int bit = (((1 << bit_pos) & current_xor) != 0);
      if(next[1 - bit] != NULL) // this is the best choice
        return next[1 - bit]->get_best_ep(current_xor, bit_pos - 1);
      else
        return next[bit]->get_best_ep(current_xor, bit_pos - 1);
    }
  }
 
  node* next[2];
  int ep;
};
 
 
 
void solve()
{
  int a, b, c;
  node *trie = new node();
  int current_xor = 0;
  a = -1;
 
  trie->add(current_xor, DIGITS, 0);
  X[0] = current_xor;
 
  for(int i = 0; i < N; i++)
  {
    current_xor ^= V[i];
    X[i + 1] = current_xor;
    int best_pos = trie->get_best_ep(current_xor, DIGITS);
    actsol(current_xor ^ X[best_pos], best_pos + 1, i + 1, a, b, c);
    trie->add(current_xor, DIGITS, i + 1);
  }
 
  printf("%d %d %d\n", a, b, c);
}
 
int main()
{
  freopen("xormax.in", "r", stdin);
  freopen("xormax.out", "w", stdout);
  read();
  solve();
  return 0;
}