using System;

public class Program{

    public static void Main(){

        long Hash((int A, int B) p, long worldSeed) {

            long result = ((long)p.A << 32) + (int)p.B;

            result += 15641334881;

            result *= 32898405851;

            result -= (worldSeed * 3910451521 + result) * 108907987;

            result ^= 0b101010101010101010101010101010101010101010101010101010101010101;

            return result;

        }

        Console.WriteLine(Hash((0, 0), 0));

        Polynomial p1 = new float[]{6, 8, 2};

        //Polynomial p2 = new float[]{5.196083f, -8.953368f, -1.228010f, 8.845261f};

        Console.WriteLine(p1);

        //Console.WriteLine(p1 * 3f);

        Console.WriteLine(p1.ValueAt(11f));

        Console.WriteLine(p1.Derivative.Derivative.Derivative);

    }

}

public class Polynomial{

    private float[] terms;

    public readonly int degree;

    public Polynomial(int degree){

        terms = new float[degree + 1];

        this.degree = degree;

        for(int a = 0; a <= degree; a++){

            terms[a] = 0;

        }

    }

    private Polynomial(float[] coefficients){

        degree = coefficients.Length - 1;

        terms = coefficients;

    }

    private Polynomial((float coefficient, int exponent) term){

        if(term.exponent < 0){

            throw new ArgumentOutOfRangeException("Negative exponents are not supported.");

        }

        degree = term.exponent;

        terms = new float[degree + 1];

        terms[0] = term.coefficient;

    }

    public static implicit operator Polynomial(float constant) => new Polynomial(new float[]{constant});

    public static implicit operator Polynomial(float[] coefficients) => new Polynomial(coefficients);

    public static implicit operator Polynomial((float coefficient, int exponent) term) => new Polynomial(term);

    public float this[int inputDegree]{

        get{

            if(inputDegree > degree || inputDegree < 0){

                throw new IndexOutOfRangeException("The input degree is outside of the degree of this polynomial.");

            }

            return terms[degree - inputDegree];

        }

        set{

            if(inputDegree > degree || inputDegree < 0){

                throw new IndexOutOfRangeException("The input degree is outside of the degree of this polynomial.");

            }

            terms[degree - inputDegree] = value;

        }

    }

    public static Polynomial operator +(Polynomial left, Polynomial right){

        if(left.degree < right.degree){

            (left, right) = (right, left);

        }

        if(left.degree == right.degree){

            Polynomial result = new Polynomial(left.degree);

            for(int a = 0; a <= left.degree; a++){

                result.terms[a] = left.terms[a] + right.terms[a];

            }

            return result;

        }else{

            Polynomial result = left;

            for(int a = 0; a <= right.degree; a++){

                result.terms[left.degree - right.degree + a] += right.terms[a];

            }

            return result;

        }

    }

    public static Polynomial operator -(Polynomial left, Polynomial right){

        if(left.degree < right.degree){

            (left, right) = (right, left);

        }

        if(left.degree == right.degree){

            Polynomial result = new Polynomial(left.degree);

            for(int a = 0; a <= left.degree; a++){

                result.terms[a] = left.terms[a] - right.terms[a];

            }

            return result;

        }else{

            Polynomial result = left;

            for(int a = 0; a <= right.degree; a++){

                result.terms[left.degree - right.degree + a] -= right.terms[a];

            }

            return result;

        }

    }

    public static Polynomial operator *(Polynomial left, Polynomial right){

        Polynomial result = new Polynomial(left.degree + right.degree);

        for(int a = right.degree; a >= 0; a--){

            for(int b = left.degree; b >= 0; b--){

                result.terms[a + b] += left.terms[b] * right.terms[a];

            }

        }

        return result;

    }

    public static bool operator ==(Polynomial left, Polynomial right){

        if(left.degree == right.degree){

            for(int a = 0; a <= left.degree; a++){

                if(left.terms[a] != right.terms[a]){

                    return false;

                }

            }

            return true;

        }else{

            return false;

        }

    }

    public static bool operator !=(Polynomial left, Polynomial right){

        if(left.degree == right.degree){

            for(int a = 0; a <= left.degree; a++){

                if(left.terms[a] != right.terms[a]){

                    return true;

                }

            }

            return false;

        }else{

            return true;

        }

    }

    public Polynomial Derivative{

        get{

            if(degree == 0){

                return 0;

            }else{

                Polynomial result = new Polynomial(degree - 1);

                for(int a = 0; a < degree; a++){

                    result.terms[a] = (degree - a) * terms[a];

                }

                return result;

            }

        }

    }

    public override bool Equals(object obj) => obj is Polynomial q && new Polynomial(terms) == q;

    public override int GetHashCode(){

        int altBin = 0b1010101010101010101010101010101;

        int result = 0;

        for(int a = 0; a < degree; a++){

            result ^= altBin;

            result += 12240953;

            result += (int)(121913909 * terms[a]) ^ ((int)(48960553 * terms[a + 1]));

            result *= 112396733;

        }

        return result;

    }

    public float ValueAt(float x){

        if(x == 0){

            return terms[degree];

        }else{

            float valueNum = MathF.Pow(x, degree);

            float result = 0;

            for(int a = 0; a < degree; a++){

                float item = terms[a];

                result += item * valueNum;

                valueNum /= x;

            }

            result += terms[degree];

            return result;

        }

    }

    public static Polynomial Interpolate((float x, float y)[] values){

        int degreeOfResult = values.Length;

        degreeOfResult--;

        Polynomial result = new Polynomial(degreeOfResult);

        for(int a = 0; a <= degreeOfResult; a++){

            Polynomial product = new Polynomial(0);

            product.terms[0] = values[a].y;

            for(int b = 0; b <= degreeOfResult; b++){

                if(a == b){

                    continue;

                }else{

                    float denominator = values[a].x - values[b].x;

                    product *= (Polynomial)new float[]{1 / denominator, (-values[b].x) / denominator};

                }

            }

            result += product;

        }

        return result;

    }

    public override string ToString(){

        string result = "";

        for(int a = 0; a <= degree; a++){

            float item = terms[a];

            bool termNegative = item < 0;

            float coefficient = termNegative ? -item : item;

            string coefficientStr = coefficient == 1 ? "" : $"{coefficient}";

            //string sign = a == 0 ? "" : (termNegative ? " - " : " + ");

            string sign = termNegative ? (a == 0 ? "-" : " - ") : (a == 0 ? "" : " + ");

            if(a == degree && coefficient > 0){

                result += $"{sign}{coefficientStr}";

            }else if(coefficient > 0 || a == 0){

                //string sign = a == 0 ? "" : (termNegative ? " - " : " + ");

                string exponent = a == degree - 1 ? "" : $"^{degree - a}";

                result += $"{sign}{coefficientStr}x{exponent}";

            }

        }

        return result;

    }

}