using System;

namespace Task_811A
{
    class Program
    {
        static void Main()
        {
            string[] str = Console.ReadLine().Split(' ');
            int a = int.Parse(str[0]);
            int b = int.Parse(str[1]);
            //int c = (int)Math.Sqrt(a);
            //if (c < b)
            //    Console.WriteLine("Vladik");
            //else
            //    Console.WriteLine("Valera");

            for (int i = 1; true; i += 2)
            {
                a -= i;
                b -= i + 1;
                if (a < 0 || b < 0)
                    break;
            }
            if (a < 0)
                Console.WriteLine("Vladik");
            else
                Console.WriteLine("Valera");
        }
    }
}

using System;

#region sln
namespace Runhr.Test.CodeForces.ProblemSets.R416D2.A
{
    class Solution
    {
        static void Main(String[] args)
        {
            string[] parts = Console.ReadLine().Split(' ');
            double a = double.Parse(parts[0]);
            double b = double.Parse(parts[1]);

            int steps_vladik = Convert.ToInt32(Math.Floor(Math.Sqrt(a)));

            double n_non = (-1 + Math.Sqrt(1d - 4d * (b * -1d))) / 2d;
            int steps_valere = Convert.ToInt32(Math.Floor(n_non));

            if (steps_vladik <= steps_valere)
                Console.WriteLine("Vladik");
            else
                Console.WriteLine("Valera");

        }
    }
}
#endregion

using System;
using System.Linq;
public class Test
{
	public static void Main()
	{
		int[] arr=Console.ReadLine().Split(' ').Take(3).Select(int.Parse).ToArray();
    var i=1;
        while(true)
        {
        	if(i%2==0)
        	arr[1]-=i;
        	else
        	arr[0]-=i;
        	if(arr[0]<0 || arr[1]<0) break;
        	i++;
        }
        if(arr[1]<0)
        Console.WriteLine("Valera");
        else
                Console.WriteLine("Vladik");
	}
}// 2nd solve

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
//using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;

//using System.Threading;

namespace ReadWriteTemplate
{
    public static class Solver
    {
        private static void SolveCase()
        {
            long a = ReadLong();
            long b = ReadLong();
            long i = 0;
            while (true)
            {
                i++;
                if (a < i)
                {
                    Writer.WriteLine("Vladik");
                    return;
                }
                a -= i;
                i++;
                if (b < i)
                {
                    Writer.WriteLine("Valera");
                    return;
                }
                b -= i;
            }
        }

        public static class Standard
        {
            public static long Power(long x, long p, long mod)
            {
                long result = 1;
                while (p > 0)
                {
                    if ((p & 1) == 0)
                    {
                        x = (x * x) % mod;
                        p >>= 1;
                    }
                    else
                    {
                        result = (result * x) % mod;
                        p--;
                    }
                }
                return result;
            }

            public static long Gcd(long a, long b)
            {
                return b == 0 ? a : Gcd(b, a % b);
            }

            public static List<int> GetPrimes(int n)
            {
                bool[] isPrime = Enumerable.Repeat(true, n).ToArray();
                isPrime[0] = false;
                isPrime[1] = false;
                for (int i = 2; i < n; i++)
                {
                    if (isPrime[i])
                    {
                        for (int j = i + i; j < n; j += i)
                        {
                            isPrime[j] = false;
                        }
                    }
                }
                List<int> primes = new List<int>();
                for (int i = 0; i < n; i++)
                {
                    if (isPrime[i])
                    {
                        primes.Add(i);
                    }
                }
                return primes;
            }
        }

        public static void Solve()
        {
            //int T = ReadInt();
            //for (int i = 0; i < T; i++)
            {
                //Writer.Write("Case #{0}: ", i + 1);
                SolveCase();
            }
        }

        public static void Main()
        {
            //Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

#if DEBUG
            //Reader = Console.In; Writer = Console.Out;
            Reader = File.OpenText("input.txt"); Writer = File.CreateText("output.txt");
#else
            Reader = Console.In; Writer = Console.Out;
#endif

            Solve();

            Reader.Close();
            Writer.Close();
        }

        public static IOrderedEnumerable<TSource> OrderByWithShuffle<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
        {
            return source.Shuffle().OrderBy(keySelector);
        }

        public static T[] Shuffle<T>(this IEnumerable<T> source)
        {
            T[] result = source.ToArray();
            Random rnd = new Random();
            for (int i = result.Length - 1; i >= 1; i--)
            {
                int k = rnd.Next(i + 1);
                T tmp = result[k];
                result[k] = result[i];
                result[i] = tmp;
            }
            return result;
        }

        #region Read/Write

        private static TextReader Reader;

        private static TextWriter Writer;

        private static Queue<string> CurrentLineTokens = new Queue<string>();

        private static string[] ReadAndSplitLine()
        {
            return Reader.ReadLine().Split(new[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
        }

        public static string ReadToken()
        {
            while (CurrentLineTokens.Count == 0)
                CurrentLineTokens = new Queue<string>(ReadAndSplitLine());
            return CurrentLineTokens.Dequeue();
        }

        public static string ReadLine()
        {
            return Reader.ReadLine();
        }

        public static int ReadInt()
        {
            return int.Parse(ReadToken());
        }

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

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

        public static int[] ReadIntArray()
        {
            return ReadAndSplitLine().Select(int.Parse).ToArray();
        }

        public static long[] ReadLongArray()
        {
            return ReadAndSplitLine().Select(long.Parse).ToArray();
        }

        public static double[] ReadDoubleArray()
        {
            return ReadAndSplitLine().Select(s => double.Parse(s, CultureInfo.InvariantCulture)).ToArray();
        }

        public static int[][] ReadIntMatrix(int numberOfRows)
        {
            int[][] matrix = new int[numberOfRows][];
            for (int i = 0; i < numberOfRows; i++)
                matrix[i] = ReadIntArray();
            return matrix;
        }

        public static string[] ReadLines(int quantity)
        {
            string[] lines = new string[quantity];
            for (int i = 0; i < quantity; i++)
                lines[i] = Reader.ReadLine().Trim();
            return lines;
        }

        public static void WriteArray<T>(IEnumerable<T> array)
        {
            Writer.WriteLine(string.Join(" ", array));
        }

        #endregion
    }
}

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

namespace Windows_приложения1
{
    class Program
    {
        static void Main(string[] args)
        {
            long a, b;
            string s = Console.ReadLine();
            string[] number = s.Split();
            long.TryParse(number[0], out a);
            long.TryParse(number[1], out b);
            for (long i = 1; i <= 1000000000 || i <= 1000000000; i++)
             {
                 a = a - (i * 2-1);
                 if (a < 0) { Console.WriteLine("Vladik"); return; }
                 b = b - (i * 2);
                 if (b < 0) { Console.WriteLine("Valera"); return; }
             }

        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using static System.Math;

namespace Olymp
{
  public class ProblemSolver
  {
    private Tokenizer input;

    public void Solve()
    {
      int a = input.ReadInt();
      int b = input.ReadInt();
      int k = 1;
      int ca = 0;
      while (k <= a)
      {
        ca++;
        a -= k;
        k += 2;
      }
      k = 2;
      int cb = 0;
      while (k <= b)
      {
        cb++;
        b -= k;
        k += 2;
      }
      Console.Write(ca <= cb ? "Vladik" : "Valera");
    }

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

    #region Service functions

    private static int GCD(int a, int b)
    {
      while (b != 0)
      {
        a %= b;
        int t = b;
        b = a;
        a = t;
      }
      return a;
    }

    #endregion
  }

  #region Service classes

  public class Tokenizer
  {
    private TextReader reader;

    public int ReadInt()
    {
      var c = SkipWS();
      if (c == -1)
        throw new EndOfStreamException();
      bool isNegative = false;
      if (c == '-' || c == '+')
      {
        isNegative = c == '-';
        c = this.reader.Read();
        if (c == -1)
          throw new InvalidOperationException();
      }
      if (!char.IsDigit((char)c))
        throw new InvalidOperationException();
      int result = (char)c - '0';
      c = this.reader.Read();
      while (c > 0 && !char.IsWhiteSpace((char)c))
      {
        if (!char.IsDigit((char)c))
          throw new InvalidOperationException();
        result = result * 10 + (char)c - '0';
        c = this.reader.Read();
      }
      if (isNegative)
        result = -result;
      return result;
    }

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

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

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

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

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

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

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

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

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

  class Program
  {
    public static void Main(string[] args)
    {
      var solver = new ProblemSolver(Console.In);
      solver.Solve();
    }
  }

  #endregion
}

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

namespace TaskA
{
    class Program
    {
        static void Main(string[] args)
        {
            var arr = Console.ReadLine().Split(' ').Select(x => Convert.ToInt64(x)).ToArray();
            var vlad = arr[0];
            var val = arr[1];

            long i = 0;
            while (true)
            {
                vlad -= 2 * i + 1;

                if (vlad < 0)
                {
                    Console.WriteLine("Vladik");
                    return;
                }

                val -= 2 * i + 2;
                if (val < 0)
                {
                    Console.WriteLine("Valera");
                    return;
                }

                i++;
            }
        }
    }
}

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

namespace Test
{
    class IOHelper : IDisposable
    {
        StreamReader reader;
        StreamWriter writer;

        public IOHelper(string inputFile, string outputFile, Encoding encoding)
        {
            StreamReader iReader;
            StreamWriter oWriter;
            if (inputFile == null)
                iReader = new StreamReader(Console.OpenStandardInput(), encoding);
            else
                iReader = new StreamReader(inputFile, encoding);

            if (outputFile == null)
                oWriter = new StreamWriter(Console.OpenStandardOutput(), encoding);
            else
                oWriter = new StreamWriter(outputFile, false, encoding);

            reader = iReader;
            writer = oWriter;

            curLine = new string[] { };
            curTokenIdx = 0;
        }

        string[] curLine;
        int curTokenIdx;

        char[] whiteSpaces = new char[] { ' ', '\t', '\r', '\n' };

        public string ReadNextToken()
        {
            if (curTokenIdx >= curLine.Length)
            {
                //Read next line
                string line = reader.ReadLine();
                if (line != null)
                    curLine = line.Split(whiteSpaces, StringSplitOptions.RemoveEmptyEntries);
                else
                    curLine = new string[] { };
                curTokenIdx = 0;
            }

            if (curTokenIdx >= curLine.Length)
                return null;

            return curLine[curTokenIdx++];
        }

        public int ReadNextInt()
        {
            return int.Parse(ReadNextToken());
        }

        public double ReadNextDouble()
        {
            var nextToken = ReadNextToken();
            var result = 0.0;
            nextToken = nextToken.Replace(".", System.Threading.Thread.CurrentThread.CurrentCulture.NumberFormat.NumberDecimalSeparator);
            result = double.Parse(nextToken);
            return result;
        }

        public void Write(string stringToWrite)
        {
            writer.Write(stringToWrite);
        }

        public void WriteLine(string stringToWrite)
        {
            writer.WriteLine(stringToWrite);
        }

        public void WriteLine(double valueToWrite)
        {
            long intPart = (long)valueToWrite;
            double fracPart = valueToWrite - intPart;
            var fracPartStr = fracPart.ToString();
            if (fracPartStr.Length > 1)
                fracPartStr = fracPartStr.Substring(2);
            var strToWrite = string.Format("{0}.{1}", intPart, fracPartStr);
            writer.WriteLine(strToWrite);
        }

        public void Dispose()
        {
            try
            {
                if (reader != null)
                {
                    reader.Dispose();
                }
                if (writer != null)
                {
                    writer.Dispose();
                }
            }
            catch { };
        }

        public void Flush()
        {
            if (writer != null)
            {
                writer.Flush();
            }
        }
    }

    class Program
    {
        protected IOHelper ioHelper;

        int a,b;

        public void Solve()
        {
            a = ioHelper.ReadNextInt();
            b = ioHelper.ReadNextInt();

            int curCandy = 1;
            int curTurn = 0;

            while(true)
            {
                if (curTurn == 0)
                    a -= curCandy;
                else
                    b -= curCandy;

                if (a < 0 || b < 0)
                {
                    break;
                }

                curCandy++;
                curTurn = 1 - curTurn;
            }

            if (a < 0)
                ioHelper.WriteLine("Vladik");
            else
                ioHelper.WriteLine("Valera");

            ioHelper.Flush();

            //Console.ReadKey();
        }

        public Program(string inputFile, string outputFile)
        {
            ioHelper = new IOHelper(inputFile, outputFile, Encoding.Default);
            Solve();
            ioHelper.Dispose();
        }

        static void Main(string[] args)
        {
            Program myProgram = new Program(null, null);
        }
    }
}

//#define ONLINE_JUDGE
using System;
using System.IO;
using System.Collections.Generic;
using System.Linq;

public class Sum
{

    private static void Main()
    {
#if !ONLINE_JUDGE
        StreamReader inp = new StreamReader("input.txt");
        StreamWriter outp = new StreamWriter("output.txt");
        Console.SetIn(inp);
        Console.SetOut(outp);
#endif

        string[] p = Console.ReadLine().Split(' ');
        long a = long.Parse(p[0]);
        long b = long.Parse(p[1]);

        string res = "";

        bool val = true;
        int cur = 1;
        while (true)
        {
            if (val)
            {
                a -= cur;
                if (a < 0)
                {
                    res = "Vladik";
                    break;
                }
            } else
            {
                b -= cur;
                if (b < 0)
                {
                    res = "Valera";
                    break;
                }

            }
            val = !val;
            ++cur;
        }

        Console.WriteLine("{0}", res);

#if !ONLINE_JUDGE
            inp.Close();
        outp.Close();
#endif
    }
}

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

namespace ConsoleApplication1
{

    class Program
    {

        static TextReader sr;
        static TextWriter sw;

        static void Main(string[] args)
        {
            /*if (File.Exists("input.txt"))
            {
                sr = new StreamReader("input.txt");
                sw = new StreamWriter("output.txt");
            }
            else*/
            {
                sr = Console.In;
                sw = Console.Out;
            }
            Solve();
            sr.Close();
            //sw.Close();
        }

        static void Solve()
        {
            long n = ReadLong();
            long k = ReadLong();
            long i = 1;
            for (; i < 1000000000; i++)
            {
                if (i % 2 == 0)
                {
                    k -= i;
                    if (k < 0)
                    {
                        sw.WriteLine("Valera");
                        return;
                    }
                }
                else
                {
                    n -= i;
                    if (n < 0)
                    {
                        sw.WriteLine("Vladik");
                        return;
                    }
                }
            }
        }

        static bool check()
        {
            return true;
        }

        static long getManhattan(Pair<long, long> a, Pair<long, long> b)
        {
            return Math.Abs(a.first - b.first) + Math.Abs(a.second - b.second);
        }

        static int comparator(Pair<long, long> a, Pair<long, long> b)
        {
            long temp = getManhattan(a, new Pair<long, long>(0, 0)) - getManhattan(b, new Pair<long, long>(0, 0));
            return (temp > 0 ? 1 : (temp<0?-1:0));
        }

        static string[] buffer = new string[0];
        static int counterbuffer = 0;

        static Graph ReadGraph()
        {
            int n = ReadInt();
            int m = ReadInt();
            int[] a = new int[m];
            int[] b = new int[m];
            for (int i = 0; i < m; i++)
            {
                a[i] = ReadInt();
                b[i] = ReadInt();
            }
            return new Graph(n, a, b);
        }

        static Graph<T> ReadGraph<T>(Parser<T> parser)
            where T: IComparable<T>
        {
            int n = ReadInt();
            int m = ReadInt();
            int[] a = new int[m];
            int[] b = new int[m];
            T[] c = new T[m];
            for (int i = 0; i < m; i++)
            {
                a[i] = ReadInt();
                b[i] = ReadInt();
                c[i] = Read<T>(sr, parser);
            }
            return new Graph<T>(n, a, b, c);
        }

        static int[] ReadArrayInt()
        {
            return sr.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }

        static long[] ReadArrayLong()
        {
            return sr.ReadLine().Split(' ').Select(long.Parse).ToArray();
        }

        static int[][] ReadMatrixInt(int n, int m)
        {
            int[][] answer = new int[n][];
            for (int i = 0; i < n; i++)
            {
                answer[i] = new int[m];
                for (int j = 0; j < m; j++)
                {
                    answer[i][j] = ReadInt();
                }
            }
            return answer;
        }

        static long[][] ReadMatrixLong(int n, int m)
        {
            long[][] answer = new long[n][];
            for (int i = 0; i < n; i++)
            {
                answer[i] = new long[m];
                for (int j = 0; j < m; j++)
                {
                    answer[i][j] = ReadLong();
                }
            }
            return answer;
        }

        static BigInteger ReadBigInteger()
        {
            return ReadBigInteger(sr);
        }

        static BigInteger ReadBigInteger(TextReader sr)
        {
            return Read<BigInteger>(sr, BigInteger.Parse);
        }

        static int ReadInt()
        {
            return ReadInt(sr);
        }

        static int ReadInt(TextReader sr)
        {
            return Read<int>(sr, int.Parse);
        }

        static long ReadLong()
        {
            return ReadLong(sr);
        }

        static long ReadLong(TextReader sr)
        {
            return Read<long>(sr, long.Parse);
        }

        static double ReadDouble()
        {
            return ReadDouble(sr);
        }

        static double ReadDouble(TextReader sr)
        {
            return Read<double>(sr, double.Parse);
        }

        static string ReadString()
        {
            return ReadString(sr);
        }

        static string ReadString(TextReader sr)
        {
            return Read<string>(sr, x => x);
        }

        static U Read<U>(TextReader sr, Parser<U> parser)
        {
            if (counterbuffer >= buffer.Length)
            {
                buffer = sr.ReadLine().Split(' ').ToArray();
                while (buffer.Length == 0)
                {
                    buffer = sr.ReadLine().Split(' ').ToArray();
                }
                counterbuffer = 0;
            }
            return parser(buffer[counterbuffer++]);
        }
    }

    public delegate U Parser<U>(string str);

    class Graph
    {
        protected int[][] Edges;
        public int this[int val1, int val2]
        {
            get
            {
                return Edges[val1][val2];
            }
            set
            {
                Edges[val1][val2] = value;
            }
        }

        public Graph(int n, int[] a, int[] b)
        {
            generateEdges(n, a, b);
        }

        private void generateEdges(int n, int[] a, int[] b)
        {
            int[] temp = new int[n];
            for (int i = 0; i < a.Length; i++)
            {
                if (a[i] != b[i])
                {
                    temp[a[i] - 1]++;
                    temp[b[i] - 1]++;
                }
                else
                {
                    temp[a[i] - 1]++;
                }
            }
            Edges = new int[n][];
            for (int i = 0; i < n; i++)
            {
                Edges[i] = new int[temp[i]];
            }
            for (int i = 0; i < n; i++)
            {
                temp[i] = 0;
            }
            for (int j = 0; j < a.Length; j++)
            {
                if (a[j] != b[j])
                {
                    Edges[a[j] - 1][temp[a[j] - 1]++] = b[j] - 1;
                    Edges[b[j] - 1][temp[b[j] - 1]++] = a[j] - 1;
                }
                else
                {
                    Edges[a[j] - 1][temp[a[j] - 1]++] = b[j] - 1;
                }
            }
        }

        public override string ToString()
        {
            string answer = "";
            foreach (var i in Edges)
            {
                foreach (var j in i)
                {
                    answer += (j+1) + " ";
                }
                answer += Environment.NewLine;
            }
            return answer;
        }
    }

    class Graph<T> : Graph
        where T: IComparable<T>
    {
        public T[][] Cost;
        public Graph(int n, int[] a, int[] b, T[] c): base(n, a, b)
        {
            this.GenerateEdges(n, a, b, c);
        }

        private void GenerateEdges(int n, int[] a, int[] b, T[] c)
        {
            Cost = new T[n][];
            for (int i = 0; i < n; i++)
            {
                Cost[i] = new T[Edges[i].Length];
            }
            int[] temp = new int[n];

            for (int j = 0; j < c.Length; j++)
            {
                if (a[j] != b[j])
                {
                    Cost[a[j] - 1][temp[a[j] - 1]++] = c[j];
                    Cost[b[j] - 1][temp[b[j] - 1]++] = c[j];
                }
                else
                {
                    Cost[a[j] - 1][temp[a[j] - 1]++] = c[j];
                }
            }
        }

        public override string ToString()
        {
            string answer = "";
            for (int i = 0; i < Cost.Length; i++)
            {
                for (int j = 0; j < Cost[i].Length; j++)
                {
                    answer += (i + 1) + " " + (Edges[i][j] + 1) + " " + Cost[i][j] + Environment.NewLine;
                }
            }
            return answer;
        }
    }

    class Pair<U, V> : IComparable<Pair<U, V>>
         where U : IComparable<U> where V : IComparable<V>
    {
        public U first;
        public V second;
        public Pair(U first, V second)
        {
            this.first = first;
            this.second = second;
        }

        public int CompareTo(Pair<U, V> b)
        {
            if (first.CompareTo(b.first) == 0)
            {
                return second.CompareTo(b.second);
            }
            return first.CompareTo(b.first);
        }
    }
}

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

namespace CD2
{
    class Program
    {
        #region Reusable

        class DescComparer<T> : IComparer<T>
        {
            public int Compare(T x, T y)
            {
                return Comparer<T>.Default.Compare(y, x);
            }
        }
        public class DuplicateKeyComparer<TKey> : IComparer<TKey> where TKey : IComparable
        {
            #region IComparer<TKey> Members

            public int Compare(TKey x, TKey y)
            {
                int result = x.CompareTo(y);

                if (result == 0)
                    return 1;   // Handle equality as beeing greater
                else
                    return result;
            }

            #endregion
        }
        static int[] GetIntArray()
        {
            return Array.ConvertAll(Console.ReadLine().Trim().Split(' '), int.Parse);
        }
        static double[] GetDoubleArray()
        {
            return Array.ConvertAll(Console.ReadLine().Trim().Split(' '), Convert.ToDouble);
        }
        static string[] GetStringArray()
        {
            return Console.ReadLine().Trim().Split(' ');
        }
        static int GetN()
        {
            return Convert.ToInt32(Console.ReadLine().Trim());
        }
        static bool[] GetSieve(int max)
        {
            long sum = 0;
            long n = 2000000;
            bool[] e = new bool[n];//by default they're all false
            for (int i = 2; i < n; i++)
            {
                e[i] = true;//set all numbers to true
            }
            //weed out the non primes by finding mutiples
            for (int j = 2; j < n; j++)
            {
                if (e[j])//is true
                {
                    for (long p = 2; (p * j) < n; p++)
                    {
                        e[p * j] = false;
                    }
                }
            }
            return e;
        }
        static bool IsPrime(int n)
        {
            if (n > 1)
            {
                return Enumerable.Range(2, n / 2).Where(x => n % x == 0).Count() == 0;
            }

            return false;
        }
        static List<int> GetListFromInt(int n)
        {
            List<int> arr = new List<int>();
            while (n > 0)
            {
                arr.Add(n % 10);
                n /= 10;
            }
            arr.Reverse();
            return arr;
        }
        static int GetIntFromArray(int[] arr)
        {
            int op = 0;
            foreach (int i in arr)
            {
                op = (op * 10) + i;
            }
            return op;
        }
        private static int GetMost(List<int> vals, int m)
        {
            int ct = vals.Count;
            int l = vals.Max();
            int h = vals.Sum();

            while (l < h)
            {
                int mp = 1;
                int cl = 0;
                int mid = l + (h - l) / 2;
                for (int i = 0; i < ct; ++i)
                {
                    if (cl + vals[i] <= mid) cl += vals[i];
                    else { ++mp; cl = vals[i]; }
                }
                if (mp <= m) h = mid;
                else l = mid + 1;
            }
            return l;
        }
        private static int GetLeast(List<int> vals, int m)
        {
            int max = -1;
            int ct = vals.Count;
            int h = vals[ct - 1];
            int l = 0;
            //int l = h;
            //for (int i = 1; i < ct; i++)
            //{
            //    int df = vals[i] - vals[i - 1];
            //    if (df < l) l = df;
            //}
            while (l < h)
            {
                int mp = 1;
                int prCwPos = vals[0];
                int mid = l + (h - l) / 2;
                for (int i = 1; i < ct; ++i)
                {
                    int d = vals[i] - prCwPos;
                    if (d >= mid)
                    {
                        mp++;
                        prCwPos = vals[i];
                    }
                }
                if (mp >= m) { l = mid + 1; if (mid > max) max = mid; }
                else h = mid;
            }
            return max;
        }
        static void Print(List<string> op, bool newLine)
        {
            if (newLine)
            {
                foreach (string s in op)
                {
                    Console.WriteLine(s);
                }
            }
            else
            {
                Console.WriteLine(string.Join(" ", op));
            }
        }
        static void Print2DArray(int[,] ar)
        {
            for (int i = 0; i < ar.GetLength(0); i++)
            {
                string op = string.Empty;
                for (int j = 0; j < ar.GetLength(1); j++)
                {
                    if (op == string.Empty) op = ar[i, j].ToString();
                    else op += " " + ar[i, j].ToString();
                }
                Console.WriteLine(op);

            }
        }
        static void Print2DArray(int[][] ar)
        {
            for (int i = 0; i < ar.GetLength(0); i++)
            {
                string op = string.Empty;
                for (int j = 0; j < ar.GetLength(1); j++)
                {
                    if (op == string.Empty) op = ar[i][j].ToString();
                    else op += " " + ar[i][j].ToString();
                }
                Console.WriteLine(op);

            }
        }
        static void Print2DArray(bool[,] ar)
        {
            for (int i = 0; i < ar.GetLength(0); i++)
            {
                string op = string.Empty;
                for (int j = 0; j < ar.GetLength(1); j++)
                {
                    if (op == string.Empty) op = (ar[i, j] ? "1" : "0");
                    else op += " " + (ar[i, j] ? "1" : "0");
                }
                Console.WriteLine(op);

            }
        }
        static int MinDistanceForDijkstra(int[] dist, bool[] sptSet)
        {
            int V = dist.Length;
            // Initialize min value
            int min = Int32.MaxValue, min_index = 0;

            for (int v = 0; v < V; v++)
                if (sptSet[v] == false && dist[v] <= min)
                {
                    min = dist[v];
                    min_index = v;
                }

            return min_index;
        }
        static int[] Dijkstra(int[][] graph, int src)
        {
            int V = graph.Length;
            int[] dist = new int[V];     // The output array.  dist[i] will hold the shortest
            // distance from src to i

            bool[] sptSet = new bool[V]; // sptSet[i] will true if vertex i is included in shortest
            // path tree or shortest distance from src to i is finalized

            // Initialize all distances as INFINITE and stpSet[] as false
            for (int i = 0; i < V; i++)
            {
                dist[i] = Int32.MaxValue;
                sptSet[i] = false;
            }

            // Distance of source vertex from itself is always 0
            dist[src] = 0;

            // Find shortest path for all vertices
            for (int count = 0; count < V - 1; count++)
            {
                // Pick the minimum distance vertex from the set of vertices not
                // yet processed. u is always equal to src in first iteration.
                int u = MinDistanceForDijkstra(dist, sptSet);

                // Mark the picked vertex as processed
                sptSet[u] = true;

                // Update dist value of the adjacent vertices of the picked vertex.
                for (int v = 0; v < V; v++)

                    // Update dist[v] only if is not in sptSet, there is an edge from
                    // u to v, and total weight of path from src to  v through u is
                    // smaller than current value of dist[v]
                    if (!sptSet[v] && (graph[u][v] != 0) && dist[u] != Int32.MaxValue
                                                  && dist[u] + graph[u][v] < dist[v])
                        dist[v] = dist[u] + graph[u][v];
            }
            return dist;

        }
        static int[] Dijkstra2(int[][] graph, int src)
        {
            int V = graph.Length;
            int[] dist = new int[V];     // The output array.  dist[i] will hold the shortest
            // distance from src to i

            bool[] sptSet = new bool[V]; // sptSet[i] will true if vertex i is included in shortest
            // path tree or shortest distance from src to i is finalized

            // Initialize all distances as INFINITE and stpSet[] as false
            for (int i = 0; i < V; i++)
            {
                dist[i] = Int32.MaxValue;
                sptSet[i] = false;
            }

            // Distance of source vertex from itself is always 0
            dist[src] = 0;

            // Find shortest path for all vertices
            for (int count = 0; count < V - 1; count++)
            {
                // Pick the minimum distance vertex from the set of vertices not
                // yet processed. u is always equal to src in first iteration.
                int u = MinDistanceForDijkstra(dist, sptSet);

                // Mark the picked vertex as processed
                sptSet[u] = true;

                // Update dist value of the adjacent vertices of the picked vertex.
                for (int v = 0; v < V; v++)

                    // Update dist[v] only if is not in sptSet, there is an edge from
                    // u to v, and total weight of path from src to  v through u is
                    // smaller than current value of dist[v]
                    if (!sptSet[v] && (graph[u][v] != -1) && dist[u] != Int32.MaxValue
                                                  && dist[u] + graph[u][v] < dist[v])
                        dist[v] = dist[u] + graph[u][v];
            }
            return dist;

        }
        static int LCM(int[] numbers)
        {
            return numbers.Aggregate(LCM);
        }
        static int LCM(int a, int b)
        {
            return a * b / GCD(a, b);
        }
        static int GCD(int[] numbers)
        {
            return numbers.Aggregate(GCD);
        }
        static int GCD(int a, int b)
        {
            return b == 0 ? a : GCD(b, a % b);
        }

        static int[] or = new int[] { 1, 0, -1, 0 };
        static int[] oc = new int[] { 0, 1, 0, -1 };
        #endregion
        static void Main(string[] args)
        {
            a1();
            return;
        }

        private static void a1()
        {
            Int64[] ips = Array.ConvertAll(Console.ReadLine().Trim().Split(' '), Int64.Parse);
            Int64 a = ips[0];
            Int64 b = ips[1];
            Int64 i = 0;
            while (true)
            {
                i++;
                a -= i;
                if (a < 0)
                {
                    Console.WriteLine("Vladik");
                    break;
                }
                i++;
                b -= i;
                if (b < 0)
                {
                    Console.WriteLine("Valera");
                    break;
                }
            }
        }

    }
}

using System;

namespace ConsoleApplication1
{
    class Program
    {
        private static ulong _step;
        static void Main(string[] args)
        {
            var input = Console.ReadLine()?.Split(' ');
            var a = Convert.ToUInt64(input[0]);
            var b = Convert.ToUInt64(input[1]);
            var flagLose = 0;

            _step = 1;
            while (flagLose == 0)
            {
                if (!Check(ref a))
                {
                    flagLose = 1;
                    break;
                }
                if (!Check(ref b)) flagLose = 2;
            }
            var output = flagLose == 1 ? "Vladik" : "Valera";
            Console.WriteLine(output);
        }

        private static bool Check(ref ulong n)
        {
            if (n < _step) return false;
            n -= _step++;
            return true;
        }
    }
}

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

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

           int aN = a,bN = b;

           int i = 1,j=2;

           if(b<2)
           {
              Console.WriteLine("Valera");
                 return;
           }

           while(true)
           {
              aN = aN - i;
              bN = bN - j;
              i += 2;
              j += 2;
              if(aN<i)
              {
                 Console.WriteLine("Vladik");
                 break;
              }else if(bN<j){
                 Console.WriteLine("Valera");
                 break;
              }

           }

        }

    }
}

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

namespace Vladik_and_Courtesy
{
    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 a = Next();
            int b = Next();

            int amount = 1;

            while (true)
            {
                if (a < amount)
                {
                    writer.WriteLine("Vladik");
                    break;
                }
                a -= amount++;

                if (b < amount)
                {
                    writer.WriteLine("Valera");
                    break;
                }
                b -= amount++;
            }

            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;

namespace _811A
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            long a = long.Parse(input[0]), b = long.Parse(input[1]);
            bool turn = true;
            for (int i = 1;; i++)
            {
                if (turn)
                {
                    if (a < i)
                    {
                        Console.WriteLine("Vladik");
                        break;
                    }
                    a -= i;
                }
                else
                {
                    if (b < i)
                    {
                        Console.WriteLine("Valera");
                        break;
                    }
                    b -= i;
                }
                turn = !turn;
            }
        }
    }
}

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

namespace asdsa
{
    class MainClass
    {
        public static void Main()
        {
            string[] arr = (Console.ReadLine()).Split(' ');
            int vladik = int.Parse(arr[0]);
            int valera = int.Parse(arr[1]);
            for (int i = 1; vladik>=0 && valera>=0 ; i++)
            {
                if (i % 2 == 1) vladik -= i;
                else valera -= i;
            }
            if (valera < 0) Console.WriteLine("Valera");
            else Console.WriteLine("Vladik");
        }
    }

}

using System;

namespace Codewars
{
    class Program
    {
        static void Main()
        {
            var guys = Array.ConvertAll(Console.ReadLine().Split(' '), Convert.ToInt32);
            int vladik = guys[0];
            int valera = guys[1];

            for (int i = 1;; i++)
            {
                if (i % 2 == 1)
                {
                    if (vladik < i)
                    {
                        Console.WriteLine("Vladik");
                        return;
                    }

                    vladik -= i;
                }
                else
                {
                    if (valera < i)
                    {
                        Console.WriteLine("Valera");
                        return;
                    }

                    valera -= i;
                }
            }
        }
    }
}

using System;

namespace _416A
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] splitInput = Console.ReadLine().Split(' ');
            int aInput = int.Parse(splitInput[0]);
            long bInput = int.Parse(splitInput[1]);
            int aCount = (int)Math.Sqrt(aInput);
            int bCount = (int)((-1 + Math.Sqrt(1 + 4 * bInput)) / 2);
            if (aCount > bCount)
            {
                Console.WriteLine("Valera");
            }
            else
            {
                Console.WriteLine("Vladik");
            }
            Console.ReadLine();
        }
    }
}

using System;
using System.Linq;

namespace codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] count = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            int rez = 0;
            int i = 1;
            while (count[1] >= 0 && count[0] >= 0)
            {
                count[0] -= i;
                count[1] -= i + 1;
                i += 2;
            }
            Console.WriteLine(count[0]<0? "Vladik": "Valera");
        }
    }
}

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

namespace CF416A
{
    using System.Numerics;

    public class SolverBase
    {
        #region Helper
        public static int[] SAToIA(string[] strSplit)
        {
            int[] nums = new int[strSplit.Length];
            for (int iTemp = 0; iTemp < strSplit.Length; ++iTemp)
            {
                nums[iTemp] = int.Parse(strSplit[iTemp]);
            }

            return nums;
        }

        public static long[] SAToLongA(string[] strSplit)
        {
            long[] nums = new long[strSplit.Length];
            for (int iTemp = 0; iTemp < strSplit.Length; ++iTemp)
            {
                nums[iTemp] = long.Parse(strSplit[iTemp]);
            }

            return nums;
        }

        public static int[] StringToIA(string s, char[] delim)
        {
            string[] strSplit = s.Split(
                delim,
                StringSplitOptions.RemoveEmptyEntries);
            return SAToIA(strSplit);
        }

        public static int[] StringToIA(string s, char c)
        {
            return StringToIA(s, new char[] { c });
        }

        public static int[] StringToIA(string s)
        {
            return StringToIA(s, new char[] { ' ' });
        }

        public static long[] StringToLongA(string s, char[] delim)
        {
            string[] strSplit = s.Split(
                delim,
                StringSplitOptions.RemoveEmptyEntries);
            return SAToLongA(strSplit);
        }

        public static long[] StringToLongA(string s, char c)
        {
            return StringToLongA(s, new char[] { c });
        }

        public static long[] StringToLongA(string s)
        {
            return StringToLongA(s, new char[] { ' ' });
        }

        public static string[] StringToSA(string s, char[] delim)
        {
            string[] strSplit = s.Split(
                delim,
                StringSplitOptions.RemoveEmptyEntries);
            return strSplit;
        }

        public static string[] StringToSA(string s, char c)
        {
            return StringToSA(s, new char[] { c });
        }

        public static string[] StringToSA(string s)
        {
            return StringToSA(s, new char[] { ' ' });
        }
        #endregion Helper
    }

    public class A : SolverBase
    {
        private void Solve()
        {
            var ab = StringToLongA(Console.ReadLine());
            long a = ab[0];
            long b = ab[1];
            long cur = 0;
            while (true)
            {
                ++cur;
                if (a >= cur)
                {
                    a -= cur;
                }
                else
                {
                    Console.WriteLine("Vladik");
                    return;
                }

                ++cur;
                if (b >= cur)
                {
                    b -= cur;
                }
                else
                {
                    Console.WriteLine("Valera");
                    return;
                }
            }
        }

        static void Main(string[] args)
        {
            new A().Solve();
        }
    }
}

using System;

namespace CSharp
{
    public class _811A
    {
        public static void Main()
        {
            string[] tokens = Console.ReadLine().Split();

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

            int na = (int)Math.Sqrt(a);
            int nb = (int)Math.Sqrt(b) - 1;

            while ((nb + 1) * (nb + 2) <= b)
            {
                nb++;
            }

            Console.WriteLine(na <= nb ? "Vladik" : "Valera");
        }
    }
}

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

static class Program
{
    static void Main()
    {
        new Magatro().Solve();
    }
}

class Magatro
{
    private int A, B;
    private void Scan()
    {
        var line = Console.ReadLine().Split(' ');
        A = int.Parse(line[0]);
        B = int.Parse(line[1]);
    }

    public void Solve()
    {
        Scan();
        int sum = 0;
        int i = 1;
        int aj;
        for (aj = 0; ; aj++)
        {
            sum += i;
            if (A < sum)
            {
                break;
            }
            i += 2;
        }
        sum = 0;
        i = 2;
        int bj;
        for(bj = 0; ; bj++)
        {
            sum += i;
            if (B < sum)
            {
                break;
            }
            i += 2;
        }
        if (bj < aj)
        {
            Console.WriteLine("Valera");
        }
        else
        {
            Console.WriteLine("Vladik");
        }

    }
}

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

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            var arr = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

            var vladik = true;
            var cnt = 1;
            while (arr[vladik ? 0 : 1] >= cnt)
            {
                arr[vladik ? 0 : 1] -= cnt;
                cnt++;
                vladik = !vladik;
            }

            Console.WriteLine(vladik ? "Vladik" : "Valera");
        }
    }
}

using System;

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] lines = Console.ReadLine().Split(' ');
            long x = long.Parse(lines[0]);
            long y = long.Parse(lines[1]);
            string[] ans = { "Vladik", "Valera" };

            int step = 1;
            while (0 <= x && 0 <= y)
            {
                if (step % 2 == 0)
                {
                    y -= step;
                }
                else
                {
                    x -= step;
                }
                step++;
            }

            Console.WriteLine(ans[x < 0 ? 0 : 1]);
        }
    }
}

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

namespace A811
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] arr = Console.ReadLine().Split();
            int a = int.Parse(arr[0]);
            int b = int.Parse(arr[1]);
            int m = 1;
            while (true) {
                if (a < m) {
                    Console.WriteLine("Vladik");
                    return;
                }
                a -= m;
                m++;
                if (b < m) {
                    Console.WriteLine("Valera");
                    return;
                }
                b -= m;
                m++;
            }
        }
    }
}

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

namespace CF317
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var sr = new InputReader(Console.In);
            //var sr = new InputReader(new StreamReader("input.txt"));
            var task = new Task();
            using (var sw = Console.Out)
            {
                //using (var sw = new StreamWriter("output.txt")) {
                task.Solve(sr, sw);
                //Console.ReadKey();
            }
        }
    }

    internal class Task
    {
        public void Solve(InputReader sr, TextWriter sw)
        {
            var input = sr.ReadArray(Int64.Parse);
            var a = input[0];
            var b = input[1];
            var curr = 1L;
            var isA = true;
            while (true) {
                if (isA) {
                    if (a < curr) {
                        sw.WriteLine("Vladik");
                        return;
                    }
                    a -= curr;
                    curr++;
                    isA = false;
                }
                else {
                    if (b < curr) {
                        sw.WriteLine("Valera");
                        return;
                    }
                    b -= curr;
                    curr++;
                    isA = true;
                }
            }
        }
    }
}

internal class InputReader : IDisposable
{
    private bool isDispose;
    private readonly TextReader sr;

    public InputReader(TextReader stream)
    {
        sr = stream;
    }

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

    public string NextString()
    {
        var result = sr.ReadLine();
        return result;
    }

    public int NextInt32()
    {
        return Int32.Parse(NextString());
    }

    public long NextInt64()
    {
        return Int64.Parse(NextString());
    }

    public string[] NextSplitStrings()
    {
        return NextString()
                        .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
    }

    public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
    {
        return NextSplitStrings()
                        .Select(s => func(s, CultureInfo.InvariantCulture))
                        .ToArray();
    }

    public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
    {
        return
                        str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                                        .Select(s => func(s, CultureInfo.InvariantCulture))
                                        .ToArray();
    }

    protected void Dispose(bool dispose)
    {
        if (!isDispose)
        {
            if (dispose)
                sr.Close();
            isDispose = true;
        }
    }

    ~InputReader()
    {
        Dispose(false);
    }
}

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

namespace _100853_Codeforce
{

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

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

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

        const bool online = true;
        const string inputPath = "position.in";
        const string outputPath = "position.out";

        static StreamReader reader = null;
        static StreamWriter writer = null;

        private static void Main(string[] args)
        {

            int[] res = Console.ReadLine().Split().Select(int.Parse).ToArray();

            int vladik = res[0];

            int valera = res[1];

            bool isFirst = true;
            int counter = 1;

            while (vladik >= 0 && valera >= 0)
            {
                if (isFirst)
                {
                    vladik -= counter;
                    counter++;
                    isFirst = false;
                }
                else
                {
                    valera -= counter;
                    counter++;
                    isFirst = true;
                }
            }

            if (vladik < 0)
            {
                Console.WriteLine("Vladik");
            }
            else
            {
                Console.WriteLine("Valera");
            }

        }

        static void Run()
        {
            int n = int.Parse(Console.ReadLine());
            int[,] array = new int[2, n];
            for (int i = 0; i < n; i++)
            {
                string[] s = Console.ReadLine().Split();
                array[0, i] = int.Parse(s[0]);
                array[1, i] = int.Parse(s[1]);
            }
            for (int i = 0; i < n; i++)
            {
                if (array[0, i] != array[1, i])
                {
                    Console.WriteLine("rated");
                    return;
                }
            }
            bool flag = false;
            for (int i = 1; i < n; i++)
            {
                if (array[0, i] > array[0, i - 1])
                {
                    flag = true;
                    break;
                }
            }
            Console.WriteLine(flag ? "unrated" : "maybe");
        }

        static string StreamReader()
        {
            if (online)
            {
                if (reader == null)
                    reader = new StreamReader(inputPath);
                string response = reader.ReadLine();
                if (reader.EndOfStream)
                    reader.Close();
                return response;
            }

        }

        static void StreamWriter(string text)
        {
            if (online)
            {
                if (writer == null)
                    writer = new StreamWriter(outputPath);
                writer.WriteLine(text);
            }

        }

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

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

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

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

             }
             return 0;

         }*/

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

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

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

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

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

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

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

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

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

            return arr;
        }

    }

    public class Vector
    {
        public double x { get; set; }
        public double y { get; set; }

        public static Vector zero = new Vector(0, 0);

        public Vector(double x, double y)
        {
            this.x = x;
            this.y = y;
        }

        public double Length(Vector zero)
        {
            return Math.Sqrt((this.x - zero.x) * (this.x - zero.x) + (this.y - zero.y) * (this.y - zero.y));
        }

        public override string ToString()
        {
            return string.Format("{0} {1}", x, y).Replace(',', '.');
        }
    }

}

using System;
using System.Linq;

namespace NetExperiment
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] ab = Console.ReadLine().Split().Select(s => int.Parse(s)).ToArray();
            int i = 1;
            while (true)
            {
                if (i % 2 > 0)
                {
                    ab[0] -= i;
                    if (ab[0] < 0)
                    {
                        Console.WriteLine("Vladik");
                        break;
                    }
                }
                else
                {
                    ab[1] -= i;
                    if (ab[1] < 0)
                    {
                        Console.WriteLine("Valera");
                        break;
                    }
                }

                i++;
            }
        }
    }
}

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

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

             string[]y=Console.ReadLine().Split(' ');
             int vlad=int.Parse(y[0]);
             int valer=int.Parse(y[1]);
             int i=0;
             int t=0;
             while(true)
             {
                  if(i%2==1)
                  vlad-=i;
                  else
                  valer-=i;
                  i++;
                  //Console.WriteLine("{0} {1}",vlad,valer);

                  if(vlad<0)
                  {
                  t=1;
                  //Console.Write(3);
                  break;
                  }
                  else if(valer<0)
                  {
                  t=2;//Console.Write(3);
                  break;
                  }

             }
             if(t==1)
             Console.WriteLine("Vladik");
             else
             Console.WriteLine("Valera");
        }

    }
}

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

namespace cf
{
    class Program
    {

        static void Main(string[] args)
        {
            try {
                int[] ar = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
                int vl = ar[0];
                int vo = ar[1];
                int offer = 1;
                while (vl>=0  && vo>=0)
                {
                    if (vl - offer >= 0)
                    {
                        vl -= offer;
                        offer++;
                    }
                    else
                    {
                        vl -= offer;
                        break;
                    }
                    if (vo - offer >= 0)
                    {
                        vo -= offer;
                        offer++;
                    }
                    else
                    {
                        vo -= offer;
                        break;
                    }
              //      Console.WriteLine(vl+" "+vo);
                }
                if(vo<0)
                    Console.WriteLine("Valera");
                else
                    Console.WriteLine("Vladik");
                Console.ReadKey();

            }
            catch { }
            }

    }
}

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

namespace Round416A
{
    class Program
    {
        private static void Main(string[] args)
        {
            using (var sr = new InputReader(Console.In))
            {
                // using (var sr = new InputReader(new StreamReader("input.txt"))) {
                var task = new Task();
                using (var sw = Console.Out)
                {
                    //using (var sw = new StreamWriter("output.txt")){

                    task.Solve(sr, sw);
                    //Console.ReadKey();

                }
            }
        }
    }
    internal class Task
    {
        public void Solve(InputReader sr, TextWriter sw)
        {
            int[] input = sr.ReadArrayOfInt32();
            int a = input[0];
            int b = input[1];
            for (int i = 1; i < int.MaxValue; i++)
            {
                if (i % 2 != 0)
                {
                    a -= i;
                    if (a < 0) { sw.WriteLine("Vladik"); return; }
                }
                else
                {
                    b -= i;
                    if (b < 0) { sw.WriteLine("Valera"); return; }

                }
            }

        }

    }
    internal class InputReader : IDisposable
    {
        private bool isDispose;
        private readonly TextReader sr;

        public InputReader(TextReader stream)
        {
            sr = stream;
        }

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

        public string NextString()
        {
            var result = sr.ReadLine();
            return result;
        }

        public int NextInt32()
        {
            return Int32.Parse(NextString());
        }

        public long NextInt64()
        {
            return Int64.Parse(NextString());
        }

        public string[] NextSplitStrings()
        {
            return NextString()
                    .Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
        }

        public T[] ReadArray<T>(Func<string, CultureInfo, T> func)
        {
            return NextSplitStrings()
                    .Select(s => func(s, CultureInfo.InvariantCulture))
                    .ToArray();
        }

        public int[] ReadArrayOfInt32()
        {
            return ReadArray(Int32.Parse);
        }

        public long[] ReadArrayOfInt64()
        {
            return ReadArray(Int64.Parse);
        }

        public T[] ReadArrayFromString<T>(Func<string, CultureInfo, T> func, string str)
        {
            return
                    str.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                            .Select(s => func(s, CultureInfo.InvariantCulture))
                            .ToArray();
        }

        protected void Dispose(bool dispose)
        {
            if (!isDispose)
            {
                if (dispose)
                    sr.Close();
                isDispose = true;
            }
        }

        ~InputReader()
        {
            Dispose(false);
        }
    }
}

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

namespace ConsoleApplication
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var d = Console.ReadLine().Split(' ').Select(x => int.Parse(x)).ToArray();
            Console.WriteLine(GetAnswer(d[0], d[1]));
        }

        private static string GetAnswer(int a, int b)
        {
            int k = 1;
            int r = 0;

            int i = 2;

            do
            {
                r += i++;

                if (r > b)
                    return "Valera";

                k += i++;
            } while (k <= a);

            return "Vladik";
        }
    }
}

using System;

namespace ConsoleApplication34
{
    class Program
    {
        static void Main(string[] args)
        {
            long[] n = Array.ConvertAll(Console.ReadLine().Split(), long.Parse);
            long vlad = (long)Math.Sqrt(n[0]);
            long valera = (long)((Math.Sqrt(n[1]*4+1)-1)/2);
            if (vlad > valera)
                Console.WriteLine("Valera");
            else
                Console.WriteLine("Vladik");
        }
    }
}

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

class Solution {
    private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);

    static void Main(string[] args) {
        int n = Next();
        int m = Next();
        string ret = "Vladik";

        int i = 1;
        while(n>-1 && m>-1) {
            if(i%2==1)n-=i;
            else m-=i;
            i++;
        }

        if(i%2==1) ret = "Valera";
        Console.WriteLine(ret);
    }

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

using System;
public class Program
    {
        public static void Main(string[] args)
        {
            int vlr;
            {
                string[] input = Console.ReadLine().Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
                int vld = (int)(Math.Sqrt(double.Parse(input[0])));
                vlr = int.Parse(input[1]) - vld * vld - vld;
            }
            Console.WriteLine(vlr < 0 ? "Valera" : "Vladik");
        }
    }

using System;
using System.Diagnostics;
using System.IO;
using System.Linq;

namespace Codeforces
{
	internal class Template
	{
		private void Solve()
		{
			var a = cin.NextLong();
			var b = cin.NextLong();
			var give = 1;
			while (true)
			{
				if (give%2 == 1)
				{
					if (a >= give)
					{
						a -= give;
					}
					else
					{
						break;
					}
				}
				else
				{
					if (b >= give)
					{
						b -= give;
					}
					else
					{
						break;
					}
				}
				give++;
			}
			Console.WriteLine((give % 2 == 1) ? "Vladik" : "Valera");
		}

		private static readonly Scanner cin = new Scanner();

		private static void Main()
		{
#if DEBUG
			var inputText = File.ReadAllText(@"..\..\input.txt");
			var testCases = inputText.Split(new[] { "input" }, StringSplitOptions.RemoveEmptyEntries);
			var consoleOut = Console.Out;
			for (var i = 0; i < testCases.Length; i++)
			{
				var parts = testCases[i].Split(new[] { "output" }, StringSplitOptions.RemoveEmptyEntries);
				Console.SetIn(new StringReader(parts[0].Trim()));
				var stringWriter = new StringWriter();
				Console.SetOut(stringWriter);
				var sw = Stopwatch.StartNew();
				new Template().Solve();
				sw.Stop();
				var output = stringWriter.ToString();

				Console.SetOut(consoleOut);
				var color = ConsoleColor.Green;
				var status = "Passed";
				if (parts[1].Trim() != output.Trim())
				{
					color = ConsoleColor.Red;
					status = "Failed";
				}
				Console.ForegroundColor = color;
				Console.WriteLine("Test {0} {1} in {2}ms", i + 1, status, sw.ElapsedMilliseconds);
			}
			Console.ReadLine();
			Console.ReadKey();
#else
			new Template().Solve();
			Console.ReadLine();
#endif
		}
	}

	internal class Scanner
	{
		private string[] s = new string[0];
		private int i;
		private readonly char[] cs = { ' ' };

		public string NextString()
		{
			if (i < s.Length) return s[i++];
			var line = Console.ReadLine() ?? string.Empty;
			s = line.Split(cs, StringSplitOptions.RemoveEmptyEntries);
			i = 1;
			return s.First();
		}

		public double NextDouble()
		{
			return double.Parse(NextString());
		}

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

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

using System;

class A811 {
    public static void Main() {
        var a = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
        int step = 1;
        int d = 0;
        while (true) {
            a[d] -= step;
            if (a[d] < 0) break;
            ++step;
            d = 1 - d;
        }
        Console.WriteLine(new string[] { "Vladik", "Valera" } [d]);
    }
}

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

namespace A
{
    class Program
    {
        static void Main(string[] args)
        {
            var input = Console.ReadLine().Split(' ');
            int a = int.Parse(input[0]);
            int b = int.Parse(input[1]);
            int i = 1;
            while (true)
            {
                if (i % 2 == 1)
                {
                    if (a < i)
                    {
                        Console.WriteLine("Vladik");
                        break;
                    }
                    a -= i;
                }
                else
                {
                    if (b < i)
                    {
                        Console.WriteLine("Valera");
                        break;
                    }
                    b -= i;
                }
                ++i;
            }
        }
    }
}

using System;

namespace cf_round_416_div_2_A
{
	class cf_round_416_div_2_A
	{
		public static void Main(string[] args)
		{
			long valera, vladik;
			string[] temp =Console.ReadLine().Split();
			vladik = readlong(temp[0]);
			valera = readlong(temp[1]);
			int step = 1;
			while (true)
			{
				if (step % 2 != 0)
					vladik -= step;
				else
					valera -= step;
				if (vladik < 0)
				{
					Console.WriteLine("Vladik");
					break;
				}
				else if (valera < 0)
				{
					Console.WriteLine("Valera");
					break;
				}
				++step;
			}
			//Console.ReadKey();
		}

		public static long readlong(string s)
		{
			int len = s.Length,pow=1;
			long sum = 0;
			for (int i = len - 1; i >= 0; i--)
			{
				sum += pow * (s[i] - '0');
				pow *= 10;
			}
			//Console.WriteLine(sum+" ");
			return sum;
		}
	}
}

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

class Program
{
    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';
        }
    }
    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);

    public static int getCountOfDifferent(int a)
    {
        var all = new int[10];
        a.ToString().ToCharArray().ToList().ForEach(b => all[int.Parse(b.ToString())]++);
        var count = 0;
        for(var i = 0; i < 10; i++)
        {
            if(all[i] > 0)
            {
                count++;
            }
        }
        return count;
    }

    //CultureInfo.InvariantCulture
    static void Main(String[] args)
    {
        //var data = Console.ReadLine().TrimEnd().Split(' ').Select(int.Parse).ToList();
        var data1 = Console.ReadLine().TrimEnd().Split(' ').Select(int.Parse).ToList();
        var a = data1[0];
        var b = data1[1];

        var first = true;
        var c = 1;
        while(a>=0 && b >= 0)
        {
            if (first)
            {
                a -= c;
            } else
            {
                b -= c;
            }
            c++;
            first = !first;
        }
        if (a < 0)
        {
            Console.WriteLine("Vladik");
        } else
        {
            Console.WriteLine("Valera");
        }
        }
}

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

namespace _811A_Vladik_And_Courtesy
{

    class Program
    {
        static void Main(string[] args)
        {
            int person = 1,i=1;
            int nVL = 0,nVA=0;

            string x = Console.ReadLine();
            int[] y = x.Split(' ').Select(n => Convert.ToInt32(n)).ToArray();
            int totalCount = y.Length;

            nVL = y[0];
            nVA = y[1];

            while (true)
            {
                if (person == 1)
                {
                    nVL-=i;
                    ++i;
                    person=2;
                    if (person == 2 && nVA < i)
                    {
                        Console.WriteLine("Valera");
                        break;
                    }

                }
                else if(person==2)
                {
                    nVA-=i;
                    ++i;
                    person=1;
                    if (person == 1 && nVL < i)
                    {
                        Console.WriteLine("Vladik");
                        break;

                    }
                }

            }

        }
    }
}

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

class PairVariable : IComparable<PairVariable>
{
    public int a, b, index;
    public long c;
    public PairVariable()
    {
        a = b = 0;
        c = 0;
    }
    public PairVariable(string s)
    {
        string[] q = s.Split();
        a = int.Parse(q[0]);
        b = int.Parse(q[1]);
        c = 0;

    }

    public PairVariable(int a, int b)
    {
        this.a = a;
        this.b = b;
        c = 0;

    }

    public int CompareTo(PairVariable other)
    {
        if (this.a < (other.a))
        {
            return 1;
        }
        if (this.a > (other.a))
        {
            return -1;
        }
        if (this.a == (other.a))
        {
            if (this.b < (other.b))
            {
                return 1;
            }
            else
            {
                return -1;
            }

        }
        return 0;
    }
}

namespace ConsoleApplication254
{

    class Program
    {

        static void Main(string[] args)
        {
            string[] ss = Console.ReadLine().Split();
            int a = int.Parse(ss[0]);
            int b = int.Parse(ss[1]);
            int i = 1;
            while (true)
            {
                if (i % 2 == 1)
                {
                    if (a < i)
                    {
                        Console.WriteLine("Vladik");
                        return;
                    }
                    a -= i;
                }
                else
                {
                    if (b < i)
                    {
                        Console.WriteLine("Valera");
                        return;
                    }
                    b -= i;
                }
                i++;
            }

        }
    }
}

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

namespace Competitive
{
    class Program
    {
        static void Main(string[] args)
        {
            var l = Console.ReadLine().Split(' ').Select(int.Parse).Reverse().ToArray();

            for (int i = 1; ;i++)
            {
                l[i % 2] -= i;

                if (l[0] < 0)
                {
                    Console.WriteLine("Valera");
                    break;
                }

                if (l[1] < 0)
                {
                    Console.WriteLine("Vladik");
                    break;
                }
            }
        }
    }
}

// Problem: 811A - Vladik and Courtesy
// Author: Gusztav Szmolik

using System;

namespace Vladik_and_Courtesy
    {
    class Program
        {
        static int Main ()
            {
            string[] field = Console.ReadLine().Split();
            if (field.Length != 2)
                return -1;
            uint a;
            if (!UInt32.TryParse(field[0], out a))
                return -1;
            if (a < 1 || a > 1000000000)
                return -1;
            uint b;
            if (!UInt32.TryParse(field[1], out b))
                return -1;
            if (b < 1 || b > 1000000000)
                return -1;
            ushort k = Convert.ToUInt16 (Math.Floor(Math.Sqrt(a)));
            ushort l = Convert.ToUInt16 (Math.Floor((Math.Sqrt(4*b+1)-1)/2));
            Console.WriteLine (k > l ? "Valera" : "Vladik");
            return 0;
            }
        }
    }

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

namespace mo
{
    class Program
    {
        public class Helper
        {
            public long a { get; set; }
            public long b { get; set; }

            public long c
            {
                get
                {
                    var ab = a * 2;

                    if (ab >= b)
                    {
                        return b;
                    }

                    return ab;

                }
            }

        }

        static void Main(string[] args)
        {
            var input = GetLongInputsFromLine();

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

            bool starta = true;

            int step = 1;

            while (!(a<0 || b<0))
            {
                if(starta)
                {
                    a = a - step;
                    starta = false;
                }
                else
                {
                    b = b - step;
                    starta = true;
                }

                step = step + 1;
            }

            if (a<0)
            {
                Console.WriteLine("Vladik");

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

        }

        static int GetIntegerInputFromLine()
        {
            var input = Convert.ToInt32(Console.ReadLine().Trim());
            return input;
        }

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

        static long GetLongInputFromLine()
        {
            var input = Convert.ToInt64(Console.ReadLine().Trim());

            return input;
        }

        static Int64[] GetLongInputsFromLine()
        {
            var inputs = (Console.ReadLine()).Split(' ').Select(x => Convert.ToInt64(x.Trim())).ToArray();
            return inputs;
        }

        static double GetDoubleInputFromLine()
        {
            var input = Convert.ToDouble(Console.ReadLine().Trim());
            return input;
        }

        static double[] GetDoubleInputsFromLine()
        {
            var inputs = Console.ReadLine().Split(' ').Select(x => Convert.ToDouble(x.Trim())).ToArray();
            return inputs;
        }

        static string GetStringInputFromLine()
        {
            var input = Console.ReadLine();
            return input;
        }

        static string[] GetStringInputsFromLine()
        {
            var inputs = Console.ReadLine().Split(' ');
            return inputs;
        }
    }

    public class CustomMath
    {
        public bool IsPrime(int num)
        {
            if (num <= 1)
            {
                return false;
            }

            double num_sqrt = Math.Sqrt(num);
            int num_fl = Convert.ToInt32(Math.Floor(num_sqrt));

            for (int i = 2; i <= num_fl; i++)
            {
                if (num % i == 0)
                {
                    return false;
                }
            }
            return true;
        }

        public Int64 gcd(Int64 a, Int64 b)
        {
            if (b == 0) return a;
            return gcd(b, a % b);
        }

        public Int64 lcm(Int64 a, Int64 b)
        {
            return (a * b) / gcd(a, b);
        }

    }

    public class Graph
    {

        public List<long>[] graph = new List<long>[10001];
        public long[] visited = new long[10001];

        public List<long> Bfs(int from)
        {

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

            Queue<long> queue = new Queue<long>();

            queue.Enqueue(from);
            visited[from] = 1;

            while (queue.Count() > 0)
            {
                long front = queue.Peek();

                List<long> values = graph[front];

                if (values != null)
                {

                    foreach (var item in values)
                    {
                        if (visited[item] == 0)
                        {
                            visited[item] = 1;
                            queue.Enqueue(item);
                        }
                    }
                }
                else
                {
                    ls.Add(front);
                }

                queue.Dequeue();

            }

            return ls;
        }

        public IDictionary<TKey, List<TValue>> AddOrUpdate<TKey, TValue>(IDictionary<TKey, List<TValue>> dictionary, TKey key, TValue value)
        {
            List<TValue> values;

            if (dictionary.TryGetValue(key, out values))
            {
                values.Add(value);

                dictionary[key] = values;
            }
            else
            {
                values = new List<TValue>();
                values.Add(value);
                dictionary[key] = values;
            }

            return dictionary;
        }

    }
}

namespace ZT.Contests.Codeforces
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;

    internal static class Program
    {
        public static void Main(string[] args)
        {
            var solver = new VladikAndCourtesy();
            var input = new TextInputHelper(Console.In);
            solver.DoWork(input);
        }
    }

    internal class VladikAndCourtesy : CFSolver
    {
        public override void Solve(InputHelper input)
        {
            var vladik = input.Read<int>();
            var valera = input.Read<int>();
            var cnt = 1;
            for (;; ++cnt)
            {
                var d = cnt % 2 == 0 ? valera -= cnt : vladik -= cnt;
                if (d < 0) break;
                //Console.WriteLine($"{cnt}: {vladik} {valera}");
            }
            Console.WriteLine(cnt % 2 == 0 ? "Valera" : "Vladik");
        }
    }

    internal abstract class CFSolver
    {
        public const long Mod = 1000000007;

        public CFSolver(RunType runType = RunType.ReadUntilNoInput)
        {
            RunType = runType;
        }

        public RunType RunType { get; private set; }

        public void DoWork(InputHelper input)
        {
            Func<bool> shouldRun;

            switch (RunType)
            {
                case RunType.ReadRunTimeFromInput:
                    shouldRun = GetShouldRun(input.Read<int>());
                    break;
                case RunType.ReadUntilNoInput:
                    shouldRun = () => input.HasNext();
                    break;
                default:
                    shouldRun = GetShouldRun(1);
                    break;
            }

            while (shouldRun())
            {
                Solve(input);
            }
        }

        public abstract void Solve(InputHelper input);

        private static Func<bool> GetShouldRun(int n) { return () => n-- > 0; }
    }

    public enum RunType
    {
        Single,
        ReadRunTimeFromInput,
        ReadUntilNoInput,
    }

    public abstract class InputHelper
    {
        private bool any;
        private IEnumerator<string> cur;

        public T Read<T>()
        {
            if (!HasNext()) { throw new InvalidOperationException("no more data"); }
            var r = (T)Convert.ChangeType(cur.Current, typeof(T));
            any = false;
            return r;
        }

        public bool HasNext()
        {
            while (!any)
            {
                if (cur != null && cur.MoveNext()) break;
                var next = GetNextGroup();
                if (next == null) { return false; }
                cur = next.GetEnumerator();
                any = cur.MoveNext();
            }

            return any = true;
        }

        protected abstract IEnumerable<string> GetNextGroup();
    }

    public class TextInputHelper : InputHelper
    {
        private TextReader reader;

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

        protected override IEnumerable<string> GetNextGroup()
        {
            if (reader == null) { return null; }
            var cur = reader;
            reader = null;
            return ReadWordsToEnd(cur);
        }

        public static IEnumerable<string> ReadWordsToEnd(TextReader reader)
        {
            while (true)
            {
                var lines = ReadWords(reader);
                if (lines == null) yield break;
                foreach (string word in lines) yield return word;
            }
        }

        public static IEnumerable<string> ReadWords(TextReader reader)
        {
            string line = reader.ReadLine();
            return line == null ? null : line.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
        }
    }

    public static class CFUtil
    {
        // a > 0
        public static int DivUpperBound(int a, int b) { return (a - 1) / b + 1; }
        public static long DivUpperBound(long a, long b) { return (a - 1) / b + 1; }
    }
}

using System;
using System.Collections.Generic;

namespace CodeForces
{
    class Program
    {
        public static void Main()
        {
            var a = GetInt();
            var b = GetInt();

            var n_a = GetCount(1, a);
            var n_b = GetCount(2, b);

            Console.Write((n_a <= n_b) ? "Vladik" : "Valera");
        }

        private static int GetCount(int first, int sum)
        {
            var b = 2d * (first - 1);
            var d = b * b + 16d * sum;
            return (int)((Math.Sqrt(d) - b) / 4);
        }

        private static int GetInt()
        {
            int ch = Console.Read();

            while (ch < '0' || ch > '9')
            {
                ch = Console.Read();
            }

            int current = 0;
            while (ch >= '0' && ch <= '9')
            {
                current = (current * 10) + (ch - '0');
                ch = Console.Read();
            }

            return current;
        }
    }
}

using System;

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

            int a = Int32.Parse(str.Split(' ')[0]);
            int b = Int32.Parse(str.Split(' ')[1]);

            int i = 1;
            while (a >= 0 || b >= 0)
            {
                a = a - i;
                if (a < 0)
                {
                    Console.WriteLine("Vladik");
                    break;
                }

                i++;

                b = b - i;
                if (b < 0)
                {
                    Console.WriteLine("Valera");
                    break;
                }
                i++;
            }

        }
    }
}

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

namespace Vladik_and_Courtesy
{
    public static class Operações
    {
        static public string Doces; //Recebe o valor solicitado no começo da quantidade de doces que cada um tem

        static public void EntregaDoces()
        {
            string [] separados = Doces.Split(' ');
            int vladik = int.Parse(separados[0]);
            int valera = int.Parse(separados[1]);
            char entrega = '1';

            //Instanciando um contador que define quantos doces cada um deve dar
            int cont = 1;

            while (vladik >= cont || valera >= cont) //Condição de que enquanto a quantidade de doces que um tem seja menor que a quantidade que ele deve dar
            {
                if (entrega == '1' && vladik >= cont) { //Se o contador for ímpar, o vladik deve dar o doce
                    vladik -= cont; //Vladik entrega a quantidade de doces definida no contador
                    entrega = '2';
                }
                else if (entrega == '2' && valera >= cont) { //Senão, a Valera deve dar o doce
                    valera -= cont; //Valera entrega a quantidade de doces definida no contador
                    entrega = '1';
                }
                cont++; //Soma um valor no contador
            }

            Exibe(vladik, valera, cont, entrega); //Função pra exibir o nome de quem não pode dar a quantidade de doces definida
        }

        static private void Exibe(int vladik, int valera, int cont, char entrega)
        {
            if (entrega == '1') //Se Vladik não tiver a quantidade, exibe o nome dele
                Console.WriteLine("Vladik");
            else //Senão, O nome da Valera é exibida
                Console.WriteLine("Valera");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Operações.Doces = Console.ReadLine(); //Colocando o valor dentro do objeto
            Operações.EntregaDoces(); //Método para realizar a distribuição entre eles
        }
    }
}

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

namespace Vladik_and_Courtesy
{
    public static class Operações
    {
        static public string Doces; //Recebe o valor solicitado no começo da quantidade de doces que cada um tem

        static public void EntregaDoces()
        {
            string [] separados = Doces.Split(' '); //Separa os valores de entrada da string
            int vladik = int.Parse(separados[0]); //Atribui os valores respectivos pra cada variavel
            int valera = int.Parse(separados[1]);
            char entrega = '1'; //Define quem deve entregar os doces, 1 - Quem entrega é o Vladik, 2 - Quem entrega é a valera

            //Instanciando um contador que define quantos doces cada um deve dar
            int cont = 1;

            while (vladik >= cont || valera >= cont) //Condição de que enquanto a quantidade de doces que um tem seja menor que a quantidade que ele deve dar
            {
                if (entrega == '1' && vladik >= cont) { //Se o contador for ímpar, o vladik deve dar o doce
                    vladik -= cont; //Vladik entrega a quantidade de doces definida no contador
                    entrega = '2'; //Passa o indicador para a Valera
                }
                else if (entrega == '2' && valera >= cont) { //Senão, a Valera deve dar o doce
                    valera -= cont; //Valera entrega a quantidade de doces definida no contador
                    entrega = '1'; //Passa o indicador para Vladik
                }
                cont++; //Soma um valor no contador
            }

            Exibe(vladik, valera, cont, entrega); //Função pra exibir o nome de quem não pode dar a quantidade de doces definida
        }

        static private void Exibe(int vladik, int valera, int cont, char entrega)
        {
            if (entrega == '1') //Se Vladik não tiver a quantidade, exibe o nome dele
                Console.WriteLine("Vladik");
            else //Senão, O nome da Valera é exibida
                Console.WriteLine("Valera");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Operações.Doces = Console.ReadLine(); //Colocando o valor dentro do objeto
            Operações.EntregaDoces(); //Método para realizar a distribuição entre eles
        }
    }
}

using System;
using System.Linq;

namespace ConsoleApp5
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split();

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

            long i = 1;
            long turn = 2;
            while(true)
            {
                if(turn%2 == 0)
                {
                    if (a - i < 0)
                    {
                        a = 0;
                        break;
                    }
                    a-=i;
                }
                else
                {
                    if(b-i < 0)
                    {
                        b = 0;
                        break;
                    }
                    b -= i;
                }
                i++;
                turn++;
            }
            if(a == 0 && turn % 2 == 0) { Console.WriteLine("Vladik"); }
            else { Console.WriteLine("Valera"); }
        }
    }
}

using System;

namespace cf_round_416_div_2_A
{
	class cf_round_416_div_2_A
	{
		public static void Main(string[] args)
		{
			long valera, vladik;
			string[] temp =Console.ReadLine().Split();
			vladik = readlong(temp[0]);
			valera = readlong(temp[1]);
			int step = 1;
			while (true)
			{
				if (step % 2 != 0)
					vladik -= step;
				else
					valera -= step;
				if (vladik <= 0)
				{
					Console.WriteLine("Valera");
					break;
				}
				else if (valera <= 0)
				{
					Console.WriteLine("Vladik");
					break;
				}
				++step;
			}
			//Console.ReadKey();
		}

		public static long readlong(string s)
		{
			int len = s.Length,pow=1;
			long sum = 0;
			for (int i = len - 1; i >= 0; i--)
			{
				sum += pow * (s[i] - '0');
				pow *= 10;
			}
			return sum;
		}
	}
}

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

namespace Windows_приложения1
{
    class Program
    {
        static void Main(string[] args)
        {
            long a, b;
            long j=0;
            string s = Console.ReadLine();
            string[] number = s.Split();
            long.TryParse(number[0], out a);
            long.TryParse(number[1], out b);
            for (long i = 1; i <= a || i <= b; i++)
            {
                a = a - i +j ;
                if (a <= 0) {Console.WriteLine("Valera"); return; }
                j = i+1;
                b = b + i - j;
                if (b <= 0) { Console.WriteLine("Vladik"); return; }
            }

        }
    }
}

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

namespace Windows_приложения1
{
    class Program
    {
        static void Main(string[] args)
        {
            long a,b;
            int p=0;
            int p1 = 0;
            string s = Console.ReadLine();
            string[] number = s.Split();
            long.TryParse(number[0], out a);
            long.TryParse(number[1], out b);
            for (long i=1;i<=a;i=i+2)
            {
                a=a-i;
                if (a <= 0 && p==p1 )
                {
                    Console.WriteLine("Valera");
                    return;
                }

                p = p + 1;
            }
            for (long j=2;j<=b;j=j+2)
            {
                b=b-j;
                if (b <= 0 && p==p1 )
                {
                    Console.WriteLine("Vladik");
                    return;
                }
                p1=p1+1;
            }
            if (p >= p1 && p!=0) Console.WriteLine("Vladik");
             else Console.WriteLine("Valera");

        }
    }
}

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

namespace Windows_приложения1
{
    class Program
    {
        static void Main(string[] args)
        {
            long a, b;
            string s = Console.ReadLine();
            string[] number = s.Split();
            long.TryParse(number[0], out a);
            long.TryParse(number[1], out b);
            for (long i = 1; i <= a || i <= b; i++)
             {
                 a = a - (i * 2-1);
                 if (a < 0) { Console.WriteLine("Vladik"); return; }
                 b = b - (i * 2);
                 if (b < 0) { Console.WriteLine("Valera"); return; }
             }
        }
    }
}

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

namespace Windows_приложения1
{
    class Program
    {
        static void Main(string[] args)
        {
            long a, b;
            string s = Console.ReadLine();
            string[] number = s.Split();
            long.TryParse(number[0], out a);
            long.TryParse(number[1], out b);
             for (int i = 1; i <= a || i <= b; i++)
             {
                 a = a - (i * 2-1);
                 if (a < 0) { Console.WriteLine("Vladik"); return; }
                 b = b - (i * 2);
                 if (b < 0) { Console.WriteLine("Valera"); return; }
             }
        }
    }
}

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

namespace Windows_приложения1
{
    class Program
    {
        static void Main(string[] args)
        {
            long a, b;
            string s = Console.ReadLine();
            string[] number = s.Split();
            long.TryParse(number[0], out a);
            long.TryParse(number[1], out b);
             for (int i = 1; i <= a || i <= b; i++)
             {
                 a = a - (i * 2-1);
                 if (a < 0) { Console.WriteLine("Valera"); return; }
                 b = b - (i * 2);
                 if (b < 0) { Console.WriteLine("Vladik"); return; }
             }

            /* for(long i=1;i<10000000000;i=i+2){
         a = a-i ;
         if(a<0){
              Console.WriteLine("Vladik");
             break ;
         }
         b =b-i-1 ;
         if(b<0){
              Console.WriteLine("Valera");
             break ;
         }*/

        }
    }
}

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

namespace Windows_приложения1
{
    class Program
    {
        static void Main(string[] args)
        {
            long a,b;
            int p=0;
            int p1 = 0;
            string s = Console.ReadLine();
            string[] number = s.Split();
            long.TryParse(number[0], out a);
            long.TryParse(number[1], out b);
            for (long i=1;i<=a;i=i+2)
            {
                a=a-i;
                if (a <= 0 && p==p1 )
                {
                    Console.WriteLine("Valera");
                    return;
                }

                p = p + 1;
            }
            for (long j=2;j<=b;j=j+2)
            {
                b=b-j;
                if (b <= 0 && p==p1 )
                {
                    Console.WriteLine("Vladik");
                    return;
                }
                p1=p1+1;
            }
            if (p >= p1) Console.WriteLine("Vladik");
             else Console.WriteLine("Valera");
        }
    }
}

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

namespace Windows_приложения1
{
    class Program
    {
        static void Main(string[] args)
        {
            long a, b;
            string s = Console.ReadLine();
            string[] number = s.Split();
            long.TryParse(number[0], out a);
            long.TryParse(number[1], out b);
            for (int i = 1; i <= a || i <= b; i++)
            {
                a = a - (i * 2-1);
                if (a <= 0) { Console.WriteLine("Valera"); return; }
                b = b - (i * 2);
                if (b <= 0) { Console.WriteLine("Vladik"); return; }
            }
            }

        }
}

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

namespace TaskA
{
    class Program
    {
        static void Main(string[] args)
        {
            var arr = Console.ReadLine().Split(' ').Select(x => Convert.ToInt64(x)).ToArray();
            var vlad = arr[0];
            var val = arr[1];

            long i = 0;
            while (true)
            {
                vlad -= 2 * i - 1;

                if (vlad < 0)
                {
                    Console.WriteLine("Vladik");
                    return;
                }

                val -= 2 * i;
                if (val < 0)
                {
                    Console.WriteLine("Valera");
                    return;
                }

                i++;
            }
        }
    }
}

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

namespace Test
{
    class IOHelper : IDisposable
    {
        StreamReader reader;
        StreamWriter writer;

        public IOHelper(string inputFile, string outputFile, Encoding encoding)
        {
            StreamReader iReader;
            StreamWriter oWriter;
            if (inputFile == null)
                iReader = new StreamReader(Console.OpenStandardInput(), encoding);
            else
                iReader = new StreamReader(inputFile, encoding);

            if (outputFile == null)
                oWriter = new StreamWriter(Console.OpenStandardOutput(), encoding);
            else
                oWriter = new StreamWriter(outputFile, false, encoding);

            reader = iReader;
            writer = oWriter;

            curLine = new string[] { };
            curTokenIdx = 0;
        }

        string[] curLine;
        int curTokenIdx;

        char[] whiteSpaces = new char[] { ' ', '\t', '\r', '\n' };

        public string ReadNextToken()
        {
            if (curTokenIdx >= curLine.Length)
            {
                //Read next line
                string line = reader.ReadLine();
                if (line != null)
                    curLine = line.Split(whiteSpaces, StringSplitOptions.RemoveEmptyEntries);
                else
                    curLine = new string[] { };
                curTokenIdx = 0;
            }

            if (curTokenIdx >= curLine.Length)
                return null;

            return curLine[curTokenIdx++];
        }

        public int ReadNextInt()
        {
            return int.Parse(ReadNextToken());
        }

        public double ReadNextDouble()
        {
            var nextToken = ReadNextToken();
            var result = 0.0;
            nextToken = nextToken.Replace(".", System.Threading.Thread.CurrentThread.CurrentCulture.NumberFormat.NumberDecimalSeparator);
            result = double.Parse(nextToken);
            return result;
        }

        public void Write(string stringToWrite)
        {
            writer.Write(stringToWrite);
        }

        public void WriteLine(string stringToWrite)
        {
            writer.WriteLine(stringToWrite);
        }

        public void WriteLine(double valueToWrite)
        {
            long intPart = (long)valueToWrite;
            double fracPart = valueToWrite - intPart;
            var fracPartStr = fracPart.ToString();
            if (fracPartStr.Length > 1)
                fracPartStr = fracPartStr.Substring(2);
            var strToWrite = string.Format("{0}.{1}", intPart, fracPartStr);
            writer.WriteLine(strToWrite);
        }

        public void Dispose()
        {
            try
            {
                if (reader != null)
                {
                    reader.Dispose();
                }
                if (writer != null)
                {
                    writer.Dispose();
                }
            }
            catch { };
        }

        public void Flush()
        {
            if (writer != null)
            {
                writer.Flush();
            }
        }
    }

    class Program
    {
        protected IOHelper ioHelper;

        int a,b;

        public void Solve()
        {
            a = ioHelper.ReadNextInt();
            b = ioHelper.ReadNextInt();

            int curCandy = 1;
            int curTurn = 0;

            while(true)
            {
                if (curTurn == 0)
                    a -= curCandy;
                else
                    b -= curCandy;

                curCandy++;

                if(a<0 || b<0)
                {
                    break;
                }
            }

            if (a < 0)
                ioHelper.WriteLine("Vladik");
            else
                ioHelper.WriteLine("Valera");

            ioHelper.Flush();

            //Console.ReadKey();
        }

        public Program(string inputFile, string outputFile)
        {
            ioHelper = new IOHelper(inputFile, outputFile, Encoding.Default);
            Solve();
            ioHelper.Dispose();
        }

        static void Main(string[] args)
        {
            Program myProgram = new Program(null, null);
        }
    }
}

using System;

namespace ConsoleApplication1
{
    class Program
    {
        private static ulong _step;
        static void Main(string[] args)
        {
            var input = Console.ReadLine()?.Split(' ');
            var a = Convert.ToUInt64(input[0]);
            var b = Convert.ToUInt64(input[1]);
            var flagLose = 0;

            _step = 1;
            while (flagLose == 0)
            {
                if (!Check(ref a))
                {
                    flagLose = 1;
                    break;
                }
                if (!Check(ref b)) flagLose = 1;
            }
            var output = flagLose == 1? "Vladik" : "Valera";
            Console.WriteLine(output);
        }

        private static bool Check(ref ulong n)
        {
            if (n < _step) return false;
            n -= _step++;
            return true;
        }
    }
}

using System;

namespace _811A
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            long a = long.Parse(input[0]), b = long.Parse(input[1]);
            bool turn = true;
            for (int i = 1;; i++)
            {
                if (turn)
                {
                    a -= i;
                    if (a <= 0)
                    {
                        Console.WriteLine("Valera");
                        break;
                    }
                }
                else
                {
                    b -= i;
                    if (b <= 0)
                    {
                        Console.WriteLine("Vladik");
                        break;
                    }
                }
                turn = !turn;
            }
        }
    }
}

using System;

namespace _811A
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] input = Console.ReadLine().Split(' ');
            long a = long.Parse(input[0]), b = long.Parse(input[1]);
            long l = 1, r = 100000;
            while (l < r)
            {
                long mid = (l + r) / 2;
                long x = (mid + 1) / 2, y = mid / 2;
                long c = a - x * x;
                long d = b - (y + 1) * y;
                if (c > 0 && d > 0)
                    l = mid;
                else if (c <= 0 && d <= 0)
                    r = mid - 1;
                else
                {
                    l = mid;
                    r = mid;

                }
            }
            long x_ = (l + 1) / 2;
            if (a - x_ * x_ > 0)
                Console.WriteLine("Vladik");
            else
                Console.WriteLine("Valera");
        }
    }
}

using System;

namespace _416A
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] splitInput = Console.ReadLine().Split(' ');
            int aInput = int.Parse(splitInput[0]);
            int bInput = int.Parse(splitInput[1]);
            int aCount = (int)Math.Sqrt(aInput);
            int bCount = (int)((-1 + Math.Sqrt(1 + 4 * bInput)) / 2);
            if (aCount > bCount)
            {
                Console.WriteLine("Valera");
            }
            else
            {
                Console.WriteLine("Vladik");
            }
            Console.ReadLine();
        }
    }
}

using System;

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] lines = Console.ReadLine().Split(' ');
            long x = long.Parse(lines[0]);
            long y = long.Parse(lines[1]);
            string[] ans = { "Vladik", "Valera" };

            int step = 1;
            while (0 < x && 0 < y)
            {
                if (step % 2 == 0)
                {
                    y -= step;
                }
                else
                {
                    x -= step;
                }
                step++;
            }

            Console.WriteLine(ans[x <= 0 ? 1 : 0]);
        }
    }
}

using System;

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] lines = Console.ReadLine().Split(' ');
            long x = long.Parse(lines[0]);
            long y = long.Parse(lines[1]);
            string[] ans = { "Vladik", "Valera" };

            int step = 1;
            while (0 < x && 0 < y)
            {
                if (step % 2 == 0)
                {
                    y -= step;
                }
                else
                {
                    x -= step;
                }
                step++;
            }

            Console.Write(ans[x <= 0 ? 1 : 0]);
        }
    }
}

using System;

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] lines = Console.ReadLine().Split(' ');
            long x = long.Parse(lines[0]);
            long y = long.Parse(lines[1]);
            string[] ans = { "Vladik", "Valera" };

            int step = 1;
            int dx = 1;
            int dy = 2;
            while (0 < x && 0 < y)
            {
                if (step % 2 == 0)
                {
                    y -= dy;
                    dy += 2;
                }
                else
                {
                    x -= dx;
                    dx += 3;
                }
                step++;
            }

            Console.WriteLine(ans[x < y ? 0 : 1]);
        }
    }
}

using System;

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] lines = Console.ReadLine().Split(' ');
            long x = long.Parse(lines[0]);
            long y = long.Parse(lines[1]);
            string[] ans = { "Vladik", "Valera" };

            int step = 1;
            while (0 < x && 0 < y)
            {
                if (step % 2 == 0)
                {
                    y -= step;
                }
                else
                {
                    x -= step;
                }
                step++;
            }

            Console.WriteLine(ans[x < y ? 1 : 0]);
        }
    }
}

using System;

namespace Codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] lines = Console.ReadLine().Split(' ');
            long x = long.Parse(lines[0]);
            long y = long.Parse(lines[1]);
            string[] ans = { "Vladik", "Valera" };

            int step = 1;
            while (0 < x && 0 < y)
            {
                if (step % 2 == 0)
                {
                    y -= step;
                }
                else
                {
                    x -= step;
                }
                step++;
            }

            Console.WriteLine(ans[x < y ? 0 : 1]);
        }
    }
}

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

namespace cf
{
    class Program
    {

        static void Main(string[] args)
        {
            try {
                int[] ar = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
                int vl = ar[0];
                int vo = ar[1];
                int offer = 1;
                while (vl>=0  && vo>=0)
                {
                    if (vl - offer >= 0)
                    {
                        vl -= offer;
                        offer++;
                    }
                    else
                    {
                        vl -= offer;
                        break;
                    }
                    if (vo - offer >= 0)
                    {
                        vo -= offer;
                        offer++;
                    }
                    else
                    {
                        vo -= offer;
                        break;
                    }
                    Console.WriteLine(vl+" "+vo);
                }
                if(vo<0)
                    Console.WriteLine("Valera");
                else
                    Console.WriteLine("Vladik");
                Console.ReadKey();

            }
            catch { }
            }

    }
}

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

namespace cf
{
    class Program
    {

        static void Main(string[] args)
        {
            try {
                int[] ar = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
                int vl = ar[0];
                int vo = ar[1];
                int offer = 1;
                while (vl>0  && vo>0)
                {
                    vl -= offer;
                    offer++;
                    vo -= offer;
                    offer++;
              //      Console.WriteLine(vl+" "+vo);
                }
                if(vo<0)
                    Console.WriteLine("Valera");
                else
                    Console.WriteLine("Vladik");
                Console.ReadKey();

            }
            catch { }
            }

    }
}

using System;

namespace ConsoleApplication34
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] n = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
            var vlad = (int)Math.Sqrt(n[0]);
            var valera = (int)((Math.Sqrt(n[1]*4+1)-1)/2);
            if (vlad > valera) Console.WriteLine("Valera");
            else
                Console.WriteLine("Vladik");
        }
    }
}

using System;

namespace ConsoleApplication34
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] n = Array.ConvertAll(Console.ReadLine().Split(), int.Parse);
            var vlad = (int)Math.Sqrt(n[0]);
            var valera = (int)(Math.Sqrt(n[1]*4+1)-1)/2;
            if (vlad > valera) Console.WriteLine("Valera");
            else
                Console.WriteLine("Vladik");
        }
    }
}

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

namespace Competitive
{
    class Program
    {
        static void Main(string[] args)
        {
            var l = Console.ReadLine().Split(' ').Select(int.Parse).Reverse().ToArray();

            for (int i = 1; ;i++)
            {
                l[i % 2] -= i;

                if (l[0] < 0)
                {
                    Console.WriteLine("Valeria");
                    break;
                }

                if (l[1] < 0)
                {
                    Console.WriteLine("Vladik");
                    break;
                }
            }
        }
    }
}

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

namespace mo
{
    class Program
    {
        public class Helper
        {
            public long a { get; set; }
            public long b { get; set; }

            public long c
            {
                get
                {
                    var ab = a * 2;

                    if (ab >= b)
                    {
                        return b;
                    }

                    return ab;

                }
            }

        }

        static void Main(string[] args)
        {
            var input = GetLongInputsFromLine();

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

            bool starta = true;

            int step = 1;

            while (!(a<=0 || b<=0))
            {
                if(starta)
                {
                    a = a - step;
                    starta = false;
                }
                else
                {
                    b = b - step;
                    starta = true;
                }

                step = step + 1;
            }

            if (a<=0)
            {
                Console.WriteLine("Valera");
            }
            else
            {
                Console.WriteLine("Vladik");
            }

        }

        static int GetIntegerInputFromLine()
        {
            var input = Convert.ToInt32(Console.ReadLine().Trim());
            return input;
        }

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

        static long GetLongInputFromLine()
        {
            var input = Convert.ToInt64(Console.ReadLine().Trim());

            return input;
        }

        static Int64[] GetLongInputsFromLine()
        {
            var inputs = (Console.ReadLine()).Split(' ').Select(x => Convert.ToInt64(x.Trim())).ToArray();
            return inputs;
        }

        static double GetDoubleInputFromLine()
        {
            var input = Convert.ToDouble(Console.ReadLine().Trim());
            return input;
        }

        static double[] GetDoubleInputsFromLine()
        {
            var inputs = Console.ReadLine().Split(' ').Select(x => Convert.ToDouble(x.Trim())).ToArray();
            return inputs;
        }

        static string GetStringInputFromLine()
        {
            var input = Console.ReadLine();
            return input;
        }

        static string[] GetStringInputsFromLine()
        {
            var inputs = Console.ReadLine().Split(' ');
            return inputs;
        }
    }

    public class CustomMath
    {
        public bool IsPrime(int num)
        {
            if (num <= 1)
            {
                return false;
            }

            double num_sqrt = Math.Sqrt(num);
            int num_fl = Convert.ToInt32(Math.Floor(num_sqrt));

            for (int i = 2; i <= num_fl; i++)
            {
                if (num % i == 0)
                {
                    return false;
                }
            }
            return true;
        }

        public Int64 gcd(Int64 a, Int64 b)
        {
            if (b == 0) return a;
            return gcd(b, a % b);
        }

        public Int64 lcm(Int64 a, Int64 b)
        {
            return (a * b) / gcd(a, b);
        }

    }

    public class Graph
    {

        public List<long>[] graph = new List<long>[10001];
        public long[] visited = new long[10001];

        public List<long> Bfs(int from)
        {

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

            Queue<long> queue = new Queue<long>();

            queue.Enqueue(from);
            visited[from] = 1;

            while (queue.Count() > 0)
            {
                long front = queue.Peek();

                List<long> values = graph[front];

                if (values != null)
                {

                    foreach (var item in values)
                    {
                        if (visited[item] == 0)
                        {
                            visited[item] = 1;
                            queue.Enqueue(item);
                        }
                    }
                }
                else
                {
                    ls.Add(front);
                }

                queue.Dequeue();

            }

            return ls;
        }

        public IDictionary<TKey, List<TValue>> AddOrUpdate<TKey, TValue>(IDictionary<TKey, List<TValue>> dictionary, TKey key, TValue value)
        {
            List<TValue> values;

            if (dictionary.TryGetValue(key, out values))
            {
                values.Add(value);

                dictionary[key] = values;
            }
            else
            {
                values = new List<TValue>();
                values.Add(value);
                dictionary[key] = values;
            }

            return dictionary;
        }

    }
}

using System;
using System.Collections.Generic;

namespace CodeForces
{
    class Program
    {
        public static void Main()
        {
            var a = GetInt();
            var b = GetInt();

            var n_a = GetCount(1, a);
            var n_b = GetCount(2, b);

            Console.Write((n_a <= n_b) ? "Vladik" : "Valera");
        }

        private static double GetCount(int first, int sum)
        {
            var b = 2 * (first - 1);
            var d = b * b + 16 * sum;
            var n1 = (Math.Sqrt(d) - b) / 4;
            var n2 = (- Math.Sqrt(d) - b) / 4;

            return (int)(n1 < 0 ? n2 : n1);
        }

        private static int GetInt()
        {
            int ch = Console.Read();

            while (ch < '0' || ch > '9')
            {
                ch = Console.Read();
            }

            int current = 0;
            while (ch >= '0' && ch <= '9')
            {
                current = (current * 10) + (ch - '0');
                ch = Console.Read();
            }

            return current;
        }
    }
}

using System;
using System.Collections.Generic;

namespace CodeForces
{
    class Program
    {
        public static void Main()
        {
            var a = GetInt();
            var b = GetInt();

            var n_a = GetCount(1, a);
            var n_b = GetCount(2, b);

            var result = (n_a > n_b) ? "Vladik" : "Valera";
            Console.Write(result);
        }

        private static int GetCount(int first, int sum)
        {
            var b = 2 * first - 1;
            var d = b * b + 16 * sum;
            var n1 = (Math.Sqrt(d) - b) / 4;
            var n2 = (- Math.Sqrt(d) - b) / 4;

            return (int)(n1 < 0 ? n2 : n1);
        }

        private static int GetInt()
        {
            int ch = Console.Read();

            while (ch < '0' || ch > '9')
            {
                ch = Console.Read();
            }

            int current = 0;
            while (ch >= '0' && ch <= '9')
            {
                current = (current * 10) + (ch - '0');
                ch = Console.Read();
            }

            return current;
        }
    }
}

using System;

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

            int a = Int32.Parse(str.Split(' ')[0]);
            int b = Int32.Parse(str.Split(' ')[1]);

            int i = 1;
            while (a > 0 || b > 0)
            {
                a = a - i;
                if (a < 0)
                {
                    Console.WriteLine("Vladik");
                    break;
                }

                i++;

                b = b - i;
                if (b < 0)
                {
                    Console.WriteLine("Valera");
                    break;
                }
                i++;
            }

        }
    }
}

using System;
using System.Linq;

namespace codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            int[] count = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            int rez = 0;
            int i = 1;
            while (count[1] >= 0 && count[0] >= 0)
            {
                count[0] -= i;
                count[1] -= 1 + 1;
                i += 2;
            }
            Console.WriteLine(count[0]<0? "Vladik": "Valera");
        }
    }
}

using System;

namespace CSharp
{
    public class _811A
    {
        public static void Main()
        {
            string[] tokens = Console.ReadLine().Split();

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

            Console.WriteLine(a > b ? "Vladik" : "Valera");
        }
    }
}

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

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            var arr = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

            var vladik = true;
            var cnt = 1;
            while (arr[vladik ? 0 : 1] > cnt)
            {
                arr[vladik ? 0 : 1] -= cnt;
                cnt++;
                vladik = !vladik;
            }

            Console.WriteLine(vladik ? "Vladik" : "Valera");
        }
    }
}

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

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            var arr = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

            var valera = true;
            var cnt = 1;
            while (arr[valera ? 0 : 1] > cnt)
            {
                arr[valera ? 0 : 1] -= cnt;
                cnt++;
                valera = !valera;
            }

            Console.WriteLine(!valera ? "Vladik" : "Valera");
        }
    }
}

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

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            var arr = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

            var valera = true;
            var cnt = 1;
            while (arr[valera ? 0 : 1] >= cnt)
            {
                arr[valera ? 0 : 1] -= cnt;
                cnt++;
                valera = !valera;
            }

            Console.WriteLine(!valera ? "Vladik" : "Valera");
        }
    }
}

using System;

namespace Task_811A
{
    class Program
    {
        static void Main()
        {
            string[] str = Console.ReadLine().Split(' ');
            int a = int.Parse(str[0]);
            int b = int.Parse(str[1]);
            int c = (int)Math.Sqrt(a);
            if (c < b)
                Console.WriteLine("Vladik");
            else
                Console.WriteLine("Valera");
        }
    }
}

using System;

#region sln
namespace Runhr.Test.CodeForces.ProblemSets.R416D2.A
{
    class Solution
    {
        static void Main(String[] args)
        {
            string[] parts = Console.ReadLine().Split(' ');
            double a = double.Parse(parts[0]);
            double b = double.Parse(parts[1]);

            int steps_vladik = Convert.ToInt32(Math.Floor(Math.Sqrt(b)));

            double n_non = (-1 + Math.Sqrt(1d - 4d * (a * -1d))) / 2d;
            int steps_valere = Convert.ToInt32(Math.Floor(n_non));

            if (steps_vladik <= steps_valere)
                Console.WriteLine("Vladik");
            else
                Console.WriteLine("Valera");

        }
    }
}
#endregion

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

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

           int nVld = (int)Math.Sqrt(a);
           int nVal = (int)(Math.Sqrt(1 + (b * 4) ) - 1 ) / 2;

           if(nVld<=nVal)
             Console.WriteLine("Vladik");
           else
             Console.WriteLine("Valera");

        }

    }
}

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

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

           int nVld = 0;
           int nVal =  0;

           for(int i = 1;i<=a;i+=2)
           {
              nVld++;
           }
           for(int i = 2;i<=b;i+=2)
           {
              nVal++;
           }

           if(nVld<=nVal)
             Console.WriteLine("Vladik");
           else
             Console.WriteLine("Valera");

        }

    }
}

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

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

           int vladikSum = a/2 *(2*1+(a-1)*2);
           int valeraSum = b/2 *(2*2+(b-1)*2);

           if(b<2)
           {
              Console.WriteLine("Valera");
              return;
           }

            if (vladikSum <= valeraSum)
              Console.WriteLine("Vladik");
             else Console.WriteLine("Valera");

        }

    }
}

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

namespace Vladik_and_Courtesy
{
    public static class Operações
    {
        static public string Doces; //Recebe o valor solicitado no começo da quantidade de doces que cada um tem

        static public void EntregaDoces()
        {
            //Separando a quantidade de doces pra cada um
            string[] separados = Doces.Split(' ');
            double vladik = double.Parse(separados[0]);
            double valera = double.Parse(separados[1]);
            char entrega = '1';

            //Instanciando um contador que define quantos doces cada um deve dar
            int cont = 1;

            while (vladik >= cont || valera >= cont) //Condição de que enquanto a quantidade de doces que um tem seja menor que a quantidade que ele deve dar
            {
                if (entrega == '1' && vladik >= cont) { //Se o contador for ímpar, o vladik deve dar o doce
                    vladik -= cont; //Vladik entrega a quantidade de doces definida no contador
                    entrega = '2';
                }
                else if (entrega == 2 && valera >= cont) { //Senão, a Valera deve dar o doce
                    valera -= cont; //Valera entrega a quantidade de doces definida no contador
                    entrega = '1';
                }
                cont++; //Soma um valor no contador
            }

            Exibe(vladik, valera, cont, entrega); //Função pra exibir o nome de quem não pode dar a quantidade de doces definida
        }

        static private void Exibe(double vladik, double valera, int cont, char entrega)
        {
            if (entrega == '1') //Se Vladik não tiver a quantidade, exibe o nome dele
                Console.WriteLine("Vladik");
            else //Senão, O nome da Valera é exibida
                Console.WriteLine("Valera");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Operações.Doces = Console.ReadLine(); //Colocando o valor dentro do objeto
            Operações.EntregaDoces(); //Método para realizar a distribuição entre eles
        }
    }
}

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

namespace Vladik_and_Courtesy
{
    public static class Operações
    {
        static public string Doces; //Recebe o valor solicitado no começo da quantidade de doces que cada um tem

        static public void EntregaDoces()
        {
            //Separando a quantidade de doces pra cada um
            string[] separed = Doces.Split(' ');
            double vladik = double.Parse(separed[0]);
            double valera = double.Parse(separed[1]);

            //Instanciando um contador que define quantos doces cada um deve dar
            double cont = 1;

            while (vladik >= cont || valera >= cont) //Condição de que enquanto a quantidade de doces que um tem seja menor que a quantidade que ele deve dar
            {
                if (cont % 2 != 0) //Se o contador for ímpar, o vladik deve dar o doce
                    vladik -= cont; //Vladik entrega a quantidade de doces definida no contador
                else //Senão, a Valera deve dar o doce
                    valera -= cont; //Valera entrega a quantidade de doces definida no contador
                cont++; //Soma um valor no contador
            }

            Exibe(vladik, valera, cont); //Função pra exibir o nome de quem não pode dar a quantidade de doces definida
        }

        static private void Exibe(double vladik, double valera, double cont)
        {
            if (vladik < cont) //Se Vladik não tiver a quantidade, exibe o nome dele
                Console.WriteLine("Vladik");
            else //Senão, O nome da Valera é exibida
                Console.WriteLine("Valera");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Menu(); //Chamando o método para exibir a entrada
            Operações.EntregaDoces(); //Método para realizar a distribuição entre eles
        }

        static void Menu()
        {
           //Solicitando uma entrada
            Operações.Doces = Console.ReadLine(); //Colocando o valor dentro do objeto
        }
    }
}

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

namespace Vladik_and_Courtesy
{
    public static class Operações
    {
        static public string Doces; //Recebe o valor solicitado no começo da quantidade de doces que cada um tem

        static public void EntregaDoces()
        {
            //Separando a quantidade de doces pra cada um
            string[] separados = Doces.Split(' ');
            double vladik = int.Parse(separados[0]);
            double valera = int.Parse(separados[1]);
            int entrega = 1;

            //Instanciando um contador que define quantos doces cada um deve dar
            int cont = 1;

            while (vladik >= cont || valera >= cont) //Condição de que enquanto a quantidade de doces que um tem seja menor que a quantidade que ele deve dar
            {
                if (entrega == 1)
                { //Se o contador for ímpar, o vladik deve dar o doce
                    vladik -= cont; //Vladik entrega a quantidade de doces definida no contador
                    entrega = 2;
                }
                else
                { //Senão, a Valera deve dar o doce
                    valera -= cont; //Valera entrega a quantidade de doces definida no contador
                    entrega = 1;
                }
                cont++; //Soma um valor no contador
            }

            Exibe(vladik, valera, cont); //Função pra exibir o nome de quem não pode dar a quantidade de doces definida
        }

        static private void Exibe(double vladik, double valera, int cont)
        {
            if (vladik > valera) //Se Vladik não tiver a quantidade, exibe o nome dele
                Console.WriteLine("Vladik");
            else //Senão, O nome da Valera é exibida
                Console.WriteLine("Valera");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Menu(); //Chamando o método para exibir a entrada
            Operações.EntregaDoces(); //Método para realizar a distribuição entre eles
        }

        static void Menu()
        {
            Operações.Doces = Console.ReadLine(); //Colocando o valor dentro do objeto
        }
    }
}

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

namespace Vladik_and_Courtesy
{
    public static class Operações
    {
        static public string Doces; //Recebe o valor solicitado no começo da quantidade de doces que cada um tem

        static public void EntregaDoces()
        {
            //Separando a quantidade de doces pra cada um
            string[] separados = Doces.Split(' ');
            double vladik = double.Parse(separados[0]);
            double valera = double.Parse(separados[1]);
            string entrega = "vladik";

            //Instanciando um contador que define quantos doces cada um deve dar
            int cont = 1;

            while (vladik >= cont || valera >= cont) //Condição de que enquanto a quantidade de doces que um tem seja menor que a quantidade que ele deve dar
            {
                if (entrega == "vladik" && vladik >= cont)
                { //Se o contador for ímpar, o vladik deve dar o doce
                    vladik -= cont; //Vladik entrega a quantidade de doces definida no contador
                    entrega = "valera";
                }
                else if (entrega == "valera" && valera >= cont)
                { //Senão, a Valera deve dar o doce
                    valera -= cont; //Valera entrega a quantidade de doces definida no contador
                    entrega = "vladik";
                }
                cont++; //Soma um valor no contador
            }

            Exibe(vladik, valera, cont); //Função pra exibir o nome de quem não pode dar a quantidade de doces definida
        }

        static private void Exibe(double vladik, double valera, int cont)
        {
            if (vladik > valera ) //Se Vladik não tiver a quantidade, exibe o nome dele
                Console.WriteLine("Vladik");
            else //Senão, O nome da Valera é exibida
                Console.WriteLine("Valera");
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Menu(); //Chamando o método para exibir a entrada
            Operações.EntregaDoces(); //Método para realizar a distribuição entre eles
        }

        static void Menu()
        {
            Operações.Doces = Console.ReadLine(); //Colocando o valor dentro do objeto
        }
    }
}

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

namespace Divisivel_por_8
{
    static public class Operacoes
    {
        static public string Num; //Guarda o número definido pelo usuário
        static public string Divisivel = "NO"; //Já inicia a variável com o valor de que não é divisível
        //static public List<string> Lista = new List<string>(); //Cria uma lista para armazenar os valores
        static public string Lista;

        static public void RemovePos() //Função para remover o dígito na string
        {
            string temp = Num; //Variável temporária recebe o valro de Num, onde o valor do mesmo não será afetado, somente o da "temp"
            int pos = 0, quantidade = 1; //Um contador para indicar qual dígito da substring remover

            while (quantidade - 1 < Num.Length - 1)
            {
                while (pos < Num.Length)
                {
                    if (decimal.Parse((temp)) % 8 == 0) //Ele vai testar todo o número pra ver se é divisível
                    {
                        Divisivel = "YES"; //Se for divisível, ele altera pra YES
                        //Lista.Add(temp); //E também adiciona o número na lista criada
                        Lista = temp;
                    }

                    temp = Num; //Ele vai receber o valor original da string para poder ser retirado o dígito do valor original
                    try
                    {
                        temp = Num.Remove(pos, quantidade); //Será removido um dígito qualquer do número (ex: 3454 -> 344)
                    }
                    catch (System.Exception)
                    {
                        break;
                    }

                    pos++; //Soma um no contador pra definir qual o próximo a ser removido do número original
                }
                pos = 0;
                quantidade++;
            }

            Exibe();
        }

        static private void Exibe()
        {
            Console.WriteLine(Divisivel);

            if (Divisivel == "YES")
            {
                Console.WriteLine(Lista);
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Operacoes.Num = Console.ReadLine(); //Solicita uma entrada e salva dentro da classe
            Operacoes.RemovePos(); //Chama a função para calcular
        }
    }
}