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>
import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log, ceil
from collections import defaultdict as dd
from collections import Counter as cc
from bisect import bisect_left as bl
from bisect import bisect_right as br

'''
testcase = sys.argv[1]
f = open(testcase, "r")
input = f.readline
'''

sys.setrecursionlimit(100000000)

intinp = lambda: int(input().strip())
stripinp = lambda: input().strip()
fltarr = lambda: list(map(float,input().strip().split()))
intarr = lambda: list(map(int,input().strip().split()))

ceildiv = lambda x,d: x//d if(x%d==0) else x//d+1

MOD=1_000_000_007

num_cases = intinp()
#num_cases = 1
#cases = []
for _ in range(num_cases):
    d, k = intarr()
    mi = int(d/((2**.5)*k))
    q = [mi*k, mi*k]
    ans = ['Ashish', 'Utkarsh']
    op = [[0,k], [k,0]]
    curr = 0

    while q[0]**2 + q[1]**2 <= d**2:
        curr ^= 1
        q[0] += op[curr][0]
        q[1] += op[curr][1]
    #print(q[0], q[1],d/(1.414) / k,q[0]**2 + q[1]**2 , d**2,d,k, q[0]//k, q[1]//k)
    print(ans[curr])
