using System;

namespace ConverterApplication
{
    abstract class Converter
    {
        protected String code = ""; // Tu zmieniłem na protected. Nie ma sensu brać jako public
        protected int value; // dodałem nowe pole, które przechowuje wartość wejściową. Jest chronione, bo nikt, prócz klas dziedziczących nie może widzieć jej wartości

        protected Converter(int value) // Tu jest ciekawostka. Jak będziesz dziedziczyć klasę, to klasa bazowa Converter wymusi na tobie wygenerowanie konstruktowa
        {
            this.value = value;
        }

        public abstract String convert(); // stąd wywaliłem argument. Wartość mamy w polu {value}
        protected abstract String reverse(String x); // Tu też dałem na protected. Nie wykorzystujesz jej na zewnatrz
    }

    class BinConverter : Converter
    {

        public BinConverter(int value) : base(value) {}

        public override String convert()
        {
            while (value > 0)
            {
                int y = value % 2;
                code += y;
                value /= 2;
            }
            return reverse(code);
        }

        protected override String reverse(String x)
        {
            code = "";
            long c = long.Parse(x);

            for (int i = 0; i < x.Length; i++)
            {
                long y = c % 10;
                code += y;
                c /= 10;
            }
            return code;
        }
    }

    class OctConverter : Methods
    {
        public OctConverter(int value) : base(value) {}

        public override String convert()
        {
            while (value > 0)
            {
                int y = value % 8;
                code += y;
                value /= 8;
            }
            return reverse(code);
        }

        protected override String reverse(String x)
        {
            code = "";
            int c = int.Parse(x);

            for (int i = 0; i < x.Length; i++)
            {
                int y = c % 10;
                code += y;
                c /= 10;
            }
            return code;
        }
    }

    class HexConverter : Converter
    {
        // Tu dałem na private. Nie potrzeba tego upubliczniać. Nigdzie tego nie wykorzystujesz
        private static String[] hex =
        { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F" };

        public HexConverter(int value) : base(value) {}

        public override String convert()
        {
            while (value > 0)
            {
                int y = value % 16;
                code += hex[y];
                value /= 16;
            }
            return reverse(code);
        }

        protected override String reverse(String x)
        {
            code = "";
            for (int i = x.Length; i > 0; i--)
            {
                char ch = x[i - 1];
                code += ch;
            }
            return code;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            int x = int.Parse(Console.ReadLine());
            Console.WriteLine("Number: "+x);

            Methods bin = new Bin();
            Methods oct = new Oct();
            Methods hex = new Hex();

            eqSign(12);
            Console.WriteLine("Bin : " + bin.convert(x));
            Console.WriteLine("Oct : " + oct.convert(x));
            Console.WriteLine("Hex : " + hex.convert(x));
            eqSign(12);

            myFooter();
        }

        static void eqSign(int x)
        {
            while (x != 0)
            {
                Console.Write("=");
                x--;
            }
            Console.WriteLine();
        }
    }
}