At regular competition Vladik and Valera won a and b candies respectively. Vladik offered 1 his candy to Valera. After that Valera gave Vladik 2 his candies, so that no one thought that he was less generous. Vladik for same reason gave 3 candies to Valera in next turn.More formally, the guys take turns giving each other one candy more than they received in the previous turn.This continued until the moment when one of them couldn’t give the right amount of candy. Candies, which guys got from each other, they don’t consider as their own. You need to know, who is the first who can’t give the right amount of candy.

Single line of input data contains two space-separated integers a, b (1 ≤ a, b ≤ 109) — number of Vladik and Valera candies respectively.

Pring a single line "Vladik’’ in case, if Vladik first who can’t give right amount of candy, or "Valera’’ otherwise.

NoteIllustration for first test case:Illustration for second test case:

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;

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

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

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

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