#define MAX_N 100000
#define DELTA 21
#define INF 0x3f3f3f3f

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

#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 = -1, J = -1, MA = -INF;

void TryUpdate(int index);

void Insert(int index);

void Delete(binnode** node);

int main()
{
	fin >> n;
	for (int i = 1, x; i <= n; ++i)
	{
		fin >> x;
		DP[i] = DP[i - 1] ^ x;
	}
	
	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(binnode* node, int value)
{
	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(root, 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)
	{
		const bool bNull = (*pn) == nullptr;
		if (bNull)
		{
			(*pn) = new binnode;
		}
		
		if ((bitIndex == 0) && bNull)
		{
			(*pn)->index = index;
		}
		
		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;
	}
}