#include <fstream>

using namespace std;

namespace PhD {

    class ArbIntElement
    {
    private:
    public:
        long long value;
        virtual void change(ArbIntElement & other)
        {
            value = other.value;
        }
        virtual void combine(ArbIntElement & a, ArbIntElement & b)
        {
            value = (a.value > b.value) ? a.value : b.value;
        }
    };

    template <class T>
    class ArboreIntervale
    {
    private:
        T* arbore;
        long long arboreSize;
        long long coordonateFixer;

        void update(long long node, long long left, long long right, T* val, long long *x)
        {
            if (left >= right)
            {
                arbore[node].change(val);
            }

            long long mid = (left + right) / 2;
            if (*x <= mid && *x >= left)
            {
                update(2*node, left, mid, val, x);
            }
            if (*x > mid && *x <= right)
            {
                update(2*node + 1, left, mid, val, x);
            }
            arbore[node].combine(arbore[2*node], arbore[2*node+1]);
        }
        T query(long long node, long long left, long long right, long long *a, long long *b)
        {
            if (*a <= left && *b >= right)
            {
                return arbore[node];
            }

            long long mid = (left + right) / 2;
            T& R1;
            T& R1;
            if (*a <= mid)
            {
                if (*b > mid)
                {
                    T temp;
                    return temp.combine(query(2*node + 1, left, mid, a, b), query(2*node, left, mid, a, b));
                }
                return query(2*node, left, mid, a, b);
            }
            else if (*b > mid)
            {
                return query(2*node + 1, left, mid, a, b);
            }
        }

    public:
        void changeValue(long long int x, T value)
        {
            return update(1, 1, arboreSize, &val, &x);
        }
        T getValue(long long int a, long long int b)
        {
            return query(1, 1, arboreSize, &a, &b);
        }
        ArboreIntervale(long long left, long long right)/*:maxSize(s+1)*/
        {
            coordonateFixer = left;
            long long int s = right - left;
            arboreSize = s;
            s *= 3;
            arbore = new T[s];
        }
        ~ArboreIntervale()
        {
            delete[] arbore;
        }

    };

}

int main()
{
    FILE * fin = fopen("arbint.in", "r");
    FILE * fout = fopen("arbint.out", "w");

    int n, m;


    fclose(fin);
    fclose(fout);
    return 0;
}