using System;
using System.Collections.Generic;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Linq;
public class Source
{
    public void Program()
    {
    }
    int binaryl(int[] array, int c)
    {
        int left = 0;
        int right = array.Length - 1;
        while (left != right - 1)
        {
            int mid = (left + right) / 2;
            if (c > array[mid])
                left = mid;
            if (c <= array[mid])
                right = mid;
        }
        if (array[left] == c)
            return left;
        return -1;
    }
    int binaryr(int[] array, int c)
    {
        int left = 0;
        int right = array.Length - 1;
        while (left != right - 1)
        {
            int mid = (left + right) / 2;
            if (c >= array[mid])
                left = mid;
            if (c < array[mid])
                right = mid;
        }
        if (array[left] == c)
            return left;
        return -1;
    }
    void Read()
    {
        int x, n;
        int[] a;
        n = ri();
        x = ri();
        a = ReadIntArray();
        Array.Sort(a);
        int buf, num = 0;
        Dictionary<int, int> d = new Dictionary<int, int>();
        for (int i = 0; i < n; i++)
        {
            if (d.ContainsKey(a[i]))
                d[a[i]]++;
            else
                d.Add(a[i], 1);
        }
        for (int i = 0; i < n; i++)
        {
            buf = x ^ a[i];
            int id = Array.BinarySearch(a, buf);
            if (id < 0)
                continue;
            if (x != 0)
                num += d[a[id]];
            else
                num += d[a[id]] - 1;

        }
        writeLine(num/2);

    }

    #region hide it
    #region Main

    protected static TextReader reader;
    protected static TextWriter writer;
    static void Main()
    {
#if DEBUG
        reader = new StreamReader("..\\..\\input.txt");
        //reader = new StreamReader(Console.OpenStandardInput());
        writer = Console.Out;
        //writer = new StreamWriter("..\\..\\output.txt");
#else
            reader = new StreamReader(Console.OpenStandardInput());
            writer = new StreamWriter(Console.OpenStandardOutput());
            //reader = new StreamReader("input.txt");
            //writer = new StreamWriter("output.txt");
#endif
        var source = new Source();
        source.Read();
        source.Program();

        /* try
         {
             new Source().Program();
         }
         catch (Exception ex)
         {
 #if DEBUG
             Console.WriteLine(ex);
 #else
             throw;
 #endif
         }*/
        reader.Close();
        writer.Close();
    }

    #endregion

    #region Read / Write
    private static Queue<string> currentLineTokens = new Queue<string>();
    private static string[] ReadAndSplitLine() { return reader.ReadLine().Split(new[] { ' ', '\t', }, StringSplitOptions.RemoveEmptyEntries); }
    public static string ReadToken()
    {
        while (currentLineTokens.Count == 0)
            currentLineTokens = new Queue<string>(ReadAndSplitLine());
        return currentLineTokens.Dequeue();
    }
    public static int ri() { return int.Parse(ReadToken()); }
    public static char ReadChar() { return char.Parse(ReadToken()); }
    public static long ReadLong() { return long.Parse(ReadToken()); }
    public static ulong ReaduLong() { return ulong.Parse(ReadToken()); }
    public static double ReadDouble() { return double.Parse(ReadToken(), CultureInfo.InvariantCulture); }
    public static int[] ReadIntArray() { return ReadAndSplitLine().Select(i => int.Parse(i)).ToArray(); }
    public static char[] ReadCharArray() { return ReadAndSplitLine().Select(i => char.Parse(i)).ToArray(); }
    public static long[] ReadLongArray() { return ReadAndSplitLine().Select(i => long.Parse(i)).ToArray(); }
    public static double[] ReadDoubleArray() { return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray(); }
    public static int[][] ReadIntMatrix(int numberOfRows) { int[][] matrix = new int[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = ReadIntArray(); return matrix; }
    public static char[][] ReadCharMatrix(int numberOfRows) { char[][] matrix = new char[numberOfRows][]; for (int i = 0; i < numberOfRows; i++) matrix[i] = ReadCharArray(); return matrix; }
    public static int[][] ReadAndTransposeIntMatrix(int numberOfRows)
    {
        int[][] matrix = ReadIntMatrix(numberOfRows); int[][] ret = new int[matrix[0].Length][];
        for (int i = 0; i < ret.Length; i++) { ret[i] = new int[numberOfRows]; for (int j = 0; j < numberOfRows; j++) ret[i][j] = matrix[j][i]; }
        return ret;
    }
    public static string[] ReadLines(int quantity) { string[] lines = new string[quantity]; for (int i = 0; i < quantity; i++) lines[i] = reader.ReadLine().Trim(); return lines; }
    public static void write<T>(T value) { writer.Write(value); }
    public static void writeLine<T>(T value) { writer.WriteLine(value); }
    public static void writeArray<T>(T[] array, string split) { for (int i = 0; i < array.Length; i++) { write(array[i] + split); } }
    public static void writeMatrix<T>(T[][] matrix, string split) { for (int i = 0; i < matrix.Length; i++) { writeArray(matrix[i], split); writer.Write("\n"); } }
    private class SDictionary<TKey, TValue> : Dictionary<TKey, TValue>
    {
        public new TValue this[TKey key]
        {
            get { return ContainsKey(key) ? base[key] : default(TValue); }
            set { base[key] = value; }
        }
    }
    private static T[] Init<T>(int size) where T : new() { var ret = new T[size]; for (int i = 0; i < size; i++) ret[i] = new T(); return ret; }
    #endregion

    #region Methods
    #region DSU
    public void MakeSet(int[] poi)
    {
        for (int i = 0; i < poi.Length; i++)
        {
            poi[i] = i;
        }
    }
    public int Find(int x, int[] poi)
    {
        if (poi[x] == x) return x;
        return poi[x] = Find(poi[x], poi);
    }
    Random rand = new Random();
    public void Unite(int x, int y, int[] poi)
    {
        y = Find(y, poi);
        x = Find(x, poi);
        if (rand.Next() % 2 == 0)
            Swap(ref x, ref y);
        poi[x] = y;
    }
    #endregion

    class Deque<T>
    {
        T[] array;
        int start, length;
        public Deque()
        {
            start = 0; length = 0; array = new T[1];
        }
        public T this[int index] { get { return array[(start + index) % array.Length]; } set { array[(start + index) % array.Length] = value; } }
        int last { get { return (start + length) % array.Length; } }
        /// <summary>
        /// ÃÆÃ¢â¬ËÃâÃÂÃÆÃ¢â¬ËÃÂ¢Ã¢âÂ¬Ã
        /// </summary>
        public T PeekFirst()
        {
            return array[start];
        }
        public int Count { get { return length; } }
        /// <summary>
        /// ÃÆÃÂÃâÃÂºÃÆÃÂÃâÃÂ¾ÃÆÃÂÃâÃÂ½ÃÆÃÂÃâÃÂµÃÆÃ¢â¬ËÃÂ¢Ã¢âÂ¬  ÃÆÃÂÃâÃÂ±ÃÆÃÂÃâÃÂµÃÆÃÂÃâÃÂ· ÃÆÃ¢â¬ËÃâ Ã¢â¬â¢ÃÆÃÂÃâÃÂ´ÃÆÃÂÃâÃÂ°ÃÆÃÂÃâÃÂ»ÃÆÃÂÃâÃÂµÃÆÃÂÃâÃÂ½ÃÆÃÂÃâÃÂ¸ÃÆÃ¢â¬ËÃâÃÂ
        /// </summary>
        public T PeekLsat()
        {
            return array[last];
        }
        public T PopLast()
        {
            if (length == 0)
                throw new IndexOutOfRangeException("OutOfRange");
            length--;
            return array[last];
        }
        public T PopFirst()
        {
            if (length == 0)
                throw new IndexOutOfRangeException("OutOfRange");
            length--;
            if (start >= array.Length - 1) start = 0; else start++;
            return array[start - 1 < 0 ? array.Length - 1 : start - 1];
        }
        public void AddFirst(T value)
        {
            IncreaseAndInspection();
            if (start <= 0) start = array.Length - 1; else start--;
            array[start] = value;
            length++;
        }
        public void AddLast(T value)
        {
            IncreaseAndInspection();
            array[last] = value;
            length++;
        }
        bool overflow { get { return length == array.Length; } }
        void IncreaseAndInspection()
        {
            if (overflow)
                increase();

        }
        void increase()
        {
            T[] array2 = new T[array.Length * 2];
            for (int i = 0; i < array.Length; i++)
            {
                int pos = (start + i) % array.Length;
                array2[i] = array[pos];
            }
            array = array2;
            start = 0;
            array2 = null;
        }
        public void Clear()
        {
            start = 0; length = 0; array = new T[1];
        }
    }
    class Heap<T>
    {
        Comparison<T> ic;
        List<T> storage = new List<T>();
        public Heap(Comparison<T> ic)
        {
            this.ic = ic;
        }
        public void Add(T element)
        {
            storage.Add(element);
            int pos = storage.Count - 1;
            while (pos != 0 && ic(storage[((int)(pos - 1) >> 1)], element) > 0)
            {
                Swap(storage, pos, ((int)(pos - 1) / 2));
                pos = ((int)(pos - 1) / 2);
            }
        }
        public T Pop()
        {
            T t = storage[0];
            Swap(storage, 0, storage.Count - 1);
            int pos = 0;
            storage.RemoveAt(storage.Count - 1);
            if (Count > 0)
                while (true)
                {
                    T my = storage[pos];
                    if (pos * 2 + 1 >= Count)
                        break;
                    T left = storage[pos * 2 + 1];
                    if (pos * 2 + 2 >= Count)
                    {
                        if (ic(left, my) < 0)
                        {
                            Swap(storage, pos, pos * 2 + 1);
                            pos = pos * 2 + 1;
                        }
                        break;
                    }
                    T right = storage[pos * 2 + 2];
                    if (ic(left, my) < 0 || ic(right, my) < 0)
                    {
                        if (ic(left, right) < 0)
                        {
                            Swap(storage, pos, pos * 2 + 1);
                            pos = pos * 2 + 1;
                        }
                        else
                        {

                            Swap(storage, pos, pos * 2 + 2);
                            pos = pos * 2 + 2;
                        }
                    }
                    else break;
                }
            return t;
        }

        public void Clear()
        {
            storage.Clear();
        }
        /// <summary>
        /// ÃÆÃÂÃâÃÂ±ÃÆÃÂÃâÃÂµÃÆÃÂÃâÃÂ· ÃÆÃ¢â¬ËÃâ Ã¢â¬â¢ÃÆÃÂÃâÃÂ´ÃÆÃÂÃâÃÂ°ÃÆÃÂÃâÃÂ»ÃÆÃÂÃâÃÂµÃÆÃÂÃâÃÂ½ÃÆÃÂÃâÃÂ¸ÃÆÃ¢â¬ËÃâÃÂ
        /// </summary>
        /// <returns></returns>
        public T Peek()
        {
            return storage[0];
        }
        public int Count
        {
            get { return storage.Count; }
        }
        //void RemoveLast, Size, peeklast, add
    }
    static void Swap<T>(ref T lhs, ref T rhs)
    {
        T temp;
        temp = lhs;
        lhs = rhs;
        rhs = temp;
    }
    static void Swap<T>(T[] a, int l, int r)
    {
        T temp;
        temp = a[l];
        a[l] = a[r];
        a[r] = temp;
    }
    static void Swap<T>(List<T> a, int l, int r)
    {
        T temp;
        temp = a[l];
        a[l] = a[r];
        a[r] = temp;
    }

    bool outregion(long y, long x, long n, long m)
    {
        if (x < 0 || x >= m || y < 0 || y >= n)
            return true;
        return false;
    }
    static void initlist<T>(ref List<T>[] list, int n)
    {
        list = new List<T>[n];
        for (int i = 0; i < n; i++)
            list[i] = new List<T>();
    }
    static void newarray<T>(ref T[][] array, int n, int m)
    {
        array = new T[n][];
        for (int i = 0; i < n; i++)
            array[i] = new T[m];
    }
    static void newarray<T>(ref T[] array, int n)
    {
        array = new T[n];
    }
    static void fill<T>(T[] array, T value)
    {
        for (int i = 0; i < array.Length; i++)
            array[i] = value;
    }
    static void fill<T>(T[][] array, T value)
    {
        for (int i = 0; i < array.Length; i++)
            for (int j = 0; j < array[i].Length; j++)
                array[i][j] = value;
    }
    public bool NextPermutation<T>(T[] b, Comparison<T> ic)
    {
        for (int j = b.Length - 2; j >= 0; j--)
        {
            if (ic(b[j], b[j + 1]) < 0)
            {
                for (int l = b.Length - 1; l >= 0; l--)
                {
                    if (ic(b[l], b[j]) > 0)
                    {
                        Swap(b, j, l);
                        Array.Reverse(b, j + 1, b.Length - (j + 1));
                        return true;
                    }
                }
            }
        }
        return false;
    }
    int[,] step8 = new int[,]
    {
        {-1,0 },
        {1,0 },
        {0,-1 },
        {0,1 },
        {1,1 },
        {-1,1 },
        {-1,-1 },
        {1,-1 },
    };
    int[,] step4 = new int[,]
    {
        {-1,0 },
        {1,0 },
        {0,-1 },
        {0,1 },
    };
    struct Vector2
    {
        public double x;
        public double y;
        public Vector2(double x, double y)
        {
            this.x = x;
            this.y = y;
        }
        public double Dist(Vector2 to)
        {
            return Math.Sqrt(Math.Abs(Math.Pow(to.x - x, 2)) + Math.Abs(Math.Pow(to.y - y, 2)));
        }
        public static bool operator ==(Vector2 left, Vector2 right) { return left.x == right.x && left.y == right.y; }
        public static bool operator !=(Vector2 left, Vector2 right) { return left.x != right.x || left.y != right.y; }
    }
    #endregion
    #endregion

}
close


using System;

namespace NetCore3
{
    public class Test
    {
        public static void Main(string[] args)
        {
            var input = long.Parse(Console.ReadLine());
            var baseNumber = 8;

            for (int i = 1; i <= input; i++)
            {
                baseNumber = Math.Pow(baseNumber, i).ToString().Reverse()[0] - '0';
            }

            Console.WriteLine(baseNumber);
        }
    }
}


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

namespace _742A
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] dig = { 6,8, 4, 2 };
            int n = Convert.ToInt32(Console.ReadLine());
            if (n > 0)
                Console.WriteLine(dig[n % 4]);
            else
                Console.WrilteLine("1");
        }
    }
}


using System;

namespace Application {
	class A {
		public static void Main(string[] args) {
			const int[] ds = {6, 8, 4, 2};
			int n = Convert.ToInt32(Console.ReadLine());
			Console.WriteLine((n == 0) ? 1 : ds[n%4]);
		}
	}
}


using System;
namespace Firstone
{
    class numbers
    {
        static void Main(string[] args)
        {
            long n;
            n=Convert.ToLong(Console.ReadLine());
            if(n%4==0)
            {
                int b=6;
                Console.Writeline("{0}",b);
            }
            else if(n%4==1)
            {
                int b=2;
                 Console.Writeline("{0}",b);
            }
            else if(n%4==2)
            {
                int b=4;
                Console.WriteLine("{0}",b);
            }
            else if(n%4==3)
            {
                int b=8;
                Console.WriteLine("{0}",b);
            }
        }

    }
}


<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>

</Project>


<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="12.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>{14D04B80-8C2F-4301-81FB-42F6718F3147}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>A.Bear_and_Big_Brother</RootNamespace>
    <AssemblyName>A.Bear_and_Big_Brother</AssemblyName>
    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
  </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.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>


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.30002.166
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BearAndBigBrother", "BearAndBigBrother.csproj", "{5B8D6E73-B63D-44C5-B1D5-E5944C000643}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{5B8D6E73-B63D-44C5-B1D5-E5944C000643}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{5B8D6E73-B63D-44C5-B1D5-E5944C000643}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{5B8D6E73-B63D-44C5-B1D5-E5944C000643}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{5B8D6E73-B63D-44C5-B1D5-E5944C000643}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {BD32D4C4-72AE-4B8C-86A5-B703692BBA61}
	EndGlobalSection
EndGlobal


using System;
using System.Linq;

namespace ConsoleApplication
{
    sealed class Program
    {
        static void Main(string[] args)
        {
            BigInteger ba = 5;
            var d = Console.ReadLine().Split().Select(Int32.Parse).ToArray();
            int a = d[0], b = d[1], result = 0;
            while (a <= b)
            {
                a *= 3;
                b *= 2;
                result++;
            }
            Console.WriteLine(result);
        }
    }
}


using System;
using System.Linq;

public class BearQuestion{
    static void Main(string[] args){
        Bear();
    }

    static void Bear(){
        int[] args = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        int a = args[0];
        int b = args[1];
        int years = 0;

        while(a <= b){
            years++;
            a *= 3;
            b *= 2;
        }
        return years

    }
}


using System;
using System.Linq;

public class BearQuestion{
    static void Main(string[] args){
        Bear();
    }

    static void Bear(){
        string[] args = Console.ReadLine.Split(' ');
        int a = int.Parse(args[0]);
        int b = int.Parse(args[1]);
        int years = 0;

        while(a <= b){
            years++;
            a *= 3;
            b *= 2;
        }
        Console.WriteLine(years);
    }
}


public int Getresult(int a,int b)
{
    try{

    for(int i=0;i<100;i++)
    {

        a=a*3;
        b=b*3;
        if(a>b)
        {
            return i+1;
        }
    }

    }
    catch(Exception ex)
    {
    Console.WriteLine("invalid input");
    }
}


using System;

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string line = Console.ReadLine();
            int age = 0;
            string[] bears = line.Split(" ");
            int limak = Int32.Parse(bears[0]);
            int bob = Int32.Parse(bears[1]);

            while (limak <= bob)
            {
                limak = limak * 3;
                bob = bob * 2;
                age++;
            }
            Console.WriteLine(age);
        }
    }
}


using System;

{
    class BearAndBigBrother
    {
        public static void Main(String[] args)
        {
            int c = 0;

            string[] t = Console.ReadLine().Split();

            int l = int.Parse(t[0]);

            int b = int.Parse(t[1]);

            while (l<=b)

            {
               l*=3;
               b*=2;

                c++;

            }

            Console.WriteLine(c);

        }
    }
}


using System;

public class program
{
public static void main()
{
    try{

    int a,b;
var input=Console.ReadLine().Split(' ');

a=Convert.ToInt32(input[0]);
b=Convert.ToInt32(input[1]);

    for(int i=0;i<100;i++)
    {

        a=a*3;
        b=b*3;
        if(a>b)
        {
            return i+1;
        }
    }

    }
    catch(Exception ex)
    {
    Console.WriteLine("invalid input");
    }
}
}


using System;

namespace Application {
	class Program {
		static void Main(string[] args) {
			string[] tokens = Console.ReadLine().Split();
			int a = int.Parse(tokens[0]);
			int b = int.Parse(tokens[1]);
			int t;
			while (a <= b) {
				a *= 3;
				b *= 2;
				++t;
			}
			Console.WriteLine(t);
		}
	}
}


        using System;
        static void Main(string[] args)
        {
            int cant = 0;
            int Limak = int.Parse(Console.ReadLine());
            int Bob = int.Parse(Console.ReadLine());

            if (Limak <= Bob)
            {
                while (Limak <= Bob)
                {
                    Limak *= 3;
                    Bob *= 2;
                    cant++;
                }
            }

            Console.WriteLine(cant);
        }


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.40629.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "A. Bear and Big Brother", "A. Bear and Big Brother\A. Bear and Big Brother.csproj", "{14D04B80-8C2F-4301-81FB-42F6718F3147}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{14D04B80-8C2F-4301-81FB-42F6718F3147}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{14D04B80-8C2F-4301-81FB-42F6718F3147}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{14D04B80-8C2F-4301-81FB-42F6718F3147}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{14D04B80-8C2F-4301-81FB-42F6718F3147}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal


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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            List<string> d = s.Split(' ');
            int p1 = int.Parce(d[0]);
            int p2 = int.Parce(d[1]);
            int i=0;
            while (p1<p2)
            {
               p1=p1*3;
               p2=p2*2;
               i++;
            }

            Console.Write(i);

        }
    }
}


using System;

namespace Problems
{
    class Program
    {
        static void Main(string[] args)
        {
            var input = Array.ConvertAll(Console.ReadLine().Split(" "), int.Parse);

            int result = 0;

            while(true)
            {
                result++;
                input[0] *= 3;
                input[1] *= 2;
                if (input[0] > input[1]) break;
            }

            Console.WriteLine(result);

        }
    }
}


using System;
using System.Collections.Generic;

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            int n=0, k =0;
            var x = Console.ReadLine();
            string[] split = x.Split(" ");
            n = Convert.ToInt32(split[0]);
            k = Convert.ToInt32(split[1]);
            int result = 1;
            while (true)
            {
                n *= 3;
                k *= 2;
                if (n > k)
                {
                    break;
                }
                result++;
            }
            //for(int i =0; i < k; i++)
            //{
            //    if(n % 10 == 0)
            //    {
            //        n /= 10;
            //    }
            //    else
            //    {
            //        n--;
            //    }
            //}
            Console.WriteLine(result);
        }
    }

}


 using System;
using System.Collections.Generic;
class Program
    {
        static void main{string[] bearsWeightsStrings = Console.ReadLine().Split(' ');
            Dictionary<string, int> bearsWeightsDictionary = new Dictionary<string, int>()
            {
                {"Limak",int.Parse(bearsWeightsStrings[0])},
                {"Bob",int.Parse(bearsWeightsStrings[1])},
            };
            int years = 0;

            while (bearsWeightsDictionary["Limak"] < bearsWeightsDictionary["Bob"])
            {
                bearsWeightsDictionary["Limak"] *= 3;
                years++;
            }

            Console.WriteLine(years);
 }}


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 14
VisualStudioVersion = 14.0.25420.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleApplication2", "ConsoleApplication2\ConsoleApplication2.csproj", "{50C91602-CE29-45B0-9CA8-A82348FCC712}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{50C91602-CE29-45B0-9CA8-A82348FCC712}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{50C91602-CE29-45B0-9CA8-A82348FCC712}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{50C91602-CE29-45B0-9CA8-A82348FCC712}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{50C91602-CE29-45B0-9CA8-A82348FCC712}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.40629.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Bear and Big Brother", "Bear and Big Brother\Bear and Big Brother.csproj", "{706791FC-FC8E-4EF9-9FB1-B10BEAABEF12}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{706791FC-FC8E-4EF9-9FB1-B10BEAABEF12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{706791FC-FC8E-4EF9-9FB1-B10BEAABEF12}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{706791FC-FC8E-4EF9-9FB1-B10BEAABEF12}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{706791FC-FC8E-4EF9-9FB1-B10BEAABEF12}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal


using System;

public class Test
{

	public static int maxStep = 5;

	public static void Main()
	{
		string[] input = Console.ReadLine().Split(' ');

		int a = int.Parse(input[0]);
		int b = int.Parse(input[1]));

		int years = 0;

		while(a <= b){
			a *= 3;
			b *= 2;

			years++;
		}

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


using System;

public static void main()
{
    try{

    int a,b;
var input=Console.ReadLine().Split(' ');

a=var[0];
b=var[1];

    for(int i=0;i<100;i++)
    {

        a=a*3;
        b=b*3;
        if(a>b)
        {
            return i+1;
        }
    }

    }
    catch(Exception ex)
    {
    Console.WriteLine("invalid input");
    }
}


using System;
using System.Linq;

public class BearQuestion{
    static void Main(string[] args){
        Bear();
    }

    static void Bear(){
        int[] args = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        int a = args[0];
        int b = args[1];
        int years = 0;

        while(a <= b){
            years++;
            a *= 3;
            b *= 2;
        }
        return years;
    }
}


using System;

namespace TasksCodeForce
{
   public static class _791ATeddyBearAndBigBrother
    {
        //done
        public static void Method()
        {
            string[] weight = Console.ReadLine().Split();

            float weightLimak = float.Parse(weight[0]);//float.Parse(Console.ReadLine());
            float weightBob = float.Parse(weight[1]);

            int year = 0;

            do
            {
                year++;
                weightLimak *= 3;
                weightBob *= 2;

            } while (weightLimak <= weightBob);

            Console.WriteLine(year);
            Console.ReadKey();

        }
    }
}


using System;

public class program
{
public static void main()
{
    try{

    int a,b;
int[] input=Console.ReadLine().Split(' ');

a=input[0];
b=input[1];

    for(int i=0;i<100;i++)
    {

        a=a*3;
        b=b*3;
        if(a>b)
        {
            return i+1;
        }
    }

    }
    catch(Exception ex)
    {
    Console.WriteLine("invalid input");
    }
}
}


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

namespace ProblemSolving
{
    class Program
    {

           #region BearAndHisBrother

            int YearCount = 0;
            string[] Weights = Console.ReadLine().Split(' ');
            List<int> Weights_ = new List<int>();
            Weights_.Add(int.Parse(Weights[0]));
            Weights_.Add(int.Parse(Weights[1]));

            while (Weights_[0]<= Weights_[1])
            {
                Weights_[0] = Weights_[0] * 3;
                Weights_[1] = Weights_[1] * 2;
                if(Weights_[0] < Weights_[1])
                {
                    YearCount++;

                }
                else if (Weights_[0] > Weights_[1])
                {
                    Console.WriteLine(YearCount + 1);

                }
                else
                {
                    YearCount++;
                }
            }

           #endregion

       }

    }
}


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

public static class Program
{
        public static void Main()
        {
            var input = GetIntegerInputsFromLine();
            int limak = input[0];
            int bob = input[1];
            Console.Writeline(Bear(limak, bob));
        }
        public static int Bear(int limak, int bob)
        {
            if (limak > bob)
            {
                return 0;
            }
            else
            {
                return 1 + (Bear(limak * 3, bob * 2));
            }
        }

        static List<int> GetIntegerInputsFromLine()
        {
            var inputs = Console.ReadLine().Split(' ').Select(x => Convert.ToInt32(x.Trim())).ToList();
            return inputs;
        }
}


class Program
    {
        static void Main(string[] args)
        {
            int cant = 0;
            double Limak = Double.Parse(Console.ReadLine());
            double Bob = Double.Parse(Console.ReadLine());

            if (Limak <= Bob)
            {
                while (Limak <= Bob)
                {
                    Limak *= 3;
                    Bob *= 2;
                    cant++;
                }
            }

            Console.WriteLine(cant);

        }


static void Main(string[] args)
        {
            int a, b, yr = 0;
            string[] scanf = Console.ReadLine().Split();
            a = int.Parse(scanf[0]);
            b = int.Parse(scanf[1]);
            if (a >= 1 && a <= b && b <= 10)
            {
                while (a <= b)
                {
                    a = a * 3;
                    b = b * 2;
                    yr++;
                }
                Console.WriteLine(yr);
            }
            else
            {
                Console.WriteLine("wrong inputs");
            }
            Console.ReadKey();
        }


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

public static class Program()
{
        public static int Main(string[] args)
        {
            var input = GetIntegerInputsFromLine();
            int limak = input[0];
            int bob = input[1];
            return Bear(limak, bob);
        }
        public static int Bear(int limak, int bob)
        {
            if (limak > bob)
            {
                return 0;
            }
            else
            {
                return 1 + (Bear(limak * 3, bob * 2));
            }
        }

        static List<int> GetIntegerInputsFromLine()
        {
            var inputs = Console.ReadLine().Split(' ').Select(x => Convert.ToInt32(x.Trim())).ToList();
            return inputs;
        }
}


<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup>
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />
    </startup>
</configuration>


using System;

public class program
{
public static void main()
{
    try{

    int a,b;
var input=Console.ReadLine().Split(' ');

a=var[0];
b=var[1];

    for(int i=0;i<100;i++)
    {

        a=a*3;
        b=b*3;
        if(a>b)
        {
            return i+1;
        }
    }

    }
    catch(Exception ex)
    {
    Console.WriteLine("invalid input");
    }
}
}


using System;

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string line = Console.ReadLine();
            var age = 0;
            var bears = line.Split(" ");
            var limak = Int64.Parse(bears[0]);
            var bob = Int64.Parse(bears[1]);

            while (limak <= bob)
            {
                limak = limak * 3;
                bob = bob * 2;
                age++;
            }
            Console.WriteLine(age);
        }
    }
}


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

public static class Program()
{
        public static void Main()
        {
            var input = GetIntegerInputsFromLine();
            int limak = input[0];
            int bob = input[1];
            return Bear(limak, bob);
        }
        public static int Bear(int limak, int bob)
        {
            if (limak > bob)
            {
                return 0;
            }
            else
            {
                return 1 + (Bear(limak * 3, bob * 2));
            }
        }

        static List<int> GetIntegerInputsFromLine()
        {
            var inputs = Console.ReadLine().Split(' ').Select(x => Convert.ToInt32(x.Trim())).ToList();
            return inputs;
        }
}


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

namespace Bear_and_Big_Brother
{
    class Program
    {
        static void Main(string[] args)
        {
            int l = Int32.Parse(Console.Read());
            int b= Int32.Parse(Console.Read());
            int count=0;
            while (l <= b)
            {
                l = 3 * l;
                b=2*b;
                count++;
            }
            Console.WriteLine(count);
        }
    }
}


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

public static class Program
{
        public static void Main()
        {
            var input = GetIntegerInputsFromLine();
            int limak = input[0];
            int bob = input[1];
            return Bear(limak, bob);
        }
        public static int Bear(int limak, int bob)
        {
            if (limak > bob)
            {
                return 0;
            }
            else
            {
                return 1 + (Bear(limak * 3, bob * 2));
            }
        }

        static List<int> GetIntegerInputsFromLine()
        {
            var inputs = Console.ReadLine().Split(' ').Select(x => Convert.ToInt32(x.Trim())).ToList();
            return inputs;
        }
}


using System;
namespace ConsoleApplication1{
 class Program {
static void Main (string[] args)
{
A();
}
static void B(){
string x= Console ReadLine();
 y = Console. ReadLine();
for (int i= 0;i< x. Length; i++)
if (y[i]> x[i]) Console. Write Line (-1); Console.WriteLine(y);
 static void A(){ var line= Console.ReadLine().ToCharArray();
 int count= GetCount(line);
for (int i =0; i< line.Length; i++)
 {line[i]=(char)( 'V'+'K'- line[i]);
 count = Math.Max(count, GetCount(line));
line[i]=(char)( 'V'+'K'- line[i]);
}
Console.WriteLine(count);
}
static int GetCount(char[] s)
{ int count=0;
 for (int i =1; i < s.Length; i++)
 if (s[i] =='K' && s[i-1]== 'V') count++ ;
return count;
}}}


using System;
namespace ConsoleApplication1{
 class Program {
static void Main (string[] args)
{
A();
}
static void B(){
string x= Console.ReadLine();
 y = Console. ReadLine();
for (int i= 0;i< x. Length; i++)
if (y[i]> x[i]) Console.WriteLine(-1); Console.WriteLine(y);
 static void A(){ var line= Console.ReadLine().ToCharArray();
 int count= GetCount(line);
for (int i =0; i< line.Length; i++)
 {line[i]=(char)( 'V'+'K'- line[i]);
 count = Math.Max(count, GetCount(line));
line[i]=(char)( 'V'+'K'- line[i]);
}
Console.WriteLine(count);
}
static int GetCount(char[] s)
{ int count=0;
 for (int i =1; i < s.Length; i++)
 if (s[i] =='K' && s[i-1]== 'V') count++ ;
return count;
}}}


using System;
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write(int.Parse(Console.ReadLine()) % 2 == 0?"Mahmoud": "Ehab");
        }
    }
}


using System;
using System.IO;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.Threading;
using System.Diagnostics;
using System.Linq;

#region testlib
public delegate ReadDelegate<T> ReadDelegate<T>(out T value);
public delegate bool ParserDelegate<T>(string word, out T item);

public class Input : IDisposable
{
    private static EventArgs DefaultEventArgs = new EventArgs();

    public TextReader TextReader { get; private set; }

    public event EventHandler OnEndOfStream;
    public event EventHandler OnParseError;
    public event EventHandler OnReadError;

    public bool CanRead { get; private set; }
    public bool ThrowExceptions { get; set; }

    string line = string.Empty;
    int pos = 0;

    static EventHandler emptyHandler;

    public Input(string path)
        : this(File.OpenRead(path))
    {
    }
    public Input(Stream s)
        : this(new StreamReader(s))
    {

    }
    public Input(TextReader tr)
    {
        TextReader = tr;

        if (emptyHandler == null)
            emptyHandler = (a, b) => { };

        OnEndOfStream = emptyHandler;
        OnParseError = emptyHandler;
        OnReadError = emptyHandler;

        CanRead = true;
    }

    public static implicit operator Input(Stream s)
    {
        return new Input(s);
    }
    public static implicit operator Input(TextReader tr)
    {
        return new Input(tr);
    }

    private bool ReadStream()
    {
        if (!CanRead) return false;
        if (pos < line.Length) return true;

        Clear();

        string s = TextReader.ReadLine();
        if (s == null)
        {
            CanRead = false;
            return false;
        }

        line = s;
        return true;
    }

    public ReadDelegate<T> r<T>(out T value)
    {
        value = ReadData<T>();
        return r;
    }

    public void SkipChar()
    {
        if (pos < line.Length) pos++;
        else
        {
            ReadStream();
        }
    }
    public void SkipChars(int length)
    {
        while (length > 0)
        {
            int dt = line.Length - pos;
            if (dt <= 0)
            {
                length--;
                if (!ReadStream()) return;
            }
            dt = Math.Min(length, dt);
            pos += dt;
            length -= dt;
        }
    }

    public void SkipWhiteSpace()
    {
        while (true)
        {
            for (; pos < line.Length; pos++)
            {
                if (!char.IsWhiteSpace(line[pos])) return;
            }
            if (!ReadStream())
            {
                OnEndOfStream(this, DefaultEventArgs);
                return;
            }
        }
    }
    public bool CanReadData()
    {
        SkipWhiteSpace();
        return CanRead;
    }

    public T[] ReadArray<T>()
    {
        int length = ReadInt32();
        return ReadArray<T>(length);
    }
    public T[] ReadArray<T>(int length)
    {
        ParserDelegate<T> parser = Parser.GetPrimitiveParser<T>();
        return ReadArray<T>(length, parser);
    }
    public T[] ReadArray<T>(ParserDelegate<T> parser)
    {
        int length = ReadInt32();
        return ReadArray<T>(length, parser);
    }
    public T[] ReadArray<T>(int length, ParserDelegate<T> parser)
    {
        T[] res = new T[length];
        for (int i = 0; i < length; i++)
        {
            res[i] = ReadData<T>(parser);
        }
        return res;
    }

    public Decimal ReadDecimal()
    {
        return ReadData<Decimal>(Parser.DecimalParser);
    }
    public Double ReadDouble()
    {
        return ReadData<Double>(Parser.DoubleParser);
    }
    public Single ReadSingle()
    {
        return ReadData<Single>(Parser.SingleParser);
    }
    public UInt64 ReadUInt64()
    {
        return ReadData<UInt64>(UInt64.TryParse);
    }
    public UInt32 ReadUInt32()
    {
        return ReadData<UInt32>(UInt32.TryParse);
    }
    public UInt16 ReadUInt16()
    {
        return ReadData<UInt16>(UInt16.TryParse);
    }
    public Int64 ReadInt64()
    {
        return ReadData<Int64>(Int64.TryParse);
    }
    public Int32 ReadInt32()
    {
        return ReadData<Int32>(Int32.TryParse);
    }
    public Int16 ReadInt16()
    {
        return ReadData<Int16>(Int16.TryParse);
    }
    public Boolean ReadYesNo()
    {
        return ReadData<Boolean>(Parser.YesNoParser);
    }
    public Boolean ReadBoolean()
    {
        return ReadData<Boolean>(Boolean.TryParse);
    }
    public Byte ReadByte()
    {
        return ReadData<Byte>(Byte.TryParse);
    }

    private bool ReadCheck()
    {
        if (!CanRead)
        {
            OnReadError(this, DefaultEventArgs);
            if (ThrowExceptions)
            {
                throw new Exception("!CanRead");
            }
            return false;
        }
        return true;
    }
    public T ReadData<T>()
    {
        return ReadData<T>(true);
    }
    public T ReadData<T>(bool skipWhiteSpace)
    {
        ParserDelegate<T> parser = Parser.GetPrimitiveParser<T>();
        return ReadData<T>(parser, skipWhiteSpace);
    }
    public T ReadData<T>(ParserDelegate<T> parser)
    {
        return ReadData<T>(parser, true);
    }
    public T ReadData<T>(ParserDelegate<T> parser, bool skipWhiteSpace)
    {
        if (skipWhiteSpace)
            SkipWhiteSpace();

        if (!ReadCheck()) return default(T);

        string s = ReadWord(false);

        T res;
        if (!parser.Invoke(s, out res))
        {
            OnParseError(this, DefaultEventArgs);
            if (ThrowExceptions)
            {
                throw new Exception("!validate, word = " + Output.ToString(s, 256));
            }
        }
        return res;
    }

    public string ReadWord()
    {
        return ReadWord(true);
    }
    public string ReadWord(bool skipWhiteSpace)
    {
        if (skipWhiteSpace)
            SkipWhiteSpace();

        if (!ReadCheck()) return string.Empty;

        int from = pos;
        int to = pos;
        for (int i = pos; i < line.Length; i++)
        {
            if (char.IsWhiteSpace(line[i])) break;
            to = i + 1;
        }
        pos = to;

        return line.Substring(from, to - from);
    }

    public string ReadLine()
    {
        if (!ReadCheck()) return string.Empty;

        ReadStream();
        string res = line.Substring(pos);
        pos = line.Length;

        return res;
    }

    public void Close()
    {
        TextReader.Close();
    }
    public void Clear()
    {
        pos = 0;
        line = string.Empty;
    }

    private bool disposed = false;
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                line = string.Empty;
                TextReader.Dispose();
            }
            disposed = true;
        }
    }
    ~Input()
    {
        Dispose(false);
    }
}
public class Output : IDisposable
{
    static char[] space = new char[] { ' ' };

    public TextWriter TextWriter { get; private set; }
    public bool AutoFlush { get; set; }

    public static string ToString(object obj, int maxLength)
    {
        return ToString(FormatReal(obj), maxLength);
    }
    public static string ToString(string s, int maxLength)
    {
        if (s.Length <= maxLength) return s;
        else return s.Substring(0, maxLength) + "...";
    }
    public static object FormatReal(object v, string format)
    {
        if (v is decimal) return ((decimal)v).ToString(format).Replace(',', '.');
        if (v is double) return ((double)v).ToString(format).Replace(',', '.');
        if (v is float) return ((float)v).ToString(format).Replace(',', '.');

        return v;
    }
    public static object FormatReal(object v)
    {
        if (v is decimal || v is double || v is float)
        {
            return v.ToString().Replace(',', '.');
        }
        return v;
    }

    public Output()
        : this(new MemoryStream())
    {
    }
    public Output(string path)
        : this(File.Create(path))
    {

    }
    public Output(Stream s)
        : this(new StreamWriter(s))
    {
    }
    public Output(TextWriter tw)
    {
        TextWriter = tw;
    }

    public static implicit operator Output(Stream s)
    {
        return new Output(s);
    }

    public static implicit operator Output(TextWriter tw)
    {
        return new Output(tw);
    }

    public static Output operator +(Output output, object obj)
    {
        output.Write(obj);
        return output;
    }
    public Output WriteArray<T>(params T[] array)
    {
        return WriteArray<T>(array, false);
    }
    public Output WriteArray<T>(T[] array, bool appendLength)
    {
        return WriteArray<T>(array, 0, array.Length, appendLength);
    }
    public Output WriteArray<T>(T[] array, int index, int count)
    {
        return WriteArray<T>(array, index, count, false);
    }
    public Output WriteArray<T>(T[] array, int index, int count, bool appendLength)
    {
        if (index + count > array.Length)
        {
            string message = string.Format(
                "Index out of range: {0} + {1} >= {2}",
                index,
                count,
                array.Length);
            throw new Exception(message);
        }
        if (appendLength)
        {
            WriteLine(count);
        }
        for (int i = 0; i < count; i++)
        {
            Write(array[i]);
            Write(space, 0, space.Length);
        }
        WriteLine();

        return this;
    }
    public Output WriteLine(object obj)
    {
        obj = FormatReal(obj);
        return WriteLine(obj.ToString());
    }
    public Output WriteLine(string format, params object[] args)
    {
        return WriteLine(string.Format(format, args));
    }
    public Output WriteLine(string s)
    {
        return WriteLine(s.ToCharArray());
    }
    public Output WriteLine(char[] buffer)
    {
        return WriteLine(buffer, 0, buffer.Length);
    }
    public Output WriteLine(char[] buffer, int index, int count)
    {
        TextWriter.WriteLine(buffer, index, count);
        if (AutoFlush) TextWriter.Flush();
        return this;
    }
    public Output WriteLine()
    {
        TextWriter.WriteLine();
        if (AutoFlush) TextWriter.Flush();
        return this;
    }
    public Output Write(object obj)
    {
        obj = FormatReal(obj);
        return Write(obj.ToString());
    }
    public Output Write(string format, params object[] args)
    {
        return Write(string.Format(format, args));
    }
    public Output Write(string s)
    {
        return Write(s.ToCharArray());
    }
    public Output Write(char[] buffer)
    {
        return Write(buffer, 0, buffer.Length);
    }
    public Output Write(char[] buffer, int index, int count)
    {
        TextWriter.Write(buffer, index, count);
        if (AutoFlush) TextWriter.Flush();
        return this;
    }

    public void Close()
    {
        TextWriter.Close();
    }
    public void Flush()
    {
        TextWriter.Flush();
    }

    private bool disposed = false;
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                TextWriter.Dispose();
            }
            disposed = true;
        }
    }
    ~Output()
    {
        Dispose(false);
    }
}
public static class Parser
{
    public static ParserDelegate<T> GetPrimitiveParser<T>()
    {
        if (!typeof(T).IsPrimitive) throw new Exception("Unknown type");
        else if (default(T) is Byte) return new ParserDelegate<Byte>(Byte.TryParse) as ParserDelegate<T>;
        else if (default(T) is Boolean) return new ParserDelegate<Boolean>(Boolean.TryParse) as ParserDelegate<T>;
        else if (default(T) is Int16) return new ParserDelegate<Int16>(Int16.TryParse) as ParserDelegate<T>;
        else if (default(T) is Int32) return new ParserDelegate<Int32>(Int32.TryParse) as ParserDelegate<T>;
        else if (default(T) is Int64) return new ParserDelegate<Int64>(Int64.TryParse) as ParserDelegate<T>;
        else if (default(T) is UInt16) return new ParserDelegate<UInt16>(UInt16.TryParse) as ParserDelegate<T>;
        else if (default(T) is UInt32) return new ParserDelegate<UInt32>(UInt32.TryParse) as ParserDelegate<T>;
        else if (default(T) is UInt64) return new ParserDelegate<UInt64>(UInt64.TryParse) as ParserDelegate<T>;
        else if (default(T) is Single) return new ParserDelegate<Single>(Parser.SingleParser) as ParserDelegate<T>;
        else if (default(T) is Double) return new ParserDelegate<Double>(Parser.DoubleParser) as ParserDelegate<T>;
        else if (default(T) is Decimal) return new ParserDelegate<Decimal>(Parser.DecimalParser) as ParserDelegate<T>;
        else if (default(T) is String) return new ParserDelegate<String>(Parser.StringParser) as ParserDelegate<T>;
        else throw new Exception("Unknown type");
    }
    public static bool YesNoParser(string s, out Boolean result)
    {
        s = s.ToLower();
        if (s == "yes") result = true;
        else if (s == "no") result = false;
        else
        {
            result = false;
            return false;
        }
        return true;
    }
    public static bool StringParser(string s, out string result)
    {
        result = s;
        return string.IsNullOrEmpty(s);
    }
    public static bool DecimalParser(string s, out Decimal result)
    {
        return Decimal.TryParse(s.Replace('.', ','), out result);
    }
    public static bool DoubleParser(string s, out Double result)
    {
        return Double.TryParse(s.Replace('.', ','), out result);
    }
    public static bool SingleParser(string s, out Single result)
    {
        return Single.TryParse(s.Replace('.', ','), out result);
    }
}
#endregion
static class Program
{
    #region Streams
    static string endl = Environment.NewLine;
    static Input cin = new Input(Console.In);
    static Output cout = new Output(Console.Out);
    static Output cerr = new Output(Console.Error);

    static void InitIO()
    {
#if !DEBUG
        cin = new Input("input.txt");
        cout = new Output("output.txt");
#endif
    }
    #endregion
    #region Time
    static Stopwatch sw = new Stopwatch();
    static void Start()
    {
        sw.Reset();
        sw.Start();
    }
    static void Restart(string text = "")
    {
        Stop(text);
        Start();
    }
    static void Time(string text = "")
    {
        if (string.IsNullOrEmpty(text))
        {
            cerr.WriteLine(sw.Elapsed);
        }
        else
        {
            cerr.WriteLine(text + ": " + sw.Elapsed);
        }
    }
    static void Stop(string text = "")
    {
        sw.Stop();
        Time(text);
    }
    //*/
    #endregion
    const string nyan = "^_^";
    static void Solve()
    {
        var a = cin.ReadInt32();
        var b = cin.ReadInt32();

        cout.WriteLine("{0} {1}", Math.Min(a, b), (Math.Max(a, b) - Math.Min(a, b) / 2);
    }

    static string[] Tests =
    {
        @"3 1 2
1 1 1",
        @"4 2 3
1 2 4 8",
        @"3 1 2
17 18 4"
    };

    static string Generate(int n, int t, int seed)
    {
        var rnd = new Random(seed);
        var a = new int[n];
        for (var i = 0; i < n; i++)
        {
            a[i] = rnd.Next(1, 101);
        }

        var sb = new StringWriter();
        var output = new Output(sb);

        output.WriteLine("{0} {1}", n, t);
        output.WriteArray(a, false);

        return sb.ToString();
    }
    static void Main()
    {
#if DEBUG
        if (Tests.Length == 0)
        {
            Solve();
        }
        else
        {
            foreach(var test in Tests)
            {
                cin = new Input(new StringReader(test));
                Solve();
            }
            /*
            for (var i = 0; i < 100; i++)
            {
                var test = Generate(100, 10000000, i);
                Start();
                cin = new Input(new StringReader(test));
                Solve();
                Stop();
            }
            //*/
        }

#else
        Solve();
#endif
    }
}


using System;
using System.Collections.Generic;
using System.Net.Http.Headers;
using System.Text;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            int red = Convert.ToInt32(input[0]);
            int blue = Convert.ToInt32(input[1]);

            StringBuilder sb = new StringBuilder();

            int diff = Math.Min(red,blue);
            sb.Append(diff + " ");

            diff = Math.Abs(red - blue);
            diff = diff / 2;

            sb.Append(diff);
            Console.WriteLine(sb.ToString());
        }
    }
}


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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] a = func(7, 3);
            for (int i = 0; i < a.Length; i++)
            {
                Console.WriteLine(a[i].ToString());
            }
        }

        private static int[] func(int a,int b)
        {
            //int[] result = new int[2];
            int f = 0;
            int s = 0;
            if (a == b)
            {
                f = a;
                s = 0;
            }
            else if (a < b)
            {
                f = a;
                b = b - a;
                s = b / 2;
            }
            else if (b < a)
            {
                f = b;
                a = a - b;
                s = a / 2;
            }

            return result;
        }
    }
}


            int a = 3;
int b = 7;
            int f = 0;
            int s = 0;
            if (a == b)
            {
                f = a;
                s = 0;
            }
            else if (a < b)
            {
                f = a;
                b = b - a;
                s = b / 2;
            }
            else if (b < a)
            {
                f = b;
                a = a - b;
                s = a / 2;
            }
Console.WriteLine(f.ToString() + " " + s.ToString());


int f = 0;
            int s = 0;
            if (a == b)
            {
                f = a;
                s = 0;
            }
            else if (a < b)
            {
                f = a;
                b = b - a;
                s = b / 2;
            }
            else if (b < a)
            {
                f = b;
                a = a - b;
                s = a / 2;
            }


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

namespace LearningAlgoCsharp
{
    class Program
    {
        static void Main(string[] args)
        {
            //var line = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
            //var arr = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(s => Convert.ToInt32(s)).ToArray();
            //var first =  Convert.ToInt32(line[0]);
            //var second = Convert.ToInt32(line[1]);

            var line = Console.ReadLine().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Select(s => Convert.ToInt32(s)).ToArray();
            var red = line[0];
            var blue = line[1];

            var f = 0;
            var s = 0;

            if(red > blue)
            {
                f = blue;
                s = (red - blue) / 2;
            }
            else
            {
                f = red;
                s = (blue - red) /2;
            }

            Console.WriteLine(f + " " + s);
            Console.ReadLine();
        }

        private static int LevenshteinDistance(string first, string second)
        {
            if (string.IsNullOrEmpty(first) && string.IsNullOrEmpty(second))
                return 0;
            if (string.IsNullOrEmpty(first))
                return second.Length;
            if (string.IsNullOrEmpty(second))
                return first.Length;

            int firstLength = first.Length;
            int secondLength = second.Length;
            var distances = new int[firstLength + 1, secondLength + 1];
            for (int i = 0; i <= firstLength; distances[i, 0] = i++) ;
            for (int j = 0; j <= secondLength; distances[0, j] = j++) ;

            for (int i = 1; i <= firstLength; i++)
            {
                for (int j = 1; j <= secondLength; j++)
                {
                    int cost = second[j - 1] == first[i - 1] ? 0 : 1;
                    distances[i, j] = Math.Min
                        (
                        Math.Min(distances[i - 1, j] + 1, distances[i, j - 1] + 1),
                        distances[i - 1, j - 1] + cost
                        );
                }
            }

            return distances[firstLength, secondLength];
        }
    }
}


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

namespace Algo
{
    public class Task228
    {
        public static HashSet<int> MakeSet(int[] ints)
        {
            return new HashSet<int>(ints);
        }

        public static void Main(string[] args)
        {
            int[] a = Console.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();

            Console.WriteLine(GetAnswer(a));
        }

        public static int GetAnswer(int[] a)
        {
            var set = MakeSet(a);

            return 4 - set.Count;
        }
    }
}


using System;
class test
{
    static void Main()
    {
        string []tmp = Console.ReadLine().Split();
        int a = int.Parse(tmp[0]);
        int b = int.Parse(tmp[1]);
        int c = int.Parse(tmp[2]);
        int d = int.Parse(tmp[3]);

        int temp = a;
        if(a == temp && b==temp && c ==temp && d==temp)
            {
            Console.WriteLine("3");
            }
        else()
            {
            Console.WriteLine("1");
            }
    }

}


using System;

namespace CodeForces
{
    class MainClass
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            int numberOfShoes = 0;

            List<int> inputList = new List<int>();
            inputList.Add(int.Parse(input[0]));
            for (int i = 1; i < input.Length; i++)
            {
                int shoe = int.Parse(input[i]);
                for(int j = 0; j < inputList.Count; j++)
                {
                    if (inputList[j] == shoe)
                    {
                        numberOfShoes++;
                        break;
                    }
                }
                inputList.Add(shoe);
            }

            Console.WriteLine(numberOfShoes);

        }
    }
}


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

class Program
{
    static void Main(string[] args)
    {
        int[] colors = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
        int answer = 4 - colors.Distinct().Count();
        Console.WriteLine(answer);
#if ONLINE_JUDGE
#else
        Console.ReadKey();
#endif
    }
}


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

namespace CodeForces
{
    class Program
    {
        public static void Main(string[] args)
        {
            int[] colors = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
            int answer = 4 - colors.Distinct().Count();
            Console.WriteLine(answer);
#if ONLINE_JUDGE
#else
            Console.ReadKey();
#endif
        }
    }
}


using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text.RegularExpressions;
using System.Text;
using System;

class Solution
{
    static void Main(string[] args)
    {
        string[] shoes = Console.ReadLine().Split(" ");
        int count = 0;
        for (int i = 0; i < 3; i++)
        {
            if (shoes[i] == shoes[i+1])
            {
                count++;
            }
        }
        Console.WriteLine(count);
    }
}


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

namespace Tasks
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] colors = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
            int answer = 4 - colors.Distinct().Count();
            Console.WriteLine(answer);
#if ONLINE_JUDGE
#else
            Console.ReadKey();
#endif
        }
    }
}


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

namespace Tasks
{
    class Tasks
    {
        static void Main(string[] args)
        {
            int[] colors = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
            int answer = 4 - colors.Distinct().Count();
            Console.WriteLine(answer);
#if ONLINE_JUDGE
#else
            Console.ReadKey();
#endif
        }
    }
}


using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text.RegularExpressions;
using System.Text;
using System;

class Solution
{
    static void Main(string[] args)
    {
        var shoes = Console.ReadLine().Split(" ");
        var sol = new List<int>();

        for (int i = 0; i < 4; i++)
        {
            if (!sol.Contains(Convert.ToInt32(shoes[i])))
            {
                sol.Add(Convert.ToInt32(shoes[i]));
            }
        }

        Console.WriteLine(4 -sol.ToArray().Length);
    }
}


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)
        {
            int[] colors = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
            int answer = 4 - colors.Distinct().Count();
            Console.WriteLine(answer);
#if ONLINE_JUDGE
#else
            Console.ReadKey();
#endif
        }
    }
}


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

namespace луна
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] tokens;

         string st    = Console.ReadLine();
            int n=int.Parse(st);
            bool up=true;
         tokens=   Console.ReadLine().Split();
         if (n == 1)
         {
             int a = int.Parse(tokens[0]);
             if (a == 15) Console.WriteLine("DOWN");else
             if (a == 0) Console.WriteLine("UP");else
             Console.WriteLine(-1);
         }
         else
         {
             int a, b;
             a = int.Parse(tokens[tokens.Length - 2]);
             b = int.Parse(tokens[tokens.Length - 1]);
             if (b < a) up = !up;
             if (b == 15 || b==0) up = !up;
             if (up) Console.WriteLine("UP");
             else Console.WriteLine("DOWN");
         }
         Console.ReadLine();
        }
    }


using System.Text;
using System.Threading.Tasks;

namespace луна
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] tokens;

         string st    = Console.ReadLine();
            int n=int.Parse(st);
            bool up=true;
         tokens=   Console.ReadLine().Split();
         if (n == 1) Console.WriteLine(-1);
         else
         {
             int a, b;
             a = int.Parse(tokens[tokens.Length - 2]);
             b = int.Parse(tokens[tokens.Length - 1]);
             if (b < a) up = !up;
             if (b == 15) up = !up;
             if (up) Console.WriteLine("UP");
             else Console.WriteLine("DOWN");
         }
         Console.ReadLine();
        }
    }
}


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.29424.173
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleApp1", "ConsoleApp1\ConsoleApp1.csproj", "{9471B2F7-4CA7-4D0D-BD91-D59F4A992C02}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{9471B2F7-4CA7-4D0D-BD91-D59F4A992C02}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{9471B2F7-4CA7-4D0D-BD91-D59F4A992C02}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{9471B2F7-4CA7-4D0D-BD91-D59F4A992C02}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{9471B2F7-4CA7-4D0D-BD91-D59F4A992C02}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {B94F39A0-E050-4998-9EA8-B4F7B36A08DC}
	EndGlobalSection
EndGlobal


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

namespace B
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split();
            string[] rez = Console.ReadLine().Split();
            int[] lol = new int[3];

            for (int l = 0; l < input.Length; l++)
            {
                if (int.Parse(input[l]) - int.Parse(rez[l]) >= 0)
                    lol[l] = 1;
                else
                    lol[l] = 0;
            }

            int a = int.Parse(input[0]);
            int b = int.Parse(input[1]);
            int c = int.Parse(input[2]);
            int x = int.Parse(rez[0]);
            int y = int.Parse(rez[1]);
            int z = int.Parse(rez[2]);
            int i = lol[0];
            int j = lol[1];
            int k = lol[2];

            Console.WriteLine(rer);
            Console.WriteLine(pop);
            Console.WriteLine(3 / 2);
            if ((i * (a - x) + j * (b - y) + k * (c - z)) / 2 >= (1 - i) * -1 * (a - x) - (1 - j) * (b - y) - (1 - k) * (c - z))
                Console.WriteLine("Yes");
            else
                Console.WriteLine("No");
        }
    }
}


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

namespace Codeforces_335
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split();
            int[] input1 = new int[3];
            for (int i = 0; i < input.Length; i++)
            {
                input1[i] = int.Parse(input[i]);
            }

            string[] rez = Console.ReadLine().Split();
            int[] rez1 = new int[3];
            for (int i = 0; i < rez.Length; i++)
            {
                rez1[i] = int.Parse(rez[i]);
            }

            bool f = false;

            int count = 0;
            for (int i = 0; i < input1.Length; i++)
            {
                if (input1[i] == rez1[i])
                    count++;
            }
            if (count == 3)
            {
                f = true;
                goto Label1;
            }

            int a = input1.Sum();
            int b = rez1.Sum();

            if (a =< b )
            {
                f = false;
                goto Label1;
            }

            for (int i = 0; true; i++)
            {
                if (a - 2 == b)
                {
                    f = true;
                    break;
                }
                else
                    a = a - 2;

                if(a + 1 == b)
                {
                    f = false;
                    break;
                }
                else
                {
                    a = a + 1;
                }
            }

            Label1:
            if (f)
                Console.WriteLine("Yes");
            else
                Console.WriteLine("No");
        }
    }
}


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

namespace ConsoleApplication1
{
    class Program
    {
        internal static void MyMain()
        {
            var ints = RInts();
            var a = ints[0];
            var b = ints[1];
            var stepps = ints[2];

            if (Math.Abs(a) + Math.Abs(b) <= stepps && (a + b - stepps) % 2 == 0)
            {
                WLine("Yes");
            }
            else
            {
                WLine("No");
            }

        }

        static void Main()
        {
#if !HOME
            MyMain();
#else
            Secret.Run();
#endif
        }

        #region Utils
        static string RLine()
        {
            return Console.ReadLine();
        }

        static int RInt()
        {
            var str = Console.ReadLine();
            return Convert.ToInt32(str);
        }
        static int[] RInts()
        {
            return Array.ConvertAll(Console.ReadLine().Split(' '), s => Convert.ToInt32(s));
        }
        static void RInts(out int a, out int b)
        {
            var ints = RInts();
            a = ints[0];
            b = ints[1];
        }
        static void RLongs(out long a, out long b)
        {
            var ints = Array.ConvertAll(Console.ReadLine().Split(' '), s => Convert.ToInt64(s));
            a = ints[0];
            b = ints[1];
        }
        public static void WLine<T>(T s)
        {
            Console.WriteLine(s);
        }
        #endregion
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication1
{
    class Program
    {
        internal static void MyMain()
        {
            var ints = RInts();
            var a = ints[0];
            var b = ints[1];
            var stepps = ints[2];

            if (a + b <= stepps && (a + b - stepps) % 2 == 0)
            {
                WLine("Yes");
            }
            else
            {
                WLine("No");
            }

        }

        static void Main()
        {
#if !HOME
            MyMain();
#else
            Secret.Run();
#endif
        }

        #region Utils
        static string RLine()
        {
            return Console.ReadLine();
        }

        static int RInt()
        {
            var str = Console.ReadLine();
            return Convert.ToInt32(str);
        }
        static int[] RInts()
        {
            return Array.ConvertAll(Console.ReadLine().Split(' '), s => Convert.ToInt32(s));
        }
        static void RInts(out int a, out int b)
        {
            var ints = RInts();
            a = ints[0];
            b = ints[1];
        }
        static void RLongs(out long a, out long b)
        {
            var ints = Array.ConvertAll(Console.ReadLine().Split(' '), s => Convert.ToInt64(s));
            a = ints[0];
            b = ints[1];
        }
        public static void WLine<T>(T s)
        {
            Console.WriteLine(s);
        }
        #endregion
    }
}


<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <ProjectGuid>{0A4645B1-EACC-4BD5-A836-243EF8E4F323}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <RootNamespace>maximum_in_table</RootNamespace>
    <AssemblyName>maximum_in_table</AssemblyName>
    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <OutputPath>bin\Debug</OutputPath>
    <DefineConstants>DEBUG;</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
    <Externalconsole>true</Externalconsole>
    <PlatformTarget>x86</PlatformTarget>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
    <DebugType>full</DebugType>
    <Optimize>true</Optimize>
    <OutputPath>bin\Release</OutputPath>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
    <Externalconsole>true</Externalconsole>
    <PlatformTarget>x86</PlatformTarget>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Program.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
</Project>


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2012
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "maximum_in_table", "maximum_in_table\maximum_in_table.csproj", "{0A4645B1-EACC-4BD5-A836-243EF8E4F323}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|x86 = Debug|x86
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{0A4645B1-EACC-4BD5-A836-243EF8E4F323}.Debug|x86.ActiveCfg = Debug|x86
		{0A4645B1-EACC-4BD5-A836-243EF8E4F323}.Debug|x86.Build.0 = Debug|x86
		{0A4645B1-EACC-4BD5-A836-243EF8E4F323}.Release|x86.ActiveCfg = Release|x86
		{0A4645B1-EACC-4BD5-A836-243EF8E4F323}.Release|x86.Build.0 = Release|x86
	EndGlobalSection
EndGlobal


<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" 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>{EDB296B5-DF93-4967-9698-D045A867CF8A}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <RootNamespace>Testerka</RootNamespace>
    <AssemblyName>Testerka</AssemblyName>
    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
    <Deterministic>true</Deterministic>
  </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" />
</Project>


using System;

public class CodeForces
{
    public void Main(string[] args)
    {
        int n = int.Parse(Console.ReadLine());
        long t = 1;
        int i = 1;
        while (i <= n)
        {
            t *= 11;
            ++i;
        }
        i = n / 2;
        while (i > 0)
        {
            t /= 10;
            --i;
        }
        Console.WriteLine(t % 10);
    }
}


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2013
VisualStudioVersion = 12.0.31101.0
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "prblm1", "prblm1\prblm1.csproj", "{8396EFD4-0C62-481C-A1AE-DD19D042BCE6}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{8396EFD4-0C62-481C-A1AE-DD19D042BCE6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{8396EFD4-0C62-481C-A1AE-DD19D042BCE6}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{8396EFD4-0C62-481C-A1AE-DD19D042BCE6}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{8396EFD4-0C62-481C-A1AE-DD19D042BCE6}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.28803.352
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Testerka", "Testerka.csproj", "{EDB296B5-DF93-4967-9698-D045A867CF8A}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{EDB296B5-DF93-4967-9698-D045A867CF8A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{EDB296B5-DF93-4967-9698-D045A867CF8A}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{EDB296B5-DF93-4967-9698-D045A867CF8A}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{EDB296B5-DF93-4967-9698-D045A867CF8A}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {7C8D704E-5175-439A-ABB8-CE25B3D699C1}
	EndGlobalSection
EndGlobal


using System;
using System.Linq;
public class Program
{

    public static void Main()
    {
		int[][] arr = new int[10][10];
		int a = int.Parse(Console.ReadLine());
		for (int i = 0; i < a; i++) {
			for (int j = 0; j < a; j++) {
				if (i == 0) {
					arr[i][j] = 1;
				} else if (j == 0) {
					arr[i][j] = 1;
				} else {
					arr[i][j] = arr[i - 1][j] + arr[i][j - 1];
				}
			}
		}
		Console.WriteLine(arr[a - 1][a - 1]);
    }
}


//#include <iostream>
//using namespace std;
//int main()
//{
//	int arr[] = { 4, 2, 7, 7, 88, 0, 10, -8, 7, 9 };
//	int input, count = 0;
//	cin >> input;
//	for (int i = 0; i < 9; i++)
//	{
//		for (int j = 0; j < 9; j++)
//		{
//			if (arr[j] == input)
//			{
//				int temp = arr[j];
//				arr[j] = arr[j + 1];
//				arr[j + 1] = temp;
//			}
//		}
//	}
//
//	for (int i = 0; i < 10; i++)
//	{
//		if (arr[i] == input)
//		{
//			count++;
//		}
//	}
//
//	for (int k = 0; k < 10-count; k++)
//	{
//		cout << arr[k] << " ";
//	}
//}

#include<iostream>
#include"Header.h"
#include <string>
using namespace std;

void main()
{
	int x = 2;
	cout << x << endl;
	f1();
	cout << x << endl;
	f2();
	cout << x << endl;

	int ** arr = new int*[5]; // pointer to pointer declaration
	int i;
	for (i = 0; i < 10; i++);

	cout << i;
	struct product
	{
		int weight;
		float price;
	}apples, bananas;

	product gold = {};

	product bagOfFlour = { 1 , 10 }, bagOfSugar;

}

void f1()
{
	int x = 3;
}
void f2()
{
	int x = 4;
}


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

    class Program
    {
        static void Main(string[] args)
        {
            string x = Console.ReadLine();
            int counter = 0;

            for(int index =0; index < x.Length/2; ++index)
            {
                if (x[index] != x[x.Length - index - 1])
                {
                    counter++;
                }
            }
            if (counter > 1)
                Console.WriteLine("NO");
            else
                Console.WriteLine("YES");
            //Console.WriteLine(counter);
        }
    }


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

namespace _3_4
{
    class Program
    {
        static void Main(string[] args)
        {
            tring str = Console.ReadLine();
            int count = 0;

            for (int i = 0; i < str.Length / 2; i++)
                if (str[i] != str[str.Length - i - 1])
                    count++;

            if (count == 1 || (count == 0 && (str.Length % 2) == 1))
                Console.WriteLine("YES");
            else
                Console.WriteLine("NO");
        }
    }
}


using System;

internal class Program
{
	static void Main()
	{
		string obj1;
		obj1 = Console.ReadLine();
		char[]  obj2=new char[obj1.Length];

		int index = 0;
		for (int i = obj1.Length-1; i >=0 ; i--)
		{
			obj2[index] = (char)obj1[i];
			++index;
		}
		int n = 0;
		for (int k = 0; k < obj1.Length; k++)
		{
			if ((char)obj1[k] != obj2[k])

				++n;
		}
		if (n == 2|| n==0)
		{
			Console.WriteLine("YES");

		}
		else
			Console.WriteLine("NO");

	}


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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            int k = 0;int e =0;
            for (int i = 0; i < s.Length/2; i++)
			{
			 if(s[i]!=s[s.Length-1-i]){e=i;k++;}
			}
            if(k>1) Console.WriteLine("NO");
            else
Console.WriteLine("YES");
                    }
        }
    }
}


#include <conio.h>
#include <iostream>
#include <math.h>
#include <stdio.h>

using namespace std;

int main()
{
    double n,m;
    int answer = 0;
    cin >> n >> m;
    for (double a = 0; a <= 100; a++)
        for (double b = 0; b<=100; b++)
            if(pow(a,2)+b==n && pow(b,2) + a == m)
                answer++;
    cout << answer << endl;
    return 0;
}


int count = 0;
            string s = Console.ReadLine();
            string[] words = s.Split(' ');
            int n = Convert.ToInt32(words[0]);
            int m = Convert.ToInt32(words[1]);
            for (int i = 0; i < 33; i++)
            {
                for (int g = 0; g < 33; g++)
                {
                    if ((i * i + g) == n)
                    {
                        if ((i + g*g) == m)
                        {
                            count++;
                        }
                    }
                }
            }
            Console.WriteLine(count);


static void Main(string[] args)
        {
            int count = 0;
            string s = Console.ReadLine();
            string[] words = s.Split(' ');
            int n = Convert.ToInt32(words[0]);
            int m = Convert.ToInt32(words[1]);
            Console.WriteLine(n + m);
            for (int i = 0; i < 33; i++)
            {
                for (int g = 0; g < 33; g++)
                {
                    if ((i * i + g) == n)
                    {
                        if ((g*g + i) == m)
                        {
                            count++;
                        }
                    }
                }
            }
            Console.WriteLine(count);
        }


 static void Main(string[] args)
        {
            int count = 0;
            string s = Console.ReadLine();
            string[] words = s.Split(' ');
            int n = Convert.ToInt32(words[0]);
            int m = Convert.ToInt32(words[1]);
            for (int i = 0; i < 33; i++)
            {
                for (int g = 0; g < 33; g++)
                {
                    if ((i * i + g) == n)
                    {
                        if ((g*g + i) == m)
                        {
                            count++;
                        }
                    }
                }
            }
            Console.WriteLine(count);
        }


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

namespace уравнение
{
    class Program
    {
        static void Main(string[] args)
        {
            string h = Console.ReadLine();

            int m = Convert.ToInt32(h.Substring(0, 1));
            int n = Convert.ToInt32(h.Substring(2, 1));

            int s = 0;
            int p = 0;
            int a = 0, b = 0, q = 0;

            if (m > n)
            {
                q = Convert.ToInt32(Math.Sqrt(m));
                while (s <= m)
                {
                    if (q * q + s == m)
                    {
                        a = q;
                        b = m - q * q;

                        if (a + b * b == n)
                        {
                            p++;
                        }
                    }
                    s = s + 1;
                }
            }

            else
            {
                q = Convert.ToInt32(Math.Sqrt(n));

                while (s <= n)
                {
                    if (q * q + s == n)
                    {
                        b = q;
                        a = n - q * q;

                        if (a * a + b == m)
                        {
                            p++;
                        }
                    }
                    s = s + 1;
                }
            }

            Console.WriteLine(p);
            Console.ReadLine();
        }
    }
}


<?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>{5C37D815-990F-4621-B7C8-5B25B5E1642A}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Система_уравнений</RootNamespace>
    <AssemblyName>Система уравнений</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>


int count = 0;
            string s = Console.ReadLine();
            string[] words = s.Split(' ');
            int n = Convert.ToInt32(words[0]);
            int m = Convert.ToInt32(words[1]);
            Console.WriteLine(n + m);
            for (int i = 0; i < 33; i++)
            {
                for (int g = 0; g < 33; g++)
                {
                    if ((i * i + g) == n)
                    {
                        if ((g*g + i) == m)
                        {
                            count++;
                        }
                    }
                }
            }
            Console.WriteLine(count);


using System;
class PerfectNumber{
    static long sumOfDigits(long n){
        long sum = 0;
        while(n>0){
            sum+=(n%10);
            n = n/10;
        }
        return sum;
    }
    static long getPerfect(int n){
        long num = 19;
        if(n==1){
            return 19;
        }
        for(int i=2;i<=n;i++){
            while(true){
                num+=9;
                if(sumOfDigits(num) == 10){
                    break;
                }
            }
            if(i == n){
                return num;
            }
        }
        return num;
    }
    static void Main(string[] args){
        int n = Convert.ToInt32(Console.ReadLine().Trim());
        Console.WriteLine(getPerfect(i));
    }
}


namespace Practic
{
    class Program
    {

        static void Main(string[] args)
        {
            int k = Convert.ToInt32(Console.ReadLine());
            string ans = "";ans += k.ToString();
            string p = k.ToString();int sm = 0;
            for (int i = 0; i < p.Length; i++)
                sm += p[i] - '0';
            ans += (10 - sm).ToString();
            Console.WriteLine(ans);
            //Console.ReadKey();
        }
    }
}


using System;

namespace CSharp
{
    internal static class Program
    {
        private static void Main(string[] args)
        {

            PerfectNumber(int.Parse(Console.ReadLine()));
        }

        private static void PerfectNumber(int k)
        {
            string temp = k.ToString();
            int diff = k - SumValue(k);

            if (temp.Contains('0'))
                temp = temp.Replace('0', char.Parse(diff.ToString()));
            else
                temp += diff;

            Console.WriteLine(temp);
        }

        private static int SumValue(int k)
        {
            int sum = 0;
            int digitCount = DigitCount(k);

            for (int i = 0; i <= digitCount; i++)
            {
                sum += k / (int)Math.Pow(10, i) % 10;
            }

            return sum;
        }

        private static int DigitCount(int k)
        {
            return (int)Math.Log(k, 10);
        }
    }
}


#define DEBUG

using System;
using System.Collections;
using System.Collections.Generic;

// (づ°ω°)づﾐe★゜・。。・゜゜・。。・゜☆゜・。。・゜゜・。。・゜

namespace dd
{

	class MainClass
	{
		const int Limit = (int)1e9 + 777;

		public static bool Check(int x)
		{
			int Sum = 0;
			while (x > 0)
			{
				Sum += x % 10;
				x /= 10;
			}
			return (Sum % 10 == 0) ? true : false;
		}

		public static void Brute(int numb)
		{
			int cnt = 0;
			for (int i = 1; i < Limit; ++i)
			{
				if (Check(i) == true)
					cnt++;
				if (cnt == numb)
				{
					Console.WriteLine(i);
					break;1
				}
			}
		}

		public static void Main(string[] args)
		{
			int numb = Reader.NextInt();
			Brute(numb);
		}

		class Reader
		{
			public static int NextInt()
			{
				int cnt = 0, sign = 1;
				char ch = Convert.ToChar(Console.Read());
				while (!(ch >= '0' && ch <= '9') && ch != '-')
					ch = Convert.ToChar(Console.Read());
				if (ch == '-')
				{
					sign = -1;
					ch = Convert.ToChar(Console.Read());
				}
				while (ch >= '0' && ch <= '9')
				{
					int t = Convert.ToInt32(ch);
					cnt = cnt * 10 + ch - '0';
					ch = Convert.ToChar(Console.Read());
				}
				return cnt * sign;
			}
			public static long NextLong()
			{
				long cnt = 0, sign = 1;
				char ch = Convert.ToChar(Console.Read());
				while (!(ch >= '0' && ch <= '9') && ch != '-')
					ch = Convert.ToChar(Console.Read());
				if (ch == '-')
				{
					sign = -1;
					ch = Convert.ToChar(Console.Read());
				}
				while (ch >= '0' && ch <= '9')
				{
					long t = Convert.ToInt64(ch);
					cnt = cnt * 10 + ch - '0';
					ch = Convert.ToChar(Console.Read());
				}
				return cnt * sign;
			}
		}
	}
}


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

            for (int i =k; i < 10000; i++)
            {
                for(int j = 1; j < 10000; j++)
                {
                    if (i + j == 10)
                    {
                        Console.WriteLine((int.Parse(i.ToString() + j.ToString())));
                        break;
                    }
                }
                break;
            }


<?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>{96676745-3910-413A-BC2B-70847196AADC}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>ProblemB</RootNamespace>
    <AssemblyName>ProblemB</AssemblyName>
    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
    <FileAlignment>512</FileAlignment>
  </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.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>