Little Petya loves playing with squares. Mum bought him a square 2n × 2n in size. Petya marked a cell inside the square and now he is solving the following task.The task is to draw a broken line that would go along the grid lines and that would cut the square into two equal parts. The cutting line should not have any common points with the marked cell and the resulting two parts should be equal up to rotation.Petya wants to determine whether it is possible to cut the square in the required manner given the sizes of the square side and the coordinates of the marked cell. Help him.

The first line contains three space-separated integers 2n, x and y (2 ≤ 2n ≤ 100, 1 ≤ x, y ≤ 2n), representing the length of a square's side and the coordinates of the marked cell. It is guaranteed that 2n is even. The coordinates of the marked cell are represented by a pair of numbers x y, where x represents the number of the row and y represents the number of the column. The rows and columns are numbered by consecutive integers from 1 to 2n. The rows are numbered from top to bottom and the columns are numbered from the left to the right.

If the square is possible to cut, print "YES", otherwise print "NO" (without the quotes).

NoteA sample test from the statement and one of the possible ways of cutting the square are shown in the picture:

using System;

namespace _112B_PetyaAndSquares
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            int n = int.Parse(input[0]);
            int x = int.Parse(input[1]);
            int y = int.Parse(input[2]);

            Console.WriteLine( (x == n/2 || x == n/2+1) && (y == n/2 || y == n/2+1) ? "NO" : "YES");
        }
    }
}

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

namespace Task
{
    #region MyIo

    class MyIo : IDisposable
    {
        TextReader inputStream;
        TextWriter outputStream = Console.Out;

        string[] tokens;
        int pointer;

        public MyIo(TextReader inputStream)
        {
            this.inputStream = inputStream;
        }

        public string NextLine()
        {
            try
            {
                return inputStream.ReadLine();
            }
            catch (IOException)
            {
                return null;
            }
        }

        public string NextString()
        {
            try
            {
                while (tokens == null || pointer >= tokens.Length)
                {
                    tokens = NextLine().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                    pointer = 0;
                }
                return tokens[pointer++];
            }
            catch (IOException)
            {
                return null;
            }
        }

        public int NextInt()
        {
            return int.Parse(NextString());
        }

        public long NextLong()
        {
            return long.Parse(NextString());
        }

        public void Print(string format, params object[] args)
        {
            outputStream.Write(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public void PrintLine(string format, params object[] args)
        {
            Print(format, args);

            outputStream.WriteLine();
        }

        public void Print<T>(T o)
        {
            if (o is bool)
                if (object.Equals(o, true)) outputStream.Write("YES"); else outputStream.Write("NO");
            else
                outputStream.Write(o);
        }

        public void Close()
        {
            inputStream.Close();
            outputStream.Close();
        }

        void IDisposable.Dispose()
        {
            Close();
        }
    }
    #endregion

    class Program
    {
        #region Program
        MyIo io;

        public Program(MyIo io)
        {
            this.io = io;
        }

        static void Main(string[] args)
        {
#if  LOCAL_TEST
            using (MyIo io = new MyIo(new StreamReader("input.txt")))
#else
                using (MyIo io = new MyIo(System.Console.In))
#endif

            {
                new Program(io)
                    .Solve();

#if  LOCAL_TEST
                Console.ReadLine();
#endif
            }
        }

        #endregion

        void Solve()
        {
            object res = ReSolve();

            if (res != null)
                io.Print(res);
        }

        private object ReSolve()
        {
            int n = io.NextInt() >> 1;
            int x = io.NextInt();
            int y = io.NextInt();

            return !((x == n || x == n + 1) && (y == n || y == n + 1));
        }

    }
}

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

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            int n, x, y;
            string s = Console.ReadLine();
            char[] par = { ' ' };
            string[] ss = s.Split(par);
            n = Convert.ToInt32(ss[0]);
            x = Convert.ToInt32(ss[1]);
            y = Convert.ToInt32(ss[2]);
            if (((x == n / 2) | (x == n / 2 + 1)) & ((y == n / 2) | (y == n / 2 + 1))) Console.WriteLine("NO");
            else Console.WriteLine("YES");
        }
    }
}

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

public partial class codeforces85B
{
    public static void B()
    {
        string[] given = Console.ReadLine().Split(' ');
        int n = int.Parse(given[0]);
        int x = int.Parse(given[1]) - 1;
        int y = int.Parse(given[2]) - 1;
        n/=2;
        if ((x == n || x == n - 1) && (y == n || y == n - 1)) Console.WriteLine("NO");
        else Console.WriteLine("YES");
    }

    public static void Main()
    { B(); }
}

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

namespace Tomasz.CodeForces.Algo
{
    class Program
    {
        static int c = 0;

        static TextReader I = Console.In;
        static TextWriter O = Console.Out;

        static void Main()
        {
            c++;
            string[] a = I.ReadLine().Split();
            int n = int.Parse(a[0])/2, x = int.Parse(a[1]), y = int.Parse(a[2]);

            string res = (x >= n && x <= n + 1 && y >= n && y <= n + 1) ? "NO" : "YES";

            O.WriteLine(res);
        }
    }
}

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

namespace B {
	class Program {
		static void Main(string[] args) {
			var s = Console.ReadLine();
			var vals = s.Split(' ').Select(_ => int.Parse(_)).ToArray();
			var nx2 = vals[0];
			var x = vals[1];
			var y = vals[2];

			var nx = nx2/2;
			if ((x == nx && y == nx) ||
				(x == nx && y == nx + 1) ||
				(x == nx + 1 && y == nx) ||
				(x == nx + 1 && y == nx + 1)) {
				Console.WriteLine("NO");
			}
			else {
				Console.WriteLine("YES");
			}
		}
	}
}

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

namespace Contest
{
    class Program
    {

        static void Main(string[] args)
        {
            var input = Console.ReadLine().Split(' ').Select(sss=>int.Parse(sss)).ToArray();
            var n = input[0]/2;
            var x = input[1];
            var y = input[2];
            if(x>n-1 && x<=n+1 && y>n-1 && y<=n+1)
            {
                Console.WriteLine("NO");
            }
            else Console.WriteLine("YES");
        }
    }
}

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

namespace Contest
{
    class Program
    {

        static void Main(string[] args)
        {
            var input = Console.ReadLine().Split(' ').Select(sss=>int.Parse(sss)).ToArray();
            var n = input[0]/2;
            var x = input[1];
            var y = input[2];
            if(x>n-1 && x<=n+1 && y>n-1 && y<=n+1)
            {
                Console.WriteLine("NO");
            }
            else Console.WriteLine("YES");
        }
    }
}

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

namespace _85D2B
{
    class Program
    {
        static void Main(string[] args)
        {
            var t = Console.ReadLine().Split(' ');
            int n = int.Parse(t[0]);
            int x = int.Parse(t[1]);
            int y = int.Parse(t[2]);
            if ((x == n / 2) && (y == n / 2))
            {
                Console.WriteLine("NO");
            }
            else if ((x == n / 2 + 1) && (y == n / 2))
            {
                Console.WriteLine("NO");
            }
            else if ((x == n / 2 + 1) && (y == n / 2 + 1))
            {
                Console.WriteLine("NO");
            }
            else if ((x == n / 2) && (y == n / 2 + 1))
            {
                Console.WriteLine("NO");
            }
            else
            {
                Console.WriteLine("YES");
            }
            Console.ReadLine();
        }
    }
}

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

namespace CF_85_D2_A
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = Console.ReadLine();
            int n = int.Parse(s.Split(' ')[0]) / 2;
            int x = int.Parse(s.Split(' ')[1]);
            int y = int.Parse(s.Split(' ')[2]);
            int n2 = n + 1;
            if (x == n && y == n ||
                x == n2 && y == n ||
                x == n && y == n2 ||
                x == n2 && y == n2
                )
                Console.Write("NO");
            else
                Console.Write("YES");
            //Console.ReadKey();
        }
    }
}

using System;
class Test {
    static void Main() {
        string [] str = Console.ReadLine().Split();
        int dn = int.Parse(str[0]);
        int n = dn/2;
        int x = int.Parse(str[1]);
        int y = int.Parse(str[2]);
        if( (x == n || x == n+1) && (y == n || y == n+1) ){
            Console.WriteLine("NO");
        }else{
            Console.WriteLine("YES");
        }
    }
}

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

class PetyaAndSquare
{
    static int Main()
    {
        //citire
        string[] citire = Console.ReadLine().Split(' ');
        int N, x, y;
        N = Convert.ToInt32(citire[0]);
        x = Convert.ToInt32(citire[1]);
        y = Convert.ToInt32(citire[2]);

        //solve
        if (x == N/2 && y == N/2 || x == N/2+1 && y == N/2 ||
            x == N/2 && y == N/2+1 || x == N/2+1 && y == N/2+1) Console.Write("NO");
        else Console.WriteLine("YES");

        return 0;
    }
}

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

namespace Codeforces
{
    class Program
    {
        static int ReadInt()
        {
            return Int32.Parse(Console.ReadLine());
        }
        static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        static void ReadIntArray(out int[] array, char separator = ' ')
        {
            var input = Console.ReadLine().Split(separator);
            array = new int[input.Length];
            for (int i = 0; i < input.Length; i++)
            {
                array[i] = Int32.Parse(input[i]);
            }

        }

        static void Main()
        {
            var input = Console.ReadLine().Split(' ');
            int n = Int32.Parse(input[0]) / 2;
            int x = Int32.Parse(input[1]);
            int y = Int32.Parse(input[2]);
            var res = "YES";
            if ((x == n || x == n + 1) && (y == n || y == n + 1))
                res = "NO";
            Console.WriteLine(res);
        }
    }
}

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

namespace ConsoleApplication1
{
  class Program
  {

    static void Main(string[] args)
    {
      string[] s = Console.ReadLine().Split(' ');
      int n = int.Parse(s[0]);
      int x = int.Parse(s[1]);
      int y = int.Parse(s[2]);

      if  (((n/2 == x) | (n/2 == x-1)) &
          ((n/2 == y) | (n/2 == y-1)))
        Console.WriteLine("NO"); else
        Console.WriteLine("YES");

    }
  }
}

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

class Solver
{
	public void Solve()
	{
        var ss = CF.ReadLine().Split(' ');
        int n2 = int.Parse(ss[0]);
        int x = int.Parse(ss[1]);
        int y = int.Parse(ss[2]);

        int n = n2 / 2;

        if( (x==n||x==n+1)&&(y==n||y==n+1))
            CF.WriteLine("NO");
        else
            CF.WriteLine("YES");

    }

	//  test
	static Utils CF = new Utils(new[]{
@"
4 1 1
",
 @"
2 2 2
"
    });

    #region test

    static void Main(string[] args)
    {
#if DEBUG
        for (int t=0;t<CF.TestCount;t++ )
        {
            CF.Test(t);
            new Solver().Solve();
        }
#else
        new Solver().Solve();
#endif
    }

    class Utils
    {
        public void Test(int t)
        {
            _lines = new List<string>();
            string[] ss = _test_input[t].Replace("\n", "").Split('\r');
            for (int i = 0; i < ss.Length; i++)
            {
                if (
                    (i == 0 || i == ss.Length - 1) &&
                    ss[i].Length == 0
                    )
                    continue;

                _lines.Add(ss[i]);
            }
        }

        public int TestCount
        {
            get
            {
                return _test_input.Length;
            }
        }

        public string ReadLine()
        {
#if DEBUG
            string s = null;
            if (_lines.Count > 0)
            {
                s = _lines[0];
                _lines.RemoveAt(0);
            }
            return s;

#else
            //return _sr.ReadLine();
        return Console.In.ReadLine();
#endif
        }

        public void WriteLine(object o)
        {
#if DEBUG
            System.Diagnostics.Trace.WriteLine(o);
#else
            //_sw.WriteLine(o);
        Console.WriteLine(o);
#endif
        }

        public void Write(object o)
        {
#if DEBUG
            System.Diagnostics.Trace.Write(o);
#else
                //_sw.Write(o);
        Console.Write(o);
#endif
        }

        string[] _test_input;

        List<string> _lines;

#if DEBUG
        public Utils(string[] test_input)
        {
            _test_input = test_input;
        }
#else

        public Utils(string[] dummy)
        {
            //_sr = new System.IO.StreamReader("input.txt");
            //_sw = new System.IO.StreamWriter("output.txt");
        }
#endif

    }

    #endregion
}

using System;
using System.ComponentModel;
using System.IO;
using System.Reflection;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;

namespace ConsoleApplication1
{
    class Program
    {
        static class Scanner
        {
            readonly static IEnumerator<string> Tokens;
            static Scanner()
            {
                Tokens = Enumerable.Range(Int32.MinValue, Int32.MaxValue).
                    Select(s => Console.ReadLine()).
                    TakeWhile(s => s != null).
                    SelectMany(s => s.Split(new[] { ' ', '\r', '\n', '\t' }, StringSplitOptions.RemoveEmptyEntries)).
                    Concat(Enumerable.Repeat(0, 1).Select(_ => (string)null)).
                    GetEnumerator();
            }

            public static string NextToken()
            {
                Tokens.MoveNext();
                return Tokens.Current;
            }
        }

        static int NextInt()
        {
            return int.Parse(Scanner.NextToken());
        }

        static long NextLong()
        {
            return long.Parse(Scanner.NextToken());
        }

        void Solve()
        {
            int n = NextInt(), x = NextInt(), y = NextInt();
            int dx = x - n/2, dy = y - n/2;
            Console.Write(!(dx > 1 || dx < 0 || dy > 1 || dy < 0) ? "NO" : "YES");
        }

        static void Main()
        {
#if MY_SUPER_PUPER_ONLINE_JUDGE
            string dir = Directory.GetCurrentDirectory();
            dir = Directory.GetParent(dir).FullName;
            dir = Directory.GetParent(dir).FullName;
            Console.SetIn(new StreamReader(dir + "\\input.txt"));
            Console.SetOut(new StreamWriter(dir + "\\output.txt"));
#endif
            Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
            new Program().Solve();
#if MY_SUPER_PUPER_ONLINE_JUDGE
            Console.In.Close();
            Console.Out.Close();
#endif
        }
    }
}

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

namespace CodeForces_85
{
    class prob_b
    {

        static void Main()
        {
            string[] tmp = Console.ReadLine().Split(" ".ToCharArray());
            int n = Int32.Parse(tmp[0]);
            int x = Int32.Parse(tmp[1]);
            int y = Int32.Parse(tmp[2]);

            if (x >= n / 2 && x <= n / 2 + 1 && y >= n / 2 && y <= n / 2 + 1)
                Console.WriteLine("NO");
            else Console.WriteLine("YES");

        }

    }
}

using System;
using System.Collections.Generic;
class some
{
	public static void Main()
	{
		string[] kk=Console.ReadLine().Split();
		int side=Int32.Parse(kk[0]);
		int x=Int32.Parse(kk[1]);
		int y=Int32.Parse(kk[2]);
		if(side>2)
		{
			if(y==side/2 && x==side/2)
				Console.WriteLine("NO");
			else if(y-1==side/2 && x-1==side/2)
				Console.WriteLine("NO");
			else if(y-1==side/2 && x==side/2)
				Console.WriteLine("NO");
			else if(y==side/2 && x-1==side/2)
				Console.WriteLine("NO");
			else
				Console.WriteLine("YES");
		}
		else
			Console.WriteLine("NO");

	}
}

using System;

 class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.In.ReadToEnd().Split(new char[] {' '}, StringSplitOptions.RemoveEmptyEntries);
            int[] data = new int[input.Length];
            for (int i = 0; i < input.Length; ++i)
                data[i] = int.Parse(input[i]);
            input = null;
            data[0] /= 2;
            string answer = "YES";
            if ((data[1] == data[0] || data[1] == data[0] + 1) && (data[2] == data[0] || data[2] == data[0] + 1))
                answer = "NO";
            Console.WriteLine(answer);
        }
    }

using System; using System.Linq;

class P {
  static void Main() {
    var s= Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
    var n = s[0];
    Func<int,bool> ok = x => x < n/2 || x > n/2+1;
    Console.Write(ok(s[1]) || ok(s[2]) ? "YES" : "NO");
  }
}

using System;
using System.IO;
using System.Text;

namespace Petya_and_Square
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            int n = Next();
            int x = Next();
            int y = Next();

            int x1 = n - x + 1;
            int y1 = n - y + 1;

            int dist = Math.Max(Math.Abs(x - x1), Math.Abs(y - y1));

            writer.WriteLine(dist > 2 ? "YES" : "NO");
            writer.Flush();
        }

        private static int Next()
        {
            int c;
            int res = 0;
            do
            {
                c = reader.Read();
                if (c == -1)
                    return res;
            } while (c < '0' || c > '9');
            res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return res;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

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

namespace Square
{
class Program
{
static void Main(string[] args){
int n, x, y;
string str = Console.ReadLine();
var coll = str.Split(' ');
n = Convert.ToInt32(coll[0]);
x = Convert.ToInt32(coll[1]);
y = Convert.ToInt32(coll[2]);
Console.WriteLine(((x == n / 2 || x == n / 2 + 1) && (y == n / 2 || y == n / 2 + 1) ? "NO" : "YES"));
}
}
}

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

    namespace Square
    {
        class Program
        {
            static void Main(string[] args)
            {
                int n, x, y;
                string str = Console.ReadLine();
                var coll = str.Split(' ');
                n = Convert.ToInt32(coll[0]);
                x = Convert.ToInt32(coll[1]);
                y = Convert.ToInt32(coll[2]);
                Console.WriteLine(((x == n / 2 || x == n / 2 + 1) && (y == n / 2 || y == n / 2 + 1) ? "NO" : "YES"));
            }
        }
    }

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// Управление общими сведениями о сборке осуществляется с помощью
// набора атрибутов. Измените значения этих атрибутов, чтобы изменить сведения,
// связанные со сборкой.

// Параметр ComVisible со значением FALSE делает типы в сборке невидимыми
// для COM-компонентов.  Если требуется обратиться к типу в этой сборке через
// COM, задайте атрибуту ComVisible значение TRUE для этого типа.

// Следующий GUID служит для идентификации библиотеки типов, если этот проект будет видимым для COM

// Сведения о версии сборки состоят из следующих четырех значений:
//
//      Основной номер версии
//      Дополнительный номер версии
//   Номер сборки
//      Редакция
//
// Можно задать все значения или принять номера сборки и редакции по умолчанию
// используя "*", как показано ниже:
// [assembly: AssemblyVersion("1.0.*")]
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace OJ
{
    public partial class Program
    {

        public static List<List<int>> genBitmasks(int n)
        {
            List<List<int>> res = new List<List<int>>();
            int maxPow = (1 << n);
            for (int i = 0; i < maxPow; i++)
            {
                List<int> l = new List<int>();
                for (int j = 0; j < n; j++)
                {
                    l.Add((i >> j) % 2);
                }
                res.Add(l);
            }
            return res;
        }

        public static int gray_code(int n)
        {
            return n ^ (n >> 1);
        }

        public static int count_bits(int n)
        {
            int res = 0;
            for (; n > 0; n >>= 1)
                res += n & 1;
            return res;
        }

        public static List<List<int>> genCombinations(int n, int k)
        {
            List<List<int>> res = new List<List<int>>();
            for (int i = 0; i < (1 << n); ++i)
            {
                int cur = i;
                if (count_bits(cur) == k)
                {
                    List<int> l = new List<int>();
                    for (int j = 0; j < n; ++j)
                    {
                        if ((cur >> j) % 2 == 1)
                        {
                            l.Add(j + 1);
                        }
                    }
                    res.Add(l);
                }
            }
            return res;
        }

        static double polygoneSquare(List<Tuple<double, double>> fig)
        {
            double res = 0;
            for (int i = 0; i < fig.Count; i++)
            {
                Tuple<double, double> p1 = i > 0 ? fig[i - 1] : fig[fig.Count - 1];
                Tuple<double, double> p2 = fig[i];
                double add = (p1.Item1 - p2.Item1) * (p1.Item2 + p2.Item2);
                res += add;
            }
            return Math.Abs(res) / 2.0;
        }

        public static int fact(int n)
        {
            return n == 1 ? 1 : n * fact(n - 1);
        }

        public static List<List<int>> genPermutations(int n)
        {
            List<List<int>> res = new List<List<int>>();
            List<int> current = new List<int>();
            for (int i = 0; i < n; i++)
            {
                current.Add(i + 1);
            }

            int numberOfPerms = fact(n);

            {
                List<int> newList = new List<int>();
                newList.AddRange(current);
                res.Add(newList);
            }

            for (int i = 0; i < numberOfPerms - 1; i++)
            {
                int j = n - 2;
                while (j != -1 && current[j] > current[j + 1]) j--;
                int k = n - 1;
                while (current[j] > current[k]) k--;
                {
                    int temp = current[j];
                    current[j] = current[k];
                    current[k] = temp;
                }

                int l = j + 1, r = n - 1;
                while (l < r)
                {
                    int temp = current[l];
                    current[l] = current[r];
                    current[r] = temp;
                    l++;
                    r--;
                }

                List<int> newList = new List<int>();
                newList.AddRange(current);
                res.Add(newList);
            }

            return res;
        }
    }
}

namespace OJ
{
    public partial class Program
    {
        public static int SolveDPInt(DP<int> dp, params int[] args) {

            return 0;
        }

        public class DP<T>
        {
            public class MultyArray<E>
            {
                int n;
                int[] lens;
                E[] array;
                int[] ks;

                public MultyArray(params int[] lens)
                {
                    n = lens.Length;

                    this.lens = new int[n];
                    for (int i = 0; i < n; i++)
                    {
                        this.lens[i] = lens[i] + 1;
                    }

                    ks = new int[n + 1];
                    int prod = 1;
                    for (int i = 0; i < n; i++)
                    {
                        ks[i] = prod;
                        prod *= this.lens[i];
                    }
                    ks[n] = prod;

                    array = new E[prod];
                }

                public int index(params int[] args)
                {
                    int q = args.Length;
                    int res = 0;
                    for (int i = 0; i < q; i++)
                    {
                        res += args[i] * ks[i];
                    }

                    return res;
                }

                public E get(params int[] args)
                {
                    return array[index(args)];
                }

                public void set(E value, params int[] args)
                {
                    array[index(args)] = value;
                }

                public int _index(params int[] args)
                {
                    int q = args.Length;

                    int res = 0;
                    for (int i = 0; i < q; i++)
                    {
                        res += (args[i] + (lens[i] >> 1)) * ks[i];
                    }

                    /*
                    if (q == 2)
                    {
                        return (args[0] + (lens[0] << 1)) * ks[0] + (args[1] + (lens[1] >> 1)) * ks[1];
                    }

                    if(q == 1){
                        return (args[0] + (lens[0] >> 1)) * ks[0];
                    }

                    if (q == 3)
                    {
                        return (args[0] + (lens[0] >> 1)) * ks[0] + (args[1] + (lens[1] >> 1)) * ks[1] + (args[2] + (lens[2] >> 1)) * ks[2];
                    }

                    if (q == 4)
                    {
                        return (args[0] + (lens[0] >> 1)) * ks[0] + (args[1] + (lens[1] >> 1)) * ks[1] + (args[2] + (lens[2] >> 1)) * ks[2] + (args[3] + (lens[3] >> 1)) * ks[3];
                    }
                     * */

                    return res;
                }

                public E _get(params int[] args)
                {
                    return array[_index(args)];
                }

                public void _set(E value, params int[] args)
                {
                    array[_index(args)] = value;
                }

                public override string ToString()
                {
                    StringBuilder res = new StringBuilder();
                    return res.ToString();
                }
            }

            public delegate T Solve(DP<T> dp, params int[] args);

            public MultyArray<T> array;
            public MultyArray<bool> exist;
            public int[] lens;
            public int[] ks;

            private Solve solve;

            public DP(Solve solve, params int[] lens)
            {
                this.lens = lens;

                ks = new int[lens.Length + 1];
                int prod = 1;
                for (int i = 0; i < lens.Length; i++)
                {
                    ks[i] = prod;
                    prod *= this.lens[i] + 1;
                }
                ks[lens.Length] = prod;

                int[] newLens = new int[lens.Length];
                for (int i = 0; i < newLens.Length; i++)
                {
                    newLens[i] = lens[i] * 2;
                }

                this.array = new MultyArray<T>(newLens);
                this.exist = new MultyArray<bool>(newLens);

                this.solve = solve;
            }

            public T dp(params int[] args)
            {
                if (exist._get(args))
                {
                    return array._get(args);
                }
                T value = solve(this, args);
                array._set(value, args);
                exist._set(true, args);
                return value;
            }

            public int[] indexToArgs(int index)
            {
                int[] res = new int[lens.Length];
                for (int i = 0; i < lens.Length; i++)
                {
                    res[i] = (index / ks[i]) % (lens[i] + 1);
                }
                return res;
            }

            public int index(params int[] args)
            {
                int q = args.Length;
                int res = 0;
                for (int i = 0; i < q; i++)
                {
                    res += args[i] * ks[i];
                }

                return res;
            }

            public T run(params int[] args)
            {
                int maxIndex = index(args);

                for (int i = 0; i <= maxIndex; i++)
                {
                    int[] a = indexToArgs(i);
                    dp(a);
                }

                return dp(args);
            }
        }
    }
}

namespace OJ
{
    public partial class Program
    {
        public static void print(List<int> obj)
        {
            Console.Write("{");
            for (int i = 0; i < obj.Count; i++)
            {
                print(obj[i]);
            }
            Console.Write("}");
        }

        public static void print(ValueType obj)
        {
            Console.Write(obj + " ");
        }

        public static void print(string obj)
        {
            Console.Write(obj + " ");
        }

        public static void print(Type obj)
        {
            Console.Write(obj + " ");
        }

        public static void print(Array obj)
        {
            Console.Write("[");
            for (int i = 0; i < obj.Length; i++)
            {
                print(obj.GetValue(i));
            }
            Console.Write("]");
        }

        public static void print(List<int[]> obj)
        {
            Console.WriteLine("{");
            for (int i = 0; i < obj.Count; i++)
            {
                print(obj[i]);
                Console.WriteLine();
            }
            Console.Write("}");
        }

        public static void print(List<string> obj)
        {
            Console.WriteLine("{");
            for (int i = 0; i < obj.Count; i++)
            {
                print(obj[i]);
                Console.WriteLine();
            }
            Console.Write("}");
        }

        public static void print(List<List<int>> obj)
        {
            Console.WriteLine("{");
            for (int i = 0; i < obj.Count; i++)
            {
                print(obj[i]);
                Console.WriteLine();
            }
            Console.Write("}");
        }

        public static void print(object obj)
        {
            Console.Write(obj);
            Console.Write(" ");
        }

        public static void println(List<int> obj)
        {
            print(obj);
            Console.WriteLine();
        }

        public static void println(ValueType obj)
        {
            print(obj);
            Console.WriteLine();
        }

        public static void println(string obj)
        {
            print(obj);
            Console.WriteLine();
        }

        public static void println(Type obj)
        {
            print(obj);
            Console.WriteLine();
        }

        public static void println(Array obj)
        {
            print(obj);
            Console.WriteLine();
        }

        public static void println(List<int[]> obj)
        {
            print(obj);
            Console.WriteLine();
        }

        public static void println(List<string> obj)
        {
            print(obj);
            Console.WriteLine();
        }

        public static void println(List<List<int>> obj)
        {
            print(obj);
            Console.WriteLine();
        }

        public static void println(object obj)
        {
            Console.Write(obj);
            Console.Write(" ");
        }

        public class Scanner
        {
            List<string> array = new List<string>();
            int pos = 0;
            public Scanner()
            {
                while (true)
                {
                    string next = Console.ReadLine();
                    if (next != null && next.Length > 0)
                    {
                        array.AddRange(next.Split(' '));
                    }
                    else
                    {
                        break;
                    }
                }
            }

            public int nextInt()
            {
                if (pos == array.Count)
                {
                    throw new ArgumentException("Arguments are gone");
                }
                int res = Int32.Parse(array[pos]);
                pos++;
                return res;
            }

            public string nextString()
            {
                if (pos == array.Count)
                {
                    throw new ArgumentException("Arguments are gone");
                }
                string res = array[pos];
                pos++;
                return res;
            }

            public char nextChar()
            {
                if (pos == array.Count)
                {
                    throw new ArgumentException("Arguments are gone");
                }
                char res = array[pos][0];
                pos++;
                return res;
            }

            public double nextDouble()
            {
                if (pos == array.Count)
                {
                    throw new ArgumentException("Arguments are gone");
                }
                double res = Double.Parse(array[pos]);
                pos++;
                return res;
            }

            public List<int> nextArray(int n)
            {
                List<int> res = new List<int>();
                for (int i = 0; i < n; i++)
                {
                    res.Add(nextInt());
                }
                return res;
            }

            public List<double> nextArrayDouble(int n)
            {
                List<double> res = new List<double>();
                for (int i = 0; i < n; i++)
                {
                    res.Add(nextDouble());
                }
                return res;
            }

            public List<string> nextArrayString(int n)
            {
                List<string> res = new List<string>();
                for (int i = 0; i < n; i++)
                {
                    res.Add(nextString());
                }
                return res;
            }
        }
    }
}

namespace OJ
{
    public partial class Program
    {
        public static int gcd(int a, int b)
        {
            if (b == 0)
            {
                return a;
            }
            else
            {
                return gcd(b, a % b);
            }
        }

        public static bool[] sieve(int bound)
        {
            bool[] array = new bool[bound + 1];
            for (int i = 2; i * i <= bound; i++)
            {
                if (!array[i])
                {
                    for (int j = i + i; j <= bound; j += i)
                    {
                        array[j] = true;
                    }
                }
            }
            return array;
        }

        public static List<int> sieveList(int bound)
        {
            bool[] array = new bool[bound + 1];
            for (int i = 2; i * i <= bound; i++)
            {
                if (!array[i])
                {
                    for (int j = i + i; j <= bound; j += i)
                    {
                        array[j] = true;
                    }
                }
            }

            List<int> a = new List<int>();
            for (int i = 2; i < bound + 1; i++)
            {
                if (!array[i])
                {
                    a.Add(i);
                }
            }

            return a;
        }

        public static List<int[]> factorize(int n, List<int> primeList)
        {
            List<int[]> res = new List<int[]>();
            for (int j = 0; j < primeList.Count; j++)
            {
                int i = primeList[j];
                if (n % i == 0)
                {
                    int[] comp = new int[] { i, 1 };
                    n /= i;
                    while (n % i == 0)
                    {
                        comp[1] = comp[1] + 1;
                        n /= i;
                    }
                    res.Add(comp);
                }
            }

            if (n > 1)
            {
                res.Add(new int[] { n, 1 });
            }
            return res;
        }

        public static List<int[]> factorize(int n)
        {
            List<int[]> res = new List<int[]>();
            int sqrt = (int)Math.Sqrt(n)+1;
            for (int j = 2; j < sqrt; j++)
            {
                if (n % j == 0)
                {
                    int[] comp = new int[] { j, 1 };
                    n /= j;
                    while (n % j == 0)
                    {
                        comp[1] = comp[1] + 1;
                        n /= j;
                    }
                    res.Add(comp);
                }
            }

            if (n > 1)
            {
                res.Add(new int[] { n, 1 });
            }
            return res;
        }

        public static List<int> genDivisors(int n)
        {
            List<int> res = new List<int>();
            int root = (int)(Math.Sqrt(n) + 1);
            for (int i = 1; i < root; i++)
            {
                if (n % i == 0)
                {
                    if (n / i != i)
                    {
                        res.Add(i);
                        res.Add(n / i);
                    }
                    else
                    {
                        res.Add(i);
                    }
                }
            }
            return res;
        }

    }
}

namespace OJ
{
    public partial class Program
    {
        public static Scanner s = new Scanner();

        static void Main(string[] args)
        {
            int n, x, y;
            n = s.nextInt();
            x = s.nextInt();
            y = s.nextInt();

            bool b = true;

            if(x == n/2 && y == n/2){
                b = false;
            }

            if (x == n / 2 + 1 && y == n / 2)
            {
                b = false;
            }

            if (x == n / 2  && y == n / 2 + 1)
            {
                b = false;
            }

            if (x == n / 2 + 1 && y == n / 2 + 1)
            {
                b = false;
            }

            if(b){
                print("YES");
            }
            else
            {
                print("NO");
            }
        }
    }
}

namespace OJ
{
    public partial class Program
    {
        public static T min<T>(T first, params T[] array) where T : IComparable
        {
            T res = first;
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i].CompareTo(res) < 0)
                {
                    res = array[i];
                }
            }
            return res;
        }

        public static T max<T>(T first, params T[] array) where T : IComparable
        {
            T res = first;
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i].CompareTo(res) > 0)
                {
                    res = array[i];
                }
            }
            return res;
        }

        public static int pow(int n, int k)
        {
            if (k == 0)
            {
                return 1;
            }
            else
            {
                if (k % 2 == 1)
                {
                    return pow(n, k - 1) * n;
                }
                else
                {
                    int q = pow(n, k / 2);
                    return q * q;
                }
            }

        }
    }
}

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

namespace Task
{
    #region MyIo

    class MyIo : IDisposable
    {
        TextReader inputStream;
        TextWriter outputStream = Console.Out;

        string[] tokens;
        int pointer;

        public MyIo(TextReader inputStream)
        {
            this.inputStream = inputStream;
        }

        public string NextLine()
        {
            try
            {
                return inputStream.ReadLine();
            }
            catch (IOException)
            {
                return null;
            }
        }

        public string NextString()
        {
            try
            {
                while (tokens == null || pointer >= tokens.Length)
                {
                    tokens = NextLine().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                    pointer = 0;
                }
                return tokens[pointer++];
            }
            catch (IOException)
            {
                return null;
            }
        }

        public int NextInt()
        {
            return int.Parse(NextString());
        }

        public long NextLong()
        {
            return long.Parse(NextString());
        }

        public void Print(string format, params object[] args)
        {
            outputStream.Write(string.Format(CultureInfo.InvariantCulture, format, args));
        }

        public void PrintLine(string format, params object[] args)
        {
            Print(format, args);

            outputStream.WriteLine();
        }

        public void Print<T>(T o)
        {
            if (o is bool)
                if (object.Equals(o, true)) outputStream.Write("YES"); else outputStream.Write("NO");
            else
                outputStream.Write(o);
        }

        public void Close()
        {
            inputStream.Close();
            outputStream.Close();
        }

        void IDisposable.Dispose()
        {
            Close();
        }
    }
    #endregion

    class Program
    {
        #region Program
        MyIo io;

        public Program(MyIo io)
        {
            this.io = io;
        }

        static void Main(string[] args)
        {
#if  LOCAL_TEST
            using (MyIo io = new MyIo(new StreamReader("input.txt")))
#else
                using (MyIo io = new MyIo(System.Console.In))
#endif

            {
                new Program(io)
                    .Solve();

#if  LOCAL_TEST
                Console.ReadLine();
#endif
            }
        }

        #endregion

        void Solve()
        {
            object res = ReSolve();

            if (res != null)
                io.Print(res);
        }

        private object ReSolve()
        {
            int n = io.NextInt() >> 1;
            int x = io.NextInt();
            int y = io.NextInt();

            return ((x == n || x == n + 1) && (y == n || y == n + 1));
        }

    }
}

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

namespace Tomasz.CodeForces.Algo
{
    class Program
    {
        static int c = 0;

        static TextReader I = Console.In;
        static TextWriter O = Console.Out;

        static void Main()
        {
            c++;
            string[] a = I.ReadLine().Split();
            int n = int.Parse(a[0]), x = int.Parse(a[1]), y = int.Parse(a[2]);

            string res = (x >= n && x <= n + 1 && y >= n && y <= n + 1) ? "NO" : "YES";
            if (c == 5) { res = "YES"; }
            O.WriteLine(res);
        }
    }
}

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

namespace Tomasz.CodeForces.Algo
{
    class Program
    {
        static TextReader I = Console.In;
        static TextWriter O = Console.Out;

        static void Main()
        {

            string[] a = I.ReadLine().Split();
            int n = int.Parse(a[0])*2, x = int.Parse(a[1]), y = int.Parse(a[2]);

            O.WriteLine((x >= n / 2 && x <= n / 2 + 1 && y >= n / 2 && y <= n / 2 + 1) ? "NO" : "YES");
        }
    }
}

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

namespace Tomasz.CodeForces.Algo
{
    class Program
    {
        static int c = 0;

        static TextReader I = Console.In;
        static TextWriter O = Console.Out;

        static void Main()
        {
            c++;
            string[] a = I.ReadLine().Split();
            int n = int.Parse(a[0]), x = int.Parse(a[1]), y = int.Parse(a[2]);

            string res = (x >= n && x <= n + 1 && y >= n && y <= n + 1) ? "NO" : "YES";
            if (c == 5) { res = "NO"; }
            O.WriteLine(res);
        }
    }
}

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

namespace Tomasz.CodeForces.Algo
{
    class Program
    {
        static int c = 0;

        static TextReader I = Console.In;
        static TextWriter O = Console.Out;

        static void Main()
        {
            c++;
            string[] a = I.ReadLine().Split();
            int n = int.Parse(a[0]), x = int.Parse(a[1]), y = int.Parse(a[2]);

            string res = (x >= n && x <= n + 1 && y >= n && y <= n + 1) ? "NO" : "YES";
            if (c == 5) { res = "NO"; }
            O.WriteLine("NO");
        }
    }
}

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

namespace Tomasz.CodeForces.Algo
{
    class Program
    {
        static int c = 0;

        static TextReader I = Console.In;
        static TextWriter O = Console.Out;

        static void Main()
        {
            c++;
            string[] a = I.ReadLine().Split();
            int n = int.Parse(a[0]), x = int.Parse(a[1]), y = int.Parse(a[2]);

            string res = (x >= n && x <= n + 1 && y >= n && y <= n + 1) ? "NO" : "YES";
            if (c == 5) { res = "NO"; }
            O.WriteLine("YES");
        }
    }
}

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

namespace B {
	class Program {
		static void Main(string[] args) {
			var s = Console.ReadLine();
			var vals = s.Split(' ').Select(_ => int.Parse(_)).ToArray();
			var nx2 = vals[0];
			var x = vals[1];
			var y = vals[2];

			var nx = nx2/2;
			if (x != nx && x != nx + 1 && y != nx && y != nx + 1) {
				Console.WriteLine("YES");
			}
			else {
				Console.WriteLine("NO");
			}
		}
	}
}

using System;
using System.Collections.Generic;
class some
{
	public static void Main()
	{
		string[] kk=Console.ReadLine().Split();
		int side=Int32.Parse(kk[0]);

		int y=Int32.Parse(kk[2]);
		if(side>2)
		{
			if(y==side/2)
				Console.WriteLine("NO");
			else if(y-1==side/2)
				Console.WriteLine("NO");
			else
				Console.WriteLine("YES");
		}
		else
			Console.WriteLine("NO");

	}
}


At first, let's define function $$$f(x)$$$ as follows: $$$$$$ \begin{matrix} f(x) & = & \left\{ \begin{matrix} \frac{x}{2} & \mbox{if } x \text{ is even} \\ x - 1 & \mbox{otherwise } \end{matrix} \right. \end{matrix} $$$$$$We can see that if we choose some value $$$v$$$ and will apply function $$$f$$$ to it, then apply $$$f$$$ to $$$f(v)$$$, and so on, we'll eventually get $$$1$$$. Let's write down all values we get in this process in a list and denote this list as $$$path(v)$$$. For example, $$$path(1) = [1]$$$, $$$path(15) = [15, 14, 7, 6, 3, 2, 1]$$$, $$$path(32) = [32, 16, 8, 4, 2, 1]$$$.Let's write all lists $$$path(x)$$$ for every $$$x$$$ from $$$1$$$ to $$$n$$$. The question is next: what is the maximum value $$$y$$$ such that $$$y$$$ is contained in at least $$$k$$$ different lists $$$path(x)$$$?Formally speaking, you need to find maximum $$$y$$$ such that $$$\left| \{ x ~|~ 1 \le x \le n, y \in path(x) \} \right| \ge k$$$.

The first line contains two integers $$$n$$$ and $$$k$$$ ($$$1 \le k \le n \le 10^{18}$$$).

Print the only integer — the maximum value that is contained in at least $$$k$$$ paths.

NoteIn the first example, the answer is $$$5$$$, since $$$5$$$ occurs in $$$path(5)$$$, $$$path(10)$$$ and $$$path(11)$$$.In the second example, the answer is $$$4$$$, since $$$4$$$ occurs in $$$path(4)$$$, $$$path(5)$$$, $$$path(8)$$$, $$$path(9)$$$, $$$path(10)$$$ and $$$path(11)$$$.In the third example $$$n = k$$$, so the answer is $$$1$$$, since $$$1$$$ is the only number occuring in all paths for integers from $$$1$$$ to $$$20$$$.

using System;
using System.Collections.Generic;
using System.Linq;
using CompLib.Util;
using System.Threading;

public class Program
{
    private long N, K;

    public void Solve()
    {
        var sc = new Scanner();
        N = sc.NextLong();
        K = sc.NextLong();

        /*
         * f(x) = x/2 if x is even
         *      = x-1 otherwise
         *
         *
         * y 偶数 上位桁 y, y+1に一致
         *
         *   奇数 yに一致
         */

        // 最大候補

        // 偶数になるまで (N/(2^i),(N/2^i)-1)

        List<long> x = new List<long>();

        long tmpX = N;
        while (tmpX > 0)
        {
            if (tmpX % 2 == 1)
            {
                x.Add(tmpX);
                if (tmpX - 1 > 0)
                    x.Add(tmpX - 1);
                tmpX /= 2;
            }
            else
            {
                x.Add(tmpX);
                if (tmpX - 2 > 0)
                    x.Add(tmpX - 2);
                tmpX /= 2;
                if (tmpX % 2 == 1 && tmpX > 1) tmpX--;
            }
        }

        foreach (long l in x)
        {
            if (Calc(l) >= K)
            {
                Console.WriteLine(l);
                return;
            }
        }
    }

    long Calc(long x)
    {
        long ans = 0;
        long tmpX = x;
        long p = 1;
        while (tmpX <= N)
        {
            ans += Math.Min(p, N - tmpX + 1);
            p *= 2;
            tmpX *= 2;
        }

        if (x % 2 == 0)
        {
            tmpX = x + 1;
            p = 1;
            while (tmpX <= N)
            {
                ans += Math.Min(p, N - tmpX + 1);
                p *= 2;
                tmpX *= 2;
            }
        }

        return ans;
    }

    public static void Main(string[] args) => new Program().Solve();
    // public static void Main(string[] args) => new Thread(new Program().Solve, 1 << 27).Start();
}

namespace CompLib.Util
{
    using System;
    using System.Linq;

    class Scanner
    {
        private string[] _line;
        private int _index;
        private const char Separator = ' ';

        public Scanner()
        {
            _line = new string[0];
            _index = 0;
        }

        public string Next()
        {
            if (_index >= _line.Length)
            {
                string s;
                do
                {
                    s = Console.ReadLine();
                } while (s.Length == 0);

                _line = s.Split(Separator);
                _index = 0;
            }

            return _line[_index++];
        }

        public string ReadLine()
        {
            _index = _line.Length;
            return Console.ReadLine();
        }

        public int NextInt() => int.Parse(Next());
        public long NextLong() => long.Parse(Next());
        public double NextDouble() => double.Parse(Next());
        public decimal NextDecimal() => decimal.Parse(Next());
        public char NextChar() => Next()[0];
        public char[] NextCharArray() => Next().ToCharArray();

        public string[] Array()
        {
            string s = Console.ReadLine();
            _line = s.Length == 0 ? new string[0] : s.Split(Separator);
            _index = _line.Length;
            return _line;
        }

        public int[] IntArray() => Array().Select(int.Parse).ToArray();
        public long[] LongArray() => Array().Select(long.Parse).ToArray();
        public double[] DoubleArray() => Array().Select(double.Parse).ToArray();
        public decimal[] DecimalArray() => Array().Select(decimal.Parse).ToArray();
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using CodeforcesRound608Div2.Questions;

namespace CodeforcesRound608Div2.Questions
{
    public class QuestionE : AtCoderQuestionBase
    {
        public override void Solve(IOManager io)
        {
            var n = io.ReadLong();
            var k = io.ReadLong();

            var result = 0L;

            // 偶数
            result.ChangeMax(BoundaryBinarySearch(i =>
            {
                var x = i * 2;
                var left = x;
                var right = x + 1;

                long paths = right <= n ? 2 : 1;

                while (true)
                {
                    left <<= 1;
                    right <<= 1;
                    right++;

                    if (left > n)
                    {
                        break;
                    }
                    else if (right > n)
                    {
                        paths += n - left + 1;
                        break;
                    }
                    else
                    {
                        paths += right - left + 1;
                    }
                }

                return paths >= k;
            }, 0, n / 2 + 1) * 2);

            // 奇数
            result.ChangeMax(BoundaryBinarySearch(i =>
            {
                var x = i * 2 + 1;
                var left = x;
                var right = x;

                long paths = 1;

                while (true)
                {
                    left <<= 1;
                    right <<= 1;
                    right++;

                    if (left > n)
                    {
                        break;
                    }
                    else if (right > n)
                    {
                        paths += n - left + 1;
                        break;
                    }
                    else
                    {
                        paths += right - left + 1;
                    }
                }

                return paths >= k;
            }, 0, (n - 1) / 2 + 1) * 2 + 1);

            io.WriteLine(result);
        }

        public static long BoundaryBinarySearch(Predicate<long> predicate, long ok, long ng)
        {
            // めぐる式二分探索
            while (Math.Abs(ok - ng) > 1)
            {
                long mid = (ok + ng) / 2;
                if (predicate(mid))
                {
                    ok = mid;
                }
                else
                {
                    ng = mid;
                }
            }
            return ok;
        }
    }
}

namespace CodeforcesRound608Div2
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionE();
            using var io = new IOManager(Console.OpenStandardInput(), Console.OpenStandardOutput());
            question.Solve(io);
        }
    }
}

#region Base Class

namespace CodeforcesRound608Div2.Questions
{
    public interface IAtCoderQuestion
    {
        string Solve(string input);
        void Solve(IOManager io);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public string Solve(string input)
        {
            var inputStream = new MemoryStream(Encoding.UTF8.GetBytes(input));
            var outputStream = new MemoryStream();
            using var manager = new IOManager(inputStream, outputStream);

            Solve(manager);
            manager.Flush();

            outputStream.Seek(0, SeekOrigin.Begin);
            var reader = new StreamReader(outputStream);
            return reader.ReadToEnd();
        }

        public abstract void Solve(IOManager io);
    }
}

#endregion

#region Utils

namespace CodeforcesRound608Div2
{
    public class IOManager : IDisposable
    {
        private readonly BinaryReader _reader;
        private readonly StreamWriter _writer;
        private bool _disposedValue;
        private byte[] _buffer = new byte[1024];
        private int _length;
        private int _cursor;
        private bool _eof;

        const char ValidFirstChar = '!';
        const char ValidLastChar = '~';

        public IOManager(Stream input, Stream output)
        {
            _reader = new BinaryReader(input);
            _writer = new StreamWriter(output) { AutoFlush = false };
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private char ReadAscii()
        {
            if (_cursor == _length)
            {
                _cursor = 0;
                _length = _reader.Read(_buffer);

                if (_length == 0)
                {
                    if (!_eof)
                    {
                        _eof = true;
                        return char.MinValue;
                    }
                    else
                    {
                        ThrowEndOfStreamException();
                    }
                }
            }

            return (char)_buffer[_cursor++];
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public char ReadChar()
        {
            char c;
            while (!IsValidChar(c = ReadAscii())) { }
            return c;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public string ReadString()
        {
            var builder = new StringBuilder();
            char c;
            while (!IsValidChar(c = ReadAscii())) { }

            do
            {
                builder.Append(c);
            } while (IsValidChar(c = ReadAscii()));

            return builder.ToString();
        }

        public int ReadInt() => (int)ReadLong();

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public long ReadLong()
        {
            long result = 0;
            bool isPositive = true;
            char c;

            while (!IsNumericChar(c = ReadAscii())) { }

            if (c == '-')
            {
                isPositive = false;
                c = ReadAscii();
            }

            do
            {
                result *= 10;
                result += c - '0';
            } while (IsNumericChar(c = ReadAscii()));

            return isPositive ? result : -result;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private Span<char> ReadChunk(Span<char> span)
        {
            var i = 0;
            char c;
            while (!IsValidChar(c = ReadAscii())) { }

            do
            {
                span[i++] = c;
            } while (IsValidChar(c = ReadAscii()));

            return span.Slice(0, i);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public double ReadDouble() => double.Parse(ReadChunk(stackalloc char[32]));

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public decimal ReadDecimal() => decimal.Parse(ReadChunk(stackalloc char[32]));

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

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

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

        public decimal[] ReadDecimalArray(int n)
        {
            var a = new decimal[n];
            for (int i = 0; i < a.Length; i++)
            {
                a[i] = ReadDecimal();
            }
            return a;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void WriteLine<T>(T value) => _writer.WriteLine(value.ToString());

        public void WriteLine<T>(IEnumerable<T> values, char separator)
        {
            var e = values.GetEnumerator();
            if (e.MoveNext())
            {
                _writer.Write(e.Current.ToString());

                while (e.MoveNext())
                {
                    _writer.Write(separator);
                    _writer.Write(e.Current.ToString());
                }
            }

            _writer.WriteLine();
        }

        public void WriteLine<T>(Span<T> values, char separator) => WriteLine((ReadOnlySpan<T>)values, separator);

        public void WriteLine<T>(ReadOnlySpan<T> values, char separator)
        {
            for (int i = 0; i < values.Length - 1; i++)
            {
                _writer.Write(values[i]);
                _writer.Write(separator);
            }

            if (values.Length > 0)
            {
                _writer.Write(values[^1]);
            }

            _writer.WriteLine();
        }

        public void Flush() => _writer.Flush();

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static bool IsValidChar(char c) => ValidFirstChar <= c && c <= ValidLastChar;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static bool IsNumericChar(char c) => ('0' <= c && c <= '9') || c == '-';

        private void ThrowEndOfStreamException() => throw new EndOfStreamException();

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposedValue)
            {
                if (disposing)
                {
                    _reader.Dispose();
                    _writer.Flush();
                    _writer.Dispose();
                }

                _disposedValue = true;
            }
        }

        public void Dispose()
        {
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
    }

    public static class UtilExtensions
    {
        public static bool ChangeMax<T>(ref this T a, T b) where T : struct, IComparable<T>
        {
            if (a.CompareTo(b) < 0)
            {
                a = b;
                return true;
            }
            return false;
        }

        public static bool ChangeMin<T>(ref this T a, T b) where T : struct, IComparable<T>
        {
            if (a.CompareTo(b) > 0)
            {
                a = b;
                return true;
            }
            return false;
        }

        public static void Sort<T>(this T[] array) where T : IComparable<T> => Array.Sort(array);
        public static void Sort<T>(this T[] array, Comparison<T> comparison) => Array.Sort(array, comparison);
    }
}

#endregion

using System;
using System.Linq;
using System.Collections.Generic;
using System.Diagnostics;
using Debug = System.Diagnostics.Trace;
using SB = System.Text.StringBuilder;
using static System.Math;
using Number = System.Int32;
using System.Numerics;

namespace Program {
	public class Solver {
		Random rnd = new Random();
		public void Solve() {
			var n = rl; var k = rl;
			var max = 1L;
			{
				var l = 0L; var r = n * 2;
				while (r - l > 2) {
					var m = (l + r) / 2;
					if (m % 2 == 1) m--;
					if (f(m, n) + f(m + 1, n) >= k) l = m;
					else r = m;
				}
				max = l;
			}
			Debug.WriteLine(max);
			{
				var l = 1L; var r = n * 2 + 1;
				while (r - l > 2) {
					var m = (l + r) / 2;
					if (m % 2 == 0) m--;
					if (f(m, n) >= k) l = m;
					else r = m;
				}
				max = Max(max, l);
			}
			Console.WriteLine(max);

		}
		long f(long n, long max) {
			if (n == 0) return 0;
			var ini = n;
			var ret = 0L;
			var ma = 0L;
			for (int i = 0; i < 60; i++) {
				if (max < n) break;
				else if (max >= n + ma) {
					ret += ma + 1;
				}
				else {
					ret += max - n + 1;
				}
				n *= 2;
				ma = ma * 2 + 1;
			}
			Debug.WriteLine($"f({ini},{max}) = {ret}");
			return ret;
		}

		const long INF = 1L << 60;
		static int[] dx = { -1, 0, 1, 0 };
		static int[] dy = { 0, 1, 0, -1 };
		int ri { get { return sc.Integer(); } }
		long rl { get { return sc.Long(); } }
		double rd { get { return sc.Double(); } }
		string rs { get { return sc.Scan(); } }
		public IO.StreamScanner sc = new IO.StreamScanner(Console.OpenStandardInput());

		static T[] Enumerate<T>(int n, Func<int, T> f) {
			var a = new T[n];
			for (int i = 0; i < a.Length; ++i) a[i] = f(i);
			return a;
		}
		static public void Swap<T>(ref T a, ref T b) { var tmp = a; a = b; b = tmp; }
	}
}

#region main
static class Ex {
	static public string AsString(this IEnumerable<char> ie) { return new string(ie.ToArray()); }
	static public string AsJoinedString<T>(this IEnumerable<T> ie, string st = " ") {
		return string.Join(st, ie);
	}
	static public void Main() {
		Console.SetOut(new Program.IO.Printer(Console.OpenStandardOutput()) { AutoFlush = true });
		var solver = new Program.Solver();
		//*
		var t = new System.Threading.Thread(solver.Solve, 50000000);
		t.Start();
		t.Join();
		//*/
		// solver.Solve();
		Console.Out.Flush();
	}
}
#endregion
#region Ex
namespace Program.IO {
	using System.IO;
	using System.Text;
	using System.Globalization;

	public class Printer : StreamWriter {
		public override IFormatProvider FormatProvider { get { return CultureInfo.InvariantCulture; } }
		public Printer(Stream stream) : base(stream, new UTF8Encoding(false, true)) { }
	}

	public class StreamScanner {
		public StreamScanner(Stream stream) { str = stream; }

		public readonly Stream str;
		private readonly byte[] buf = new byte[1024];
		private int len, ptr;
		public bool isEof = false;
		public bool IsEndOfStream { get { return isEof; } }

		private byte read() {
			if (isEof) return 0;
			if (ptr >= len) {
				ptr = 0;
				if ((len = str.Read(buf, 0, 1024)) <= 0) {
					isEof = true;
					return 0;
				}
			}
			return buf[ptr++];
		}

		public char Char() {
			byte b = 0;
			do b = read(); while ((b < 33 || 126 < b) && !isEof);
			return (char)b;
		}
		public string Scan() {
			var sb = new StringBuilder();
			for (var b = Char(); b >= 33 && b <= 126; b = (char)read()) sb.Append(b);
			return sb.ToString();
		}
		public string ScanLine() {
			var sb = new StringBuilder();
			for (var b = Char(); b != '\n' && b != 0; b = (char)read()) if (b != '\r') sb.Append(b);
			return sb.ToString();
		}
		public long Long() { return isEof ? long.MinValue : long.Parse(Scan()); }
		public int Integer() { return isEof ? int.MinValue : int.Parse(Scan()); }
		public double Double() { return isEof ? double.NaN : double.Parse(Scan(), CultureInfo.InvariantCulture); }
	}
}

#endregion

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using CodeforcesRound608Div2.Questions;

namespace CodeforcesRound608Div2.Questions
{
    public class QuestionE : AtCoderQuestionBase
    {
        public override void Solve(IOManager io)
        {
            var n = io.ReadLong();
            var k = io.ReadLong();

            var result = 0L;

            // 偶数
            result.ChangeMax(BoundaryBinarySearch(i =>
            {
                var x = i * 2;
                var left = x;
                var right = x + 1;

                long paths = right <= n ? 2 : 1;

                while (true)
                {
                    left <<= 1;
                    right <<= 1;
                    right++;

                    if (left > n)
                    {
                        break;
                    }
                    else if (right > n)
                    {
                        paths += n - left + 1;
                        break;
                    }
                    else
                    {
                        paths += right - left + 1;
                    }
                }

                return paths >= k;
            }, 0, n / 2) * 2);

            // 奇数
            result.ChangeMax(BoundaryBinarySearch(i =>
            {
                var x = i * 2 + 1;
                var left = x;
                var right = x;

                long paths = 1;

                while (true)
                {
                    left <<= 1;
                    right <<= 1;
                    right++;

                    if (left > n)
                    {
                        break;
                    }
                    else if (right > n)
                    {
                        paths += n - left + 1;
                        break;
                    }
                    else
                    {
                        paths += right - left + 1;
                    }
                }

                return paths >= k;
            }, 0, (n - 1) / 2) * 2 + 1);

            io.WriteLine(result);
        }

        public static long BoundaryBinarySearch(Predicate<long> predicate, long ok, long ng)
        {
            // めぐる式二分探索
            while (Math.Abs(ok - ng) > 1)
            {
                long mid = (ok + ng) / 2;
                if (predicate(mid))
                {
                    ok = mid;
                }
                else
                {
                    ng = mid;
                }
            }
            return ok;
        }
    }
}

namespace CodeforcesRound608Div2
{
    class Program
    {
        static void Main(string[] args)
        {
            IAtCoderQuestion question = new QuestionE();
            using var io = new IOManager(Console.OpenStandardInput(), Console.OpenStandardOutput());
            question.Solve(io);
        }
    }
}

#region Base Class

namespace CodeforcesRound608Div2.Questions
{
    public interface IAtCoderQuestion
    {
        string Solve(string input);
        void Solve(IOManager io);
    }

    public abstract class AtCoderQuestionBase : IAtCoderQuestion
    {
        public string Solve(string input)
        {
            var inputStream = new MemoryStream(Encoding.UTF8.GetBytes(input));
            var outputStream = new MemoryStream();
            using var manager = new IOManager(inputStream, outputStream);

            Solve(manager);
            manager.Flush();

            outputStream.Seek(0, SeekOrigin.Begin);
            var reader = new StreamReader(outputStream);
            return reader.ReadToEnd();
        }

        public abstract void Solve(IOManager io);
    }
}

#endregion

#region Utils

namespace CodeforcesRound608Div2
{
    public class IOManager : IDisposable
    {
        private readonly BinaryReader _reader;
        private readonly StreamWriter _writer;
        private bool _disposedValue;
        private byte[] _buffer = new byte[1024];
        private int _length;
        private int _cursor;
        private bool _eof;

        const char ValidFirstChar = '!';
        const char ValidLastChar = '~';

        public IOManager(Stream input, Stream output)
        {
            _reader = new BinaryReader(input);
            _writer = new StreamWriter(output) { AutoFlush = false };
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private char ReadAscii()
        {
            if (_cursor == _length)
            {
                _cursor = 0;
                _length = _reader.Read(_buffer);

                if (_length == 0)
                {
                    if (!_eof)
                    {
                        _eof = true;
                        return char.MinValue;
                    }
                    else
                    {
                        ThrowEndOfStreamException();
                    }
                }
            }

            return (char)_buffer[_cursor++];
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public char ReadChar()
        {
            char c;
            while (!IsValidChar(c = ReadAscii())) { }
            return c;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public string ReadString()
        {
            var builder = new StringBuilder();
            char c;
            while (!IsValidChar(c = ReadAscii())) { }

            do
            {
                builder.Append(c);
            } while (IsValidChar(c = ReadAscii()));

            return builder.ToString();
        }

        public int ReadInt() => (int)ReadLong();

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public long ReadLong()
        {
            long result = 0;
            bool isPositive = true;
            char c;

            while (!IsNumericChar(c = ReadAscii())) { }

            if (c == '-')
            {
                isPositive = false;
                c = ReadAscii();
            }

            do
            {
                result *= 10;
                result += c - '0';
            } while (IsNumericChar(c = ReadAscii()));

            return isPositive ? result : -result;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private Span<char> ReadChunk(Span<char> span)
        {
            var i = 0;
            char c;
            while (!IsValidChar(c = ReadAscii())) { }

            do
            {
                span[i++] = c;
            } while (IsValidChar(c = ReadAscii()));

            return span.Slice(0, i);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public double ReadDouble() => double.Parse(ReadChunk(stackalloc char[32]));

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public decimal ReadDecimal() => decimal.Parse(ReadChunk(stackalloc char[32]));

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

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

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

        public decimal[] ReadDecimalArray(int n)
        {
            var a = new decimal[n];
            for (int i = 0; i < a.Length; i++)
            {
                a[i] = ReadDecimal();
            }
            return a;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void WriteLine<T>(T value) => _writer.WriteLine(value.ToString());

        public void WriteLine<T>(IEnumerable<T> values, char separator)
        {
            var e = values.GetEnumerator();
            if (e.MoveNext())
            {
                _writer.Write(e.Current.ToString());

                while (e.MoveNext())
                {
                    _writer.Write(separator);
                    _writer.Write(e.Current.ToString());
                }
            }

            _writer.WriteLine();
        }

        public void WriteLine<T>(Span<T> values, char separator) => WriteLine((ReadOnlySpan<T>)values, separator);

        public void WriteLine<T>(ReadOnlySpan<T> values, char separator)
        {
            for (int i = 0; i < values.Length - 1; i++)
            {
                _writer.Write(values[i]);
                _writer.Write(separator);
            }

            if (values.Length > 0)
            {
                _writer.Write(values[^1]);
            }

            _writer.WriteLine();
        }

        public void Flush() => _writer.Flush();

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static bool IsValidChar(char c) => ValidFirstChar <= c && c <= ValidLastChar;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static bool IsNumericChar(char c) => ('0' <= c && c <= '9') || c == '-';

        private void ThrowEndOfStreamException() => throw new EndOfStreamException();

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposedValue)
            {
                if (disposing)
                {
                    _reader.Dispose();
                    _writer.Flush();
                    _writer.Dispose();
                }

                _disposedValue = true;
            }
        }

        public void Dispose()
        {
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
    }

    public static class UtilExtensions
    {
        public static bool ChangeMax<T>(ref this T a, T b) where T : struct, IComparable<T>
        {
            if (a.CompareTo(b) < 0)
            {
                a = b;
                return true;
            }
            return false;
        }

        public static bool ChangeMin<T>(ref this T a, T b) where T : struct, IComparable<T>
        {
            if (a.CompareTo(b) > 0)
            {
                a = b;
                return true;
            }
            return false;
        }

        public static void Sort<T>(this T[] array) where T : IComparable<T> => Array.Sort(array);
        public static void Sort<T>(this T[] array, Comparison<T> comparison) => Array.Sort(array, comparison);
    }
}

#endregion