// Xor Max.cpp : Defines the entry point for the console application.
//

//#include "stdafx.h"
#include <iostream>
#include <iterator>
#include <fstream>
#include <sstream>
#include <list>
#include <vector>
#include <string>
using namespace std;

class MaxNumber
{
public:
    MaxNumber(int max, int start, int stop, int elements)
        : m_Max(max)
        , m_Start(start++) // The position is taken from an array, so position 0 would be the 1st position in the file
        , m_Stop(stop++)
        , m_Elements(elements) {};
    int GetMax() { return m_Max; };
    int GetStart() { return m_Start; };
    int GetStop() { return m_Stop; };
    int GetNumberOfElements() { return m_Elements; };

private:
    int m_Max;
    int m_Start;
    int m_Stop;
    int m_Elements;
};

class Element
{
public:
    Element(int elem, int pos)
        : m_Element(elem)
        , m_Position(pos) {};
    const int GetElement() { return m_Element; };
    int& GetPosition() { return m_Position; };

private:
    int m_Element;
    int m_Position;
};

int _inNoOfElements;
vector<int> _inElements;
list<MaxNumber> _maxElements;
list<Element> _currentCombination;
list<list<Element>> _allCombinations;

void readFile()
{
    ifstream inputFile ("xormax.in");

    if (inputFile.is_open())
    {
        string sLine;

        while(getline(inputFile, sLine))
        {
            stringstream ss(sLine);
            istream_iterator<string> begin(ss);
            istream_iterator<string> end;
            vector<std::string> vLine(begin, end);

            for(vector<string>::iterator it = vLine.begin(); it != vLine.end(); ++it)
            {
                if (vLine.size() == 1)
                {
                    _inNoOfElements = atoi((*it).c_str());
                } 
                else if (_inElements.size() != _inNoOfElements)
                {
                    _inElements.push_back(atoi((*it).c_str()));
                }
            }
        }

        inputFile.close();
    }
    else
    {
        //cout << "Unable to open read file." << endl;
    }

}

void writeFile(MaxNumber number)
{
    ofstream writeFile ("xormax.out");

    if (writeFile.is_open())
    {
        writeFile << number.GetMax() << " " << number.GetStart() << " " << number.GetStop();
        writeFile.close();
    } 
    else
    {
        //cout << "Unable to open write file." << endl;
    }
}

void makeCombinations(int offset, int groupOfXNumbers)
{
    if (groupOfXNumbers == 0)
    {
        _allCombinations.push_back(_currentCombination);
        return;
    }

    for (size_t count = offset; count <= _inElements.size() - groupOfXNumbers; ++count)
    {
        _currentCombination.push_back(Element(_inElements[count], count));
        makeCombinations(count + 1, groupOfXNumbers - 1);
        _currentCombination.pop_back();
    }
}

void makeXor()
{
    for (list<list<Element>>::iterator listIt = _allCombinations.begin(); listIt != _allCombinations.end(); ++listIt) 
    {
        int xorResult = 0;
        int elementsCount = 0;

        for (list<Element>::iterator intIt = (*listIt).begin(); intIt != (*listIt).end(); ++intIt) 
        {
            xorResult = xorResult ^ (*intIt).GetElement();
            elementsCount++;
        }

        int start = (*(*listIt).begin()).GetPosition();
        int stop = (*--(*listIt).end()).GetPosition(); // Nigga you ugly as fuck :))

        _maxElements.push_back(MaxNumber(xorResult, start, stop, elementsCount));
    }
}

MaxNumber ChooseMaxNumber()
{
    MaxNumber maxNumber = MaxNumber(0, 0, 0, 0);

    for (list<MaxNumber>::iterator maxIt = _maxElements.begin(); maxIt != _maxElements.end(); ++maxIt)
    {
        if (maxIt == _maxElements.begin())
        {
            maxNumber = *maxIt;
        }
        else if (maxNumber.GetMax() < (*maxIt).GetMax())
        {
            maxNumber = *maxIt;
        }
        else if (maxNumber.GetMax() == (*maxIt).GetMax())
        {
            if (maxNumber.GetStop() > (*maxIt).GetStop())
            {
                maxNumber = *maxIt;
            }
            else if (maxNumber.GetStop() == (*maxIt).GetStop() && maxNumber.GetNumberOfElements() > (*maxIt).GetNumberOfElements())
            {
                maxNumber = *maxIt;
            }
        }
    }

    return maxNumber;
}

int main()
{
    readFile();

    if (_inElements.size() == 0)
    {
        //cout << "There are no elements." << endl;
        //system("pause");
        return 0;
    }
    else if (_inElements.size() == 1)
    {
        //cout << "There are not enough elements." << endl;
        //system("pause");
        return 0;
    }

    for (int i = 1; i <= _inNoOfElements; ++i)
    {
        makeCombinations(0, i);
    }

    makeXor();
    writeFile(ChooseMaxNumber());

    //system("pause");
    return 0;
}