using System;

using System.Numerics;

public class Program{

    public static void Main(){

        BigDecimal n = -955;

        n /= 6478;

        BigFraction f1 = (BigFraction) n;

        BigComplex z = BDMath.I;

        Console.WriteLine($"{n} n");

        Console.WriteLine($"{f1} {f1.decimalForm} f1\n");

        BigFraction f2 = f1.LimitDenominator(128);

        Console.WriteLine(f2);

        Console.WriteLine(BDMath.Exp(z));

        Console.WriteLine((BigDecimal) f2);

        Console.WriteLine(z * z * z);

    }

}

public class BigDecimal{

    private BigInteger Value;

    private static int PRECISION_DISPLAY = 25;

    private static int PRECISION = PRECISION_DISPLAY + 30;

    public static BigInteger DecimalVal = 1;

    private static bool decimalValCalculated = false;

    public static BigDecimal PI;

    private BigDecimal(BigInteger num){

        setDecimalVal();

        Value = num * DecimalVal;

    }

    private BigDecimal(int num){

        setDecimalVal();

        Value = num * DecimalVal;

    }

    private BigDecimal(long num){

        setDecimalVal();

        Value = num * DecimalVal;

    }

    private BigDecimal(BigInteger num, Boolean isShifted){

        if(isShifted){

            Value = num;

        }

    }

    private BigDecimal(double num){

        BigInteger result = (int)(num);

        double remainder = num % 1;

        Value = result;

        DecimalVal = 1;

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

            remainder *= 10;

            Value *= 10;

            DecimalVal *= 10;

            Value += (int)(remainder);

            remainder %= 1;

        }

    }

    //Implicit operators

    public static implicit operator BigDecimal(BigInteger num) => new BigDecimal(num);

    public static implicit operator BigDecimal(double num) => new BigDecimal(num);

    public static implicit operator BigDecimal(long num) => new BigDecimal(num);

    public static implicit operator BigDecimal(int num) => new BigDecimal(num);

    //Explicit operators

    public static explicit operator BigInteger(BigDecimal num) => num.Value / DecimalVal;

    //Addition operators

    public static BigDecimal operator +(BigDecimal n1, BigDecimal n2) => new BigDecimal(n1.Value + n2.Value, true);

    public static BigDecimal operator +(BigDecimal n1) => new BigDecimal(n1.Value, true);

    public static BigDecimal operator ++(BigDecimal n1) => new BigDecimal(n1.Value + DecimalVal, true);

    //Subtraction operators

    public static BigDecimal operator -(BigDecimal n1, BigDecimal n2) => new BigDecimal(n1.Value - n2.Value, true);

    public static BigDecimal operator -(BigDecimal n1) => new BigDecimal(-n1.Value, true);

    public static BigDecimal operator --(BigDecimal n1) => new BigDecimal(n1.Value - DecimalVal, true);

    //Multiplication operators

    public static BigDecimal operator *(BigDecimal n1, BigDecimal n2) => new BigDecimal((n1.Value * n2.Value) / DecimalVal, true);

    //Division operators

    public static BigDecimal operator /(BigDecimal n1, BigDecimal n2) => new BigDecimal((DecimalVal * n1.Value) / n2.Value, true);

    //Modulus operators

    public static BigDecimal operator %(BigDecimal n1, BigDecimal n2) => new BigDecimal(n1.Value % n2.Value, true);

    //Comparison operators

    public static bool operator ==(BigDecimal n1, BigDecimal n2) => n1.Value == n2.Value;

    public static bool operator !=(BigDecimal n1, BigDecimal n2) => n1.Value != n2.Value;

    public static bool operator >(BigDecimal n1, BigDecimal n2) => n1.Value > n2.Value;

    public static bool operator <(BigDecimal n1, BigDecimal n2) => n1.Value < n2.Value;

    public static bool operator >=(BigDecimal n1, BigDecimal n2) => n1.Value >= n2.Value;

    public static bool operator <=(BigDecimal n1, BigDecimal n2) => n1.Value <= n2.Value;

    //Other mathematical operations

    public static BigDecimal Abs(BigDecimal num) => num < 0 ? -num : num;

    public static BigInteger Abs(BigInteger num) => num < 0 ? -num : num;

    public static BigInteger Round(BigDecimal num) => num.Value / DecimalVal;

    //Calculate values and constants

    private static void setDecimalVal(){

        if(!decimalValCalculated){

            DecimalVal = 1;

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

                DecimalVal *= 10;

            }

            decimalValCalculated = true;

        }

    }

    //String conversion

    public override string ToString(){

        BigInteger quotient = Value / DecimalVal;

        BigInteger remainder = Abs(Value % DecimalVal);

        int digits_remaining = PRECISION_DISPLAY;

        String decimalPart = "";

        while(remainder != 0 && digits_remaining > 0){

            remainder *= 10;

            BigInteger d = remainder / DecimalVal;

            decimalPart += $"{d}";

            remainder %= DecimalVal;

            digits_remaining--;

        }

        String result = $"{quotient}";

        if(Value < 0){

            result = $"-{result}";

        }

        if(!decimalPart.Equals("")){

            result += $".{decimalPart}";

        }

        return result;

    }

}

public class BigFraction{

    public readonly BigInteger num;

    public readonly BigInteger den;

    public BigFraction(BigInteger num, BigInteger den){

        this.num = num;

        this.den = den;

        if(den < 0){

            (this.num, this.den) = (-this.num, -this.den);

        }

        if(den == 0){

            throw new DivideByZeroException("Denominator can't be 0");

        }

        BigInteger commonFactor = GCD(num, den);

        if(commonFactor > 1){

            this.num /= commonFactor;

            this.den /= commonFactor;

        }

    }

    //Get fraction from int, set the denominator to 1

    public static implicit operator BigFraction(int num) => new BigFraction(num, 1);

    public static implicit operator BigFraction(BigInteger num) => new BigFraction(num, 1);

    //Explicit operators

    public static explicit operator BigInteger(BigFraction a) => a.num / a.den;

    public static explicit operator BigDecimal(BigFraction a) => ((BigDecimal) a.num) / a.den;

    public static explicit operator float(BigFraction a) => ((float) a.num) / ((float) a.den);

    public static explicit operator double(BigFraction a) => ((double) a.num) / ((double) a.den);

    public static explicit operator BigFraction(BigDecimal num){

        BigDecimal n = num;

        BigInteger aN = (BigInteger) n;

        BigInteger fractionTop = 0;

        BigInteger fractionTopN1 = 1;

        BigInteger fractionTopN2 = 1;

        BigInteger fractionBot = 1;

        BigInteger fractionBotN1 = 0;

        BigInteger fractionBotN2 = 0;

        BigInteger denominatorLimit = BDMath.Pow(2, 48);

        BigInteger convergentLimit = BDMath.Pow(2, 30);

        BigInteger intPart = (BigInteger) n;

        n %= 1;

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

            if(n == 0){

                break;

            }

            n = 1 / n;

            aN = (BigInteger) n;

            n %= 1;

            //Console.WriteLine($"{aN} {n} {fractionBot}");

            fractionTopN2 = fractionTopN1;

            fractionTopN1 = fractionTop;

            fractionTop = aN * fractionTopN1 + fractionTopN2;

            fractionBotN2 = fractionBotN1;

            fractionBotN1 = fractionBot;

            fractionBot = aN * fractionBotN1 + fractionBotN2;

            if(fractionBot > denominatorLimit || aN > convergentLimit){

                fractionTop = fractionTopN1;

                fractionBot = fractionBotN1;

                break;

            }

            //Console.WriteLine($"{aN} {fractionTop} {fractionBot} {n}");

        }

        return new BigFraction(fractionTop + intPart * fractionBot, fractionBot);

    }

    //Addition operator

    public static BigFraction operator +(BigFraction a, BigFraction b) => new BigFraction(a.num * b.den + a.den * b.num, a.den * b.den);

    public static BigFraction operator +(BigFraction a) => a;

    public static BigFraction operator ++(BigFraction a) => new BigFraction(a.num + a.den, a.den);

    //Subtraction operator

    public static BigFraction operator -(BigFraction a, BigFraction b) => new BigFraction(a.num * b.den - a.den * b.num, a.den * b.den);

    public static BigFraction operator -(BigFraction a) => new BigFraction(-a.num, -a.den);

    public static BigFraction operator --(BigFraction a) => new BigFraction(a.num - a.den, a.den);

    //Multiplication operator

    public static BigFraction operator *(BigFraction a, BigFraction b) => new BigFraction(a.num * b.num, a.den * b.den);

    //Division operator

    public static BigFraction operator /(BigFraction a, BigFraction b) => new BigFraction(a.num * b.den, a.den * b.num);

    //Comparison operators

    public static bool operator ==(BigFraction a, BigFraction b) => a.num * b.den == a.den * b.num;

    public static bool operator !=(BigFraction a, BigFraction b) => a.num * b.den != a.den * b.num;

    public static bool operator >(BigFraction a, BigFraction b) => a.num * b.den > a.den * b.num;

    public static bool operator <(BigFraction a, BigFraction b) => a.num * b.den < a.den * b.num;

    public static bool operator >=(BigFraction a, BigFraction b) => a.num * b.den >= a.den * b.num;

    public static bool operator <=(BigFraction a, BigFraction b) => a.num * b.den <= a.den * b.num;

    //Get GCD of the numerator and denominator

    public BigInteger GCD(BigInteger a, BigInteger b) => b == 0 ? a : GCD(b, a % b);

    public BigFraction reciprocal{

        get{return new BigFraction(den, num);}

    }

    public BigDecimal decimalForm{

        get{return ((BigDecimal) num) / den;}

    }

    public BigFraction LimitDenominator(BigInteger size){

        BigDecimal n = ((BigDecimal) num) / den;

        BigInteger aN = (BigInteger) n;

        BigInteger fractionTop = 0;

        BigInteger fractionTopN1 = 1;

        BigInteger fractionTopN2 = 1;

        BigInteger fractionBot = 1;

        BigInteger fractionBotN1 = 0;

        BigInteger fractionBotN2 = 0;

        BigInteger denominatorLimit = size;

        BigInteger convergentLimit = BDMath.Pow(2, 30);

        BigInteger intPart = (BigInteger) n;

        n %= 1;

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

            if(n == 0){

                break;

            }

            n = 1 / n;

            aN = (BigInteger) n;

            n %= 1;

            //Console.WriteLine($"{aN} {n} {fractionBot}");

            fractionTopN2 = fractionTopN1;

            fractionTopN1 = fractionTop;

            fractionTop = aN * fractionTopN1 + fractionTopN2;

            fractionBotN2 = fractionBotN1;

            fractionBotN1 = fractionBot;

            fractionBot = aN * fractionBotN1 + fractionBotN2;

            if(fractionBot > denominatorLimit || aN > convergentLimit){

                fractionTop = fractionTopN1;

                fractionBot = fractionBotN1;

                break;

            }

        }

        return new BigFraction(fractionTop + intPart * fractionBot, fractionBot);

    }

    //Reduce the fraction to simplest terms

    //public Fraction reduce() => new Fraction(numerator / GCD(numerator, denominator), denominator / GCD(numerator, denominator));

    //Convert the fraction to string

    public override string ToString() => den == 1 ? $"{num}" : $"{num} / {den}";

}

public class BigComplex{

    public BigDecimal Re;

    public BigDecimal Im;

    public BigComplex(BigDecimal R, BigDecimal I){

        Re = R;

        Im = I;

    }

    //Implicit operators

    public static implicit operator BigComplex(int n) => new BigComplex(n, 0);

    public static implicit operator BigComplex(double n) => new BigComplex(n, 0);

    public static implicit operator BigComplex(BigDecimal n) => new BigComplex(n, 0);

    //Explicit operators

    public static explicit operator BigComplex(BigFraction n) => new BigComplex(n.decimalForm, 0);

    //Addition operators

    public static BigComplex operator +(BigComplex z1, BigComplex z2) => new BigComplex(z1.Re + z2.Re, z1.Im + z2.Im);

    public static BigComplex operator +(BigComplex z) => z;

    public static BigComplex operator -(BigComplex z1, BigComplex z2) => new BigComplex(z1.Re - z2.Re, z1.Im - z2.Im);

    public static BigComplex operator -(BigComplex z) => new BigComplex(-z.Re, -z.Im);

    public static BigComplex operator *(BigComplex z1, BigComplex z2) => new BigComplex(z1.Re * z2.Re - z1.Im * z2.Im, z1.Im * z2.Re + z1.Re * z2.Im);

    public static BigComplex operator /(BigComplex z1, BigComplex z2) =>

        new BigComplex((z1.Re * z2.Re + z1.Im * z2.Im) / z2.SquaredNorm, (z1.Im * z2.Re - z1.Re * z2.Im) / z2.SquaredNorm);

    //Comparison operators

    public static bool operator ==(BigComplex z1, BigComplex z2) => z1.SquaredNorm == z2.SquaredNorm;

    public static bool operator !=(BigComplex z1, BigComplex z2) => z1.SquaredNorm != z2.SquaredNorm;

    public static bool operator <(BigComplex z1, BigComplex z2) => z1.SquaredNorm < z2.SquaredNorm;

    public static bool operator >(BigComplex z1, BigComplex z2) => z1.SquaredNorm > z2.SquaredNorm;

    public static bool operator <=(BigComplex z1, BigComplex z2) => z1.SquaredNorm <= z2.SquaredNorm;

    public static bool operator >=(BigComplex z1, BigComplex z2) => z1.SquaredNorm >= z2.SquaredNorm;

    //Properties

    public BigComplex Conjugate{

        get{return new BigComplex(Re, -Im);}

    }

    public BigDecimal Norm{

        get{return BDMath.Pow(Re * Re + Im * Im, 0.5);}

    }

    public BigDecimal SquaredNorm{

        get{return Re * Re + Im * Im;}

    }

    public override string ToString(){

        String ImString = Im >= 0 ? $"+ {Im}i" : $"- {-Im}i";

        if(Re == 0){

            return Im == 0 ? "0" : (Im == -1 ? "- i" : (Im == 1 ? "i" : $"{Im}i"));

        }else{

            return $"{Re} {ImString}";

        }

    }

}

public class BDMath{

    private static BigDecimal pi = 0;

    public static BigDecimal PI{

        get{

            if(pi != 0){

                return pi;

            }else{

                int n = 0;

                BigDecimal term = 1;

                BigDecimal result = 0;

                while(term != 0){

                    term = (n % 2 == 0 ? 1 : -1) * Factorial(4 * n) * (1123 + 21460 * n);

                    term /= (Pow(Pow(4, n) * Factorial(n), 4) * Pow(882, 2 * n));

                    result += term;

                    n++;

                }

                pi = 3528 / result;

                return pi;

            }

        }

    }

    private static BigDecimal eulerNumber = 0;

    public static BigDecimal E{

        get{

            if(eulerNumber != 0){

                return eulerNumber;

            }else{

                eulerNumber = Exp(1);

                return eulerNumber;

            }

        }

    }

    public static BigComplex I{

        get{

            return new BigComplex(0, 1);

        }

    }

    public static BigInteger Pow(BigInteger n1, BigInteger n2){

        BigInteger result = 1;

        if(n2 < 0){

            return 0;

        }else if(n2 == 0 || n1 == 1){

            return 1;

        }else{

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

                result *= n1;

            }

            return result;

        }

    }

    public static BigDecimal Pow(BigDecimal n1, BigInteger n2){

        BigDecimal result = 1;

        if(n2 < 0){

            return 0;

        }else if(n2 == 0 || n1 == 1){

            return 1;

        }else{

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

                result *= n1;

            }

            return result;

        }

    }

    public static BigDecimal Pow(BigDecimal n1, BigDecimal n2) => Exp(Log(n1) * n2);

    public static BigDecimal Pow(BigFraction n1, BigFraction n2) => Pow((BigDecimal) n1, (BigDecimal) n2);

    public static BigInteger Factorial(BigInteger num){

        BigInteger result = 1;

        for(int a = 1; a <= num; a++){

            result *= a;

        }

        return result;

    }

    public static BigDecimal Abs(BigDecimal num) => num < 0 ? -num : num;

    public static BigDecimal Abs(BigComplex num) => Pow(num.SquaredNorm, 0.5);

    public static BigInteger Abs(BigInteger num) => num < 0 ? -num : num;

    public static BigDecimal Exp(BigDecimal num){

        BigDecimal sum = 0;

        BigDecimal term = 1;

        int counter = 1;

        bool isNegative = num <= 0;

        if(isNegative){

            num *= -1;

        }

        while(term > 0){

            sum += term;

            term *= num / counter;

            counter++;

        }

        return isNegative ? 1 / sum : sum;

    }

    public static BigComplex Exp(BigComplex num){

        BigComplex sum = 0;

        BigComplex term = 1;

        int counter = 1;

        bool isNegative = num <= 0;

        if(isNegative){

            num *= -1;

        }

        while(term > 0){

            sum += term;

            term *= num / counter;

            counter++;

        }

        return isNegative ? 1 / sum : sum;

    }

    public static dynamic Log(BigDecimal num){

        BigDecimal result = 0;

        if(num <= 0){

            throw new ArithmeticException("Logarithms must be positive");

        }else if(num < 1){

            BigDecimal runningNum = 1;

            while(num < runningNum){

                runningNum /= E;

                result--;

            }

        }else{

            BigDecimal runningNum = 1;

            while(num > runningNum){

                runningNum *= E;

                result++;

            }

        }

        BigDecimal pastResult = 0;

        int counter = 0;

        while(Abs(pastResult - result) * BigDecimal.DecimalVal > 20){

            pastResult = result;

            result = result - 1 + num * Exp(-result);

            counter++;

            if(counter > 100){

                break;

            }

        }

        //Console.WriteLine(isNegative);

        return result;

    }

    public static BigDecimal Sin(BigDecimal num){

        BigDecimal term = -1;

        BigDecimal result = 0;

        int n = 0;

        num %= 2 * PI;

        num -= PI;

        while(term != 0){

            term = (n % 2 == 0 ? 1 : -1) * Pow(num, 2 * n + 1);

            term /= Factorial(2 * n + 1);

            result += term;

            n++;

        }

        return -result;

    }

    public static BigDecimal Cos(BigDecimal num){

        BigDecimal term = -1;

        BigDecimal result = 0;

        int n = 0;

        num %= 2 * PI;

        num -= PI;

        while(term != 0){

            term = (n % 2 == 0 ? 1 : -1) * Pow(num, 2 * n);

            term /= Factorial(2 * n);

            result += term;

            n++;

        }

        return -result;

    }

    public static BigDecimal Tan(BigDecimal num) => Sin(num) / Cos(num);

}