#define MAX_N 100000
#define DELTA 30

#define GET_BIT(x, ind) ((x & (1 << ind)) >> ind)

#include <fstream>
using namespace std;

ifstream fin("xormax.in");
ofstream fout("xormax.out");

struct binnode
{
	int index     = -1;
	binnode* N[2] = { nullptr, nullptr };
} *root = new binnode;

int n, DP[MAX_N + 1];
int I, J, MA;

void TryUpdate(int index);

void Insert(int index);

void Delete(binnode** node);

int main()
{
	fin >> n;
	for (int i = 1; i <= n; ++i)
	{
		fin >> DP[i];
		DP[i] ^= DP[i - 1];
	}
	
	I  = J = 1;
	MA = DP[1];
	Insert(1);
	
	for (int i = 2; i <= n; ++i)
	{
		TryUpdate(i);
		Insert(i);
	}
	
	fout << MA << ' ' << I << ' ' << J;
	
	Delete(&root);
	
	fin.close();
	fout.close();
	return 0;
}

pair<int, int> GetPair(int value)
{
	binnode* node = root;
	pair<int, int> res = { 0, 0 };
	
	int bitIndex = DELTA;
	
	while ((--bitIndex) > 0)
	{
		const bool bitVal = GET_BIT(value, bitIndex);
		
		if (node->N[!bitVal] != nullptr)
		{
			res.first |= (!bitVal) << bitIndex;
			node = node->N[!bitVal];
		}
		else
		{
			res.first |= bitVal << bitIndex;
			node = node->N[bitVal];
		}
	}
	
	res.second = node->index;
	
	return res;
}

void TryUpdate(int index)
{
	pair<int, int> bestPair = GetPair(DP[index]);
	
	if (MA < (bestPair.first ^ DP[index]))
	{
		MA = bestPair.first ^ DP[index];
		I  = bestPair.second + 1;
		J  = index;
	}
}

void Insert(int index)
{	
	binnode** pn = &root;
	
	int bitIndex = DELTA;
	while ((--bitIndex) >= 0)
	{
		if ((*pn) == nullptr)
		{
			(*pn) = new binnode;
		}
		
		if (bitIndex == 0)
		{
			(*pn)->index = index;
		}
		else
		{
			if (GET_BIT(DP[index], bitIndex) == true)
			{
				pn = &((*pn)->N[1]);
			}
			else
			{
				pn = &((*pn)->N[0]);
			}
		}
	}
}

void Delete(binnode** node)
{
	if ((*node) != nullptr)
	{
		Delete(&((*node)->N[0]));
		Delete(&((*node)->N[1]));
		
		delete (*node);
		(*node) = nullptr;
	}
}