using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Globalization;

class Program
{
    public class Point
    {
        public double X, Y;

        public double Dist(Point p)
        {
            double dx = this.X - p.X;
            double dy = this.Y - p.Y;

            return Math.Sqrt(dx * dx + dy * dy);
        }
    }

    private static Point ReadPoint()
    {
        var tmp = Console.ReadLine().Split(' ');
        return new Point()
        {
            X = DoubleFromString(tmp[0]),
            Y = DoubleFromString(tmp[1])
        };
    }

    private static void FindR()
    {
        double ab = a.Dist(b);
        double ac = a.Dist(c);
        double bc = c.Dist(b);
        q.Add(ab);
        q.Add(ac);
        q.Add(bc);

        double p = (ab + ac + bc) / 2;

        R = ab * ac * bc / (4 * Math.Sqrt(p * (p - ab) * (p - ac) * (p - bc)));
    }

    private static double Solve2()
    {

    }

    private static Point a,b,c;
    private static double R;
    private static List<double> q = new List<double>();
    static void Main(string[] args)
    {/*
-46.482632 -31.161247
19.689679 -70.646972
-17.902656 -58.455808
*/
        a = new Point() { X = -46.482632, Y = -31.161247 };
        b = new Point() { X = 19.689679, Y = -70.646972 };
        c = new Point() { X = -17.902656, Y = -58.455808 };

        a = ReadPoint();
        b = ReadPoint();
        c = ReadPoint();
        FindR();
        q.Sort();

        for (int i = 3; i <= 100; i++)
        {
            List<double> d = new List<double>();
            for (int j = 1; j <= i / 2; j++)
            {
                double alpha = (Math.PI * 2 * j) / i;
                double dd = 2 * Math.Sin(alpha / 2) * R;
                d.Add(dd);
            }

            int p = 0;
            for (int j = 0; j < d.Count; j++)
            {
                double delta = Math.Abs(d[j] - q[p]);
                if (delta < 1e-4)
                {
                    p++;
                    if (p == 3)
                    {
                        double alpha = (2* Math.PI) / i;
                        double dd = 2 * Math.Sin(alpha / 2) * R;
                        double h = Math.Cos(alpha / 2) * R;
                        double s = (h * dd / 2) * i;
                        Console.WriteLine(DoubleToString(s));
                        return;
                    }
                    j--;
                }
            }

        }

        Console.WriteLine("WA");
    }

    private const int Mod = 1000000000 + 7;

    #region Data Read
    private static char ReadSign()
    {
        while (true)
        {
            int ans = consoleReader.Read();
            if (ans == '+' || ans == '-' || ans == '?')
                return (char)ans;
        }
    }

    private static long GCD(long a, long b)
    {
        if (a % b == 0) return b;
        return GCD(b, a % b);
    }

    private static List<int>[] ReadGraph(int n, int m)
    {
        List<int>[] g = new List<int>[n];
        for (int i = 0; i < n; i++) g[i] = new List<int>();
        for (int i = 0; i < m; i++)
        {
            int a = RI();
            int b = RI();

            g[a].Add(b);
            g[b].Add(a);
        }

        return g;
    }

    private static int[,] ReadGraphAsMatrix(int n, int m)
    {
        int[,] matrix = new int[n + 1, n + 1];
        for (int i = 0; i < m; i++)
        {
            int a = RI();
            int b = RI();
            matrix[a, b] = matrix[b, a] = 1;
        }

        return matrix;
    }

    private static void Sort(ref int a, ref int b)
    {
        if (a > b) Swap(ref a, ref b);
    }

    private static void Swap(ref int a, ref int b)
    {
        int tmp = a;
        a = b;
        b = tmp;
    }

    private const int BufferSize = 1 << 16;
    private static StreamReader consoleReader;
    private static MemoryStream testData;

    private static int RI()
    {
        int ans = 0;
        int mul = 1;
        do
        {
            ans = consoleReader.Read();
            if (ans == -1)
                return 0;
            if (ans == '-') mul = -1;
        } while (ans < '0' || ans > '9');

        ans -= '0';
        while (true)
        {
            int chr = consoleReader.Read();
            if (chr < '0' || chr > '9')
                return ans * mul;
            ans = ans * 10 + chr - '0';
        }
    }

    private static ulong RUL()
    {
        ulong ans = 0;
        int chr;
        do
        {
            chr = consoleReader.Read();
            if (chr == -1)
                return 0;
        } while (chr < '0' || chr > '9');

        ans = (uint)(chr - '0');
        while (true)
        {
            chr = consoleReader.Read();
            if (chr < '0' || chr > '9')
                return ans;
            ans = ans * 10 + (uint)(chr - '0');
        }
    }

    private static long RL()
    {
        long ans = 0;
        int mul = 1;
        do
        {
            ans = consoleReader.Read();
            if (ans == -1)
                return 0;
            if (ans == '-') mul = -1;
        } while (ans < '0' || ans > '9');

        ans -= '0';
        while (true)
        {
            int chr = consoleReader.Read();
            if (chr < '0' || chr > '9')
                return ans * mul;
            ans = ans * 10 + chr - '0';
        }
    }

    private static int[] RIA(int n)
    {
        int[] ans = new int[n];
        for (int i = 0; i < n; i++)
            ans[i] = RI();
        return ans;
    }

    private static long[] RLA(int n)
    {
        long[] ans = new long[n];
        for (int i = 0; i < n; i++)
            ans[i] = RL();
        return ans;
    }

    private static char[] ReadString()
    {
        int ans;

        do
        {
            ans = consoleReader.Read();
        } while (!((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z')));

        List<char> s = new List<char>();
        do
        {
            s.Add((char)ans);
            ans = consoleReader.Read();
        } while ((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z'));

        return s.ToArray();
    }

    private static char[] ReadString(int n)
    {
        int ans;

        do
        {
            ans = consoleReader.Read();
        } while (!((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z')));

        char[] s = new char[n];
        int pos = 0;
        do
        {
            s[pos++] = (char)ans;
            if (pos == n) break;
            ans = consoleReader.Read();
        } while ((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z'));

        return s;
    }

    private static char[] ReadStringLine()
    {
        int ans;

        do
        {
            ans = consoleReader.Read();
        } while (ans == 10 || ans == 13);

        List<char> s = new List<char>();

        do
        {
            s.Add((char)ans);
            ans = consoleReader.Read();
        } while (ans != 10 && ans != 13);

        return s.ToArray();
    }

    private static char ReadLetter()
    {
        while (true)
        {
            int ans = consoleReader.Read();
            if ((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z'))
                return (char)ans;
        }
    }
    private static char ReadNonLetter()
    {
        while (true)
        {
            int ans = consoleReader.Read();
            if (!((ans >= 'a' && ans <= 'z') || (ans >= 'A' && ans <= 'Z')))
                return (char)ans;
        }
    }

    private static char ReadDigit()
    {
        while (true)
        {
            int ans = consoleReader.Read();
            if (ans >= '0' && ans <= '9')
                return (char)ans;
        }
    }

    private static int ReadDigitInt()
    {
        return ReadDigit() - (int)'0';
    }

    private static char ReadAnyChar()
    {
        return (char)consoleReader.Read();
    }

    private static string DoubleToString(double x)
    {
        return x.ToString(CultureInfo.InvariantCulture);
    }

    private static double DoubleFromString(string x)
    {
        return double.Parse(x, CultureInfo.InvariantCulture);
    }

    static Program()
    {
        //Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
        consoleReader = new StreamReader(Console.OpenStandardInput(BufferSize), Encoding.ASCII, false, BufferSize);
    }

    private static void PushTestData(string data)
    {
#if TOLYAN_TEST
        if (testData == null)
        {
            testData = new MemoryStream();
            consoleReader = new StreamReader(testData);
        }

        var pos = testData.Position;
        var bytes = Encoding.UTF8.GetBytes(data);
        testData.Write(bytes, 0, bytes.Length);
        testData.Flush();
        testData.Position = pos;
#endif
    }
    #endregion
}


using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace contestsharp
{
    public struct Dot
    {
        public double x;
        public double y;
    }

    class Program
    {
        static public double Det(Dot[] vector)
        {
            return (vector[0].x * vector[1].y - vector[1].x * vector[0].y);
        }
        static public double FindAngle(Dot dot1, Dot dot2, Dot centre)
        {
            Dot[] vector = new Dot[2];
            vector[0].x = dot1.x - centre.x;
            vector[0].y = dot1.y - centre.y;
            vector[1].x = dot2.x - centre.x;
            vector[1].y = dot2.y - centre.y;
            double Cos = Math.Round((vector[0].x * vector[1].x + vector[0].y * vector[1].y) / (Math.Sqrt(vector[0].x * vector[0].x + vector[0].y * vector[0].y) * Math.Sqrt(vector[1].x * vector[1].x + vector[1].y * vector[1].y)),6);
            if (Det(vector) < 0)
                return Math.Acos(Cos);
            else
                return (2 * Math.PI - Math.Acos(Cos));
        }

        static double nod(double a, double b)
        {
            if (b % a < 0.0001)
                return a;
            if (Math.Abs(a - b) > 0.0001) return nod(b % a, a);
            else return b;
        }

        static void Main(string[] args)
        {
            double mina=0;
            Dot[] a = new Dot[3];
            string[][] input = new string[3][];
            for (int i = 0; i < 3; i++)
            {
                input[i] = new string[2];
                input[i] = Console.ReadLine().Split(' ');
                try
                {
                    input[i][0] = input[i][0].Substring(0, input[i][0].IndexOf('.')) + ',' + input[i][0].Substring(input[i][0].IndexOf('.') + 1);
                    input[i][1] = input[i][1].Substring(0, input[i][1].IndexOf('.')) + ',' + input[i][1].Substring(input[i][1].IndexOf('.') + 1);
                }
                catch { }
                a[i].x = double.Parse(input[i][0]);
                a[i].y = double.Parse(input[i][1]);
            }
            Dot centre = new Dot();
            centre.x = -(a[0].y * ((a[1].x * a[1].x) + (a[1].y * a[1].y) - (a[2].x * a[2].x) - (a[2].y * a[2].y)) + a[1].y * ((a[2].x * a[2].x) + (a[2].y * a[2].y) - (a[0].x * a[0].x) - (a[0].y * a[0].y)) + a[2].y * ((a[0].x * a[0].x) + (a[0].y * a[0].y) - (a[1].x * a[1].x) - (a[1].y * a[1].y))) / (2 * (a[0].x * (a[1].y - a[2].y) + a[1].x * (a[2].y - a[0].y) + a[2].x * (a[0].y - a[1].y)));
            centre.y = (a[0].x * ((a[1].x * a[1].x) + (a[1].y * a[1].y) - (a[2].x * a[2].x) - (a[2].y * a[2].y)) + a[1].x * ((a[2].x * a[2].x) + (a[2].y * a[2].y) - (a[0].x * a[0].x) - (a[0].y * a[0].y)) + a[2].x * ((a[0].x * a[0].x) + (a[0].y * a[0].y) - (a[1].x * a[1].x) - (a[1].y * a[1].y))) / (2 * (a[0].x * (a[1].y - a[2].y) + a[1].x * (a[2].y - a[0].y) + a[2].x * (a[0].y - a[1].y)));
            double[] An = new double[3];
            An[0] = FindAngle(a[0], a[1], centre);
            An[1] = FindAngle(a[1], a[2], centre);
            An[2] = FindAngle(a[2], a[0], centre);
            if((An[0]+ An[1]+ An[2])>(2*Math.PI+0.00001))
            {
                An[0] = 2*Math.PI - An[0];
                An[1] = 2*Math.PI - An[1];
                An[2] = 2*Math.PI - An[2];
            }
            mina = nod(nod(An[0], An[1]), An[2]);
            double S = (Math.PI / mina) * ((a[0].x - centre.x)* (a[0].x - centre.x) + (a[0].y-centre.y)* (a[0].y - centre.y)) *Math.Sin(mina);
            string answer = S.ToString();
            try
            {
                answer = answer.Substring(0, answer.IndexOf(',')) + '.' + answer.Substring(answer.IndexOf(',') + 1);
            }
            catch { answer+=".000000"}
            Console.WriteLine(answer);
            Console.Read();
        }
    }
}


using System;
using System.IO;

namespace code
{
    class Program
    {
        static float x1, y1, x2, y2, x3, y3;

        static float xc, yc;
        static double r, d;

        static double d12, d13, d23;

        static double angle;

        static int n;

        static double S;

        static void Main(string[] args)
        {

            GetXY(out x1, out y1);
            GetXY(out x2, out y2);
            GetXY(out x3, out y3);
return;
            GetCenter();

            r = GetDistance(x1, y1, xc, yc);

            d12 = GetDistance((double)x1, (double)y1, (double)x2, (double)y2);
            d13 = GetDistance((double)x1, (double)y1, (double)x3, (double)y3);
            d23 = GetDistance((double)x2, (double)y2, (double)x3, (double)y3);

            if (d12 < d13)
            {
                if (d12 < d23)
                {
                    d = d12;
                }
                else
                {
                    x1 = x3;
                    y1 = y3;
                    d = d23;
                }
            }
            else
            {
                if (d13 < d23)
                {
                    x2 = x3;
                    y2 = y3;
                    d = d13;
                }
                else
                {
                    x1 = x3;
                    y1 = y3;
                    d = d23;
                }
            }

            // ищем угол между 1-с-2
            angle = GetAngle(x1, y1, xc, yc, x2, y2);

            // количество сторон
            n = (int)(2 * Math.PI / angle);

            //
            S = GetSquart(n, r);

            Console.WriteLine("{0:0.00000000}", S);

        }

        // http://hardfire.ru/angle
        // Угол между тремя точками - через произведение векторов
            // a * b = |a| * |b| * cos (alpha) = xa * xb + ya * yb
        static double GetAngle(double ax, double ay, double bx, double by, double cx, double cy)
        {
            double x1 = ax - bx, x2 = cx - bx;
            double y1 = ay - by, y2 = cy - by;
            double d1 = Math.Sqrt(x1 * x1 + y1 * y1);
            double d2 = Math.Sqrt(x2 * x2 + y2 * y2);
            return Math.Acos((x1 * x2 + y1 * y2) / (d1 * d2));
        }

        static private void GetXY(out float x, out float y)
        {
            string s = Console.ReadLine();
            Console.WriteLine(s);

            var ss = s.Split(' ');
            Console.WriteLine(ss[0]);
            Console.WriteLine(ss[1]);

            try
{
            x = float.Parse(ss[0]);
            y = float.Parse(ss[1]);
}
catch(Exception e)
{
  Console.WriteLine(e.Message);
}
            Console.WriteLine(x);
            Console.WriteLine(y);

        }

        static private void GetCenter()
        {
            // Центр окружности по 3-м точкам на дуге.
            // http://www.delphimaster.net/view/9-1172844946/all
            float A = x2 - x1;
            float B = y2 - y1;
            float C = x3 - x1;
            float D = y3 - y1;
            float E = A * (x1 + x2) + B * (y1 + y2);
            float F = C * (x1 + x3) + D * (y1 + y3);
            float G = 2 * (A * (y3 - y2) - B * (x3 - x2));

            xc = (D * E - B * F) / G;
            yc = (A * F - C * E) / G;
        }

        static double GetDistance(double x1, double y1, double x2, double y2)
        {
            return Math.Sqrt(Math.Abs(x1 - x2) * Math.Abs(x1 - x2) + Math.Abs(y1 - y2) * Math.Abs(y1 - y2));
        }

        static double GetSquart(int n, double r)
        {
            // https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D1%8C%D0%BD%D1%8B%D0%B9_%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%D1%83%D0%B3%D0%BE%D0%BB%D1%8C%D0%BD%D0%B8%D0%BA
            // Правильный многоугольник
            // S = \frac{n}{2}R^2 \sin \frac{2 \pi}{n}.
            return r * r * n / 2 * Math.Sin(2 * Math.PI / n);
        }

    }
}


using System;

namespace Olymp
{
    class Program
    {
        static void Main(string[] args)
        {
            var str = Console.ReadLine();
            var count = Int32.Parse(str);
            for (int i = 0; i < count; i++) {
                var cellStr = Console.ReadLine();
                var cell = new Table(cellStr);
                if (cell.SelfType == CellType.Exel)
                {
                    Console.WriteLine(cell.SetRCValue());
                }
                else
                {
                    Console.WriteLine(cell.SetExelValue());
                }
            }
        }
    }
}


using System;
using System.Globalization;

namespace Olymp
{
    public class Point2D
    {
        private double _x;
        private double _y;

        public double X { get => _x; private set => _x = value; }
        public double Y { get => _y; private set => _y = value; }

        public Point2D(double x, double y)
        {
            X = x;
            Y = y;
        }
    }
    public class Vector2D : Point2D
    {
        public double Length
        {
            get => Math.Sqrt(X * X + Y * Y);
        }
        public Vector2D(double x, double y) : base(x, y) { }
    }
    public class Direct2D
    {
        private Point2D _point;
        private Vector2D _vector;

        public Point2D Point { get => _point; private set => _point = value; }
        public Vector2D Vector { get => _vector; private set => _vector = value; }

        public double X { get => _point.X; }
        public double Y { get => _point.Y; }
        public double VX { get => _vector.X; }
        public double VY { get => _vector.Y; }

        public double Length { get => Vector.Length; }

        public Direct2D GetPerpendicularLine(Point2D p)
        {
            double x = VY;
            double y = VX;
            if (x != 0)
                x *= -1;
            else
                y *= -1;

            return new Direct2D(p, new Point2D(p.X + x, p.Y + y));

        }

        public Direct2D GetPerpendicularLine(double x, double y)
        {
            return GetPerpendicularLine(new Point2D(x, y));
        }

        public Point2D GetPoint(double t)
        {
            return new Point2D(X + VX * t, Y + VY * t);
        }

        public Point2D Intersection(Direct2D d)
        {
            double t1 = 0;
            if (d.VX == 0)
            {
                if (d.VY == 0)
                {
                    return null;
                }
                else
                {
                    var n = VY / d.VY;
                    var m = (Y - d.Y) / d.Y;
                    var l = d.VX * n - VX;
                    if (l == 0)
                    {
                        return null;
                    }
                    var b = X - d.X - m * d.VX;
                    t1 = b / l;

                }
            }
            else
            {
                var n = VX / d.VX;
                var m = (X - d.X) / d.VX;
                var l = d.VY * n - VY;
                if (l == 0)
                {
                    return null;
                }
                var b = Y - d.Y - m * d.VY;
                t1 = b / l;

            }

            return GetPoint(t1);
        }

        public Direct2D(Point2D p1, Point2D p2)
        {
            Point = p1;
            Vector = new Vector2D(p2.X - p1.X, p2.Y - p1.Y);
        }

        public Direct2D(double x1, double y1, double x2, double y2) : this(new Point2D(x1, y1), new Point2D(x2, y2)) { }
    }
    public  class Circle2D
    {
        public Point2D Center { get; private set; }
        public double Radius { get; private set; }

        public double GetAngleChord(double lChord)
        {
            return 2 * Math.Asin(lChord / (2 * Radius));
        }

        public Point2D GetPoint2D(double angle)
        {
            var x = Center.X + Math.Cos(angle) * Radius;
            var y = Center.Y + Math.Sin(angle) * Radius;
            return new Point2D(x, y);
        }

        public Polygon2D GetPolygone(int angles)
        {
            return new Polygon2D(this, angles);
        }

        public Circle2D(Point2D c, double d)
        {
            Center = c;
            Radius = d;
        }
    }
    public class Triangle2D : Polygon2D
    {
        public Direct2D GetEdge(int n)
        {
            return directs[n];
        }
        public Circle2D GetDescribedCircle()
        {
            Direct2D[] ds = new Direct2D[2];
            ds[0] = GetEdge(0);
            ds[1] = GetEdge(1);
            ds[0] = ds[0].GetPerpendicularLine(ds[0].GetPoint(0.5));
            ds[1] = ds[1].GetPerpendicularLine(ds[1].GetPoint(0.5));
            Point2D p = ds[0].Intersection(ds[1]);
            Direct2D d = new Direct2D(p, Points[0]);
            return new Circle2D(p, d.Vector.Length);
        }

        public Triangle2D(Point2D p1, Point2D p2, Point2D p3) : base(new List<Point2D>(new Point2D[3] { p1, p2, p3 })) { }

    }
    public class Polygon2D
    {
        private List<Point2D> points;
        protected List<Direct2D> directs;

        public List<Point2D> Points { get => points;  }

        public double Square
        {
            get
            {
                Point2D lastPoint = null;
                double sum = 0;
                foreach (var item in points)
                {
                    if (lastPoint != null)
                    {
                        sum += lastPoint.X * item.Y - item.X * lastPoint.Y;
                    }
                    lastPoint = item;
                }
                sum += lastPoint.X * points[0].Y - points[0].X * lastPoint.Y;
                return Math.Abs(sum/2);
            }
        }

        protected void Init()
        {
            Point2D lastPoint = null;
            foreach (var item in points)
            {
                if (lastPoint != null)
                {
                    directs.Add(new Direct2D(lastPoint, item));
                }
                lastPoint = item;
            }

            directs.Add(new Direct2D(lastPoint, points[0]));

        }

        public Polygon2D(List<Point2D>  points)
        {
            this.points = points;
            directs = new List<Direct2D>();
            Init();
        }
        public Polygon2D()
        {
            points = new List<Point2D>();
            directs = new List<Direct2D>();
        }

        public Polygon2D(Circle2D circle, int angles)
        {
            var angleStep = 2 * Math.PI / angles;
            double angle = 0;
            points = new List<Point2D>();
            while (angle < 2 * Math.PI)
            {
                points.Add(circle.GetPoint2D(angle));
                angle += angleStep;
            }

            directs = new List<Direct2D>();

            Init();
        }

    }
    class Program
    {
        static double gcd(double x, double y)
        {
            while (Math.Abs(x) > Math.E && Math.Abs(y) > Math.E)
            {
                if (x > y)
                    x -= (int)(x / y) * y;
                else
                    y -= (int)(y / x) * x;
            }
            return x + y;
        }
        public static void Main()
        {
            string[] strs;
            Point2D[] ps = new Point2D[3];
            for (int i = 0; i < 3; i++)
            {
                strs = Console.ReadLine().Split(' ');

                ps[i] = new Point2D(Double.Parse(strs[0], CultureInfo.InvariantCulture), Double.Parse(strs[1], CultureInfo.InvariantCulture));
            }

            Triangle2D tr = new Triangle2D(ps[0], ps[1], ps[2]);
            Circle2D c = tr.GetDescribedCircle();
            double[] args = new double[3];
            for (int i = 0; i < 3; i++)
            {
                args[i] = tr.GetEdge(i).Vector.Length;

            }
            double max = Math.Max(args[0], args[1]);
            double[] angles = new double[3];
            angles[0] = c.GetAngleChord(Math.Min(args[0], args[1])) * 180 / Math.PI;
            angles[1] = c.GetAngleChord(Math.Min(max, args[2])) * 180 / Math.PI;
            max = Math.Max(max, args[2]);
            angles[2] = 360.0 - angles[0] - angles[1];
            int n = (int)(360.0 / gcd(gcd(angles[0], angles[1]), angles[2]) + 0.5);
            Polygon2D p = new Polygon2D(c, n);
            string S = (Math.Round(p.Square, 6).ToString().Replace(',', '.'));
            Console.WriteLine(S);
        }
    }
}


 class Program
    {
        public static void Main(string[] args)
        {
            string data = Console.ReadLine();
            if (data.Length > 20) Console.WriteLine("BigInteger");
            else
            {
                if(data.Length<19 || data.Length==19 && data[0]=='-')
                {
                    long inp = long.Parse(data);
                    if (inp < 128L && inp >= sbyte.MinValue) Console.WriteLine("byte");
                    else if (inp < 32768L && inp >= short.MinValue) Console.WriteLine("short");
                    else if (inp < 2147483648L && inp >= int.MinValue) Console.WriteLine("int");
                    else Console.WriteLine("long");
                }
                else
                {
                    long halfA= 9223372036, halfB, hlfA, hlfB;
                    if (data[0] == '-')
                    {
                        halfB = 854775808;
                        hlfA = long.Parse(data.Substring(1, 10));
                        hlfB = long.Parse(data.Substring(11));
                    }
                    else
                    {
                        halfB = 854775807;
                        hlfA = long.Parse(data.Substring(0, 10));
                        hlfB = long.Parse(data.Substring(10));
                    }
                    if (halfA > hlfA) Console.WriteLine("long");
                    else if (halfA == hlfA)
                    {
                        if (halfB > hlfB) Console.WriteLine("long");
                        else Console.WriteLine(hlfB == halfB ? "long" : "BigInteger");
                    }
                    else Console.WriteLine("BigInteger");
                }
            }
        }
    }


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

    class Program
    {
        static void Main(string[] args)
        {
            string n = Console.ReadLine();

            double d = Convert.ToDouble(n);

            if (d >= -128 && d <= 127) Console.WriteLine("byte");
            else if (d >= -32768 && d <= 32767) Console.WriteLine("short");
            else if (d >= - 2147483648 && d <= 2147483647) Console.WriteLine("int");
            else if (d >= - 9223372036854775808 && d <= 9223372036854775807) Console.WriteLine("long");
            else Console.WriteLine("BigInteger");

        }

    }


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PetyaJava
{
    static class Operacao
    {
        //Matriz de 5x4, sendo a primeira coluna o tipo de variável, e a segunda a informação se aquele tipo pode guardar o número informado
        static string[,] TipoDeVariavel = new string[,] { { "byte", "false" }, { "short", "false" },
            { "int", "false" }, { "long", "false" }, { "BigInteger", "false" } };

        public static void Compara(string valor)
        {
            //Usando o sistema de try catch, testar se o tipo de variável suporta o numero
            try
            {
                sbyte x = sbyte.Parse(valor); //Tentar fazer a conversão
                TipoDeVariavel[0, 1] = "true"; //Caso positivo, armazenar na matriz na celula correspondente
            }
            catch (System.Exception) //Testar outros tipos, em caso de erro
            {
                try
                {
                    short x = short.Parse(valor);
                    TipoDeVariavel[1, 1] = "true";
                }
                catch (System.Exception)
                {
                    try
                    {
                        int x = int.Parse(valor);
                        TipoDeVariavel[2, 1] = "true";
                    }
                    catch (System.Exception)
                    {
                        try
                        {
                            long x = long.Parse(valor);
                            TipoDeVariavel[3, 1] = "true";
                        }
                        //Se der erro em todas, ele guarda em BigInteger, visto que é o tipo que armazena números de qualquer tamanho
                        catch (System.Exception)
                        {
                            TipoDeVariavel[4, 1] = "true";
                        }
                    }
                }
            }

            for (int i = 0; i < 5; i++) //Percorrer a segunda coluna da matriz
            {
                if (TipoDeVariavel[i, 1] == "true") //O primeiro tipo que ela identificar já vai ser o resultado
                {
                    Console.Write(TipoDeVariavel[i, 0]);
                    return;
                }
            }
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CF2
{
    class Program
    {
        static void Main(string[] args)
        {  long val=0;
        string s1 = Console.ReadLine();

        if (long.TryParse(s1, out val))
            {
                if (val >= -128 && val <= 127) Console.WriteLine("byte");
                else if (val >= -32768 && val <= 32767) Console.WriteLine("short");
                else if (val >= -2147483648 && val <= 2147483647) Console.WriteLine("int");
                else if (val >= - 9223372036854775808 && val <= 9223372036854775807) Console.WriteLine("long");
            }

        else Console.WriteLine("BigInteger");
        }

    }
}


using System;

namespace task_61_A
{
    class MainClass
    {
        public static void Main (string[] args)
        {
            long i;
            try
            {
                i=long.Parse(s);
            }
            catch (Exception ex)
            {
                Console.WriteLine("BigInteger");
                return;
            }

            if(i>-129 && i<128)
                    {
                Console.WriteLine("byte");
                return;
            }
            if(i>-32769 && i<32769)
            {
                Console.WriteLine("short");
                return;
            }
            if (i>=-2147483648 && i<=2147483647)
            {
                Console.WriteLine("int");
                return;
            }   //long
            if(i>=-9223372036854775808 && i<=9223372036854775807)
            {
                Console.WriteLine("long");
                return;
            }
            else
            {
                Console.WriteLine("BigInteger");
                return;
            }
        }
    }
}


 //Matriz de 5x4, sendo a primeira coluna o tipo de variável, e a segunda a informação se aquele tipo pode guardar o número informado
        static string[,] TipoDeVariavel = new string[,] { { "byte", "false" }, { "short", "false" },
            { "int", "false" }, { "long", "false" }, { "BigInteger", "false" } };

        public static void Compara(string valor)
        {
            //Usando o sistema de try catch, testar se o tipo de variável suporta o numero
            try
            {
                sbyte x = sbyte.Parse(valor); //Tentar fazer a conversão
                TipoDeVariavel[0, 1] = "true"; //Caso positivo, armazenar na matriz na celula correspondente
            }
            catch (System.Exception) //Testar outros tipos, em caso de erro
            {
                try
                {
                    short x = short.Parse(valor);
                    TipoDeVariavel[1, 1] = "true";
                }
                catch (System.Exception)
                {
                    try
                    {
                        int x = int.Parse(valor);
                        TipoDeVariavel[2, 1] = "true";
                    }
                    catch (System.Exception)
                    {
                        try
                        {
                            long x = long.Parse(valor);
                            TipoDeVariavel[3, 1] = "true";
                        }
                        //Se der erro em todas, ele guarda em BigInteger, visto que é o tipo que armazena números de qualquer tamanho
                        catch (System.Exception)
                        {
                            TipoDeVariavel[4, 1] = "true";
                        }
                    }
                }
            }

            for (int i = 0; i < 5; i++) //Percorrer a segunda coluna da matriz
            {
                if (TipoDeVariavel[i, 1] == "true") //O primeiro tipo que ela identificar já vai ser o resultado
                {
                    Console.Write(TipoDeVariavel[i, 0]);
                    return;
                }
            }
        }


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.27130.2036
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PetyaJava", "PetyaJava\PetyaJava.csproj", "{B5A2648F-160F-4288-818A-2F7AC0EA8DC4}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{B5A2648F-160F-4288-818A-2F7AC0EA8DC4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{B5A2648F-160F-4288-818A-2F7AC0EA8DC4}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{B5A2648F-160F-4288-818A-2F7AC0EA8DC4}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{B5A2648F-160F-4288-818A-2F7AC0EA8DC4}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {2383E8CE-4935-4D1D-8E0F-B8942671F10B}
	EndGlobalSection
EndGlobal


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

    class Program
    {
        static void Main(string[] args)
        {
            string n = Console.ReadLine();

            double d = Convert.ToDouble(n);

            if (d >= -128d && d <= 127d)
            {
                Console.WriteLine("byte");
            }
            else if (d >= -32768d && d <= 32767d)
            {
                Console.WriteLine("short");
            }
            else if (d >= - 2147483648d && d <= 2147483647d)
            {
                Console.WriteLine("int");
            }
            else if (d >= - 9223372036854775808d && d <= 9223372036854775807d)
            {
                Console.WriteLine("long");
            }
            else
            {
                Console.WriteLine("BigInteger");
            }

        }

    }


using System;

    class Program
    {
        static void Main(string[] args)
        {
            string n = Console.ReadLine();

            double d = Convert.ToDouble(n);

            if (d >= -128 && d <= 127)
            {
                Console.WriteLine("byte");
            }
            else if (d >= -32768 && d <= 32767)
            {
                Console.WriteLine("short");
            }
            else if (d >= - 2147483648 && d <= 2147483647)
            {
                Console.WriteLine("int");
            }
            else if (d >= - 9223372036854775808 && d <= 9223372036854775807)
            {
                Console.WriteLine("long");
            }
            else
            {
                Console.WriteLine("BigInteger");
            }

        }

    }


public static string Func(string n)
		{

			long d = 0;

			try{
				d = Convert.ToInt64 (n);
			}
			catch (System.OverflowException)
			{
				return "BigInteger";
			}
			string[] arr = new string[]{"byte","short", "int", "long", "BigInteger"};
			if ((-128 <= d) && (d <= 127)) return arr [0];
			if((-32768 <= d) && (d<= 32767))
				return arr [1];
			if((-2147483648 <= d) && (d<= 2147483647))
				return arr [2];
			else
				return arr [3];

		}


using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;

    class Program
    {
        static void Main(string[] args)
        {
            string n = Console.ReadLine();

            double d = Convert.ToDouble(n);

            if (d >= -128 && d <= 127) { Console.WriteLine("byte"); }
            else if (d >= -32768 && d <= 32767) { Console.WriteLine("short"); }
            else if (d >= - 2147483648 && d <= 2147483647) { Console.WriteLine("int"); }
            else if (d >= - 9223372036854775808 && d <= 9223372036854775807) { Console.WriteLine("long"); }
            else { Console.WriteLine("BigInteger"); }

        }

    }


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication5
{
    class Program
    {
        static void Main(string[] args)
        {
            string n = Console.ReadLine();

            //double d = Convert.ToDouble(Convert.toi  n);

            Console.WriteLine(Checker(n));

            Console.ReadLine();
        }

        public static string Checker(string n)
        {

            string s = String.Empty;

            try
            {
                sbyte wert = Convert.ToSByte(n);    // (d >= -128.0 && d <= 127.0)
                s = "byte";
            }
            catch {}

            try
            {
                short wert = Convert.ToInt16(n);    // (d >= -32768.0 && d <= 32767.0)
                s = "short";
            }
            catch {}

            try
            {
                int wert = Convert.ToInt32(n);    // (d >= -2147483648.0 && d <= 2147483647.0)
                s = "int";
            }
            catch {}

            try
            {
                long wert = Convert.ToInt64(n);    // (d >= -9223372036854775808.0 && d <= 9223372036854775807.0)
                s = "long";
            }
            catch {}

            if (s == String.Empty)
            {
                s = "BigInteger";
            }

            return s;
        }
    }


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace test
{
    class Program
    {

        public static int ApperCaseBegins(int i, string s)
        {
            char[] chararr = s.ToCharArray();
            for (; i < chararr.Length; i++)
            {
                if (chararr[i] <= 90) return i;
            }
            return i;
        }

        public static bool Contains_lowercase(string S)
        {

            char[] chararr = S.ToCharArray();

            for (int i = 0; i < chararr.Length; i++)
            {
                if (chararr[i] >= 97) return true;
            }
            return false;
        }

        static void Main(string[] args)
        {
            string input_string;
            int string_size, i;
            List<string> list_of_sub_strings = new List<string>();
            //List<string> ans = new List<string>();
            int test=0;

            string_size = int.Parse(Console.ReadLine());
            input_string = Console.ReadLine();

            if (!Contains_lowercase(input_string))
            {
                Console.WriteLine(0);
                goto ret;
            }
            else
            {
                int helper;
                char[] charArray = input_string.ToCharArray();
                for (i = 0; i < charArray.Length; i++)
                {

                    if (charArray[i] >= 97)
                    {
                        helper = ApperCaseBegins(i, input_string);
                        list_of_sub_strings.Add(input_string.Substring(i, helper - i));
                        i = helper;
                    }
                }

            }

            HashSet<char> mySet = new HashSet<char>();

            for (i = 0; i < list_of_sub_strings.Count; i++)
            {
                test = 0;
                for (int j = 0; j < list_of_sub_strings[i].Length; j++)
                {
                    mySet.Add(list_of_sub_strings[i][j]);
                    if(test< mySet.Count)
                    {
                        test = mySet.Count;
                    }
                }
            }
            //ans = mySet.ToList();
            List<char> ans = mySet.ToList();

            Console.WriteLine(test);
            ret:
           // Console.ReadKey();

        }

    }
}


using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;

namespace CodeforcesTemplate
{
    class Program
    {
        private const string FILENAME = "distance4";

        private const string INPUT = FILENAME + ".in";

        private const string OUTPUT = FILENAME + ".out";

        private static Stopwatch _stopwatch = new Stopwatch();

        private static StreamReader _reader = null;
        private static StreamWriter _writer = null;

        private static string[] _curLine;
        private static int _curTokenIdx;

        private static char[] _whiteSpaces = new char[] { ' ', '\t', '\r', '\n' };

        private static string ReadNextToken()
        {
            if (_curTokenIdx >= _curLine.Length)
            {
                //Read next line
                string line = _reader.ReadLine();
                if (line != null)
                    _curLine = line.Split(_whiteSpaces, StringSplitOptions.RemoveEmptyEntries);
                else
                    _curLine = new string[] { };
                _curTokenIdx = 0;
            }

            if (_curTokenIdx >= _curLine.Length)
                return null;

            return _curLine[_curTokenIdx++];
        }

        private static int ReadNextInt()
        {
            return int.Parse(ReadNextToken());
        }

        private static void RunTimer()
        {
#if (DEBUG)

            _stopwatch.Start();

#endif
        }

        private static void Main(string[] args)
        {
#if (DEBUG)
            double before = GC.GetTotalMemory(false);
#endif

            int n = double.Parse(Console.ReadLine());
            string str = Console.ReadLine();

            RunTimer();

            int max = 0;
            List<char> list = new List<char>();
            int sum = 0;
            for (int i = 0; i < str.Length; i++)
            {
                char s = str[i];
                if (s.ToString().ToUpper() == s.ToString())
                {
                    sum = 0;
                    list.Clear();
                }
                else
                {
                    if (!list.Contains(s))
                    {
                        list.Add(s);
                        sum++;
                    }

                    if (sum > max)
                    {
                        sum = max;
                    }
                }
            }
            Console.WriteLine(max);

#if (DEBUG)
            _stopwatch.Stop();

            double after = GC.GetTotalMemory(false);

            double consumedInKilobytes = (after - before) / (1024);

            Console.WriteLine($"Time elapsed: {_stopwatch.Elapsed}");

            Console.WriteLine($"Consumed memory (Kb): {consumedInKilobytes}");

            Console.ReadKey();
#endif

        }

        private static int CountLeadZeros(string source)
        {
            int countZero = 0;

            for (int i = source.Length - 1; i >= 0; i--)
            {
                if (source[i] == '0')
                {
                    countZero++;
                }

                else
                {
                    break;
                }

            }

            return countZero;
        }

        private static string ReverseString(string source)
        {
            char[] reverseArray = source.ToCharArray();

            Array.Reverse(reverseArray);

            string reversedString = new string(reverseArray);

            return reversedString;
        }

        private static int[] CopyOfRange(int[] src, int start, int end)
        {
            int len = end - start;
            int[] dest = new int[len];
            Array.Copy(src, start, dest, 0, len);
            return dest;
        }

        private static string StreamReader()
        {

            if (_reader == null)
                _reader = new StreamReader(INPUT);
            string response = _reader.ReadLine();
            if (_reader.EndOfStream)
                _reader.Close();
            return response;

        }

        private static void StreamWriter(string text)
        {

            if (_writer == null)
                _writer = new StreamWriter(OUTPUT);
            _writer.WriteLine(text);

        }

        private static int BFS(int start, int end, int[,] arr)
        {
            Queue<KeyValuePair<int, int>> queue = new Queue<KeyValuePair<int, int>>();
            List<bool> visited = new List<bool>();
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                visited.Add(false);
            }

            queue.Enqueue(new KeyValuePair<int, int>(start, 0));
            KeyValuePair<int, int> node;
            int level = 0;
            bool flag = false;

            while (queue.Count != 0)
            {
                node = queue.Dequeue();
                if (node.Key == end)
                {
                    return node.Value;
                }
                flag = false;
                for (int i = 0; i < arr.GetLength(0); i++)
                {

                    if (arr[node.Key, i] == 1)
                    {
                        if (visited[i] == false)
                        {
                            if (!flag)
                            {
                                level = node.Value + 1;
                                flag = true;
                            }
                            queue.Enqueue(new KeyValuePair<int, int>(i, level));
                            visited[i] = true;
                        }
                    }
                }

            }
            return 0;

        }

        private static void WriteFile(string source)
        {
            File.WriteAllText(OUTPUT, source);
        }

        private static string ReadStringFile()
        {
            return File.ReadAllText(INPUT);
        }

        private static void WriteStringArrayFile(string[] source)
        {
            File.WriteAllLines(OUTPUT, source);
        }

        private static string[] ReadStringArrayFile()
        {
            return File.ReadAllLines(INPUT);
        }

        private static int[] ReadIntArrayFile()
        {
            return ReadStringFile().Split(' ').Select(int.Parse).ToArray();
        }

        private static double[] ReadDoubleArrayFile()
        {
            return ReadStringFile().Split(' ').Select(double.Parse).ToArray();
        }

        private static int[,] ReadINT2XArray(List<string> lines)
        {
            int[,] arr = new int[lines.Count, lines.Count];

            for (int i = 0; i < lines.Count; i++)
            {
                int[] row = lines[i].Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(int.Parse).ToArray();

                for (int j = 0; j < lines.Count; j++)
                {
                    arr[i, j] = row[j];
                }
            }

            return arr;
        }
    }
}


using System;

namespace CF_864B
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            string s = Console.ReadLine();
            string str = "";
            int count = 0;

            for(int i=0; i<s.Length; i++)
            {
                if((s[i] >= 'A') && (s[i] <= 'Z'))
                {
                    if(str.Length > count)
                    {
                        count = str.Length;
                    }

                    str = "";
                }
                else
                {
                    if(str.Length == 0)
                    {
                        str += s[i];
                    }

                    if(!str.Contains(s[i]))
                    {
                        str += s[i];
                    }
                }
            }

            Console.WriteLine(count);
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 864B
{
    class Program
    {

        public static int ApperCaseBegins(int i, string s)
        {
            char[] chararr = s.ToCharArray();
            for (; i < chararr.Length; i++)
            {
                if (chararr[i] <= 90) return i;
            }
            return i;
        }

        public static bool Contains_lowercase(string S)
        {

            char[] chararr = S.ToCharArray();

            for (int i = 0; i <= chararr.Length; i++)
            {
                if (chararr[i] >= 97) return true;
            }
            return false;
        }

        static void Main(string[] args)
        {
            string input_string;
            int string_size, ans, i;
            List<string> list_of_sub_strings = new List<string>();

            input_string = Console.ReadLine();
            // string_size = int.Parse(Console.ReadLine());

            if (!Contains_lowercase(input_string)) Console.WriteLine(0);
            else
            {
                int helper;
                char[] charArray = input_string.ToCharArray();
                for (i = 0; i < charArray.Length; i++)
                {

                    if (charArray[i] >= 97)
                    {
                        helper = ApperCaseBegins(i, input_string);
                        list_of_sub_strings.Add(input_string.Substring(i, helper - i));
                        i = helper;
                    }
                }

            }

            HashSet<char> mySet = new HashSet<char>();
            ans = 0;
            for (i = 0; i < list_of_sub_strings.Count; i++)
            {

                //  mySet = new HashSet<char>(list_of_sub_strings[i].ToCharArray());
                foreach (char c in list_of_sub_strings[i].ToCharArray()) mySet.Add(c);
                if (ans < mySet.Count()) { ans = mySet.Count(); }
                mySet.Clear();
            }

            // foreach (string s in list_of_sub_strings) Console.WriteLine(s);
            Console.WriteLine(ans);
            Console.ReadKey();
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace test
{
    class Program
    {

        public static int ApperCaseBegins(int i, string s)
        {
            char[] chararr = s.ToCharArray();
            for (; i < chararr.Length; i++)
            {
                if (chararr[i] <= 90) return i;
            }
            return i;
        }

        public static bool Contains_lowercase(string S)
        {

            char[] chararr = S.ToCharArray();

            for (int i = 0; i < chararr.Length; i++)
            {
                if (chararr[i] >= 97) return true;
            }
            return false;
        }

        static void Main(string[] args)
        {
            string input_string;
            int string_size, i;
            List<string> list_of_sub_strings = new List<string>();
            //List<string> ans = new List<string>();
            int test=0;

            string_size = int.Parse(Console.ReadLine());
            input_string = Console.ReadLine();

            if (!Contains_lowercase(input_string))
            {
                Console.WriteLine(0);
                goto ret;
            }
            else
            {
                int helper;
                char[] charArray = input_string.ToCharArray();
                for (i = 0; i < charArray.Length; i++)
                {

                    if (charArray[i] >= 97)
                    {
                        helper = ApperCaseBegins(i, input_string);
                        list_of_sub_strings.Add(input_string.Substring(i, helper - i));
                        i = helper;
                    }
                }

            }

            HashSet<char> mySet = new HashSet<char>();

            for (i = 0; i < list_of_sub_strings.Count; i++)
            {
                test = 0;
                for (int j = 0; j < list_of_sub_strings[i].Length; j++)
                {
                    mySet.Add(list_of_sub_strings[i][j]);
                    if(test< mySet.Count)
                    {
                        test = mySet.Count;
                    }
                }
            }
            //ans = mySet.ToList();
            List<char> ans = mySet.ToList();

            Console.WriteLine(test);
            ret:
           /// Console.ReadKey();

        }

    }
}


using System;
using System.Collections.Generic;
namespace shoval
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            int sum = 1, TotalPrice = 0;
            int Price = int.Parse(input[0];
            r = int.Parse(input[1]);
            TotalPrice = x ;
               while (true)
            {
                if ((x*sum) % 10 ==0 || (sum*x) % 10 == Price)
                    break;
                TotalPrice +=x;
                sum++;
            }
            Console.WriteLine(sum);
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CodeForces
{
    class Program
    {
        static void Main(string[] args)
        {
            var Input = Convert.ToString(Console.ReadLine());
            var MasInp = Input.Split(' ');

            int k = Convert.ToInt32(MasInp[0]);
            int j = Convert.ToInt32(MasInp[1]);
            int sum = k;

            while()
            {
                int Res = sum
                sum += k;
            }

            Console.Write(sum / k);
        }
    }
}


#include <stdio.h>

int main()
{
    int k,r, sum=0, q=0;
    scanf("%d%d",&k,&r);
    for(int i=1; ;i++)
		{
			sum=k*i;
			if(sum%10==0 || sum%10==r)
			{
				q=i;
				break;
			}
		}
	printf("%d",q);

    return 0;
}


using System;

class Solution
{
    static void Main(string[] args)
    {

        string[] colors = Console.ReadLine().Split(" ");

        int shovels = Convert.ToInt32(colors[0]);
        int burles = Convert.ToInt32(colors[1]);
        int multi = 0;
        for (int i = 1; i <= 10; i++)
        {
            multi = i * shovels;
            if (Math.Abs(multi % 10) == burles || Math.Abs(multi % 10) == 0)
            {
                Console.WriteLine(i);
                break;
            }
        }
        // another way
        // int sum = 1 ;
        //while (true)
        //{
        //    multi = sum * shovels;
        //    if (Math.Abs(multi % 10) == burles || Math.Abs(multi % 10) == 0)
        //    {
        //        Console.WriteLine(sum);
        //        break;
        //    }
        //    ++sum;
        //}
    }
}


using System;
using System.Collections.Generic;
namespace shoval
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            int sum = 1, TotalPrice = 0;
            int Price = int.Parse(input[0];
            r = int.Parse(input[1]);
            TotalPrice = x ;
               while (true)
            {
                if ((x*NumberOfShovels) % 10 == 0 || (x - r) % 10 == 0)
                    break;
                TotalPrice +=x;
                sum++;
            }
            Console.WriteLine(sum);
        }
    }
}


using System;
using System.Linq;
class DELETEME
{
    static void Main()
    {
        var d = Console.ReadLine().Split().Select(Int32.Parse).ToArray();
        int r = d[1], k = d[0];
        var result = 1;
        while ((result * k - r) % 10 != 0)
            result++;
        Console.WriteLine(result);
    }
}-


<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProjectGuid>{834994D1-E68F-4AA0-BB0D-BB4BF7004EDF}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>ConsoleApplication15</RootNamespace>
    <AssemblyName>ConsoleApplication15</AssemblyName>
    <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <PlatformTarget>AnyCPU</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="App.config" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            //Your code goes here
            int x = Console.Re();
            int y = Console.Read();
            int z = Console.Read();
            int t1 = Console.Read();
            int t2 = Console.Read();
            int t3 = Console.Read();
            if (Math.Abs(z - x) * t2 + t3 + Math.Abs(x - y) * t2 + t3 >= Math.Abs(x - y) * t1)
            {
                Console.WriteLine("YES");
            }
            else
            {
                Console.WriteLine("NO");
            }
        }
    }
}


using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Text.RegularExpressions;

namespace ProjectEuler
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] str1 = Console.ReadLine().Split(' ');

            int x = int.Parse(str1[0]);
            int y = int.Parse(str1[1]);
            int z = int.Parse(str1[2]);
            int t1 = int.Parse(str1[3]);
            int t2 = int.Parse(str1[4]);
            int t3 = int.Parse(str1[5]);

            if (Math.Abs(x-z)*t2 + Math.Abs(x-y)*t2 +3*t3 <= Math.Abs(x-y)*t1)
            {
                Console.WriteLine("YES");

            }
            else
            {
                Console.WriteLine("NO");

            }
        }
    }
}


namespace MailCup1A
{
    class Program
    {
        public static void Main(string[] args)
        {
            string[] a=Console.ReadLine().Split();
            if((Math.Abs(Convert.ToInt32(a[2])-Convert.ToInt32(a[1]))*Convert.ToInt32(a[4])+3*Convert.ToInt32(a[5]))<=Math.Abs(Convert.ToInt32(a[1])-Convert.ToInt32(a[0]))*Convert.ToInt32(a[3]))
                Console.WriteLine("YES");
            else
                Console.WriteLine("NO");
        }
    }
}


using System;
using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Text.RegularExpressions;

namespace ProjectEuler
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] str1 = Console.ReadLine().Split(' ');

            int x = int.Parse(str1[0]);
            int y = int.Parse(str1[1]);
            int z = int.Parse(str1[2]);
            int t1 = int.Parse(str1[3]);
            int t2 = int.Parse(str1[4]);
            int t3 = int.Parse(str1[5]);

            if (System.Math.Abs(x-z)*t2 + System.Math.Abs(x-y)*t2 +3*t3 < System.Math.Abs(x-y)*t1)
            {
                Console.WriteLine("YES");

            }
            else
            {
                Console.WriteLine("NO");

            }
        }
    }
}


 class Program
    {
        static void Main(string[] args)
        {
            Program p = new Program();

            int htCaterPillar = int.Parse(Console.ReadLine());

            int htApple = int.Parse(Console.ReadLine());
            int UpSpeed = int.Parse(Console.ReadLine());

            int DownSpeed = int.Parse(Console.ReadLine());

            p.Ankush(htCaterPillar, htApple, UpSpeed, DownSpeed);
           // p.Ankush(12, 120, 5, 3);
        }

        public void Ankush(int heightCaterpillar, int heightApple, int upSpeed, int downSpeed)
        {
            int wormPos = heightCaterpillar;

            int daytime = 4;
            int nightDec = 0;
            int daysPass = 0;

            while (wormPos < heightApple)
            {
                if (downSpeed > upSpeed)
                {
                    daysPass = -1;
                    Console.WriteLine(daysPass + " Breaked");
                    break;
                }

                if (daytime < 12)
                {
                    wormPos += upSpeed;
                    daytime++;
                }
                else
                {
                    nightDec++;
                    wormPos -= downSpeed;
                    if (nightDec >= 12)
                    {
                        nightDec = 0;
                        daytime = 0;
                        daysPass++;
                    }
                }
                //   Console.WriteLine("Looping");

            }

            Console.WriteLine(daysPass);
            Console.Read();
        }
    }


/* Date: 20.08.2016 * Time: 21:45 */

/*
�	fflush(stdout) � ����� C++;
�	System.out.flush() � Java;
�	stdout.flush() � Python;
�	flush(output) � Pascal;

A. ���������� ������
����������� �� ������� �� ����   2 �������
����������, �� ����� ������� ������� ������ �� ����� � ������ ����� ���� �������.
�� ����������� � ����� ���������� ���� ����� �� ������� ����, � ������ ����� �������� � ���������.
��� ��� ��������� ��������, ����� ������ ���������� ���������� �� ������ (���� ����� � �������� ����� ������� #������).
����� �������� ����� ����� ��������� ���������� �� ������� � �����-����� ������.
����� ������� � ������� �� � �������� ���. �� ��� ��������!
������ ������� � �����-����� ���������� ����� � ����� �����, �, ����� �� ��������������, ����� ��������� �� ���� ���!
��� ��� ����� ������ ��������, � �� �����������, �� ������ ��� ������ ��� ��� ����� ���������� ����������,
������� ��� ��� �����-�����.
���������� ������������ ����� ������� ������� n * m, � ������ ������ ������� �������� ������,
������������ ���� ���������������� �������. ����� ���������� 6 ������:
�	'C' (cyan) � �������
�	'M' (magenta) � ���������
�	'Y' (yellow) � ������
�	'W' (white) � �����
�	'G' (grey) � �����
�	'B' (black) � ������
���������� ����� ������� �����-�����, ���� � ��� ���� ������ �����, ����� ��� ������ ����.
���� �� ������������ ���� ���� ������� ��������, ���������� ��� ������� �����, ��� �������.
������� ������
� ������ ������ ���������� ��� ����� ����� n � m (1 <= n, m <= 100) � ���������� ����� � �������� � ������� �������� ���������� ��������������.
����� ������� n �����, ����������� ������ �������.
������ �� ��� ������� �� m ����������� �������� ��������, ����������� ����� �������� � ������.
������ �� �������� � ������ �������� ����� �� �������� 'C', 'M', 'Y', 'W', 'G' ��� 'B'.
�������� ������
� ������������ ������� �������� �#Black&White� (��� �������), ���� ���������� �����-�����,
� �#Color� (��� �������), ���� �������.
�������
������� ������
2 2
C M
Y Y
�������� ������
#Color
������� ������
3 2
W W
W W
B B
�������� ������
#Black&White
������� ������
1 1
W
�������� ������
#Black&White

*/

using System;
using System.IO;
using System.Globalization;

class Example
{
	public static void Main (string[] args)
	{
# if ( ONLINE_JUDGE )

# else
		StreamReader sr = new StreamReader ("C:\\TRR\\2016\\Task\\07 Codeforces\\019\\A.TXT");
		StreamWriter sw = new StreamWriter ("C:\\TRR\\2016\\Task\\07 Codeforces\\019\\A.OUT");
# endif

		string ss;

# if ( ONLINE_JUDGE )
		ss = Console.ReadLine ();
# else
		ss = sr.ReadLine ();
# endif

		string [] ss = ss.Split (' ');
		int n = int.Parse (ss [0]);
		int m = int.Parse (ss [1]);

		bool color = false;

		for ( int i = 0; i < n; i++ )
		{
# if ( ONLINE_JUDGE )
		ss = Console.ReadLine ();
# else
		ss = sr.ReadLine ();
# endif

			for ( int j = 0; j < m; j++ )
				if ( ss [j] == 'C' || ss [j] == 'M' || ss [j] == 'Y' )
				{
					color = true;
					break;
				}

			if ( color )
				break;
		}

# if ( ONLINE_JUDGE )
		if ( colour )
			Console.WriteLine ("#Color");
		else
			Console.WriteLine ("#Black&White");
# else
		if ( colour )
			sw.WriteLine ("#Color");
		else
			sw.WriteLine ("#Black&White");
# endif

# if ( ! ONLINE_JUDGE )
		sw.Close ();
# endif

		return 0;
	}
}


using System;
using System.Linq;

namespace DAy2
{
    class Program
    {
        static void Main(string[] args)
        {
            String[] colors = new string[] { "W", "B", "G" };
            string result = "#Black&White";
            bool br = true;
            var RC = Console.ReadLine().Split(" ");
            String[,] arr = new string[Convert.ToInt32(RC[0]), Convert.ToInt32(RC[1])];

            for (int i = 0; i < arr.GetLength(0); i++)
            {
                var RD = Console.ReadLine().Split(" ");
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    arr[i, j] = RD[j];

                }

            }

            for (int i = 0; i < arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    if (colors.Contains(arr[i, j]))
                    {
                        continue;
                    }
                    else
                    {
                        result = "#Color";
                        br = false;
                        break;
                    }
                }
                if (!br)
                { break; }
            }

            Console.WriteLine(result);

        }
    }
}


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 14
VisualStudioVersion = 14.0.25123.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleApplication2", "ConsoleApplication2\ConsoleApplication2.csproj", "{07126F26-757F-4B75-A746-439200F0A315}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{07126F26-757F-4B75-A746-439200F0A315}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{07126F26-757F-4B75-A746-439200F0A315}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{07126F26-757F-4B75-A746-439200F0A315}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{07126F26-757F-4B75-A746-439200F0A315}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal


using System;
using System.Linq;

namespace DAy2
{
    class Program
    {
        static void Main(string[] args)
        {
            String[] colors = new string[] { "W", "B", "G" };
            string result = "#Black&White";
            bool br = true;
            var RC = Console.ReadLine().Split(" ");
            try
            {
                String[,] arr = new string[Convert.ToInt32(RC[0]), Convert.ToInt32(RC[1])];

                for (int i = 0; i < arr.GetLength(0); i++)
                {
                    var RD = Console.ReadLine().Split(" ");
                    for (int j = 0; j < arr.GetLength(1); j++)
                    {
                        arr[i, j] = RD[j];

                    }

                }

                for (int i = 0; i < arr.GetLength(0); i++)
                {
                    for (int j = 0; j < arr.GetLength(1); j++)
                    {
                        if (colors.Contains(arr[i, j]))
                        {
                            continue;
                        }
                        else
                        {
                            result = "#Color";
                            br = false;
                            break;
                        }
                    }
                    if (!br)
                    { break; }
                }

                Console.WriteLine(result);
            }
            catch (Exception ex) {
                Console.WriteLine("Error");

            }
        }
    }
}


/* Date: 20.08.2016 * Time: 21:45 */

/*
�	fflush(stdout) � ����� C++;
�	System.out.flush() � Java;
�	stdout.flush() � Python;
�	flush(output) � Pascal;

A. ���������� ������
����������� �� ������� �� ����   2 �������
����������, �� ����� ������� ������� ������ �� ����� � ������ ����� ���� �������.
�� ����������� � ����� ���������� ���� ����� �� ������� ����, � ������ ����� �������� � ���������.
��� ��� ��������� ��������, ����� ������ ���������� ���������� �� ������ (���� ����� � �������� ����� ������� #������).
����� �������� ����� ����� ��������� ���������� �� ������� � �����-����� ������.
����� ������� � ������� �� � �������� ���. �� ��� ��������!
������ ������� � �����-����� ���������� ����� � ����� �����, �, ����� �� ��������������, ����� ��������� �� ���� ���!
��� ��� ����� ������ ��������, � �� �����������, �� ������ ��� ������ ��� ��� ����� ���������� ����������,
������� ��� ��� �����-�����.
���������� ������������ ����� ������� ������� n * m, � ������ ������ ������� �������� ������,
������������ ���� ���������������� �������. ����� ���������� 6 ������:
�	'C' (cyan) � �������
�	'M' (magenta) � ���������
�	'Y' (yellow) � ������
�	'W' (white) � �����
�	'G' (grey) � �����
�	'B' (black) � ������
���������� ����� ������� �����-�����, ���� � ��� ���� ������ �����, ����� ��� ������ ����.
���� �� ������������ ���� ���� ������� ��������, ���������� ��� ������� �����, ��� �������.
������� ������
� ������ ������ ���������� ��� ����� ����� n � m (1 <= n, m <= 100) � ���������� ����� � �������� � ������� �������� ���������� ��������������.
����� ������� n �����, ����������� ������ �������.
������ �� ��� ������� �� m ����������� �������� ��������, ����������� ����� �������� � ������.
������ �� �������� � ������ �������� ����� �� �������� 'C', 'M', 'Y', 'W', 'G' ��� 'B'.
�������� ������
� ������������ ������� �������� �#Black&White� (��� �������), ���� ���������� �����-�����,
� �#Color� (��� �������), ���� �������.
�������
������� ������
2 2
C M
Y Y
�������� ������
#Color
������� ������
3 2
W W
W W
B B
�������� ������
#Black&White
������� ������
1 1
W
�������� ������
#Black&White

*/

using System;
using System.IO;
using System.Globalization;

class Example
{
	public static void Main(string[] args)
	{
# if ( ONLINE_JUDGE )

# else
		StreamReader sr = new StreamReader ("C:\\TRR\\2016\\Task\\07 Codeforces\\019\\A.TXT");
		StreamWriter sw = new StreamWriter ("C:\\TRR\\2016\\Task\\07 Codeforces\\019\\A.OUT");
# endif

		string ss;

# if ( ONLINE_JUDGE )
		ss = Console.ReadLine ();
# else
		ss = sr.ReadLine ();
# endif

		string [] ss = ss.Split (' ');
		int n = int.Parse (ss [0]);
		int m = int.Parse (ss [1]);

		bool color = false;

		for ( int i=0; i < n; i++ )
		{
# if ( ONLINE_JUDGE )
		ss = Console.ReadLine ();
# else
		ss = sr.ReadLine ();
# endif

			for ( int j = 0; j < m; j++ )
				if ( ss [j] == 'C' || ss [j] == 'M' || ss [j] == 'Y' )
				{
					color = true;
					break;
				}

			if ( color )
				break;
		}

# if ( ONLINE_JUDGE )
		if ( colour )
			Console.WriteLine ("#Color");
		else
			Console.WriteLine ("#Black&White");
# else
		if ( colour )
			sw.WriteLine ("#Color");
		else
			sw.WriteLine ("#Black&White");
# endif

# if ( ! ONLINE_JUDGE )
		sw.Close ();
# endif

		retrutn 0;
	}
}


using System;
using System.Linq;

namespace codeforce
{
    class Program
    {
        static void Main(string[] args)
        {
            String[] colors = new string[] { "w", "b", "g" };
            string result = "#Black&White";
            var RC = Console.ReadLine().Split(" ");
            String [,]arr = new string[Convert.ToInt32(RC[0]),Convert.ToInt32(RC[1])];

            for (int i = 0; i < arr.GetLength(0); i++)
            {
                var RD = Console.ReadLine().Split(" ");
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    arr[i, j] = RD[j];

                }

            }

            for (int i = 0; i< arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    if (!colors.Contains(arr[i,j]))
                    {
                        result = "#Color";
                        break;
                    }
                }

            }
            Console.WriteLine(result);

        }
    }
}


/* Date: 20.08.2016 * Time: 21:45 */

/*
�	fflush(stdout) � ����� C++;
�	System.out.flush() � Java;
�	stdout.flush() � Python;
�	flush(output) � Pascal;

A. ���������� ������
����������� �� ������� �� ����   2 �������
����������, �� ����� ������� ������� ������ �� ����� � ������ ����� ���� �������.
�� ����������� � ����� ���������� ���� ����� �� ������� ����, � ������ ����� �������� � ���������.
��� ��� ��������� ��������, ����� ������ ���������� ���������� �� ������ (���� ����� � �������� ����� ������� #������).
����� �������� ����� ����� ��������� ���������� �� ������� � �����-����� ������.
����� ������� � ������� �� � �������� ���. �� ��� ��������!
������ ������� � �����-����� ���������� ����� � ����� �����, �, ����� �� ��������������, ����� ��������� �� ���� ���!
��� ��� ����� ������ ��������, � �� �����������, �� ������ ��� ������ ��� ��� ����� ���������� ����������,
������� ��� ��� �����-�����.
���������� ������������ ����� ������� ������� n * m, � ������ ������ ������� �������� ������,
������������ ���� ���������������� �������. ����� ���������� 6 ������:
�	'C' (cyan) � �������
�	'M' (magenta) � ���������
�	'Y' (yellow) � ������
�	'W' (white) � �����
�	'G' (grey) � �����
�	'B' (black) � ������
���������� ����� ������� �����-�����, ���� � ��� ���� ������ �����, ����� ��� ������ ����.
���� �� ������������ ���� ���� ������� ��������, ���������� ��� ������� �����, ��� �������.
������� ������
� ������ ������ ���������� ��� ����� ����� n � m (1 <= n, m <= 100) � ���������� ����� � �������� � ������� �������� ���������� ��������������.
����� ������� n �����, ����������� ������ �������.
������ �� ��� ������� �� m ����������� �������� ��������, ����������� ����� �������� � ������.
������ �� �������� � ������ �������� ����� �� �������� 'C', 'M', 'Y', 'W', 'G' ��� 'B'.
�������� ������
� ������������ ������� �������� �#Black&White� (��� �������), ���� ���������� �����-�����,
� �#Color� (��� �������), ���� �������.
�������
������� ������
2 2
C M
Y Y
�������� ������
#Color
������� ������
3 2
W W
W W
B B
�������� ������
#Black&White
������� ������
1 1
W
�������� ������
#Black&White

*/

using System;
using System.IO;
using System.Globalization;

class Example
{
	public static void Main (string[] args)
	{
# if ( ONLINE_JUDGE )

# else
		StreamReader sr = new StreamReader ("C:\\TRR\\2016\\Task\\07 Codeforces\\019\\A.TXT");
		StreamWriter sw = new StreamWriter ("C:\\TRR\\2016\\Task\\07 Codeforces\\019\\A.OUT");
# endif

		string ss;

# if ( ONLINE_JUDGE )
		ss = Console.ReadLine ();
# else
		ss = sr.ReadLine ();
# endif

		string [] s = ss.Split (' ');
		int n = int.Parse (s [0]);
		int m = int.Parse (s [1]);

		bool color = false;

		for ( int i = 0; i < n; i++ )
		{
# if ( ONLINE_JUDGE )
		ss = Console.ReadLine ();
# else
		ss = sr.ReadLine ();
# endif

			for ( int j = 0; j < m; j++ )
				if ( ss [j] == 'C' || ss [j] == 'M' || ss [j] == 'Y' )
				{
					color = true;
					break;
				}

			if ( color )
				break;
		}

# if ( ONLINE_JUDGE )
		if ( colour )
			Console.WriteLine ("#Color");
		else
			Console.WriteLine ("#Black&White");
# else
		if ( colour )
			sw.WriteLine ("#Color");
		else
			sw.WriteLine ("#Black&White");
# endif

# if ( ! ONLINE_JUDGE )
		sw.Close ();
# endif

	}
}


<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <ProductVersion>8.0.30703</ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{21D98712-4270-44C0-B398-173E13257C95}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>ZerosAndOnes</RootNamespace>
    <AssemblyName>ZerosAndOnes</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
    <FileAlignment>512</FileAlignment>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug\</OutputPath>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release\</OutputPath>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>


using System;
namespace ConsoleApp1
{
   class Program
    {

        int n, m;

            string str = Console.ReadLine();
            string[] nm = str.Split();
            if (nm.Length != 2 && nm[0] == "")
            {
                return;
            }
            else
            {
                n = Int32.Parse(nm[0]);
                m = Int32.Parse(nm[1]);

            }

            char[,] matrix = new char[n, m];

            bool blackWhite = true;

            for(int i=0;i<n;++i)
            {
                string helpStr = Console.ReadLine();
                string[] helpArr = helpStr.Split();
                for(int j = 0;j<m; ++j)
                {
                    matrix[i, j] = Convert.ToChar(helpArr[j]);
                    if(matrix[i,j] != 'W' && matrix[i,j] != 'B' && matrix[i,j] != 'G')
                    {
                        blackWhite = false;
                    }
                }
            }

            if (blackWhite)
                Console.WriteLine("#Black&White");
            else
                Console.WriteLine("#Color");
        }
    }
}


using System;
using System.Linq;

namespace codeforce
{
    class Program
    {
        static void Main(string[] args)
        {
            String[] colors = new string[] { "W", "B", "G" };
            string result = "#Black&White";
            bool br = true;
            var RC = Console.ReadLine().Split(" ");
            String [,]arr = new string[Convert.ToInt32(RC[0]),Convert.ToInt32(RC[1])];

            for (int i = 0; i < arr.GetLength(0); i++)
            {
                var RD = Console.ReadLine().Split(" ");
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    arr[i, j] = RD[j];

                }

            }

                for (int i = 0; i < arr.GetLength(0); i++)
                {
                    for (int j = 0; j < arr.GetLength(1); j++)
                    {
                    if (colors.Contains(arr[i, j]))
                    {
                        continue;
                    }
                    else
                    {
                        result = "#Color";
                        br = false;
                        break;
                    }
                    }
                    if (!br)
                    { break; }
                }

                Console.WriteLine(result);

        }
    }
}


using System;
using System.Text;
using System.IO;
using System.Globalization;
using System.Collections.Generic;
using System.Linq;

class App {
	static void Main() {
		var s = Console.ReadLine().TrimEnd("/");
		foreach (var i in Enumerable.Range(0, 100)) s = s.Replace("//", "/");
		if (s == "") s = "/";
		Console.WriteLine(s);
	}
}


using System;

public class Main
{
	public static void Main()
	{
		string inp = Console.ReadLine();

		while ( ( inp ) != null )
		{
			string [] split = inp.Split(new Char [] {'/'});

	        foreach (string s in split) {

	            if (s.Trim() != "")
	                Console.Write("/" + s);
	        }
	        inp = Console.ReadLine();

	        if( inp != null )
		        Console.WriteLine();
		}
	}
}


using System;
using System.Linq;

namespace B20
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(new char[] { '/' }).Where(val => val != "").ToArray();
            string output = "/" + string.Join('/', input);
            Console.WriteLine(output);
        }
    }
}


using System;
using System.Linq;

namespace B20
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(new char[] { '/' }).Where(val => val != "").ToArray();
            Console.WriteLine("/" + string.Join('/', input));
        }
    }
}


using System;

class Program
{
	static void Main(string[] args)
	{
		string w = Console.ReadLine();
		string []wtime = w.Split(':');
		string s = Console.ReadLine();
		string []stime = s.Split(':');
		int []ww = new int[2] {int.Parse(wtime[0]),int.Parse(wtime[1])};
		int []ss = new int[2] {int.Parse(stime[0]),int.Parse(stime[1])};
		//int []h = new int[2];
		if(0<=ww[0]&&0<=ss[0]&&ww[0]<=23&&ss[0]<=23 &&0<=ww[1]&&0<=ss[1]&&ww[1]<=59&&ss[1]<=59)
		{
			if(ww[1]<ss[1])
			{
				ww[1] += 60 - ss[1];
				ww[0]--;
			}
			else
				ww[1] -= ss[1];
			if(ww[0]<ss[0])
			{
				ww[0] += 24 - ss[0];
			}
			else
				ww [0] -= ss[0]
		}
		Console.WriteLine("{0:d2}:{1:d2}",ww[0],ww[1]);
	}
}


em;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace George_and_Sleep
{
    class Program
    {
        static void Main(string[] args)
        {
            var currentTime = DateTime.Parse(Console.ReadLine());
            var duration = DateTime.Parse(Console.ReadLine());

            var went2sleep = currentTime - duration;

            if (went2sleep.Hours < 0)
            {
                TimeSpan day = TimeSpan.FromHours(24);
                went2sleep = went2sleep.Add(day);
            }

            if (went2sleep.Hours == 0 && went2sleep.Minutes<0)
            {
                if (went2sleep.Minutes < 0)
                {
                    TimeSpan hour = TimeSpan.FromMinutes(60);
                    went2sleep.Add(hour);
                }
                TimeSpan hours = TimeSpan.FromHours(22);
                went2sleep = went2sleep.Add(hours);
            }

            Console.WriteLine(went2sleep.ToString().Substring(0,5));
        }
    }

}


var currentTime = DateTime.Parse(Console.ReadLine());
            var duration = DateTime.Parse(Console.ReadLine());

            var went2sleep = currentTime - duration;

            if (went2sleep.Hours < 0)
            {
                TimeSpan day = TimeSpan.FromHours(24);
                went2sleep = went2sleep.Add(day);
            }
            Console.WriteLine(went2sleep.Hours + ":" + went2sleep.Minutes);


using System;
using System.Collections.Generic;
using System.Text;
using System.Linq;
using System.Xml.Linq;
using System.IO;
using System.Net;

namespace Sharp
{
	class Program
	{
		static DateTime final;
		static bool Solve(Int32 d, Int32 m, Int32 y)
		{
			DateTime v;
			try
			{
				v = new DateTime(y, m, d);
			}
			catch { return false; }

			int dy = final.Year - y;

			if (dy > 18) return true;
			if (dy < 18) return false;
			if (final.Month > m) return true;
			if (final.Month < m) return false;
			if (final.Day > d) return true;
			if (final.Day < d) return false;
			return true;
		}

		static void Main(string[] args)
		{
			String s1, s2;
			s1 = Console.ReadLine();
			s2 = Console.ReadLine();
			string[] ss;
			int[] a;

			ss = s1.Split('.');
			a = new int[ss.Length];
			for (int i = 0; i < ss.Length; i++)
			{
				a[i] = Int32.Parse(ss[i]);
			}
			final = new DateTime(2000 + a[2], a[1], a[0]);

			ss = s2.Split('.');
			a = new int[ss.Length];
			for (int i = 0; i < ss.Length; i++)
			{
				a[i] = Int32.Parse(ss[i]);
			}

			int n = 3;
			for (int i = 0; i < n; i++)
			{
				for (int j = 0; j < n; j++)
				{
					for (int k = 0; k < n; k++)
					{
						if (i != j && i != k && j != k)
							if (Solve(a[i], a[j], 2000 + a[k]))
						{
							Console.WriteLine("YES");
							return;
						}
					}
				}
			}
			Console.WriteLine("NO");
		}

	}
}


using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Text.RegularExpressions;
using System.Globalization;

namespace CodeForcesApp
{
    class B
    {
        #region Shortcuts
        static string RL() { return Console.ReadLine(); }
        static string[] RSA() { return RL().Split(' '); }
        static int[] RIA() { return Array.ConvertAll<string, int>(RSA(), int.Parse); }
        static int RInt() { return int.Parse(RL()); }
        static long RLong() { return long.Parse(RL()); }
        static double RDouble() { return double.Parse(RL()); }
        static void RInts2(out int p1, out int p2) { int[] a = RIA(); p1 = a[0]; p2 = a[1]; }
        static void RInts3(out int p1, out int p2, out int p3) { int[] a = RIA(); p1 = a[0]; p2 = a[1]; p3 = a[2]; }

        static void Swap<T>(ref T a, ref T b) { T tmp = a; a = b; b = tmp; }
        static void Fill<T>(T[] d, T v) { for (int i = 0; i < d.Length; i++) d[i] = v; }
        static void Fill<T>(T[,] d, T v) { for (int i = 0; i < d.GetLength(0); i++) { for (int j = 0; j < d.GetLength(1); j++) { d[i, j] = v; } } }
        #endregion

        static void Main(string[] args)
        {
            System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;

            SolutionTester tester = new SolutionTester(CodeForcesTask.B);
            tester.Test();

            //Task task = new Task();
            //task.Solve();
        }

        public class Task
        {
            public void Solve()
            {
                string cd = RL();
                string bd = RL();

                string[] cd_dd = cd.Split('.');

                string format = "dd.MM.yyyy";

                DateTime cd_date = DateTime.ParseExact(string.Format("{0}.{1}.{2}", cd_dd[0], cd_dd[1], 2000 + int.Parse(cd_dd[2])), format, CultureInfo.InvariantCulture);

                int[] dd = Array.ConvertAll<string, int>(bd.Split('.'), int.Parse);

                int[] p = { 0, 1, 2 };

                do
                {
                    string nd = string.Format("{0}.{1}.{2}", dd[p[0]].ToString().PadLeft(2, '0'), dd[p[1]].ToString().PadLeft(2, '0'), 2000 + dd[p[2]]);

                    DateTime ddt;
                    if (DateTime.TryParseExact(nd, format, CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out ddt))
                    {
                        if (ddt.Year % 4 == 0 && ddt.Month == 2 && ddt.Day == 29)
                            ddt = new DateTime(ddt.Year, 3, 1);

                        if (ddt.AddYears(18) <= cd_date.AddMinutes(23 * 60 + 59))
                        {
                            Console.WriteLine("YES");
                            return;
                        }
                    }

                } while (GetNext(p));

                Console.WriteLine("NO");
            }

            public bool GetNext(int[] p)
            {
                int n = p.Length;
                int i = n - 2;
                while (i >= 0 && p[i] >= p[i + 1])
                    i--;
                if (i == -1)
                    return false;

                int k = i + 1;
                for (int j = i + 1; j < n; j++)
                    if (p[j] < p[k] && p[j] > p[i])
                        k = j;

                int t = p[i];
                p[i] = p[k];
                p[k] = t;

                for (int j = 0; j < (n - i - 1) / 2; j++)
                {
                    t = p[j + i + 1];
                    p[j + i + 1] = p[n - j - 1];
                    p[n - j - 1] = t;
                }

                return true;
            }
        }

    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ProgrammingContest.Codeforces.Round30
{
    class B
    {
        public static void Run()
        {
            int[] xs = Console.ReadLine().Split('.').Select(s => int.Parse(s)).ToArray();
            int[] ys = Console.ReadLine().Split('.').Select(s => int.Parse(s)).ToArray();

            DateTime match = new DateTime(xs[2] + 2000, xs[1], xs[0]);
            //if (xs[1] == 2 && xs[0] == 29) { xs[1] = 3; xs[0] = 1; }
            //DateTime lower = new DateTime(xs[2] + 2000-18, xs[1], xs[0]);
            bool ok = false;
            for(int i = 0; i < 3; i++)
                for(int j = 0; j < 3; j++)
                    for (int k = 0; k < 3; k++)
                    {
                        if (i == j || j == k || k == i) continue;
                        try
                        {
                            DateTime birth = new DateTime(2000 + ys[i], ys[j], ys[k]);
                            if (match >= birth.AddYears(18)) ok = true;
                        }
                        catch { }
                    }
            Console.WriteLine(ok ? "YES" : "NO");
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DoubleCola
{
    class Program
    {
        static void Main(string[] args)
        {
            Queue<string> friends = new Queue<string>();
            friends.Enqueue("Sheldon");
            friends.Enqueue("Leonard");
            friends.Enqueue("Penny");
            friends.Enqueue("Rajesh");
            friends.Enqueue("Howard");
            int num = Convert.ToInt32(Console.ReadLine());
            string tmp;
            while (num > friends.Count)
            {
                tmp= friends.Dequeue();
                friends.Enqueue(tmp);
                friends.Enqueue(tmp);
            }
            int count = friends.Count;
            for (int i = friends.Count; i > 0; i--)
            {
                if (i == count-num+1)
                {
                    Console.WriteLine(friends.Peek());
                    break;
                }
                else
                    friends.Dequeue();
            }
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Problems
{
    class _82A_DoubleCola
    {
        public static void main()
        {
            int N;
            String[] Row={"","Sheldon","Leonard","Penny","Rajesh","Howard"};
            while (N>5)
            {
                N = N / 2;
                N = N - 2;
            }
            Console.Write(Row[N]);

        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Problems
{
    class _82A_DoubleCola
    {
        public static void _82A()
        {
            int N, Mult=1;
            N = Console.Read();
            N = N - 48;
            String[] Row={"Sheldon","Leonard","Penny","Rajesh","Howard"};
            while (N>Mult*5)
            {
                N=N-Mult*5;
                Mult=Mult*2;
            }
            Console.Write(Row[(N-1)/Mult]);

        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;

namespace ConsoleApplication19
{
    class Program
    {
        static void Main()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            string slprh = "slprh";

            for (int i = 1; i < n; i++)
            {
                if(slprh[0]=='s')
                {
                    slprh=slprh.Remove(0, 1);
                    slprh += "ss";
                    continue;
                }
                if(slprh[0]=='l')
                {
                    slprh = slprh.Remove(0, 1);
                    slprh += "ll";
                    continue;
                }
                if(slprh[0]=='p')
                {
                    slprh = slprh.Remove(0, 1);
                    slprh += "pp";
                    continue;
                }
                if(slprh[0]=='r')
                {
                    slprh = slprh.Remove(0, 1);
                    slprh += "rr";
                    continue;
                }
                if(slprh[0]=='h')
                {
                    slprh = slprh.Remove(0, 1);
                    slprh += "hh";
                    continue;
                }
            }
            if(slprh[0]=='s')
                Console.WriteLine("Sheldon");
            if(slprh[0]=='l')
                Console.WriteLine("Leonard");
            if(slprh[0]=='p')
                Console.WriteLine("Penny");
            if(slprh[0]=='r')
                Console.WriteLine("Rajesh");
            if(slprh[0]=='h')
                Console.WriteLine("Howard");
            Console.ReadLine();

        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

    class main
    {
        public static void main(string[] args)
        {
            int N;
            String[] Row={"","Sheldon","Leonard","Penny","Rajesh","Howard"};
            while (N>5)
            {
                N = N / 2;
                N = N - 2;
            }
            Console.Write(Row[N]);

        }
    }


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DoubleCola
{
    class Program
    {
        static void Main(string[] args)
        {
            Queue<string> friends = new Queue<string>();
            friends.Enqueue("Sheldon");
            friends.Enqueue("Leonard");
            friends.Enqueue("Penny");
            friends.Enqueue("Rajesh");
            friends.Enqueue("Howard");
            int num = Convert.ToInt32(Console.ReadLine());
            string tmp;
            while (num > friends.Count)
            {
                tmp= friends.Dequeue();
                friends.Enqueue(tmp);
                friends.Enqueue(tmp);
            }
            Console.WriteLine(friends.ElementAt(num-1));
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Problems
{
    class _82A_DoubleCola
    {
        public static void main(string[] args)
        {
            int N;
            String[] Row={"","Sheldon","Leonard","Penny","Rajesh","Howard"};
            while (N>5)
            {
                N = N / 2;
                N = N - 2;
            }
            Console.Write(Row[N]);

        }
    }
}


Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "82A", "82A\82A.csproj", "{CDCA034B-677B-47B0-B087-DD16BBBC6EAB}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|x86 = Debug|x86
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{CDCA034B-677B-47B0-B087-DD16BBBC6EAB}.Debug|x86.ActiveCfg = Debug|x86
		{CDCA034B-677B-47B0-B087-DD16BBBC6EAB}.Debug|x86.Build.0 = Debug|x86
		{CDCA034B-677B-47B0-B087-DD16BBBC6EAB}.Release|x86.ActiveCfg = Release|x86
		{CDCA034B-677B-47B0-B087-DD16BBBC6EAB}.Release|x86.Build.0 = Release|x86
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal