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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            long l;
            long r;
            string readStr = System.Console.ReadLine();
            string[] arg = readStr.Split(' ');
            l = int.Parse(arg[0]);
            r = int.Parse(arg[1]);

            System.Console.Write("{0}", palindrom(r) - palindrom(l-1));
        }

        public static long palindrom(long arg)
        {
            string str = arg.ToString();

            if (str.Length == 1)
                return long.Parse(str[0].ToString());
            else
            {
                long res = 0;
                for (int i = 2; i <= str.Length-1; i++)
                {
                    res += (long)System.Math.Pow(10, i - 2) * 9;
                }

                int firstDigit = int.Pйarse(str[0].ToString());
                int lastDigit = int.Parse(str[str.Length - 1].ToString());
                int min = System.Math.Min(firstDigit, lastDigit);
                int max = System.Math.Max(firstDigit, lastDigit);

                res += (long)System.Math.Pow(10, str.Length - 2) * (firstDigit-1);
                res += 9;

               // if (min != 0)
                {
                    string s = str.Remove(0, 1);
                    s = s.Remove(s.Length - 1, 1);
                    if (s == "")
                        res++;
                    else res += long.Parse(s) + 1;

                    if (firstDigit > lastDigit)
                        res--;
                }

                return res;
            }
        }
    }
}


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

namespace Preparation
{
    public class CodeForces710A
    {
        public void Main(string[] args)
        {
            var str = Console.ReadLine();
            if(str[0] == 'a' && str[1] == '1' ||
               str[0] == 'a' && str[1] == '8' ||
               str[0] == 'h' && str[1] == '1' ||
               str[0] == 'h' && str[1] == '8')
                Console.WriteLine(3);
            else if(str[0] == 'h' || str[1] == '8' || str[0] == 'a' || str[1] == '1')
                Console.WriteLine(5);
            else
                Console.WriteLine(8);
        }
    }
}


using static System.Console;
namespace test
{
    class Program
    {
        static void Main()
        {
            var a = ReadLine().Split();
            int b = int.Parse(a[0]);
            for (int i = 0; i < b; i++)
            {
                string c = ReadLine();
                if (c.Contains('Y') || c.Contains('M') || c.Contains('C'))
                {
                    WriteLine("#Color");
                    System.Environment.Exit(1);
                }
            }
            WriteLine("#Black&White");
        }
    }
}


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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
             string[]y=Console.ReadLine().Split(' ');
             int n=int.Parse(y[0]);
             int m=int.Parse(y[1]);
             int k=int.Parse(y[2]);
             if(m>=n&&k>=n)
             Console.WriteLine("Yes");
             else
             Cosnole.WriteLine("No");
        }
    }
}


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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
             string[]y=Console.Readline().Split(' ');
             int n=int.Parse(y[0]);
             int m=int.Parse(y[1]);
             int k=int.Parse(y[2]);
             if(m>=n&&k>=n)
             Console.WriteLine("Yes");
             else
             Cosnole.WriteLine("No");
        }
    }
}


using System;
    sealed class Program
    {
        static void Main(string[] args)
        {
            var d = Console.ReadLine().Split().Select(Int32.Parse).ToArray();
            Console.WriteLine(Math.Min(d[1], d[2]) >= d[0] ? "YES" : "NO");
        }
    }


using System;

//Driver Class

namespace Calculating_Function
{
    class Program
    {
        static void Main(string[] args)
        {
            Calculate cal = new Calculate();

            cal.num = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine(cal.calculate(cal.num));

        }
    }
}

//Interface
namespace Calculating_Function
{
    interface ICalculating
    {
        public int calculate(int num);
    }
}

//Working Class
namespace Calculating_Function
{
    class Calculate : ICalculating
    {
        public int num { get; set; }

        public int calculate(int num)
        {
            int count = 0;

            for (int i=1; i<=num; i++)
            {
                if (i%2 != 0)
                {
                    count -= i;
                }
                else
                {
                    count += i;
                }
            }

            return count;
        }
    }
}


using System.IO;

namespace prA {

    class Program {
#if ONLINE_JUDGE
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024 * 10), System.Text.Encoding.ASCII, false, 1024 * 10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024 * 10), System.Text.Encoding.ASCII, 1024 * 10);
#else
        private static readonly StreamWriter writer = new StreamWriter("output");
        private static readonly StreamReader reader = new StreamReader("input");
#endif
        static void Main(string[] args) {
            long p = long.Parse(reader.ReadLine());
            long ans = p / 2;
            if(p % 2 == 1)
                ans -= p;
            writer.WriteLine(ans);

            writer.Flush();
#if !ONLINE_JUDGE
            writer.Close();
#endif
        }
        private static int Next() {
            int c;
            int res = 0;
            do {
                c = reader.Read();
                if(c == -1)
                    return res;
            } while(c != '-' && (c < '0' || c > '9'));
            int sign = 1;
            if(c == '-') {
                sign = -1;
                c = reader.Read();
            }
            res = c - '0';
            while(true) {
                c = reader.Read();
                if(c < '0' || c > '9')
                    return res * sign;
                res *= 10;
                res += c - '0';
            }
        }
    }
}


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

namespace Dreamoon_and_WiFi
{
     class Codigo
    {
	 //Iniciando as variáveis dreamoon e drazil
         private string dreamoon;
         private string drazil;

	 //Iniciando um vetor que vai guardar os dois valores possíveis nas instruções
         private int[] contaDreamon = new int[2];
         private int[] contaDrazil = new int[2];

	 //Quantidade de valores desconhecidos passados ao drazil
         private int quantInt;

        public Codigo(string dreamoon, string drazil)
        {
            this.dreamoon = dreamoon; //Iniciando valores
            this.drazil = drazil; //Iniciando valores
            contaDreamon[0] = dreamoon.Split(new char[] { '-' }).Length - 1; //Vai contar quantos '-' possui e vai passar para a variável, e assim respectivamente com as 3 próxima linhas
            contaDreamon[1] = dreamoon.Split(new char[] { '+' }).Length - 1;
            contaDrazil[0] = drazil.Split(new char[] { '-' }).Length - 1;
            contaDrazil[1] = drazil.Split(new char[] { '+' }).Length - 1;
            quantInt = drazil.Split(new char[] { '?' }).Length - 1; //Quantidade de códigos desconhecidos
        }

        private double compara()
        {
            if (contaDreamon[0] == contaDrazil[0] && contaDreamon[1] == contaDrazil[1]) //Se receberem a mesma quantidade de '+' e '-', a conta termina em 100%
            {
                return 1;
            }
            else if ((contaDreamon[0] == 0 && contaDrazil[0] != 0) || (contaDreamon[1] == 0 && contaDrazil[1] != 0)) //Se receber valores incorretos, a probabilidade é zero
                return 0;
            else
                return ((double)(drazil.Length - quantInt) / dreamoon.Length); //Se não for nenhum disso, ele calcula a probabilidade de o Drazil retornar a posição original
        }

        public void exibe()
        {
            string result = compara().ToString();
            result = result.Replace(',', '.');
            Console.WriteLine("{0:F12}", result); //Exibe o resultado com 12 algarismos
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Teste x = new Teste();
            x.calcula(Console.ReadLine(), Console.ReadLine());
            //Codigo cod = new Codigo(Console.ReadLine(), Console.ReadLine()); //Chama a função com os dois valores digitados
            //cod.exibe(); //Exibe o resultado em decimal
        }
    }
}


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

            int input1 = Convert.ToInt32(Console.ReadLine());

            int input2 = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine(FindDivisor(input1, input2));

        }

        static int FindDivisor(int x , int y)
        {
            List<int> a = new List<int>();

            for (int i = 1 ; i <= x; i++) if (x % i == 0) a.Add(i);

            try
            {
                return a[y - 1];
            }
            catch (ArgumentOutOfRangeException)
            {

                return -1;
            }

        }
    }


Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ааа", "ааа\ааа.csproj", "{39F427EA-74BD-4CC2-B84E-670FC4E9D7E3}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|x86 = Debug|x86
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{39F427EA-74BD-4CC2-B84E-670FC4E9D7E3}.Debug|x86.ActiveCfg = Debug|x86
		{39F427EA-74BD-4CC2-B84E-670FC4E9D7E3}.Debug|x86.Build.0 = Debug|x86
		{39F427EA-74BD-4CC2-B84E-670FC4E9D7E3}.Release|x86.ActiveCfg = Release|x86
		{39F427EA-74BD-4CC2-B84E-670FC4E9D7E3}.Release|x86.Build.0 = Release|x86
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal


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

namespace _1B
{
    class Program
    {
        static void Main(string[] args)
        {

            var a = Console.ReadLine().Split().Select(int.Parse).ToArray();
            if((a[0]==a[1]||a[0]==a[1]+1||a[0]==a[1]-1)&&a[0]!=0&&a[1]!=0])
            {
                Console.WriteLine("YES");
            }
            else
            {
                Console.WriteLine("NO");
            }

        }
    }

}


<?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>{348B755E-D841-49C7-AA54-3781E9C7497B}</ProjectGuid>
    <OutputType>Exe</OutputType>
    <RootNamespace>_122A</RootNamespace>
    <AssemblyName>122A</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;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class cf110a
    {
        public static void Main()
        {
            int n = Int32.Parse(Console.ReadLine());
            Console.WriteLine("YES");
        }
    }
}


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

namespace CSharp_Shell
{

    public static class Program
    {
        public static void Main()
        {
           int palo=int.Parse(Console.ReadLine());
           int a,b,c,f=0;
           if(palo%47==0 | palo%4==0 | palo%7==0 | palo%477=0 |palo%744==p)
           {Console.WriteLine("YES");}
           else{Console.WriteLine("NO");

        }
    }
}


using System;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using static System.Console;
using static System.Math;

namespace Olymp
{
  public class ProblemSolver
  {
    private readonly Tokenizer input;

    public void Solve()
    {
      var x = input.ReadInt();
      var l = new[] { 'D', 'A', 'C', 'B' };
      int c(int i, int k) => l[(i + k) % 4];
      var d = 0;
      if (c(x, d) > c(x, 1))
        d = 1;
      if (c(x, d) > c(x, 2))
        d = 2;
      Write(d + " " + c(x, d));
    }

    public ProblemSolver(TextReader input)
    {
      this.input = new Tokenizer(input);
    }
  }

  #region Service classes

  public class Tokenizer
  {
    private readonly TextReader reader;

    public string ReadToEnd()
    {
      return reader.ReadToEnd();
    }

    public int ReadInt()
    {
      var c = SkipWS();
      if (c == -1)
        throw new EndOfStreamException();
      var isNegative = false;
      if (c == '-' || c == '+')
      {
        isNegative = c == '-';
        c = reader.Read();
        if (c == -1)
          throw new EndOfStreamException("Digit expected, but end of stream occurs");
      }

      if (!char.IsDigit((char)c))
        throw new InvalidOperationException($"Digit expected, but was: '{(char)c}'");
      var result = (char)c - '0';
      c = reader.Read();
      while (c > 0 && !char.IsWhiteSpace((char)c))
      {
        if (!char.IsDigit((char)c))
          throw new InvalidOperationException($"Digit expected, but was: '{(char)c}'");
        result = result * 10 + (char)c - '0';
        c = reader.Read();
      }

      if (isNegative)
        result = -result;
      return result;
    }

    public string ReadLine()
    {
      return reader.ReadLine();
    }

    public long ReadLong()
    {
      return long.Parse(ReadToken());
    }

    public double ReadDouble()
    {
      return double.Parse(ReadToken(), CultureInfo.InvariantCulture);
    }

    public int[] ReadIntArray(int n)
    {
      var a = new int[n];
      for (var i = 0; i < n; i++)
        a[i] = ReadInt();
      return a;
    }

    public (int, int) Read2Int() =>
      (ReadInt(), ReadInt());

    public (int, int, int) Read3Int() =>
      (ReadInt(), ReadInt(), ReadInt());

    public (int, int, int, int) Read4Int() =>
      (ReadInt(), ReadInt(), ReadInt(), ReadInt());

    public long[] ReadLongArray(int n)
    {
      var a = new long[n];
      for (var i = 0; i < n; i++)
        a[i] = ReadLong();
      return a;
    }

    public double[] ReadDoubleArray(int n)
    {
      var a = new double[n];
      for (var i = 0; i < n; i++)
        a[i] = ReadDouble();
      return a;
    }

    public string ReadToken()
    {
      var c = SkipWS();
      if (c == -1)
        return null;
      var sb = new StringBuilder();
      while (c > 0 && !char.IsWhiteSpace((char)c))
      {
        sb.Append((char)c);
        c = reader.Read();
      }

      return sb.ToString();
    }

    private int SkipWS()
    {
      var c = reader.Read();
      if (c == -1)
        return c;
      while (c > 0 && char.IsWhiteSpace((char)c))
        c = reader.Read();
      return c;
    }

    public Tokenizer(TextReader reader)
    {
      this.reader = reader;
    }
  }

  internal class Program
  {
    public static void Main()
    {
      var solver = new ProblemSolver(In);
      solver.Solve();
    }
  }

  #endregion
}


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

namespace code_21_a
{
    class Program
    {
        static void Main(string[] args)
        {

            string s = Console.ReadLine();
            bool can=true;
            int k = s.IndexOf('@');
            if(k==-1 || k==0 || k==s.Length-1 || k>=17) can =false;
            if(can)
            {
                string first = s.Substring(0, k);
                for (int i = 0; i < first.Length; i++)
                {
                    if (first[i] == '_' || (first[i] >= 'A' && first[i] <= 'Z') ||
                   (first[i] >= 'a' && first[i] <= 'z') || (first[i] >= '0' && first[i] <= '9'))
                    {

                    }
                    else
                    {
                        can = false;
                        break;
                    }

                }
            }
            if (!can) {Console.WriteLine("NO"); return;}
            int kk = s.IndexOf('/');
            int to;
            if (kk == -1)
                to = s.Length;
            else
                to = kk;
            string second = s.Substring(k+1 , to-k-1);
            if (second.Length==0 || second.Length > 32 || kk==s.Length-1) can = false;
            if (can)
            {
                int kol = 0;
                for (int i = 0; i < second.Length; i++)
                {
                    if (second[i] == '_' || (second[i] >= 'A' && second[i] <= 'Z') ||
                   (second[i] >= 'a' && second[i] <= 'z') || (second[i] >= '0' && second[i] <= '9'))
                    {
                        kol++;
                    }
                    else
                        if (second[i] == '.')
                         if (kol > 0 && kol < 17) kol = 0;
                         else
                         {
                             can = false;
                             break;
                        }
                }
            }
            if (!can) {Console.WriteLine("NO"); return;}
            if (kk !=-1)
            {
                string third = s.Substring(to+1,s.Length-to-1);
                if (third.Length > 16) {can = false; break;}
                for (int i = 0; i < third.Length; i++)
                {
                    if (third[i] == '_' || (third[i] >= 'A' && third[i] <= 'Z') ||
                   (third[i] >= 'a' && third[i] <= 'z') || (third[i] >= '0' && third[i] <= '9'))
                    {

                    }
                    else
                    {
                        can = false;
                        break;
                    }

                }
            }
            if (!can) {Console.WriteLine("NO"); return;}

            Console.WriteLine("YES");

         }
    }
}


using System;
using System.Linq;
using System.Text;

namespace ConsoleApp3
{
    class Program
    {
        static void Main(string[] args)
        {
            byte[] a = Console.ReadLine().Split(' ').Select(s => byte.Parse(s)).ToArray();

            byte[,] c = new byte[a[0], 3];
            byte minHours = 0;
            byte maxHours = 0;

            for (byte i = 0; i < a[0]; i++)
            {
                byte[] b = Console.ReadLine().Split(" ").Select(s => byte.Parse(s)).ToArray();
                minHours += b[0];
                maxHours += b[1];
                c[i, 0] = b[0];
                c[i, 1] = b[1];
                c[i, 2] = b[0];
            }
            if (minHours<=a[1] && a[1] <= maxHours)
            {
                byte sumHours = minHours;

                for (byte i = 0; i < a[0]; i++)
                {
                    if (sumHours + c[i, 1] - c[i,0] > a[1])
                    {
                        byte tail= (byte)(a[1] - sumHours);
                        c[i, 2] += tail;
                        sumHours += tail;
                    }
                    else
                    {
                        sumHours += (byte)(c[i, 1] - c[i, 0]);
                        c[i, 2] += c[i, 1];
                    }
                    if (sumHours >= a[1])
                        break;
                }

                for (int i = 0; i < c.Length; i++)
                {
                    Console.Write(c[i, 2] + " ");
                }
                Console.WriteLine("YES");
            }
            else
            {
                Console.WriteLine("NO");
            }
        }
        private void print (byte[,] c)
        {
            for (int i = 0; i < c.Length; i++)
            {
                Console.Write(c[i, 2] + " ");
            }
        }
    }
}


using System;

namespace CF677_D2_A
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            double dieNumber = 6;

            double yakko = int.Parse(input[0]);
            double wakko = int.Parse(input[1]);

            if (yakko >= wakko)
            {
                double remain = dieNumber - yakko;
                double result = Math.Round((remain + 1) / dieNumber, 1);
                switch (result)
                {
                    case 0.2:
                        Console.WriteLine("1/6");
                        break;

                    case 0.3:
                        Console.WriteLine("1/3");
                        break;

                    case 0.5:
                        Console.WriteLine("1/2");
                        break;

                    case 0.7:
                        Console.WriteLine("2/3");
                        break;

                    case 0.8:
                        Console.WriteLine("5/6");
                        break;

                    case 1:
                        Console.WriteLine("1/1");
                        break;
                }
            }
            else
            {
                double remain = dieNumber - wakko;
                double result = Math.Round((remain + 1) / dieNumber, 1);
                switch (result)
                {
                    case 0.2:
                        Console.WriteLine("1/6");
                        break;

                    case 0.3:
                        Console.WriteLine("1/3");
                        break;

                    case 0.5:
                        Console.WriteLine("1/2");
                        break;

                    case 0.7:
                        Console.WriteLine("2/3");
                        break;

                    case 0.8:
                        Console.WriteLine("5/6");
                        break;

                    case 1:
                        Console.WriteLine("1/1");
                        break;
                }
            }
        }
    }
}


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

namespace raising_bactaria
{
    class Program
    {
        static void Main(string[] args)
        {
            int z = 0;
            int n = int.Parse(Console.ReadLine());
            string x = Convert.ToString(n, 2);
            for (int i = 0; i < x.Length; i++)
            {
                if (x[i] == '1')
                {
                    z++;
                }
            }
            Console.WriteLine(z);

        }
    }
}

        }
    }
}


namespace Problem3
{
    class Program
    {
        static void Main(string[] args)
        {
            int count = 0;
            string input = Convert.ToString(int.Parse(Console.ReadLine()), 2);
            for(int i = 0; i < input.Length; i++)
            {
                if (input[i] == '1')
                    count++;
            }
            Console.WriteLine(count);
        }
    }
}


using System;

class Program
{
    void Main()
    {
        int n = int.Parse(Console.ReadLine());
        int result = 0;
        while (n > 0)
        {
            n -= ((int)Math.Log(n, 2) - 1);
            ++result;
        }
        Console.WriteLine(result);
    }
}


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

namespace Stone_on_the_table
{
    class Program
    {
        static void Main(string[] args)
        {
            int a =int.Parse( Console.ReadLine());
            int co=0;
            char[] c=Console.ReadLine().ToCharArray();
            for (int b = 0; b < a; b++)
            {
                if (b + 1 == a)
                    break;
                if (c[b] == c[b + 1])
                    co += 1;
            }
            Console.WriteLine(co.ToString());
        }
    }
}


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 2012
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Stone on the table", "Stone on the table\Stone on the table.csproj", "{D9768989-261D-4493-9CE1-1AD4785AEF09}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{D9768989-261D-4493-9CE1-1AD4785AEF09}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{D9768989-261D-4493-9CE1-1AD4785AEF09}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{D9768989-261D-4493-9CE1-1AD4785AEF09}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{D9768989-261D-4493-9CE1-1AD4785AEF09}.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;
using System.Threading.Tasks;

namespace Stone_on_the_table
{
    class Program
    {
        static void Main(string[] args)
        {
            int a =int.Parse( Console.ReadLine());
            int co=0;
            string c=Console.ReadLine();
            for (int b = 0; b < a; b++)
            {
                if (b + 1 == a)
                    break;
                if (c[b] == c[b + 1])
                    co += 1;
            }
            Console.WriteLine(co.ToString());
            Console.ReadKey();
        }
    }
}


using System;

class Program
{
	static void Main()
	{
		int stone = int.Parse();
		string colors = Console.ReadLine();
		int counter = 0;
		for(int i = 1; i < stone; i++)
		{
			if(colors[i-1] != colors[i])
			{
				continue;
			}
			else
			{
				counter++;
			}
		}
		Console.WriteLine(counter);
	}
}


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

namespace Codeforces
{
    class B
    {
        private static int V(char ch)
        {
            if (ch - '0' >= 0 && ch - '0' <= 9) return ch - '0';
            return ch - 'A' + 10;
        }

        private static int Convert(string s, int rad)
        {
            int v = 0;
            int m = 1;
            for (int i = s.Length - 1; i >=0 ; i--)
            {
                if (V(s[i]) >= rad) return -1;
                v += m * V(s[i]);
                m *= rad;
            }

            return v;
        }

        private static object Go()
        {
            string[] data = GetString().Split(':');
            string h = data[0];
            string m = data[1];

            List<int> sol = new List<int>();
            for (int rad = 2; rad < 61; rad++)
            {
                int hi = Convert(h, rad);
                int mi = Convert(m, rad);

                if (hi > -1 && mi > -1 && hi < 24 && mi < 60)
                {
                    sol.Add(rad);
                    if (rad == 60)
                    {
                        return -1;
                    }
                }
            }

            if (sol.Count == 0) return 0;

            return string.Join(" ", sol.ToArray());
        }

        #region Template

        public static void Main(string[] args)
        {
            object output = Go();
            if (output != null)
                Wl<string>(output.ToString());
        }

        private static IEnumerator<string> ioEnum;
        private static string GetString()
        {
            while (ioEnum == null || !ioEnum.MoveNext())
            {
                ioEnum = Console.ReadLine().Split().AsEnumerable().GetEnumerator();
            }

            return ioEnum.Current;
        }

        private static int GetInt()
        {
            return int.Parse(GetString());
        }

        private static long GetLong()
        {
            return long.Parse(GetString());
        }

        private static double GetDouble()
        {
            return double.Parse(GetString());
        }

        private static void Wl<T>(T o)
        {
            Console.WriteLine(o.ToString());
        }

        private static void Wl<T>(IEnumerable<T> enumerable)
        {
            Wl(string.Join(" ", enumerable.Select(e => e.ToString()).ToArray()));
        }

        public struct Tuple<T, K>
        {
            public T Item1;
            public K Item2;

            public Tuple(T t, K k)
            {
                Item1 = t;
                Item2 = k;
            }

            public override bool Equals(object obj)
            {
                var o = (Tuple<T, K>)obj;
                return o.Item1.Equals(Item1) && o.Item2.Equals(Item2);
            }

            public override int GetHashCode()
            {
                return Item1.GetHashCode() ^ Item2.GetHashCode();
            }

            public override string ToString()
            {
                return "(" + Item1 + " " + Item2 + ")";
            }
        }

        #endregion
    }
}


int n, p, k;
String[] input = Console.ReadLine().Split(' ');
n = Int16.Parse(input[0]); //osszes oldal
p = Int16.Parse(input[1]); //jelenlegi
k = Int16.Parse(input[2]); //pluszba
for(int i = p-k; i <= p+k; i++){
    if(i < 1) i = 1;
    if(i != 1 && i == p-k){
        Console.Write("<< ");
    }
    if(i == p) Console.Write("("+i+") ");
    else Console.Write(i+" ");
    if(i >= n) break;
    else if(i == p+k){
        Console.Write(">>");
        break;
	}
}


using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Security.Cryptography.X509Certificates;

namespace cf
{
    public class Cf
    {
        private static void Println(int n)
        {
            Console.WriteLine(n);
        }

        private static void Println(String s)
        {
            Console.WriteLine(s);
        }

        private static void Print(int n)
        {
            Console.Write(n);
        }

        private static void Print(String s)
        {
            Console.Write(s);
        }

        public static void Main(String[] args)
        {
            C();
        }

        private static void C()
        {
            var scanner = new MyScanner();
            var a = scanner.NextInt();
            var b = scanner.NextInt();
            long long  m = 1000000007;
            long long  ans = 0;
            for (int i = 1; i < b; i++)
            {
                ans += (a*i + (((a*(a + 1)/2)%m)*b)%m*i)%m;
                ans %= m;
            }
            Print(ans.ToString());
        }

        private static void A()
        {
            var scanner = new MyScanner();
            var n = scanner.NextInt();
            var m = scanner.NextInt();
            var x2 = n / 2;
            var x1 = n % 2;
            var d = (m - ((x1 + x2) % m)) % m;
            x2 -= d;
            x1 += 2 * d;
            if (x2 < 0)
            {
                Print(-1);
            }
            else
            {
                Print(x1 + x2);
            }
        }

        private static void B()
        {
            var f = new int[11];
            f[0] = 1;
            for (int i = 1; i < 11; i++)
                f[i] = f[i - 1]*i;
            var scanner = new MyScanner();
            var s1 = scanner.NextString();
            var s2 = scanner.NextString();
            var p1 = s1.Count(c => c == '+') - s1.Count(c => c == '-');
            var p2 = s2.Count(c => c == '+') - s2.Count(c => c == '-');
            var d = Math.Abs(p1 - p2);
            var q = s2.Count(c => c == '?');
            if (d > q)
            {
                Print(0);
                return;
            }
            var x = q - d;
            if (x%2 == 1)
            {
                Print(0);
                return;
            }
            x /= 2;
            double pp = ((double)f[q])/(f[x]*f[q - x]);
            Print((pp/Math.Pow(2,q)).ToString().Replace(',','.'));
        }
    }

    class Pair
    {
        public int X;
        public int Y;

        Pair(int x, int y)
        {
            this.X = x;
            this.Y = y;
        }
    }
    class MyScanner
    {
        private String[] _buffer;
        private int _pos = 0;

        public int NextInt()
        {
            if (_buffer == null)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            if (_buffer.Length <= _pos)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            _pos++;
            return int.Parse(_buffer[_pos - 1]);
        }

        public String NextString()
        {
            if (_buffer == null)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            if (_buffer.Length <= _pos)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            _pos++;
            return _buffer[_pos - 1];
        }

        public List<int> GetIntList(int n)
        {
            var result = new List<int>(n);
            for (int i = 0; i < n; i++)
                result.Add(NextInt());
            return result;
        }

        public int[] GetIntArray(int n)
        {
            var result = new int[n];
            for (int i = 0; i < n; i++)
                result[i] = (NextInt());
            return result;
        }

    }
}


using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Security.Cryptography.X509Certificates;

namespace cf
{
    public class Cf
    {
        private static void Println(int n)
        {
            Console.WriteLine(n);
        }

        private static void Println(String s)
        {
            Console.WriteLine(s);
        }

        private static void Print(int n)
        {
            Console.Write(n);
        }

        private static void Print(String s)
        {
            Console.Write(s);
        }

        public static void Main(String[] args)
        {
            C();
        }

        private static void C()
        {
            var scanner = new MyScanner();
            ulong a = (ulong)scanner.NextInt();
            ulong b = (ulong)scanner.NextInt();
            ulong m = 1000000007;
            ulong ans = 0;
            for (ulong i = 1; i < b; i++)
            {
                ans += (a*i + (((a*(a + 1)/2)%m)*b)%m*i)%m;
                ans %= m;
            }
            Print(ans.ToString());

    }

    class Pair
    {
        public int X;
        public int Y;

        Pair(int x, int y)
        {
            this.X = x;
            this.Y = y;
        }
    }
    class MyScanner
    {
        private String[] _buffer;
        private int _pos = 0;

        public int NextInt()
        {
            if (_buffer == null)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            if (_buffer.Length <= _pos)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            _pos++;
            return int.Parse(_buffer[_pos - 1]);
        }

        public String NextString()
        {
            if (_buffer == null)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            if (_buffer.Length <= _pos)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            _pos++;
            return _buffer[_pos - 1];
        }

        public List<int> GetIntList(int n)
        {
            var result = new List<int>(n);
            for (int i = 0; i < n; i++)
                result.Add(NextInt());
            return result;
        }

        public int[] GetIntArray(int n)
        {
            var result = new int[n];
            for (int i = 0; i < n; i++)
                result[i] = (NextInt());
            return result;
        }

    }
}


using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Security.Cryptography.X509Certificates;

namespace cf
{
    public class Cf
    {
        private static void Println(int n)
        {
            Console.WriteLine(n);
        }

        private static void Println(String s)
        {
            Console.WriteLine(s);
        }

        private static void Print(int n)
        {
            Console.Write(n);
        }

        private static void Print(String s)
        {
            Console.Write(s);
        }

        public static void Main(String[] args)
        {
            C();
        }

        private static void C()
        {
            var scanner = new MyScanner();
            var a = scanner.NextInt();
            var b = scanner.NextInt();
            long m = 1000000007;
            ulong ans = 0;
            for (ulong i = 1; i < b; i++)
            {
                ans += (a*i + (((a*(a + 1)/2)%m)*b)%m*i)%m;
                ans %= m;
            }
            Print(ans.ToString());
        }

        private static void A()
        {
            var scanner = new MyScanner();
            var n = scanner.NextInt();
            var m = scanner.NextInt();
            var x2 = n / 2;
            var x1 = n % 2;
            var d = (m - ((x1 + x2) % m)) % m;
            x2 -= d;
            x1 += 2 * d;
            if (x2 < 0)
            {
                Print(-1);
            }
            else
            {
                Print(x1 + x2);
            }
        }

        private static void B()
        {
            var f = new int[11];
            f[0] = 1;
            for (int i = 1; i < 11; i++)
                f[i] = f[i - 1]*i;
            var scanner = new MyScanner();
            var s1 = scanner.NextString();
            var s2 = scanner.NextString();
            var p1 = s1.Count(c => c == '+') - s1.Count(c => c == '-');
            var p2 = s2.Count(c => c == '+') - s2.Count(c => c == '-');
            var d = Math.Abs(p1 - p2);
            var q = s2.Count(c => c == '?');
            if (d > q)
            {
                Print(0);
                return;
            }
            var x = q - d;
            if (x%2 == 1)
            {
                Print(0);
                return;
            }
            x /= 2;
            double pp = ((double)f[q])/(f[x]*f[q - x]);
            Print((pp/Math.Pow(2,q)).ToString().Replace(',','.'));
        }
    }

    class Pair
    {
        public int X;
        public int Y;

        Pair(int x, int y)
        {
            this.X = x;
            this.Y = y;
        }
    }
    class MyScanner
    {
        private String[] _buffer;
        private int _pos = 0;

        public int NextInt()
        {
            if (_buffer == null)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            if (_buffer.Length <= _pos)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            _pos++;
            return int.Parse(_buffer[_pos - 1]);
        }

        public String NextString()
        {
            if (_buffer == null)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            if (_buffer.Length <= _pos)
            {
                _buffer = Console.ReadLine().Split(' ');
                _pos = 0;
            }
            _pos++;
            return _buffer[_pos - 1];
        }

        public List<int> GetIntList(int n)
        {
            var result = new List<int>(n);
            for (int i = 0; i < n; i++)
                result.Add(NextInt());
            return result;
        }

        public int[] GetIntArray(int n)
        {
            var result = new int[n];
            for (int i = 0; i < n; i++)
                result[i] = (NextInt());
            return result;
        }

    }
}


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

namespace CodeForce
{
    class _66a
    {
        public static void Main()
        {
            var line = Console.ReadLine();
            var big = BigInteger.Parse(line);
            if (big >= -128 && big <= 127)
            {
                Console.WriteLine("byte");
            }
            else if (big >= -32768 && big <= 32767)
            {
                Console.WriteLine("short");
            }
            else if (big >= -2147483648 && big <= 2147483647)
            {
                Console.WriteLine("int");
            }
            else if (big >= -9223372036854775808 && big <= 9223372036854775807)
            {
                Console.WriteLine("long");
            }
            else
            {
                Console.WriteLine("BigInteger");
            }
        }
    }
}


class program
{
    static void Main()
    {
        double t = double.Parse(Console.ReadLine());
        if(t >= - 128 && t  <= 127)
            Console.WriteLine("byte");
        if (t >= -32768 && t <= 32767)
            Console.WriteLine("short");
        if (t >= - 2147483648 && t <= 2147483647)
            Console.WriteLine("int");
        if (t >= -9223372036854775808 && t <= 9223372036854775807)
            Console.WriteLine("long ");
        else
            Console.WriteLine("BigInteger");
    }
}


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

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

            double d = Convert.ToDouble(n);

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

        }

    }


using System;

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

            double d = Convert.ToDouble(n);

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

        }

    }


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

namespace ConsoleApplication6
{
    class Program
    {
        static void Main(string[] args)
        {
            long n;
            string res="";
            try
            {
                n = long.Parse(Console.ReadLine());

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


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}") = "ConsoleApplication63", "ConsoleApplication63\ConsoleApplication63.csproj", "{EEDB3FBD-376F-4342-836B-E5C0F5F107FF}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{EEDB3FBD-376F-4342-836B-E5C0F5F107FF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{EEDB3FBD-376F-4342-836B-E5C0F5F107FF}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{EEDB3FBD-376F-4342-836B-E5C0F5F107FF}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{EEDB3FBD-376F-4342-836B-E5C0F5F107FF}.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 14
VisualStudioVersion = 14.0.25420.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleApplication62", "ConsoleApplication62\ConsoleApplication62.csproj", "{C60EB15D-E743-4E19-8590-28626807264F}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{C60EB15D-E743-4E19-8590-28626807264F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{C60EB15D-E743-4E19-8590-28626807264F}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{C60EB15D-E743-4E19-8590-28626807264F}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{C60EB15D-E743-4E19-8590-28626807264F}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
EndGlobal


using System;

namespace Codeforces
{
	class Problem74t6A
	{
	   	static void Main() {
		    string[] args = Console.In.ReadLine().Split(' ');
            long S = long.Parse(args[0]);
            long xIgor = long.Parse(args[1]);
            long xGoal = long.Parse(args[2]);
            args = Console.In.ReadLine().Split(' ');
            long tTram = long.Parse(args[0]);
            long tIgor = long.Parse(args[1]);
            args = Console.In.ReadLine().Split(' ');
            long xTram = long.Parse(args[0]);
            int dirTram = int.Parse(args[1]);

            if (xIgor > xGoal){
                xIgor = S - xIgor;
                xGoal = S - xGoal;
                xTram = S - xTram;
                dirTram = -dirTram;
            }

            long resIgor = (xGoal - xIgor) * tIgor;
            long resTram = 0;
            if (dirTram == 1){
                if (xTram < xIgor){
                resTram = (xGoal - xTram) * tTram;
                } else{
                     resTram =((S - xTram) + S + (xGoal)) * tTram;
                }
            } else{a
                 resTram =(xTram + xGoal) * tTram;
            }

			Console.Out.WriteLine(resTram < resIgor ? resTram : resIgor);
			Console.In.ReadLine();
		}
	}
}


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

namespace crosses
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.SetIn(File.OpenText("input.txt"));

            var field = new char[3, 3];

            int readedChars = 0;
            int row = 0, col = 0;
            bool hasUnsetted = false;
            int v_1 = 0, v_2 = 0;

            while (true)
            {
                if (readedChars == 9)
                {
                    break;
                }

                char temp = (char)Console.Read();
                if (temp == '\r' || temp == '\n')
                {
                    continue;
                }
                else
                {
                    readedChars++;
                    field[row, col] = temp;
                    if (temp == '.')
                    {
                        hasUnsetted = true;
                    }
                    else if (temp == 'X')
                    {
                        v_1++;
                    }
                    else if (temp == '0')
                    {
                        v_2++;
                    }

                    if (col == 2)
                    {
                        row++;
                        col = 0;
                    }
                    else
                    {
                        col++;
                    }
                }
            }

            char x = 'X';
            char o = '0';
            int winsX = 0, wins0 = 0;

            for (int i = 0; i < 3; i++)
            {
                bool rowXWin = true, row0win = true, colXwin = true, col0win = true;
                for (int j = 0; j < 3; j++)
                {
                    if (field[i, j] != x)
                    {
                        rowXWin = false;
                    }

                    if (field[j, i] != x)
                    {
                        colXwin = false;
                    }

                    if (field[i, j] != o)
                    {
                        row0win = false;
                    }

                    if (field[j, i] != o)
                    {
                        col0win = false;
                    }
                }

                if (rowXWin)
                {
                    winsX++;
                }

                if(colXwin)
                {
                    winsX++;
                }

                if (row0win)
                {
                    wins0++;
                }

                if (col0win)
                {
                    wins0++;
                }
            }

            //if (winsX > 1 || wins0 > 1 || (wins0 == 1 && winsX == 1))
            if ((wins0 >= 1 && winsX >= 1))
            {
                Console.WriteLine("illegal");
                return;
            }

            if (v_1 - v_2 > 1 || v_1 - v_2 < 0)
            {
                Console.WriteLine("illegal");
                return;
            }

            if (v_1 > v_2 && wins0 >= 1)
            {
                Console.WriteLine("illegal");
                return;
            }

            if (v_1 == v_2 && wins1 >= 1)
            {
                Console.WriteLine("illegal");
                return;
            }

            if (winsX >= 1)
            {
                Console.WriteLine("the first player won");
                return;
            }

            if (wins0 >= 1)
            {
                Console.WriteLine("the second player won");
                return;
            }

            if (!hasUnsetted)
            {
                Console.WriteLine("draw");
                return;
            }

            if (v_1 > v_2)
            {
                Console.WriteLine("second");
                //return;
            }
            else
            {
                Console.WriteLine("first");
            }
        }
    }
}


using System;
using System.Collections.Generic;

public class Program
{
    public static HashSet<char> vowels = new HashSet<char>(new string[] { 'A', 'E', 'I', 'O', 'U', 'Y' });

	public static void Main(string[] args)
	{
        var input = Console.ReadLine().ToUpper();

        var max = int.MinValue;
        var position = 0;

        while (position != input.Length)
        {
            var tuple = NextVowel(input, position);
            if (tuple == null)
            {
                break;
            }
            position = tuple.Item1;
            max = Math.Max(tuple.Item2, max);
        }

        Console.WriteLine(max);
	}

    public static Tuple<int, int> NextVowel(string text, int position)
    {
        for (var i = position; i < input.Length; i++)
        {
            if (vowels.Contains(text[i]))
            {
                return new Tuple<int, int>(i, (i + 1) - position);
            }
        }

        return null;
    }
}


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

namespace Pr1
{
    class Program
    {
        static void Main()
        {
            string a= Console.ReadLine();
            int k=1,max=0;
            string s="AEIOUY";
            for(int i=0;i<a.Length;i++)
            {
                if(!s.Contains(a[i]))
                {
                    k++;
                    if(i==a.Length-1)
                        max=Math.Max(k,max)
                }
                else
                {
                    max=Math.Max(k,max);
                    k=1;
                }
            }
            Console.WriteLine(max);

        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Globalization
namespace ConsoleApplication3
{
    class Line
    {
        public double a, b, c;
        public Line(double x1, double y1, double x2, double y2)
        {
            a = y2 - y1;
            b = x1 - x2;
            c = -a * x1 - b * y1;
        }
        public Line getPerp(double x1, double y1)
        {
            Line temp = new Line(x1, y1, x1 + a, y1 + b);
            return temp;
        }
        public Tuple<double, double> getInter(Line l2)
        {
            double d = a * l2.b - b * l2.a;
            double dx = -c * l2.b + l2.c * b;
            double dy = -a * l2.c + l2.a * c;
            return new Tuple<double, double>(dx / d, dy / d);
        }
    }
    class Program
    {
        static double sqr(double x)
        {
            return x * x;
        }
        static double getAngle(double x, double y) {
            return Math.PI / 2 - Math.Atan2(x, y);
        }
        static void Main(string[] args)
        {
            string s1 = Console.ReadLine();
            string s2 = Console.ReadLine();
            string s3 = Console.ReadLine();
            string[] sm1 = s1.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
            string[] sm2 = s2.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
            string[] sm3 = s3.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries);
            double x1 = double.Parse(sm1[0], CultureInfo.InvariantCulture);
            double y1 = double.Parse(sm1[1], CultureInfo.InvariantCulture);
            double x2 = double.Parse(sm2[0], CultureInfo.InvariantCulture);
            double y2 = double.Parse(sm2[1], CultureInfo.InvariantCulture);
            double x3 = double.Parse(sm3[0], CultureInfo.InvariantCulture);
            double y3 = double.Parse(sm3[1], CultureInfo.InvariantCulture);
            Line l1 = new Line(x1, y1, x2, y2);
            Line l2 = new Line(x2, y2, x3, y3);
            l1 = l1.getPerp((x1 + x2) / 2, (y1 + y2) / 2);
            l2 = l2.getPerp((x2 + x3) / 2, (y2 + y3) / 2);
            Tuple<double, double> center = l1.getInter(l2);
            double xc = center.Item1;
            double yc = center.Item2;
            double r = Math.Sqrt(sqr(xc - x1) + sqr(yc - y1));
            double ans = 1e+12;

            double angle1 = getAngle(x1 - xc, y1 - yc);
            double angle2 = getAngle(x2 - xc, y2 - yc);
            double angle3 = getAngle(x3 - xc, y3 - yc);
            for (int i = 3; i <= 100; ++i)
            {
                List<Tuple<double, double>> v = new List<Tuple<double,double>>();
                bool flag1 = false;
                bool flag2 = false;
                bool flag3 = false;

                for (int j = 0; j < i; ++j)
                {
                    Tuple<double, double> t = new Tuple<double, double> (xc + Math.Cos(angle1 + (double)2 * (double)Math.PI * j / i) * r, yc + Math.Sin(angle1 + 2 * Math.PI * j / i) * r);
                    v.Add(t);
                }
                foreach (var item in v) {

                    if (Math.Abs(item.Item1 - x1) < (double)1e-5 && Math.Abs(item.Item2 - y1) < (double)1e-5) flag1 = true;
                    if (Math.Abs(item.Item1 - x2) < (double)1e-5 && Math.Abs(item.Item2 - y2) < (double)1e-5) flag2 = true;
                    if (Math.Abs(item.Item1 - x3) < (double)1e-5 && Math.Abs(item.Item2 - y3) < (double)1e-5) flag3 = true;
                }
                if (flag1 && flag2 && flag3) {
                    ans = Math.Min(ans, Convert.Todouble(i) / 2 * sqr(r) * Math.Sin(2 * Math.PI / i));
                }

            }
            Console.WriteLine(ans.ToString());
           // s1 = Console.ReadLine();
        }

    }
}


using System;

class CF0001C_Ancient_Berland_Circus
{
	// minimum legal delta for n up to 100 is 0.009999999999991 (for 67/100 with 97)
	// but computational error encroaches from both ends
	const double EPSILON = 0.0001;

	static int likely_denominator (double d)
	{
		for (int n = 3; n <= 100; ++n)
		{
			double k = d * n;

			if (Math.Abs(k - Math.Round(k)) <= EPSILON)
				return n;
		}

		throw new Exception("likely_denominator(): EPSILON needs tuning");
	}

	static double acos (double x)
	{
		return Math.Acos(Math.Max(-1.0, Math.Min(1.0, x)));
	}

	static double minimal_area (double a, double u, double b, double v, double c, double w)
	{
		double bbvv = b * b + v * v;
		double abuv = a * a + u * u - bbvv;
		double cbwv = c * c + w * w - bbvv;
		double u_v = 2 * (u - v);
		double w_v = 2 * (w - v);
		double a_b = 2 * (a - b);
		double c_b = 2 * (c - b);

		double x = (u_v * cbwv - w_v * abuv) / (u_v * c_b - w_v * a_b);
		double y = (abuv - x * a_b) / u_v;
		double r2 = (a - x) * (a - x) + (u - y) * (u - y);

		const double TWO_PI = 2 * Math.PI;
		double r_ab = acos(((a - x) * (b - x) + (u - y) * (v - y)) / r2) / TWO_PI;
		double r_bc = acos(((b - x) * (c - x) + (v - y) * (w - y)) / r2) / TWO_PI;
		double r_ca = acos(((c - x) * (a - x) + (w - y) * (u - y)) / r2) / TWO_PI;

		int n_ab = likely_denominator(r_ab);
		int n_bc = likely_denominator(r_bc);
		int n_ca = likely_denominator(r_ca);
		int n = Math.Max(n_ab, Math.Max(n_bc, n_ca));

		return n * r2 * Math.Sin(TWO_PI / n) / 2;
	}

	static void Main ()
	{
//		System.Threading.Thread.CurrentThread.CurrentCulture = new System.Globalization.CultureInfo("en-US");
		var nfi = new System.Globalization.NumberFormatInfo();
		nfi.NumberDecimalSeparator = ".";
		string s = Console.ReadLine() + " " + Console.ReadLine() + " " + Console.ReadLine();
		var tokens = s.Split(' ');
		var x0 = double.Parse(tokens[0], nfi);
		var y0 = double.Parse(tokens[1], nfi);
		var x1 = double.Parse(tokens[2], nfi);
		var y1 = double.Parse(tokens[3], nfi);
		var x2 = double.Parse(tokens[4], nfi);
		var y2 = double.Parse(tokens[5], nfi);

		Console.WriteLine(minimal_area(x0, y0, x1, y1, x2, y2), nfi);
	}
}


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

namespace test
{
    class Program
    {

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

        public static bool Contains_lowercase(string S)
        {

            char[] chararr = S.ToCharArray();

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

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

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

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

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

            }

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

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

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

    }
}


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

class Program
{
	static void Main()
	{
		long[] nmk = Console.ReadLine().Split().Select(x => long.Parse(x)).ToArray();
		Console.WriteLine(nmk[0] & 1 == nmk[1] & 1 ? BigInteger.ModPow(2, new BigInteger(nmk[0] - 1) * new BigInteger(nmk[1] - 1), 1000000007) : 0);
	}
}


using System;
using System.Text;

namespace program
{
    class Program
    {
        static StringBuilder output = new StringBuilder();

        static void RunIteration()
        {
            string num = Console.ReadLine();

            int result = (num[0] - 49) * 10;
            result += num.Length switch
            {
                1 => 1,
                2 => 3,
                3 => 6,
                4 => 10,
            };

            output.AppendLine(result.ToString());
        }

        static void Main()
        {
            int count = int.Parse(Console.ReadLine());
            while (count-- > 0)
                RunIteration();

            Console.WriteLine(output);
        }
    }
}


string input = Console.ReadLine();
            int x1 = Convert.ToInt32(input.Split(new Char[] { ' ' })[0]);
            int x2 = Convert.ToInt32(input.Split(new Char[] { ' ' })[1]);
            int count = 0;
            x1--;
            while (true)
            {
                if (count % x2 == 0)
                {
                    x1++;
                }
                if (x1 == 0)
                {
                    break;
                }
                x1--;
                count++;
            }

            Console.WriteLine(count);


using System;

namespace Task47B
{
    class Program
    {
        static void Main(string[] args)
        {
            //string[] container = new string[3];
            //for (int i = 0; i < 3; i++)
            //    container[i]= Console.ReadLine();

            //char lower, mediun, high;
            string ans = "";
            for (int i = 0; i < 3; i++)
            {
                string temp = Console.ReadLine();
                char c1 = temp[0], c2 = temp[2], mark = temp[1];

                if (ans.Equals(""))
                {
                    ans = mark.Equals('<') ? "" + c1 + c2 : "" + c2 + c1;
                }
                else if (!ans.Contains(c1) && ans.Contains(c2))
                {
                    int indexOfC2 = ans.IndexOf(c2);

                    if (mark.Equals('<'))
                       ans = ans.Insert(indexOfC2, c1.ToString());
                    else
                      ans = ans.Insert(indexOfC2 + 1, c1.ToString());
                }
                else if (ans.Contains(c1) && !ans.Contains(c2))
                {
                    int indexOfC1 = ans.IndexOf(c1);

                    if (mark.Equals('<'))
                       ans = ans.Insert(indexOfC1 + 1, c2.ToString());
                    else
                       ans = ans.Insert(indexOfC1, c2.ToString());
                }
                else
                {
                    int indexOfC1 = ans.IndexOf(c1);
                    int indexOfC2 = ans.IndexOf(c2);
                    if ((mark.Equals('<') && indexOfC1 > indexOfC2) || (mark.Equals('>') && indexOfC1 < indexOfC2))
                        ans = "Impossible";
                }
            }

            Console.WriteLine(ans);
          //  Console.ReadKey();
        }

        // private static
    }
}


static void Main(String[] args)
    {
        int[] arrInput = Console.ReadLine().Split(' ').Select(k => int.Parse(k)).ToArray();

        int simon = arrInput[0];
        int antisimon = arrInput[1];
        int stones = arrInput[2];
        int finalResult = -1;
        int j = 1;

        while (j<=100)
        {

            int simonChance = GCD(simon, stones);

            stones -= simonChance;

            if (stones < antisimon)
            {
                finalResult = 0;
                break;
            }

            int antisimonChance = GCD(antisimon, stones);

            stones -= antisimonChance;

            j++;
        }

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

    private static int GCD(int a, int b)
    {
        while (a != 0 && b != 0)
        {
            if (a > b)
                a %= b;
            else
                b %= a;
        }

        return a == 0 ? b : a;
    }


using System;
class test
{
	public static int hrm(int i, int n)
	{
		for(int j=n;j>0;j--)
			{
				if(j%n==0 && i%j==0) return j;
			}

	}
	public static void Main()
	{
		string []input = Console.ReadLine().Split();
        int []input_v = new int [input.Length];

        for(int i=0;i<input.Length;i++)
            {
                input_v[i] = int.Parse(input[i]);
            }

        int j=0;

        while(input_v[2]>0)
        	{
        	if(j%2==0){input_v[2]-=hrm(input_v[0],input_v[2]);}
        	else if(j%2!=0){input_v[2]-=hrm(input_v[1],input_v[2]);}

        	j++;
        	}

        j--;

        if(j%2==0){Console.WriteLine("0");}
        if(j%2!=0){Console.WriteLine("1");}

        Console.ReadLine("");

	}

}


using System;
using System.Text.RegularExpressions;

namespace _20AV1
{
     class Program
     {
          static void Main()
          {
               string st = Console.ReadLine();
               while (st.Contains("//"))
               {
                    st = st.Replace("//", "/");
               }
               if (st.EndsWith('/'))
               {
                    st = st.Remove(st.Length-1, 1);
               }
               Console.WriteLine(st);
          }
     }
}


//Rextester.Program.Main is the entry point for your code. Don't change it.
//Compiler version 4.0.30319.17929 for Microsoft (R) .NET Framework 4.5

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

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            int numeroSorte= int.Parse(Console.ReadLine());  // receber valor
        		  	ForcaBrruta(numeroSorte);
            //Console.ReadKey();
        }
        static void ForcaBrruta(int numSorte)
		{
		int indice =0;
		List<int> mylista = new List<int>();
		int resultado = 0;

			for( int i =0; i <= numSorte; i++)
			{
				if(NumeroSort(Convert.ToString(i)))
				{
					mylista.Add(new int(i));
					if(mylista[indice] == numSorte)
					{
						resultado =

indice;
					}
					indice++;
				}
			}
			Console.WriteLine(resultado+1);
		}
        static bool NumeroSort(string x)
		{
			for(int i = 0; i < x.Length; i++)
			{
				if(x[i] != '4' && x[i] != '7')
					return(false);
			}
			return (true);
		}
    }
}


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

namespace Rextester
{
    public class Program
    {
        public static void Main(string[] args)
        {
            int numeroSorte= int.Parse(Console.ReadLine());  // receber valor
        		  	ForcaBrruta(numeroSorte);
            //Console.ReadKey();
        }
        static void ForcaBrruta(int numSorte)
		{
		int indice =0;
		int32 [ ] Vetor = new int32 [10000000000];
		int resultado = 0;

			for( int i =0; i <= numSorte; i++)
			{
				if(NumeroSort(Convert.ToString(i)))
				{
					Vetor[indice] = i;
					if(Vetor[indice] == numSorte)
					{
						resultado = indice;
					}
					indice++;
				}
			}
			Console.WriteLine(resultado+1);
		}
        static bool NumeroSort(string x)
		{
			for(int i = 0; i < x.Length; i++)
			{
				if(x[i] != '4' && x[i] != '7')
					return(false);
			}
			return (true);
		}
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Configuration;
using System.Runtime.Remoting.Metadata.W3cXsd2001;
using System.Text;
using System.Threading.Tasks;

namespace codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string line = Console.ReadLine();
            string[] numbers = line.Split(' ');
            int a = int.Parse(numbers[0]);
            int b = int.Parse(numbers[1]);

            if(a == b)
                Console.WriteLine(a + " " + b);
            else if (a > b)
            {
                int temp = a - b;
                temp = temp / 2;
                Console.WriteLine(b +" " + temp);
            }
            else
            {
                int temp = b - a;
                temp = temp / 2;
                Console.WriteLine(a + " " + temp);
            }
            Console.ReadLine();
        }


using System;
public class test{
    public static void Main(){
        string input = Console.ReadLine();
        string[] socks = input.Split(' ');

        int days1 = 0;
        int days2 = 0;
        int max = (int)MathF.Max(Int32.Parse(socks[0]), Int32.Parse(socks[1]));
        int min = (int)MathF.Min(Int32.Parse(socks[0]), Int32.Parse(socks[1]));

        days1 = min;
        if (max > 1){
            if ((max - min) % 2 == 0){
                days2 = (max - min) / 2;
            }
            else{
                days2 = (max - min - 1) / 2;
            }
        }
        else{
            days2 = 0;
        }

        System.Console.WriteLine(days1 + " " + days2);
    }
}


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = Convert.ToInt16(Console.ReadLine());
            if (num >= 2)
                Console.WriteLine("25");
            else
                return;
        }
    }
}


int n= 0;
function square (){
console.writeLine("Plesae enter the Input number");
n = console.ReadLine();
for(int i =0;i<n;i++){
int output = 5*5;
int result = output + result;
Console.writeLine(result);
};
};


import java.util.Scanner;
public class Codeforces {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        System.out.print("25");
    }
}


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

namespace OOP

{
    class MainClass
    {
        public static void Main(string[] args)
        {

            int[] point = Console.ReadLine().Split().Select(int.Parse).ToArray();
            Triangle triangle = new Triangle(point[0], point[1], point[2], point[3], point[4], point[5]);
            if (triangle.IsRight())
                Console.WriteLine("RIGHT");
            else if (triangle.IsAlmostRight())
                Console.WriteLine("ALMOST");
            else
                Console.WriteLine("NEITHER");

        }
    }
    class Triangle
    {

        int[] x = new int[4];
        int[] y = new int[4];

        public Triangle(int x1, int y1, int x2, int y2, int x3, int y3)
        {
            x[1] = x1;
            x[2] = x2;
            x[3] = x3;
            y[1] = y1;
            y[2] = y2;
            y[3] = y3;
        }
        public int a { get { return (x[2] - x[1]) * (x[2] - x[1]) + (y[2] - y[1]) * (y[2] - y[1]); } }
        public int b { get { return (x[3] - x[2]) * (x[3] - x[2]) + (y[3] - y[2]) * (y[3] - y[2]); } }
        public int c { get { return (x[3] - x[1]) * (x[3] - x[1]) + (y[3] - y[1]) * (y[3] - y[1]); } }

        public bool IsRight()
        {

            if (a > b && a > c)
            {
                return c + b == a;
            }
            else if (b > c && b > a)
            {
                return a + c == b;
            }
            else if (c > a && c > b)
            {
                return a + b == c;
            }

            return false;
        }
        public bool IsAlmostRight()
        {
            int[] dx = { -1, 0, 1, 0 };
            int[] dy = { 0, 1, 0, -1 };
            for (int i = 0; i < 4; i++)
            {
                Triangle t1 = new Triangle(x[1] + dx[i], y[1] + dy[i], x[2], y[2], x[3], y[3]);
                Triangle t2 = new Triangle(x[1], y[1], x[2] + dx[i], y[2] + dy[i], x[3], y[3]);
                Triangle t3 = new Triangle(x[1], y[1], x[2], y[2], x[3] + dx[i], y[3] + dy[i]);
                if (t1.IsRight() || t2.IsRight() || t3.IsRight())
                    return true;
            }
            return false;

        }


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

namespace ConsoleApplication4
{
    class Program
    {
        static void Main(string[] args)
        {
            int w1, h1, w2, h2, result;
            string []s;
           do
            {
            s = Console.ReadLine().Split(' ');
            w1 = int.Parse(s[0]);
            h1 = int.Parse(s[1]);
            w2 = int.Parse(s[2]);
            h2 = int.Parse(s[3]);
            } while (w1<w2)

            result = w1 + h1 + h2 + w2 + h2 + h2;

            if (w1 == w2)
                result += 4;
            else
                result += 5;
            Console.WriteLine(result);
            Console.ReadKey();
        }
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.Threading.Tasks;

namespace project
{
    class Program
    {
        static void Main(string[] args)
        {
            string input = Console.ReadLine();
            int x = int.Parse(input.Split(new char[] { ' ' })[0]);
            int y = int.Parse(input.Split(new char[] { ' ' })[1]);
            int startX = 1, startY = 0, ans = 0, type = 0 , output = - 1;
            int ax = 1, ay = 1 , t;
            if (x == 0 && y == 0)
                Console.WriteLine(0);
            else
            {
                while (output == -1)
                {
                    if (type == 0)
                    {
                        t = startX;
                        while (startX <= t + ax - 1)
                        {
                            if (startX == x && startY == y)
                            {
                                output = ans;
                                break;
                            }
                            startX++;
                        }
                        startX--;
                        startY++;
                    }
                    else if (type == 1)
                    {
                        t = startY;
                        while (startY <= t + ay - 1)
                        {
                            if (startX == x && startY == y)
                            {
                                output = ans;
                                break;
                            }
                            startY++;
                        }
                        startX--;
                        startY--;
                        ax++;
                        ay++;
                    }
                    else if (type == 2)
                    {
                        t = startX;
                        while (startX >= t - ax + 1)
                        {
                            if (startX == x && startY == y)
                            {
                                output = ans;
                                break;
                            }
                            startX--;
                        }
                        startX++;
                        startY--;
                    }
                    else if (type == 3)
                    {
                        t = startY;
                        while (startY >= t - ay + 1)
                        {
                            if (startX == x && startY == y)
                            {
                                output = ans;
                                break;
                            }
                            startY--;
                        }
                        startY++;
                        startX++;
                        ax++;
                        ay++;
                    }
                    type = (type + 1) % 4;
                    ans++;
                }
                Console.WriteLine(output);
            }
        }
    }
}


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

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

            string[] input = Console.ReadLine().Split(' ');

            int xCoordinate = Int32.Parse(input[0]);
            int yCoordinate = Int32.Parse(input[1]);
            //int turnsCOmpleted = 0;
            int turnsTaken = 0;
            if ((xCoordinate == 0 && yCoordinate == 0) || (xCoordinate == 1 && yCoordinate == 0))
                return 0;
            else
            {
                int currentXCoor = 0;
                int currentYCoor = 0;
                int previousXCoor = 1;
                int previousYCoor = 0;
                int quadrant = 1;

                for (int i = 0; i < int.MaxValue; i++)
                {
                    //int y = 0;
                    //int x = 0;
                    if (quadrant == 1)
                    {
                        currentXCoor = previousXCoor;
                        currentYCoor = previousYCoor + 1 +(2*(-previousYCoor));
                        turnsTaken += 1;
                        if(xCoordinate == currentXCoor)
                        {
                            if (yCoordinate >= previousYCoor && yCoordinate <= currentYCoor)
                                break;

                        }

                    }
                    //continue;
                    else if (quadrant == 2)
                    {
                        currentXCoor = -previousXCoor;
                        currentYCoor = previousYCoor;
                        turnsTaken += 1;
                        if(yCoordinate == currentYCoor)
                        {
                            if (xCoordinate <= previousXCoor && xCoordinate >= currentXCoor)
                                break;
                        }

                        //c//ontinue;
                    }
                    else if (quadrant == 3)
                    {
                        currentXCoor = previousXCoor;
                        currentYCoor = -previousYCoor;
                        turnsTaken += 1;
                        if(xCoordinate == currentXCoor)
                        {
                            if (yCoordinate >= currentYCoor && yCoordinate <= previousYCoor)
                                break;
                        }

                    }

                    else if(quadrant == 4)
                    {
                        currentXCoor = -previousXCoor+1;
                        currentYCoor = previousYCoor;
                        turnsTaken += 1;
                        if(yCoordinate == currentYCoor)
                        {
                            if (xCoordinate >= previousXCoor && xCoordinate <= currentXCoor)
                                break;
                        }

                    }
                    previousXCoor = currentXCoor;
                    previousYCoor = currentYCoor;
                    if (quadrant == 4)
                        quadrant = 1;
                    else
                        quadrant += 1;

                }
            }
            Console.WriteLine(turnsTaken);
        }

    }


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

namespace CodeForces
{
    class Program
    {
        static void Main(string[] args)
        {
            var input = Console.ReadLine().Split(" ").Select((s) => int.Parse(s)).ToList();
            var n = input[0];
            var t = input[1];

            var queue = Console.ReadLine().ToArray();

            while (t-- > 0)
            {
                for (int i = 0; i < queue.Count() - 1; i++)
                {
                    var isBoy = queue[i] == 'B';
                    var isNextBoy = queue[i + 1] == 'B';

                    if (isBoy && !isNextBoy)
                    {
                        queue[i] = 'G';
                        queue[i + 1] = 'B';
                        i++;
                    }
                }
            }
            Console.WriteLine(new string(queue));
        }
    }
}


using System;
class test{
    public static void Main(string[] temp){
        int[] NK=Array.ConvertAll(Console.ReadLine().Split(' '),Int32.Parse);
        StringBuilder queue=new StringBuilder(Console.ReadLine());
        for(int i=0;i<NK[1];i++){
            for(int j=1;j<NK[0];j++){
                if(queue[j]='G'&&queue[j-1]=='B'){
                    queue[j-1]=='G';
                    queue[j]='B';
                    }
            }
            Console.WriteLine(queue.ToString());
        }
    }
}


int t = int.Parse(Console.ReadLine().Trim().Split(' ')[1]);
			string s = Console.ReadLine().Trim();
			for(int i = 0; i < t; i++) s = s.Replace("BG", "GB");
			Console.WriteLine(s);


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

namespace NSproul //A
{
    static class Program
    {
        static void Main()
        {
            int x = Int32.Parse(Console.ReadLine());
            int a = 0;
			int b = 0;
            for (int i = Math.Floor(Math.Sqrt(x)); i > 0; i--)
            {
                if(x%i == 0) {
					a = i;
					b = x/i;
				}
            }
            Console.WriteLine(a + " " + b);
        }
    }
}


using System;
using System.Linq;
using Xunit.Abstractions;

namespace CodeForce
{
    internal class Quserty
    {
        private static void Main(string[] args)
        {
            var input = Console.ReadLine();
            var inps = input.Split(' ');
            var length =  int.Parse(inps.First());
            var diameter =  int.Parse(inps[1]);

            input = Console.ReadLine();
            var array =  input.Split(' ').Select(int.Parse).OrderBy(it => it).ToArray();
            var max = array[array.Length - 1];

            var isInSet = new int[max + 1];
            for (var i = 0; i < array.Length; i++)
            {
                var el = array[i];
                isInSet[el] += 1;
            }

            for (var i = 1; i < isInSet.Length; i++)
            {
                isInSet[i] = isInSet[i - 1] + isInSet[i];
            }

            var result = int.MaxValue;

            for (var i = 0;; i++)
            {
                var leftElement = array[i];
                var rightElement = leftElement + diameter;
                if (rightElement > max)
                {
                    rightElement = max;
                }

                var diff = isInSet[rightElement] - isInSet[leftElement - 1];
                var newResult = array.Length - diff;
                result = Math.Min(result, newResult);

                if (rightElement == max)
                {
                    break;
                }
            }

            Console.WriteLine(result);
        }
    }
}


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)
		{
			Console.WriteLine("YES");

		}
			else
			Console.WriteLine("NO");

	}
}


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

namespace acm{
    class Program{
#if DEBUG
        static bool file = true;
        static TextReader fin = new StreamReader("input.txt");
        static TextWriter fout = new StreamWriter("output.txt");
        static void open(bool f) { if (f) { Console.SetIn(fin); Console.SetOut(fout);  } }
        static void close(bool f) { if (f) fout.Close(); }
#endif
        static void swap<T>(ref T a, ref T b) { T t = a; a = b; b = t; }
        static void print(object o) { Console.Write(o); }
        static void print(String f, params object[] o) { Console.WriteLine(f, o); }
        static void println() { Console.WriteLine(); }
        static void println(object o) { Console.WriteLine(o); }
        static void println(String f, params object[] o) { Console.WriteLine(f, o); }
        static string RL() { return Console.ReadLine(); }

        static void Main(string[] args) {
#if DEBUG
            open(file);
#endif
 			BigInteger test=12379187;
			string n1=Console.ReadLine(), n2=Console.ReadLine();
			int[] digits=new int[n1.Length];

			for(int i=0; i<n1.Length; i++){
				digits[i]=int.Parse(""+n1[i]);
			}

			Array.Sort(digits);

			if (digits[0]!=0){
				string t="";
				foreach(int v in digits) t+=v.ToString();
				if (t==n2) println("OK");
				else println("WRONG_ANSWER");
			} else {
				int k=0;
				while(k<n1.Length && digits[k]==0) k++;
				swap(ref digits[0], ref digits[k]);
				string t="";
				foreach(int v in digits) t+=v.ToString();
				if (t==n2) println("OK");
				else println("WRONG_ANSWER");
			}

#if DEBUG
            close(file);
#endif
        }
    }
}


using System;

namespace ConsoleApp7
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            string word = Console.ReadLine();

            Console.WriteLine(word.Contains('Q') || word.Contains('H') || word.Contains('9') ? "YES" : "NO");
        }
    }
}


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

namespace ConsoleApp2
{
    class Program
    {
        static void swap<T>(ref T a, ref T b)
        {
            T c = a;
            a = b;
            b = c;
        }
        static void Main(string[] args)
        {
            string str = Console.ReadLine();
            bool flag = false;
            foreach (char i in str)
            {
                if ((i == 'H') | (i == 'Q') | (i == '9'))
                {
                    Console.WriteLine("YES");
                    flag = !flag;
                    break;
                }
            }
            if (!flag)
                {
                    Console.WriteLine("NO");

                }
            }
            //System.Console.ReadKey();
        }
    }
}


using System;
class Program
    {
        static void Main(string[] args)
        {
            string input = Console.ReadLine();
            char[] dt = {'H', 'Q', 9' };
            for (int i = 0; i < 3; ++i)
                if (input.IndexOf(dt[i]) >= 0) { dt[0] = 's'; break; }
            Console.WriteLine(dt[0] == 's' ?"YES":"NO");
        }
    }


using System;
using System.Linq;

namespace Application
{
    class Program
    {
        static void Main(string[] args)
        {
            CConsole.WriteLine(Console.ReadLine().Where(c => "HQ9".Contains(c)).Count() == 0 ? "NO" : "YES");
        }
    }
}


class Program
    {
        static void Main(string[] args)
        {
            string q = Console.ReadLine();
            if (q.Contains("H")|| q.Contains("Q") || q.Contains("9") )
            {
                Console.WriteLine("YES");
            }
            else
            {
                Console.WriteLine("NO");
            }
        }
    }


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

public class HQ9
{
    public HQ9()
    {
        int i = 0;
        bool output = false;
        string x = Console.ReadLine().Trim();
        for (i = 0; i < x.Length; i++)
        {
            if (x[i] == 'H' || x[i] == 'Q' || x[i] == '9')
            {
                output = true;
                break;
            }
        }
        Console.WriteLine(output ? "YES" : "NO");
    }
}


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

namespace Codeforces
{
    class _268B
    {
        public static void Main_268()
        {
            int n = int.Parse(Console.ReadLine());
            int s = n;
            for (int i = 1; i < n; i++)
            {
                s = s + i * (n - i);
            }
            Console.WriteLine(s);
        }
    }
}


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

using std::cout;
using std::endl;
using std::cin;

int main()
{
    int n, k = 1, answer;
    cin >> n;
    answer = n;
    n--;
    while (n>0)
    {
        answer+=n*k;
        k++;
        n--;
    }
    cout << answer << endl;
    return 0;
}


using System;
using System.Collections.Generic;

namespace ConsoleApp14
{
    class Program
    {
        public static int Reachable_Num(int ip)
        {
           if (ip < 10)
            {
                Console.WriteLine('9');
                return;
            }
            int res = 10 - (ip % 10);
            ip /= 10;
            while(ip>= 10)
            {
                res += 9 - (ip % 10);
                ip /= 10;
            }
            res += 9;
            return res;
        }

        static void Main(string[] args)
        {
            Console.WriteLine(Reachable_Num(Convert.ToInt32(Console.ReadLine())));
        }
    }
}


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

class Program{
    static void Main(){
        System.Threading.Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
#if !ONLINE_JUDGE
        StreamWriter fout;
        Console.SetIn(new StreamReader("input.txt"));
        Console.SetOut(fout=new StreamWriter("output.txt"));
#endif
        int n = readInt();
        int count = 0;
        HashSet<int> divs = new HashSet<int>();

        for (int i = 2; i <= n; i++)
        {
            int k = 2, j = i;
            while (true) {
                if (j % k == 0)
                {
                    divs.Add(k);
                    j /= k;
                } else k++;

                if (j == 1) break;
            }

            if (divs.Count == 2) count++;
            divs.Clear();
        }

        print(count);

#if !ONLINE_JUDGE
        fout.Close();
#endif
    }

    struct quat<T1, T2, T3, T4> { public T1 fst; public T2 snd; public T3 thr; public T4 frt; }
    struct trip<T1, T2, T3> { public T1 fst; public T2 snd; public T3 thr; }
    struct pair<T1, T2> { public T1 fst; public T2 snd; }
    static long LCM(long a, long b) { return a / GCD(a, b) * b; }
    static long GCD(long a, long b) { if (b == 0) return a; else return GCD(b, a % b); }
    static void swap<T>(ref T a, ref T b) { T tmp = a; a = b; b = tmp; }
    static double dist(double x1, double y1, double x2, double y2) { return Math.Sqrt(Math.Pow(x1-x2, 2)+Math.Pow(y1-y2, 2)); }
    static void fill<T>(T[] d, T v) { for (int i = 0; i < d.Length; i++) d[i] = v; }
    static void fill<T>(T[,] d, T v) { for (int i = 0; i < d.GetLength(0); i++) { for (int j = 0; j < d.GetLength(1); j++) { d[i, j] = v; } } }

    static void print(double v) { Console.Write(v); }
    static void print(long v) { Console.Write(v); }
    static void print(int v) { Console.Write(v); }
    static void print(string v) { Console.Write(v); }
    static void print(char v) { Console.Write(v); }
    static void print(BigInteger v) { Console.Write(v); }
    static void print(String f, params object[] o) { Console.Write(f, o); }

    static void println(double v) { Console.WriteLine(v); }
    static void println(long v) { Console.WriteLine(v); }
    static void println(int v) { Console.WriteLine(v); }
    static void println(string v) { Console.WriteLine(v); }
    static void println(char v) { Console.WriteLine(v); }
    static void println(BigInteger v) { Console.WriteLine(v); }
    static void println() { Console.WriteLine(); }
    static void println(String f, params object[] o) { Console.WriteLine(f, o); }

    static string RL() { return Console.ReadLine(); }
    static int[] readValsI(int n) { int[] t = new int[n]; for (int i = 0; i < n; i++) t[i] = readInt(); return t; }
    static double[] readValsD(int n) { double[] t = new double[n]; for (int i = 0; i < n; i++) t[i] = readDouble(); return t; }

    static BigInteger readBigInt()
    {
        BigInteger val = 0;
        bool m = false;
        int c;
        while (((c = Console.Read()) < '0' || c > '9') && c != '-') { }
        val = (c >= '0' && c <= '9') ? c - 48 : (c == '-' ? m=true : m=false) ? 0 : 0;
        while ((c = Console.Read() - 48) >= 0 && c <= 9) val = val*10 + (m?-c:c);
        return val;
    }

    static double readDouble() {
        bool m = false;
        double val = 0;
        int c = 0, r = 1;
        while(((c=Console.Read())<'0' || c>'9') && c!='-') {}
        val = (c >= '0' && c <= '9') ? c - 48 : (c == '-' ? m=true : m=false) ? 0 : 0;
        while ((c = Console.Read()) >= '0' && c <= '9') val = val * 10 + (m?-(c-48):(c-48));
        if(c=='.') while ((c = Console.Read()) >= '0' && c <= '9'){ val += ((double)(c-48))/(r*=10); }

        return val;
    }

    static long readLong()
    {
        long val = 0;
        bool m = false;
        int c;
        while (((c = Console.Read()) < '0' || c > '9') && c != '-') { }
        val = (c >= '0' && c <= '9') ? c - 48 : (c == '-' ? m=true : m=false) ? 0 : 0;
        while ((c = Console.Read() - 48) >= 0 && c <= 9) val = val*10 + (m?-c:c);
        return val;
    }

    static int readInt()
    {
        bool m = false;
        int val = 0, c;
        while (((c = Console.Read()) < '0' || c > '9') && c != '-') { }
        val = (c >= '0' && c <= '9') ? c - 48 : (c == '-' ? m=true : m=false) ? 0 : 0;
        while ((c = Console.Read() - 48) >= 0 && c <= 9) val = val*10 + (m?-c:c);
        return val;
    }

    static string readLine() {
        string s = "";
        int c;
        while((c=Console.Read())!=10 && c!=-1) s+=(char)c;
        return s;
    }

    static string readString() {
        string s = "";
        int c;
        while ((c = Console.Read()) != 10 && c != 32 && c != -1) s += (char)c;
        return s;
    }
}


Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.27428.2015
MinimumVisualStudioVersion = 10.0.40219.1
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Cakeminator", "Cakeminator\Cakeminator.csproj", "{69B40C6B-8B15-4893-BC10-C83C32D163CE}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{69B40C6B-8B15-4893-BC10-C83C32D163CE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{69B40C6B-8B15-4893-BC10-C83C32D163CE}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{69B40C6B-8B15-4893-BC10-C83C32D163CE}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{69B40C6B-8B15-4893-BC10-C83C32D163CE}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {145B729C-3B15-4625-9DF8-9D75548722C1}
	EndGlobalSection
EndGlobal