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.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; 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;
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;

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.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");

	}
}


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.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) * 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