class Node {
		    int data; 
		    Node left; 
		    Node right; 
		    Node() {
		      this.data = 0; 
		      this.left = null; 
		      this.right = null; 
		    }
		    Node(int data) {
		      this.data = data; 
		      this.left = null; 
		      this.right = null; 
		    }
		  }
		  
	
	int visibleNodes(Node root) {
       Queue<Node> q = new LinkedList<Node>();
       Queue<Integer> level = new LinkedList<Integer>();
       q.add(root);
       level.add(1);
       int count = 0;
       while(!q.isEmpty()) {
    	   Node n = q.poll();
    	    count = level.poll();
    	   if(n.right != null ) {
    		   q.add(n.right);
    		   level.add(count+1);
    	   }
    	   if(n.left != null ) {
    		   q.add(n.left);
    		   level.add(count+1);
    	   }
       }
       return count;
	}

	public int maxCandies(int[] arr, int K) {
		PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(Comparator.reverseOrder());
		for (int i : arr)
			maxHeap.add(i);
		int maxCandies = 0;
		for (int i = 1; i <= K; i++) {
			int rem = maxHeap.remove();
			maxCandies += rem;
			maxHeap.add(rem / 2);
		}

		return maxCandies;
	}

	public static int minLengthSubstring(String s, String t) {
		int min = Integer.MAX_VALUE;
		boolean found = false;
		for (int i = 0; i <= s.length(); i++) {
			for (int j = i; j <= s.length(); j++) {
				String takedString = s.substring(i, j);
				boolean contained = true;
				HashMap<Character, Integer> h = new HashMap<Character, Integer>();
				for (Character c : t.toCharArray()) {
					h.put(c, h.getOrDefault(c, 0) + 1);
				}
				for (Character c : takedString.toCharArray()) {
					h.put(c, h.getOrDefault(c, 0) - 1);
				}

				for (Character c : h.keySet()) {
					if (h.get(c) > 0)
						contained = false;
				}
				if (contained) {
					found = true;
					min = Integer.min(min, takedString.length());
				}
			}
		}
		if (!found)
			return -1;
		return min;
	}

	public static int[] getMilestoneDays(int[] revenues, int[] milestones) {
		int[] output = new int[milestones.length];
		Arrays.fill(output, -1);
		int sum = 0;
		for (int i = 0; i < revenues.length; i++) {
			revenues[i] += sum;
			sum = revenues[i];
		}
		for (int i = 0; i < milestones.length; i++) {
			int searchFor = milestones[i];
			int low = 0;
			int high = revenues.length - 1;
			int mid = 0;

			while (low <= high) {
				mid = (high + low) / 2;

				if (searchFor == revenues[mid]) {
					output[i] = mid;
					break;
				} else if (searchFor < revenues[mid] && (mid - 1 < revenues.length && searchFor > revenues[mid - 1])) {
					output[i] = mid - 1;
					break;
				} else if (searchFor < revenues[mid])
					high = mid - 1;
				else if (searchFor > revenues[mid] && (mid + 1 < revenues.length && searchFor < revenues[mid + 1])) {
					output[i] = mid + 1;
					break;
				} else if (searchFor > revenues[mid])
					low = mid + 1;

			}
		}
		for (int i = 0; i < output.length; i++)
			output[i]++;
		return output;
	}

	public static class Pair {
		int index;
		int value;

		public Pair(int index, int value) {
			super();
			this.index = index;
			this.value = value;
		}

		public int getIndex() {
			return index;
		}

		public void setIndex(int index) {
			this.index = index;
		}

		public int getValue() {
			return value;
		}

		public void setValue(int value) {
			this.value = value;
		}

	}

	public static int[] findPositions(int[] arr, int x) {
		Queue<Pair> q = new LinkedList<Pair>();
		for (int i = 0; i < arr.length; i++)
			q.add(new Pair(i + 1, arr[i]));
		ArrayList<Integer> removed = new ArrayList<Integer>();
		for (int i = x; i >= 1; i--) {
			int pops = x;
			PriorityQueue<Pair> maxHeap = new PriorityQueue<Pair>(new Comparator<Pair>() {
				@Override
				public int compare(Pair o1, Pair o2) {
					if (o1.getValue() == o2.getValue())
						return Integer.compare(o1.getIndex(), o2.getIndex());
					return -Integer.compare(o1.getValue(), o2.getValue());
				}
			});
			Queue<Pair> temp = new LinkedList<Pair>();
			while (pops != 0 && !q.isEmpty()) {
				Pair c = q.poll();
				maxHeap.add(c);
				temp.add(c);
				pops--;
			}
			Pair ToRemove = maxHeap.remove();
			int ToRemoveIndex = ToRemove.getIndex();
			removed.add(ToRemoveIndex);
			while (!temp.isEmpty()) {
				Pair a = temp.poll();
				if (a.getIndex() != ToRemoveIndex) {
					q.add((a.getValue() > 0) ? new Pair(a.getIndex(), a.getValue() - 1) : a);
				}
			}
		}
		int[] out = new int[removed.size()];
		for (int i = 0; i < out.length; i++)
			out[i] = removed.get(i);
		return out;
	}

 public static String caesarCipher(String input, int rotationFactor) {
    // Write your code here
StringBuilder sb = new StringBuilder();
        for (int i = 0; i < input.length(); i++) {
            if (input.charAt(i) >= 'a' && input.charAt(i) <= 'z') {
                char newChar = (char) (input.charAt(i) + rotationFactor%26);
                sb.append((newChar >= 'a' && newChar <= 'z') ? newChar : (char) (newChar - 'z' - 1 + 'a'));
            } else if (input.charAt(i) >= 'A' && input.charAt(i) <= 'Z') {
                char newChar = (char) (input.charAt(i) + rotationFactor%26);
                sb.append((newChar >= 'A' && newChar <= 'Z') ? newChar : (char) (newChar - 'Z' - 1 + 'A'));
            } else
                sb.append(input.charAt(i));
        }
        return sb.toString();
    }

class Solution {
      public static List<List<Integer>> generate(int numRows) {
        List<List<Integer>> all = new ArrayList();
        
      List<Integer> first = new ArrayList<>();
      first.add(1);
      all.add(first);
      
      if(numRows >=2) {
    	  List<Integer> second = new ArrayList<>();
          second.add(1);
          second.add(1);
          all.add(second);  
      }
      for(int i = 2;i < numRows; i++) {
    	  List<Integer> row = new ArrayList<>();
    	  row.add(1);
    	  int start =0;
    	  for(int j = 1; start<all.get(i-1).size()-1; j++) {
    		  int a = all.get(i-1).get(start)+all.get(i-1).get(start+1);
    		  start++;
    		  row.add(a);
    	  }
    	  
    	 row.add(1);
    	 all.add(row); 
      }
        
        return all;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int len = 0;
        ListNode current = head;
        while(current != null){
            len++;
            current = current.next;
        }
       int required = len - n;
        if(required == 0) return head.next;
        ListNode c = head;
        for(int i =0; i < len; i++){
            if(i == required-1) {
                c.next = c.next.next;
               
            }
             else c = c.next;
        }
        return head;
    }
}

class Solution {
    public boolean isPalindrome(String s) {

        StringBuilder sIgnoreBuffer = new StringBuilder();
        for (int i = 0; i < s.length(); i++){
            if((s.charAt(i)>='0' && s.charAt(i)<='9')||(s.charAt(i) >= 'a' && s.charAt(i) <= 'z') || (s.charAt(i) >= 'A' && s.charAt(i) <= 'Z'))
                sIgnoreBuffer.append(Character.toLowerCase(s.charAt(i)));
        }
    
        String sIgnore = sIgnoreBuffer.toString();
        int start = 0;
        int end = sIgnore.length() - 1;   
                                
        while(start < end){
            if(sIgnore.charAt(start) == sIgnore.charAt(end)){
                start++;
                end --;
            } else return false;
        }
       return true;
}}