using System;

public class Program{

    public static void Main(){

        InvertedInt[] a1 = {2022, 3033, 1533, 43};

        Fraction frac = 0;

        for(int a = 0; a < a1.Length; a++){

            frac += a1[a];

            Console.WriteLine(a1[a]);

        }

        Console.WriteLine(frac.reciprocal());

        Console.WriteLine((int)(a1.Length * frac.reciprocal()));

        /*for(int a = 1; a < 1000; a++){

            Console.WriteLine($"{a / 1000.0}: {(Fraction)(a / 1000.0)}");

        }*/

    }

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

}

public class Fraction{

    public readonly int num;

    public readonly int den;

    public Fraction(int num, int 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");

        }

        int 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 Fraction(InvertedInt num) => new Fraction(1, num.num);

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

    public static implicit operator Fraction(double num){

        double error = 0.00012;

        int n = (int)(Math.Floor(num));

        num -= n;

        if(num < error){

            return new Fraction(n, 1);

        }else if(1 - error < num){

            return new Fraction(n + 1, 1);

        }

        int lower_n = 0;

        int lower_d = 1;

        //The upper fraction is 1/1

        int upper_n = 1;

        int upper_d = 1;

        while(true){

            //The middle fraction is (lower_n + upper_n) / (lower_d + upper_d)

            int middle_n = lower_n + upper_n;

            int middle_d = lower_d + upper_d;

            //If x + error < middle

            if(middle_d * (num + error) < middle_n){

                //middle is our new upper

                upper_n = middle_n;

                upper_d = middle_d;

            //Else If middle < x - error

            }else if(middle_n < (num - error) * middle_d){

                //# middle is our new lower

                lower_n = middle_n;

                lower_d = middle_d;

            //Else middle is our best fraction

            }else{

                return new Fraction(n * middle_d + middle_n, middle_d);

            }

        }

    }

    //Explicit operators

    public static explicit operator int(Fraction a) => a.num / a.den;

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

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

    //Addition operator

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

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

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

    //Subtraction operator

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

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

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

    //Multiplication operator

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

    //Division operator

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

    //Get GCD of the numerator and denominator

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

    public Fraction reciprocal() => new Fraction(den, num);

    //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 InvertedInt{

    public readonly int num;

    private InvertedInt(int num){

        this.num = num;

    }

    //Implicit operators

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

    //Explicit operators

    public static explicit operator int(InvertedInt a) => 1 / a.num;

    public static explicit operator float(InvertedInt a) => 1f / a.num;

    public static explicit operator double(InvertedInt a) => 1.0 / a.num;

    //Addition operator

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

    public static Fraction operator +(InvertedInt a, int valueNum) => new Fraction(valueNum * a.num + 1, a.num);

    public static Fraction operator +(int valueNum, InvertedInt a) => new Fraction(valueNum * a.num + 1, a.num);

    public static Fraction operator +(InvertedInt a) => a;

    //Subtraction operator

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

    public static Fraction operator -(InvertedInt a, int valueNum) => new Fraction(-valueNum * a.num + 1, a.num);

    public static Fraction operator -(int valueNum, InvertedInt a) => new Fraction(valueNum * a.num - 1, a.num);

    public static Fraction operator -(InvertedInt a) => -a.num;

    //Multiplication operator

    public static InvertedInt operator *(InvertedInt a, InvertedInt b) => a.num * b.num;

    public static Fraction operator *(InvertedInt a, int valueNum) => new Fraction(valueNum, a.num);

    public static Fraction operator *(int valueNum, InvertedInt a) => new Fraction(valueNum, a.num);

    //Division operator

    public static Fraction operator /(InvertedInt a, InvertedInt b) => new Fraction(b.num, a.num);

    public static Fraction operator /(InvertedInt a, int valueNum) => new Fraction(1, a.num * valueNum);

    public static Fraction operator /(int valueNum, InvertedInt a) => a.num * valueNum;

    //Other operations

    public int reciprocal() => num;

    //String

    public override string ToString() => Math.Abs(num) == 1 ? $"{num}" : num > 0 ? $"1 / {num}" : $"-1 / {-num}";

}