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.

Input

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

Output

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

Examples

Input

1 1


Output

Valera


Input

7 6


Output

Vladik

Note

Illustration for first test case:

<image>

Illustration for second test case:

<image>
	        			/*
	        		     * Author- Priyam Vora
	        		     * BTech 2nd Year DAIICT
	        		     */
	     
	     
	        		    import java.awt.Checkbox;
	import java.awt.Point;
	import java.io.*;
	        		    import java.math.*;
	        		    import java.util.*;
	import java.util.Map.Entry;
	
	import javax.print.attribute.SetOfIntegerSyntax;
	
	     
	        		    public class Main{
	        		  	private static InputStream stream;
	        		    	private static byte[] buf = new byte[1024];
	        		    	private static int curChar;
	        		    	private static int numChars;
	        		    	private static SpaceCharFilter filter;
	        		    	private static PrintWriter pw;
	        		    	private static long count = 0,mod=1000000007;
	        		    //	private static TreeSet<Integer> ts=new TreeSet[200000];
	        		    	public final static int INF = (int) 1E9;
	
	        		        
	        		        public static void main(String[] args) {
	        		        	InputReader(System.in);
	        		    		pw = new PrintWriter(System.out); 
	        		            new Thread(null ,new Runnable(){
	        		               public void run(){
	        		                   try{
	        		                       solve();
	        		                       pw.close();
	        		                   } catch(Exception e){
	        		                       e.printStackTrace();
	        		                   }
	        		               }
	        		           },"1",1<<26).start();
	        		       }
	        		        public static long pow(long n, long p,long mod) {
	        					if(p==0)
	        						return 1;
	        					if(p==1)
	        						return n%mod;
	        					if(p%2==0){
	        						long temp=pow(n, p/2,mod);
	        					return (temp*temp)%mod;
	        					}else{
	        						 	long temp=pow(n,p/2,mod);
	        						 	temp=(temp*temp)%mod;
	        						 	return(temp*n)%mod;
	        						 	
	        					}
	        				}
	        		        public static long pow(long n, long p) {
	        					if(p==0)
	        						return 1;
	        					if(p==1)
	        						return n;
	        					if(p%2==0){
	        						long temp=pow(n, p/2);
	        					return (temp*temp);
	        					}else{
	        						 	long temp=pow(n,p/2);
	        						 	temp=(temp*temp);
	        						 	return(temp*n);
	        						 	
	        					}
	        				}
	        		        public static void Merge(long a[],int p,int r){
	        		            if(p<r){
	        		                int q = (p+r)/2;
	        		                Merge(a,p,q);
	        		                Merge(a,q+1,r);
	        		                Merge_Array(a,p,q,r);
	        		            }
	        		        }
	        		        public static void Merge_Array(long a[],int p,int q,int r){
	        		           long b[] = new long[q-p+1];
	        		            long c[] = new long[r-q];
	        		            for(int i=0;i<b.length;i++)
	        		                b[i] = a[p+i];
	        		            for(int i=0;i<c.length;i++)
	        		                c[i] = a[q+i+1];
	        		            int i = 0,j = 0;
	        		            for(int k=p;k<=r;k++){
	        		                if(i==b.length){
	        		                    a[k] = c[j];
	        		                    j++;
	        		                }
	        		                else if(j==c.length){
	        		                    a[k] = b[i];
	        		                    i++;
	        		                }
	        		                else if(b[i]<c[j]){
	        		                    a[k] = b[i];
	        		                    i++;
	        		                }
	        		                else{
	        		                    a[k] = c[j];
	        		                    j++;
	        		                }
	        		            }
	        		        }
	        		    	public static long gcd(long x, long y) {
	        		    		if (x == 0)
	        		    			return y;
	        		    		else
	        		    			return gcd( y % x,x);
	        		    	}	public static boolean isPrime(int n) {
	        		    	// Corner cases
				    		if (n <= 1)
				    			return false;
				    		if (n <= 3)
				    			return true;
				     
				    		// This is checked so that we can skip 
				    		// middle five numbers in below loop
				    		if (n % 2 == 0 || n % 3 == 0)
				    			return false;
				     
				    		for (int i = 5; i * i <= n; i = i + 6)
				    			if (n % i == 0 || n % (i + 2) == 0)
				    				return false;
				     
				    		return true;
				    	}
	        		        static LinkedList<Integer> adj[];
	        		        static boolean Visited[];
	        		        static HashSet<Integer> exc;
	        		        static long oddsum[]=new long[1000001];
	        		        static int co=0,ans=0;
	        		       
	        		        public static void solve() {
	        		        HashSet<Integer> prime=new HashSet<Integer>();
	        		        prime.add(2);
	        		        for(int i=3;i<=1;i+=2){
	        		        	if(isPrime(i))
	        		        	prime.add(i);
	        		        }
	        		        
	        		        int a=nextInt();
	        		        int b=nextInt();
	        		        int start=1;
	        		        for(int i=0;;i++){
	        		        	if(i%2==0){
	        		        		if(a<start){
	        		        			pw.println("Vladik");
	        		        			return;
	        		        		}
	        		        		a-=start;
	        		        		start++;
	        		        	}else{
	        		        		if(b<start){
	        		        			pw.println("Valera");
	        		        			return;
	        		        		}
	        		        		b-=start;
	        		        		start++;
	        		        	}
	        		        }
	        		        	 
	        		        }
	        		        
	        	        	
	        		      
	        		        public static String reverseString(String s) {
	        					StringBuilder sb = new StringBuilder(s);
	        					sb.reverse();
	        					return (sb.toString());
	        				}
	        		        
	        		        
	        		        private static void BFS(int sou,int dest){
	        		        	Queue<Integer> q=new LinkedList<Integer>();
	        		        	q.add(sou);
	        		        	Visited[sou]=true;
	        		        	while(!q.isEmpty()){
	        		        		int top=q.poll();
	        		        		
	        		        		for(int i:adj[top]){
	        		        			//pw.println(i+" "+top);
	        		        			if(!Visited[i])
	        		        			{
	        		        				
	        		        				q.add(i);
	        		        			}
	        		        			
	        		        			Visited[i]=true;
	        		        			if(i==dest){
	        		        				pw.println("Yes");
	        		        			return;	
	        		        			}
	        		        		}
	        		        	}
	        		        	pw.println("No");
	        		        	
	        		        	
	        		        }
	        		        
	        		        private static long ncr(int n,int k){
	    				    	if (k < 0 || k > n) return 0;
	    				        if (n-k < k) k = n-k;
	    			
	    				        BigInteger x = BigInteger.ONE;
	    				        for (int i = 1; i <= k; i++) {
	    				            x = x.multiply(new BigInteger(""+(n-i+1)));
	    				            x = x.divide(new BigInteger(""+i));
	    				        }
	    			
	    				return x.longValue();
	    				    }
	        		       private  static long fact(long count){
	        		        	long ans=1;
	        		        	for(int i=1;i<=count;i++){
	        		        		ans*=i;
	        		        	}
	        		        	return ans;
	        		        }
	        		        
	        		        
	        		        static int state=1;
	        		        static long no_exc=0,no_vert=0;
	        		      static Stack<Integer> st;
	        		      static HashSet<Integer> inset;
	        		        private static void topo(int curr){
	        		        	
	        		        	Visited[curr]=true;
	        		        	inset.add(curr);
	        		        	for(int x:adj[curr]){
	        		        		if(adj[x].contains(curr) || inset.contains(x)){
	        		        			state=0;
	        		        			return;
	        		        		}
	        		        		if(state==0)
	        		        			return;
	        		        		
	        		        	}
	        		        	st.push(curr);
	        		        	
	        		        	inset.remove(curr);
	        		        }
	        		        static HashSet<Integer> hs;
	        		       
	        		     	private static void buildgraph(int n){
	        		    		adj=new LinkedList[150000+1];
	        		    		Visited=new boolean[150000+1];
	        		    		st=new Stack<Integer>();
	        		    		inset=new HashSet<Integer>();
	        		    		exc=new HashSet<Integer>();
	        		    		
	        		    		state=1;
	        		    		for(int i=0;i<=150000;i++){
	        		    			adj[i]=new LinkedList<Integer>();
	        		    		
	        		    		}
	     
	     
	        		    	}
	        		     	
	        		    	// To Get Input
	        		    	// Some Buffer Methods
	     
	        		     	public static void sort(long a[]){
	        		     		Merge(a, 0, a.length-1);
	        		     	}
	        		    	public static void InputReader(InputStream stream1) {
	        		    		stream = stream1;
	        		    	}
	     
	        		    	private static boolean isWhitespace(int c) {
	        		    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	        		    	}
	     
	        		    	private static boolean isEndOfLine(int c) {
	        		    		return c == '\n' || c == '\r' || c == -1;
	        		    	}
	     
	        		    	private static int read() {
	        		    		if (numChars == -1)
	        		    			throw new InputMismatchException();
	        		    		if (curChar >= numChars) {
	        		    			curChar = 0;
	        		    			try {
	        		    				numChars = stream.read(buf);
	        		    			} catch (IOException e) {
	        		    				throw new InputMismatchException();
	        		    			}
	        		    			if (numChars <= 0)
	        		    				return -1;
	        		    		}
	        		    		return buf[curChar++];
	        		    	}
	     
	        		    	private static int nextInt() {
	        		    		int c = read();
	        		    		while (isSpaceChar(c))
	        		    			c = read();
	        		    		int sgn = 1;
	        		    		if (c == '-') {
	        		    			sgn = -1;
	        		    			c = read();
	        		    		}
	        		    		int res = 0;
	        		    		do {
	        		    			if (c < '0' || c > '9')
	        		    				throw new InputMismatchException();
	        		    			res *= 10;
	        		    			res += c - '0';
	        		    			c = read();
	        		    		} while (!isSpaceChar(c));
	        		    		return res * sgn;
	        		    	}
	     
	        		    	private static long nextLong() {
	        		    		int c = read();
	        		    		while (isSpaceChar(c))
	        		    			c = read();
	        		    		int sgn = 1;
	        		    		if (c == '-') {
	        		    			sgn = -1;
	        		    			c = read();
	        		    		}
	        		    		long res = 0;
	        		    		do {
	        		    			if (c < '0' || c > '9')
	        		    				throw new InputMismatchException();
	        		    			res *= 10;
	        		    			res += c - '0';
	        		    			c = read();
	        		    		} while (!isSpaceChar(c));
	        		    		return res * sgn;
	        		    	}
	     
	        		    	private static String nextToken() {
	        		    		int c = read();
	        		    		while (isSpaceChar(c))
	        		    			c = read();
	        		    		StringBuilder res = new StringBuilder();
	        		    		do {
	        		    			res.appendCodePoint(c);
	        		    			c = read();
	        		    		} while (!isSpaceChar(c));
	        		    		return res.toString();
	        		    	}
	     
	        		    	private static String nextLine() {
	        		    		int c = read();
	        		    		while (isSpaceChar(c))
	        		    			c = read();
	        		    		StringBuilder res = new StringBuilder();
	        		    		do {
	        		    			res.appendCodePoint(c);
	        		    			c = read();
	        		    		} while (!isEndOfLine(c));
	        		    		return res.toString();
	        		    	}
	     
	        		    	private static int[] nextIntArray(int n) {
	        		    		int[] arr = new int[n];
	        		    		for (int i = 0; i < n; i++) {
	        		    			arr[i] = nextInt();
	        		    		}
	        		    		return arr;
	        		    	}
	     
	        		    	private static long[][] next2dArray(int n, int m) {
	        		    		long[][] arr = new long[n][m];
	        		    		for (int i = 0; i < n; i++) {
	        		    			for (int j = 0; j < m; j++) {
	        		    				arr[i][j] = nextLong();
	        		    			}
	        		    		}
	        		    		return arr;
	        		    	}
	        		    	private static char[][] nextCharArray(int n,int m){
	        		    		char [][]c=new char[n][m];
	        		    		for(int i=0;i<n;i++){
	        		    			String s=nextLine();
	        		    			for(int j=0;j<s.length();j++){
	        		    				c[i][j]=s.charAt(j);
	        		    			}
	        		    		}
	        		    		return c;
	        		    	}
	     
	        		    	private static long[] nextLongArray(int n) {
	        		    		long[] arr = new long[n];
	        		    		for (int i = 0; i < n; i++) {
	        		    			arr[i] = nextLong();
	        		    		}
	        		    		return arr;
	        		    	}
	     
	        		    	private static void pArray(int[] arr) {
	        		    		for (int i = 0; i < arr.length; i++) {
	        		    			pw.print(arr[i] + " ");
	        		    		}
	        		    		pw.println();
	        		    		return;
	        		    	}
	     
	        		    	private static void pArray(long[] arr) {
	        		    		for (int i = 0; i < arr.length; i++) {
	        		    			pw.print(arr[i] + " ");
	        		    		}
	        		    		pw.println();
	        		    		return;
	        		    	}
	     
	        		    	private static void pArray(boolean[] arr) {
	        		    		for (int i = 0; i < arr.length; i++) {
	        		    			pw.print(arr[i] + " ");
	        		    		}
	        		    		pw.println();
	        		    		return;
	        		    	}
	     
	        		    	private static boolean isSpaceChar(int c) {
	        		    		if (filter != null)
	        		    			return filter.isSpaceChar(c);
	        		    		return isWhitespace(c);
	        		    	}
	     
	        		    	private interface SpaceCharFilter {
	        		    		public boolean isSpaceChar(int ch);
	        		    	}
	     
	     
	    }
	        		    
	        		    class HungarianBipartiteMatching
	
	        		    {
	
	        		        private final double[][] costMatrix;
	
	        		        private final int        rows, cols, dim;
	
	        		        private final double[]   labelByWorker, labelByJob;
	
	        		        private final int[]      minSlackWorkerByJob;
	
	        		        private final double[]   minSlackValueByJob;
	
	        		        private final int[]      matchJobByWorker, matchWorkerByJob;
	
	        		        private final int[]      parentWorkerByCommittedJob;
	
	        		        private final boolean[]  committedWorkers;
	
	        		     
	
	        		        public HungarianBipartiteMatching(double[][] costMatrix)
	
	        		        {
	
	        		            this.dim = Math.max(costMatrix.length, costMatrix[0].length);
	
	        		            this.rows = costMatrix.length;
	
	        		            this.cols = costMatrix[0].length;
	
	        		            this.costMatrix = new double[this.dim][this.dim];
	
	        		            for (int w = 0; w < this.dim; w++)
	
	        		            {
	
	        		                if (w < costMatrix.length)
	
	        		                {
	
	        		                    if (costMatrix[w].length != this.cols)
	
	        		                    {
	
	        		                        throw new IllegalArgumentException("Irregular cost matrix");
	
	        		                    }
	
	        		                    this.costMatrix[w] = Arrays.copyOf(costMatrix[w], this.dim);
	
	        		                }
	
	        		                else
	
	        		                {
	
	        		                    this.costMatrix[w] = new double[this.dim];
	
	        		                }
	
	        		            }
	
	        		            labelByWorker = new double[this.dim];
	
	        		            labelByJob = new double[this.dim];
	
	        		            minSlackWorkerByJob = new int[this.dim];
	
	        		            minSlackValueByJob = new double[this.dim];
	
	        		            committedWorkers = new boolean[this.dim];
	
	        		            parentWorkerByCommittedJob = new int[this.dim];
	
	        		            matchJobByWorker = new int[this.dim];
	
	        		            Arrays.fill(matchJobByWorker, -1);
	
	        		            matchWorkerByJob = new int[this.dim];
	
	        		            Arrays.fill(matchWorkerByJob, -1);
	
	        		        }
	
	        		     
	
	        		        protected void computeInitialFeasibleSolution()
	
	        		        {
	
	        		            for (int j = 0; j < dim; j++)
	
	        		            {
	
	        		                labelByJob[j] = Double.POSITIVE_INFINITY;
	
	        		            }
	
	        		            for (int w = 0; w < dim; w++)
	
	        		            {
	
	        		                for (int j = 0; j < dim; j++)
	
	        		                {
	
	        		                    if (costMatrix[w][j] < labelByJob[j])
	
	        		                    {
	
	        		                        labelByJob[j] = costMatrix[w][j];
	
	        		                    }
	
	        		                }
	
	        		            }
	
	        		        }
	
	        		     
	
	        		        public int[] execute()
	
	        		        {
	
	        		            /*
	
	        		             * Heuristics to improve performance: Reduce rows and columns by their
	
	        		             * smallest element, compute an initial non-zero dual feasible solution
	
	        		             * and
	
	        		             * create a greedy matching from workers to jobs of the cost matrix.
	
	        		             */
	
	        		            reduce();
	
	        		            computeInitialFeasibleSolution();
	
	        		            greedyMatch();
	
	        		            int w = fetchUnmatchedWorker();
	
	        		            while (w < dim)
	
	        		            {
	
	        		                initializePhase(w);
	
	        		                executePhase();
	
	        		                w = fetchUnmatchedWorker();
	
	        		            }
	
	        		            int[] result = Arrays.copyOf(matchJobByWorker, rows);
	
	        		            for (w = 0; w < result.length; w++)
	
	        		            {
	
	        		                if (result[w] >= cols)
	
	        		                {
	
	        		                    result[w] = -1;
	
	        		                }
	
	        		            }
	
	        		            return result;
	
	        		        }
	
	        		     
	
	        		        protected void executePhase()
	
	        		        {
	
	        		            while (true)
	
	        		            {
	
	        		                int minSlackWorker = -1, minSlackJob = -1;
	
	        		                double minSlackValue = Double.POSITIVE_INFINITY;
	
	        		                for (int j = 0; j < dim; j++)
	
	        		                {
	
	        		                    if (parentWorkerByCommittedJob[j] == -1)
	
	        		                    {
	
	        		                        if (minSlackValueByJob[j] < minSlackValue)
	
	        		                        {
	
	        		                            minSlackValue = minSlackValueByJob[j];
	
	        		                            minSlackWorker = minSlackWorkerByJob[j];
	
	        		                            minSlackJob = j;
	
	        		                        }
	
	        		                    }
	
	        		                }
	
	        		                if (minSlackValue > 0)
	
	        		                {
	
	        		                    updateLabeling(minSlackValue);
	
	        		                }
	
	        		                parentWorkerByCommittedJob[minSlackJob] = minSlackWorker;
	
	        		                if (matchWorkerByJob[minSlackJob] == -1)
	
	        		                {
	
	        		                    /*
	
	        		                     * An augmenting path has been found.
	
	        		                     */
	
	        		                    int committedJob = minSlackJob;
	
	        		                    int parentWorker = parentWorkerByCommittedJob[committedJob];
	
	        		                    while (true)
	
	        		                    {
	
	        		                        int temp = matchJobByWorker[parentWorker];
	
	        		                        match(parentWorker, committedJob);
	
	        		                        committedJob = temp;
	
	        		                        if (committedJob == -1)
	
	        		                        {
	
	        		                            break;
	
	        		                        }
	
	        		                        parentWorker = parentWorkerByCommittedJob[committedJob];
	
	        		                    }
	
	        		                    return;
	
	        		                }
	
	        		                else
	
	        		                {
	
	        		                    /*
	
	        		                     * Update slack values since we increased the size of the
	
	        		                     * committed
	
	        		                     * workers set.
	
	        		                     */
	
	        		                    int worker = matchWorkerByJob[minSlackJob];
	
	        		                    committedWorkers[worker] = true;
	
	        		                    for (int j = 0; j < dim; j++)
	
	        		                    {
	
	        		                        if (parentWorkerByCommittedJob[j] == -1)
	
	        		                        {
	
	        		                            double slack = costMatrix[worker][j]
	
	        		                                    - labelByWorker[worker] - labelByJob[j];
	
	        		                            if (minSlackValueByJob[j] > slack)
	
	        		                            {
	
	        		                                minSlackValueByJob[j] = slack;
	
	        		                                minSlackWorkerByJob[j] = worker;
	
	        		                            }
	
	        		                        }
	
	        		                    }
	
	        		                }
	
	        		            }
	
	        		        }
	
	        		     
	
	        		        protected int fetchUnmatchedWorker()
	
	        		        {
	
	        		            int w;
	
	        		            for (w = 0; w < dim; w++)
	
	        		            {
	
	        		                if (matchJobByWorker[w] == -1)
	
	        		                {
	
	        		                    break;
	
	        		                }
	
	        		            }
	
	        		            return w;
	
	        		        }
	
	        		     
	
	        		        protected void greedyMatch()
	
	        		        {
	
	        		            for (int w = 0; w < dim; w++)
	
	        		            {
	
	        		                for (int j = 0; j < dim; j++)
	
	        		                {
	
	        		                    if (matchJobByWorker[w] == -1
	
	        		                            && matchWorkerByJob[j] == -1
	
	        		                            && costMatrix[w][j] - labelByWorker[w] - labelByJob[j] == 0)
	
	        		                    {
	
	        		                        match(w, j);
	
	        		                    }
	
	        		                }
	
	        		            }
	
	        		        }
	
	        		     
	
	        		        protected void initializePhase(int w)
	
	        		        {
	
	        		            Arrays.fill(committedWorkers, false);
	
	        		            Arrays.fill(parentWorkerByCommittedJob, -1);
	
	        		            committedWorkers[w] = true;
	
	        		            for (int j = 0; j < dim; j++)
	
	        		            {
	
	        		                minSlackValueByJob[j] = costMatrix[w][j] - labelByWorker[w]
	
	        		                        - labelByJob[j];
	
	        		                minSlackWorkerByJob[j] = w;
	
	        		            }
	
	        		        }
	
	        		     
	
	        		        protected void match(int w, int j)
	
	        		        {
	
	        		            matchJobByWorker[w] = j;
	
	        		            matchWorkerByJob[j] = w;
	
	        		        }
	
	        		     
	
	        		        protected void reduce()
	
	        		        {
	
	        		            for (int w = 0; w < dim; w++)
	
	        		            {
	
	        		                double min = Double.POSITIVE_INFINITY;
	
	        		                for (int j = 0; j < dim; j++)
	
	        		                {
	
	        		                    if (costMatrix[w][j] < min)
	
	        		                    {
	
	        		                        min = costMatrix[w][j];
	
	        		                    }
	
	        		                }
	
	        		                for (int j = 0; j < dim; j++)
	
	        		                {
	
	        		                    costMatrix[w][j] -= min;
	
	        		                }
	
	        		            }
	
	        		            double[] min = new double[dim];
	
	        		            for (int j = 0; j < dim; j++)
	
	        		            {
	
	        		                min[j] = Double.POSITIVE_INFINITY;
	
	        		            }
	
	        		            for (int w = 0; w < dim; w++)
	
	        		            {
	
	        		                for (int j = 0; j < dim; j++)
	
	        		                {
	
	        		                    if (costMatrix[w][j] < min[j])
	
	        		                    {
	
	        		                        min[j] = costMatrix[w][j];
	
	        		                    }
	
	        		                }
	
	        		            }
	
	        		            for (int w = 0; w < dim; w++)
	
	        		            {
	
	        		                for (int j = 0; j < dim; j++)
	
	        		                {
	
	        		                    costMatrix[w][j] -= min[j];
	
	        		                }
	
	        		            }
	
	        		        }
	
	        		     
	
	        		        protected void updateLabeling(double slack)
	
	        		        {
	
	        		            for (int w = 0; w < dim; w++)
	
	        		            {
	
	        		                if (committedWorkers[w])
	
	        		                {
	
	        		                    labelByWorker[w] += slack;
	
	        		                }
	
	        		            }
	
	        		            for (int j = 0; j < dim; j++)
	
	        		            {
	
	        		                if (parentWorkerByCommittedJob[j] != -1)
	
	        		                {
	
	        		                    labelByJob[j] -= slack;
	
	        		                }
	
	        		                else
	
	        		                {
	
	        		                    minSlackValueByJob[j] -= slack;
	
	        		                }
	
	        		            }
	
	        		        }
	        		    }
	        		    
	        		    class Node{
	        		    	int to;
	        		    	long dist;
	        		    	Node(int to,long dist){
	        		    		this.to=to;
	        		    		this.dist=dist;
	        		    	}
	        		    	
	        		    }
	        		    class Pair implements Comparable<Pair>{
	        				
	    					
	    					int h,m,s;
	    					Pair(int h,int m,int s){
	    					
	    						this.h=h;
	    						this.m=m;
	    						this.s=s;
	    					}
	    					@Override
	    					public int compareTo(Pair o) {
	    				
	    					/*	if(((double)a/(double)b)!=((double)o.a/(double)o.b))
	    						return (int)(((double)o.a/(double)o.b)-((double)a/(double)b));
	    						else*/
	    							
	    						//return (int)(o.size-size);
	    						return 0;
	    					}
	    					public int hashCode() {
	    							//int hu = (int) (x ^ (x >>> 32));
	    							//int hv = (int) (y ^ (y >>> 32));
	    							//int hw = (int) (mass ^ (mass >>> 32));
	    							//return 31 * hu + hv ;
	    						return 0;
	    						}
	    						public boolean equals(Object o) {
	    							Pair other = (Pair) o;
	    						//	return x == other.x && y == other.y;
	    						return false;
	    						}
	    				}  class Dsu{
		    		    	private int rank[], parent[] ,n;
		    		    	private static int[] parent1;
		    		    	Dsu(int size){
		    		    		this.n=size+1;
		    		    		rank=new int[n];
		    		    		//parent=new int[n];
		    		    		parent=new int[n];
		    		    	makeSet();
		    		
		    		    	}
		    		    	
		    		    	void makeSet(){
		    		    		for(int i=0;i<n;i++){
		    		    			parent[i]=i;
		    		    		}
		    		    	}
		    		    	
		    		    	int find(int x){
		    		    		if(parent[x]!=x){
		    		    			
		    		    			parent[x]=find(parent[x]);
		    		    		}
		    		    		return parent[x];
		    		    	}
		    		    
		    		    	
		    		    	boolean union(int x,int y){
		    		    		int xRoot=find(x);
		    		    		int yRoot=find(y);
		    		    		
		    		    		if(xRoot==yRoot)
		    		    			return false;
		    		    		if(rank[xRoot]<rank[yRoot]){
		    		    		parent[xRoot]=yRoot;	
		    		    		}else if(rank[yRoot]<rank[xRoot]){
		    		    			parent[yRoot]=xRoot;
		    		    		}else{
		    		    			parent[yRoot]=xRoot;
		    		    			rank[xRoot]++;
		    		    		}
		    		    		return true;
		    		    	}
	
		    		     
		    		    }