Utkarsh is forced to play yet another one of Ashish's games. The game progresses turn by turn and as usual, Ashish moves first.

Consider the 2D plane. There is a token which is initially at (0,0). In one move a player must increase either the x coordinate or the y coordinate of the token by exactly k. In doing so, the player must ensure that the token stays within a (Euclidean) distance d from (0,0).

In other words, if after a move the coordinates of the token are (p,q), then p^2 + q^2 ≤ d^2 must hold.

The game ends when a player is unable to make a move. It can be shown that the game will end in a finite number of moves. If both players play optimally, determine who will win.

Input

The first line contains a single integer t (1 ≤ t ≤ 100) — the number of test cases.

The only line of each test case contains two space separated integers d (1 ≤ d ≤ 10^5) and k (1 ≤ k ≤ d).

Output

For each test case, if Ashish wins the game, print "Ashish", otherwise print "Utkarsh" (without the quotes).

Example

Input


5
2 1
5 2
10 3
25 4
15441 33


Output


Utkarsh
Ashish
Utkarsh
Utkarsh
Ashish

Note

In the first test case, one possible sequence of moves can be

(0, 0) \xrightarrow{Ashish } (0, 1) \xrightarrow{Utkarsh } (0, 2).

Ashish has no moves left, so Utkarsh wins.

<image>
//note: 0<=|int|<= 2 * 10^9
//note: 0<=|long|<= 9 * 10^18
//note: 20! max w/ long
//note: 91st fibonacci # highest calculable w/long
//note: 0 <= |double| <= 1.8 * 10^308
//note: 170! max w/double;
//java machine can make 10^8 computations in a second.
import java.io.*;
import java.util.*;
import java.util.Set;
import java.util.HashSet;
import java.util.ArrayList;
    
public class CP{
    static int MAX = Integer.MAX_VALUE, MIN = Integer.MIN_VALUE;
    static FastScanner sc = new FastScanner();
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    static boolean bestAnsFound = false;
    static int visits = 0;
    public static void main(String[] args){
    	solve();	
        out.close();
    }
    
    static void solve() {
    	int t = sc.nextint();
    	while(t-->0) {
    		double d = sc.nextdouble();
    		int k = sc.nextint();
    		
    		long maxY = (long) Math.floor(Math.sqrt(d*d/2));
    		maxY = (maxY/k * k);
    		if((maxY*maxY + (maxY+k)*(maxY+k)) <= d*d) {
    			out.println("Ashish");
    		}
    		else if((maxY-k)*(maxY-k)+(maxY+k)*(maxY+k) <= d*d) {
    			out.println("Utkarsh");
    		}
    		else {
    			out.println("Utkarsh");
    		}
    	}
    }
    
    static class Node{
        int id;
        Set<Edge> adj = new HashSet<Edge>();
        public Node(int id) {
            this.id = id;
        }
        void add(Edge e) {
        	adj.add(e);
        }
    }
    
    static class Edge{
    	public Node from, to;
    	public Edge residual;
    	public int flow, capacity;
    	public Edge(Node from, Node to, int capacity) {
    		this.from = from;
    		this.to = to;
    		this.capacity = capacity;
    	}
    	
    	public int remainingCapacity() {
    		return capacity-flow;
    	}
    	
    	public void augment(int bottleNeck) {
    		flow += bottleNeck;
    		residual.flow -= bottleNeck;
    	}
    }
    
    static class UnionFind{
        public int numComponents;
        public int[] sz, id;
        public UnionFind(int size) {
            numComponents = size;
            sz = new int[size];
            id = new int[size];
            for(int i = 0; i < size; ++i) {
                id[i] = i;
                sz[i] = 1;
            }
        }
        
        public int find(int p) {
            int root = p;
            while(root != id[root]) {
                root = id[root];
            }
            while(p != root) {
                int next = id[p];
                id[p] = root;
                p = next;
            }
            return root;
        }
        
        public void unify(int p, int q) {
            int root1 = find(p);
            int root2 = find(q);
            
            if(root1 == root2) {
                return;
            }
            
            if(sz[root1] < sz[root2]) {
                sz[root2] += sz[root1];
                id[root1] = id[root2];
            }
            else {
                sz[root1] += sz[root2];
                id[root2] = id[root1];
            }
                
            --numComponents;
        }
    }
    
    static class RMQ{
        int leftMost, rightMost, min, max;
        RMQ lChild, rChild;
        public RMQ(int lb, int rb, int[] a) {
            leftMost = lb;
            rightMost = rb;
            if(lb == rb) {
                min = max = a[lb];
                return;
            }
            int mb = (lb+rb)/2;
            lChild = new RMQ(lb, mb, a); 
            rChild = new RMQ(mb+1, rb, a);
            min = Math.min(lChild.min, rChild.min); 
            max = Math.max(lChild.max, rChild.max);
        }
        
        public void pointUpdate(int index, int val) {
            if(leftMost == rightMost) {
                min = val;
                max = val;
                return;
            }
            if(index <= lChild.rightMost) {
                lChild.pointUpdate(index, val);
            }
            else {
                rChild.pointUpdate(index, val);;
            }
            min = Math.min(lChild.min, rChild.min);
            max = Math.max(lChild.max, rChild.max);
        }
        
        public int rangeMin(int lb, int rb) {
            if(rightMost < lb || leftMost > rb) {
                return Integer.MAX_VALUE;
            }
            else if(rightMost <= rb && leftMost >= lb) {
                return min;
            }
            return Math.min(lChild.rangeMin(lb, rb), rChild.rangeMin(lb,rb));
        }
        
        public int rangeMax(int lb, int rb) {
            if(rightMost < lb || leftMost > rb) {
                return Integer.MIN_VALUE;
            }
            else if(rightMost <= rb && leftMost >= lb) {
                return max;
            }
            return Math.max(lChild.rangeMax(lb, rb), rChild.rangeMax(lb,rb));
        }
    }
    
    static class SegTree{
        int lb, rb;
        int sum;
        SegTree lChild, rChild;
        
        public SegTree(int lb, int rb, int[] a) {
            this.lb = lb;
            this.rb = rb;
            if(lb==rb) {
                sum = a[lb];
                return;
            }
            int mb = (lb+rb)/2;
            lChild = new SegTree(lb, mb, a);
            rChild = new SegTree(mb+1, rb, a);
            recalc();   
        }
        
        public void recalc() {
            if(lb == rb) {
                return;
            }
            sum = lChild.sum + rChild.sum;
        }
        
        public void pointUpdate(int index, int val) {
            if(lb == rb) {
                sum = val;
                return;
            }
            if(index <= lChild.rb) {
                lChild.pointUpdate(index, val);
            }
            else {
                rChild.pointUpdate(index, val);
            }
            recalc();
        }
        
        public long rangeSum(int l, int r) {
            if(l <= lb && rb <= r) {
                return sum;
            }
            if(l > rb || r < lb) {
                return 0;
            }
            return lChild.rangeSum(l, r) + rChild.rangeSum(l, r);
        }
    }
    
    static long modInverse(long a, long b) {
        long bb = b, temp, q;
        long x0 = 0, x1 = 1;
        if(b == 1){
            return 1L;
        }
        while(a > 1){
            q = a/b;
            temp = b; b = a-(a/b)*b; a=temp;
            temp = x0; x0 = x1-q*x0; x1 = temp;
        }
        if(x1 < 0){
            x1 += bb;
        }
        return x1;
    }
    
    static long gcd(long a, long b) {
        if(a == 0) {
            return b;
        }
        return gcd(b%a, a);
    }
    
    static int gcd(int a, int b){
        if(a == 0){
            return b;
        }
        return gcd(b%a, a);
    }
    
    static BufferedReader br;
    static StringTokenizer st;
    
    static class FastScanner{
        public FastScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }
        String next() {
            while(st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int[] readint(int n) {
            int[] res = new int[n];
            for(int i = 0; i < n; i++) {
                res[i] = nextint();
            }
            return res;
        }
        long[] readlong(int n) {
            long[] res = new long[n];
            for(int i = 0; i < n; i++) {
                res[i] = nextlong();
            }
            return res;
        }
        int nextint(){
            return Integer.parseInt(next());
        }
        long nextlong() {
            return Long.parseLong(next());
        }
        double nextdouble() {
            return Double.parseDouble(next());
        }
        
        String nextline() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
}

