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 \leq 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 \leq t \leq 100$) — the number of test cases.

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


-----Output-----

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


-----Examples-----

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{\text{Ashish }} (0, 1) \xrightarrow{\text{Utkarsh }} (0, 2)$.

Ashish has no moves left, so Utkarsh wins.

Difficulty: MEDIUM_HARD

Solutions:
from math import floor, sqrt

def readints():
	return list(map(int, input().split(' ')))
t = readints()[0]
for _ in range(t):
	(d, k) = readints()
	z = floor(sqrt(d ** 2 / 2 / k ** 2))
	if (k * z) ** 2 + k ** 2 * (z + 1) ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


from math import sqrt

def read_int():
	return int(input())

def read_ints():
	return map(int, input().split(' '))
t = read_int()
for case_num in range(t):
	(d, k) = read_ints()
	h = int(d / sqrt(2) / k)
	if (h * h + (h + 1) * (h + 1)) * k * k > d * d:
		print('Utkarsh')
	else:
		print('Ashish')


for nt in range(int(input())):
	(d, k) = map(int, input().split())
	x = (d ** 2 / 2) ** 0.5 / k
	if (k * int(x)) ** 2 + (k * int(x + 1)) ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


from math import sqrt
for _ in range(int(input())):
	(d, k) = [int(i) for i in input().split()]
	sq = d ** 2
	a = int(d / (sqrt(2) * k))
	z = a * k
	if (z + k) ** 2 + z ** 2 <= sq:
		print('Ashish')
	else:
		print('Utkarsh')


from math import floor
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	c2 = d ** 2 / (2 * k ** 2)
	c = int(pow(c2, 0.5))
	t2 = (c ** 2 + (c + 1) ** 2) * k ** 2
	if t2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


t = int(input(''))
while t > 0:
	(d, k) = [int(x) for x in input().split()]
	val = int(d // 2 ** 0.5)
	val -= val % k
	maxi = int((d ** 2 - val ** 2) ** 0.5)
	diff = maxi // k - val // k
	if diff % 2 == 0:
		print('Utkarsh')
	else:
		print('Ashish')
	t -= 1


import math
q = int(input())
for i in range(q):
	x = input()
	d = int(x.split(' ')[0])
	k = int(x.split(' ')[1])
	a = 2 * k * k
	b = -1 * a
	c = k * k - d * d
	l = b * b - 4 * a * c
	x1 = (-b + math.sqrt(l)) / (2 * a)
	x = float(math.sqrt(2) * int(x1) * k * 1.0)
	if x < float(d):
		print('Utkarsh')
	else:
		print('Ashish')


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	r2 = 2 ** (1 / 2)
	diag = int(d / (k * r2)) * k
	maxi = (diag + k) ** 2 + diag ** 2
	print(('Utkarsh', 'Ashish')[maxi <= d ** 2])


import os
import sys
from io import BytesIO, IOBase
import math

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def primeFactors(n):
	l = []
	while n % 2 == 0:
		l.append(2)
		n = n / 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			l.append(i)
			n = n / i
	if n > 2:
		l.append(int(n))
	return l

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def maxPrimeFactors(n):
	maxPrime = -1
	while n % 2 == 0:
		maxPrime = 2
		n >>= 1
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			maxPrime = i
			n = n / i
	if n > 2:
		maxPrime = n
	return int(maxPrime)

def countcon(s, i):
	c = 0
	ch = s[i]
	for i in range(i, len(s)):
		if s[i] == ch:
			c += 1
		else:
			break
	return c

def lis(arr):
	n = len(arr)
	lis = [1] * n
	for i in range(1, n):
		for j in range(0, i):
			if arr[i] > arr[j] and lis[i] < lis[j] + 1:
				lis[i] = lis[j] + 1
	maximum = 0
	for i in range(n):
		maximum = max(maximum, lis[i])
	return maximum

def isSubSequence(str1, str2):
	m = len(str1)
	n = len(str2)
	j = 0
	i = 0
	while j < m and i < n:
		if str1[j] == str2[i]:
			j = j + 1
		i = i + 1
	return j == m

def maxfac(n):
	root = int(n ** 0.5)
	for i in range(2, root + 1):
		if n % i == 0:
			return n // i
	return n
for xyz in range(0, int(input())):
	(d, k) = map(int, input().split())
	m = int((d * d / (2 * k * k)) ** 0.5)
	tt = 2 * m
	tx = ty = m * k
	tx += k
	if tx * tx + ty * ty <= d * d:
		tt += 1
	if tt % 2 == 0:
		print('Utkarsh')
	else:
		print('Ashish')


test = int(input())
for testcase in range(test):
	arr = [int(x) for x in input().split()]
	(d, k) = (arr[0], arr[1])
	(x, y) = (k, k)
	x = d // 2 ** 0.5
	x = x - x % k
	y = x
	if x == 0 and y == 0:
		print('Ashish')
	elif (x + k) * (x + k) + y * y <= d * d:
		print('Ashish')
	else:
		print('Utkarsh')


from __future__ import print_function
from collections import Counter, OrderedDict
from itertools import permutations as perm
from collections import deque
from sys import stdin
from bisect import *
from heapq import *
import math
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
inf = float('inf')
mod = int(1000000000.0) + 7
(t,) = gil()

def isInside(x, y, r):
	return True if x ** 2 + y ** 2 <= r ** 2 else False
root = math.sqrt(2)
for _ in range(t):
	(r, k) = gil()
	x = r // root
	x //= k
	x *= k
	if isInside(x + k, x, r):
		print('Ashish')
	else:
		print('Utkarsh')


import math
import sys
from sys import stdin
t = int(input())
for i in range(t):
	(d, k) = [int(x) for x in input().split()]
	x = 2 ** 0.5
	n = d // (k * x)
	n2 = n ** 2
	x = (2 * n2 + 2 * n + 1) ** 0.5
	x *= k
	if x <= d:
		print('Ashish')
	else:
		print('Utkarsh')


t = int(input())
import math
for _ in range(t):
	(d, k) = map(int, input().split())
	c = ['Ashish', 'Utkarsh']
	i = int(d / (k * math.sqrt(2)))
	if (i * k) ** 2 + (i * k + k) ** 2 <= d ** 2:
		print(c[0])
	else:
		print(c[1])


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	(p, q) = (0, 0)
	f = 0
	while p * p + q * q <= d * d:
		if f % 2 == 0:
			if (p + k) * (p + k) + q * q <= d * d:
				p += k
			else:
				break
		elif p * p + (q + k) * (q + k) <= d * d:
			q += k
		else:
			break
		f += 1
	if f % 2 == 0:
		print('Utkarsh')
	else:
		print('Ashish')


for x in range(int(input())):
	(d, k) = map(int, input().split())
	a = (d * d // 2) ** 0.5
	a = a - a % k
	b = a + k
	if a * a + b * b <= d * d:
		print('Ashish')
	else:
		print('Utkarsh')


import math
import bisect
MAX_D = int(math.sqrt(2) * (100000 + 7))
seq = [float(math.ceil(n * n / 2.0)) for n in range(MAX_D)]
t = int(input())
for g in range(1, t + 1):
	dk = input().split(' ')
	d = float(dk[0])
	k = float(dk[1])
	ratio = d * d / (k * k)
	left = 1
	right = len(seq) - 1
	marker = None
	while left <= right:
		middle = math.floor((left + right) / 2)
		if seq[middle] == ratio:
			marker = middle
			break
		elif seq[middle] < ratio:
			marker = middle
			left = middle + 1
		elif seq[middle] > ratio:
			right = middle - 1
	if marker % 2 == 0:
		print('Utkarsh')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, k) = map(int, input().split())
	x = int(n / k / 2 ** 0.5)
	a = (x + 1) ** 2 + x ** 2
	b = (n / k) ** 2
	if a > b:
		print('Utkarsh')
	else:
		print('Ashish')


for t in range(int(input())):
	(d, k) = map(int, input().rstrip().split())
	d = d ** 2
	k = k ** 2
	a = 0
	u = 0
	while 1:
		a += 1
		if d < a * a * k + u * u * k:
			print('Utkarsh')
			break
		u += 1
		if d < a * a * k + u * u * k:
			print('Ashish')
			break


from math import *
from sys import *
input = stdin.readline
for u in range(int(input())):
	(d, k) = map(int, input().split())
	n = d // (sqrt(2) * k)
	x = n * k
	if x ** 2 + (x + k) ** 2 > d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
import time
from types import GeneratorType
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict as dd, deque as dq, Counter as dc
import math, string
start_time = time.time()

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def getMat(n):
	return [getInts() for _ in range(n)]
MOD = 998244353
u = 'Utkarsh'
a = 'Ashish'

def solve():
	(D, K) = getInts()
	(x, y) = (0, 0)
	D_sq = D ** 2

	def dist(x, y):
		return x ** 2 + y ** 2
	left = 0
	right = 10 ** 7
	while right - left > 1:
		mid = (right + left) // 2
		if dist(mid * K, mid * K) > D_sq:
			right = mid
		else:
			left = mid
	x = left * K
	y = left * K
	if dist(x, y + K) > D_sq:
		return u
	if K <= D and 2 * K > D:
		return a
	(left, right) = (0, 10 ** 7)
	while right - left > 1:
		mid = (left + right) // 2
		if dist(mid * K, mid * K + 2 * K) > D_sq:
			right = mid
		else:
			left = mid
	x = left * K
	y = left * K + 2 * K
	if dist(x, y + K) > D_sq and dist(x + K, y) > D_sq:
		return u
	return a
for _ in range(getInt()):
	print(solve())


t = int(input())
for i in range(t):
	l = list(map(int, input().split()))
	j = int(l[0] / (2 ** 0.5 * l[1]))
	if 2 * j ** 2 + 2 * j + 1 <= l[0] ** 2 // l[1] ** 2 < 2 * (j + 1) ** 2:
		print('Ashish')
	elif l[0] ** 2 // l[1] ** 2 < 2 * j ** 2 + 2 * j + 1:
		print('Utkarsh')


import math
n = int(input())
res = []
for t in range(n):
	(d, k) = map(int, input().split())
	d /= k
	x = d // math.sqrt(2)
	y = x
	x += 1
	if x * x + y * y <= d * d:
		res.append('Ashish')
	else:
		res.append('Utkarsh')
for i in res:
	print(i)


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	x = 0
	while True:
		if 2 * (x + 1000 * k) ** 2 <= d ** 2:
			x += 1000 * k
		elif 2 * (x + 100 * k) ** 2 <= d ** 2:
			x += 100 * k
		elif 2 * (x + 10 * k) ** 2 <= d ** 2:
			x += 10 * k
		elif 2 * (x + k) ** 2 <= d ** 2:
			x += k
		else:
			break
	if x ** 2 + (x + k) ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	p = q = k = k
	farthest = 0
	while p * p + q * q <= d * d:
		farthest += 2
		p += k
		q += k
	q -= k
	sign = 0
	while p * p + q * q <= d * d:
		farthest += 1
		sign += 1
		p += k
	print('Ashish' if sign else 'Utkarsh')


import math
cases = int(input())
for t in range(cases):
	(r, moveSize) = list(map(int, input().split()))
	maxDist = r ** 2
	xPos = 0
	yPos = 0
	while xPos ** 2 + yPos ** 2 <= maxDist:
		xPos += moveSize
		if xPos ** 2 + yPos ** 2 <= maxDist:
			yPos += moveSize
		else:
			winner = 'Utkarsh'
			break
		if maxDist > (xPos + moveSize * 20) ** 2 + (yPos + moveSize * 20) ** 2:
			xPos += moveSize * 20
			yPos += moveSize * 20
	else:
		winner = 'Ashish'
	print(winner)


from math import sqrt
q = int(input())
for i in range(q):
	(d, k) = map(float, input().split())
	k = int(k)
	p = int(d / sqrt(2))
	if (p + 1) * (p + 1) * 2 <= d:
		p += 1
	d = int(d)
	p = p // k * k
	val1 = p * p + (p + k) * (p + k)
	val2 = d * d
	if val1 <= val2:
		print('Ashish')
	else:
		print('Utkarsh')


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	ans = 'Ashish'
	(x, y) = (0, 0)
	while True:
		if x <= y and (x + k) * (x + k) + y * y <= d * d:
			x += k
		elif x > y and x * x + (y + k) * (y + k) <= d * d:
			y += k
		else:
			break
	if x == y:
		ans = 'Utkarsh'
	print('%s' % ans)


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	s = d * d
	p = k * k
	for i in range(1, d + 1):
		if 2 * p * i * i > s:
			r = i
			break
	if r * r * p + (r - 1) * (r - 1) * p <= s:
		print('Ashish')
	else:
		print('Utkarsh')


from sys import stdin, stdout
(readline, writeline) = (stdin.readline, stdout.write)

def lint():
	return list(mint())

def mint():
	return map(int, readline().strip().split())

def iint():
	return int(readline().strip())
for _ in range(iint()):
	(d, k) = mint()
	n = d // (k * 2 ** 0.5)
	l = k * n
	if (d ** 2 - l ** 2) ** 0.5 - l >= k:
		ans = 'Ashish'
	else:
		ans = 'Utkarsh'
	writeline('{}\n'.format(ans))


import io
import os
from collections import Counter, defaultdict, deque

def solveBrute(D, K):

	def inCircle(x, y):
		return x * x + y * y <= D * D
	if D > 30:
		return
	from functools import lru_cache

	@lru_cache(maxsize=None)
	def dp(r, c):
		if not inCircle(r + K, c) and (not inCircle(r, c + K)):
			return 1
		if not inCircle(r + K, c):
			return dp(r, c + K) ^ 1
		if not inCircle(r, c + K):
			return dp(r + K, c) ^ 1
		if dp(r + K, c) == 1 or dp(r, c + K) == 1:
			return 0
		return 1
	if True:
		print(D, K)
		for r in range(0, D + 1, K):
			print(''.join(('01'[dp(r, c)] if abs(r - c) <= 2 else ' ' for c in range(0, D + 1, K))))
	return ['Ashish', 'Utkarsh'][dp(0, 0)]

def solve(D, K):
	root = 0
	for s in range(K, D, K):
		if s * s + s * s <= D * D:
			root = s
		else:
			break
	assert 2 * root ** 2 <= D * D < 2 * (root + K) ** 2
	player = 1
	if (root + K) * (root + K) + root * root <= D * D:
		player = 0
	return ['Ashish', 'Utkarsh'][player]
DEBUG = False
if DEBUG:
	import random
	random.seed(0)
	for D in range(1, 30):
		for K in range(1, 10):
			ans1 = solveBrute(D, K)
			ans2 = solve(D, K)
			print(ans1, ans2)
			assert ans1 == ans2
	exit()
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
	(D, K) = [int(x) for x in input().split()]
	ans = solve(D, K)
	print(ans)


from sys import stdout, stdin, maxsize
from collections import defaultdict, deque
arr = [0] * 100001
for i in range(1, 100001):
	arr[i] = i ** 2
t = int(stdin.readline())
for _ in range(t):
	(d, k) = map(int, stdin.readline().split())
	zz = d ** 2
	ks = int((zz / 2) ** 0.5)
	z = ks // k
	ks = z * k
	te = ks ** 2
	ans = 0
	for i in range(1, d + 1):
		if te + arr[i] <= zz:
			ans = i
		else:
			break
	kk = ans // k
	if (z + kk) % 2 == 0:
		stdout.write('Utkarsh' + '\n')
	else:
		stdout.write('Ashish' + '\n')


t = int(input())
for _ in range(t):
	(d, k) = map(int, input().split())
	val = int(d // (2 ** 0.5 * k))
	p = q = val * k
	i = 0
	while p ** 2 + q ** 2 <= d ** 2:
		if p != q:
			q += k
		else:
			p += k
		i += 1
	if i % 2 == 1:
		print('Utkarsh')
	else:
		print('Ashish')


import math
t = int(input())
for _ in range(t):
	(d, k) = map(int, input().split())
	m = d // (k * math.sqrt(2))
	if m < 1:
		print('Ashish')
	elif (m * k) ** 2 + ((m + 1) * k) ** 2 > d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


import math
t = int(input())
while t != 0:
	(d, k) = map(int, input().split())
	p = d // (math.sqrt(2) * k)
	xcor = p * k
	ycor = p * k
	if (xcor + k) * (xcor + k) + ycor * ycor <= d * d:
		xcor += k
	if xcor == ycor:
		print('Utkarsh')
	else:
		print('Ashish')
	t -= 1


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
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 = 1000000007
num_cases = intinp()
for _ in range(num_cases):
	(d, k) = intarr()
	mi = int(d / (2 ** 0.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(ans[curr])


t = int(input())
for i in range(t):
	(d, k) = map(int, input().split())
	C = d * d
	C /= 2
	C = C ** (1 / 2)
	C = int(C // 1)
	Z = C / k
	Z = int(Z // 1)
	if (k * Z + k) ** 2 + (k * Z) ** 2 <= d * d:
		print('Ashish')
	else:
		print('Utkarsh')


import math
from collections import deque
from sys import stdin, stdout, setrecursionlimit
from string import ascii_letters
letters = ascii_letters[:26]
from collections import defaultdict
input = stdin.readline
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	n = math.sqrt(d ** 2 // 2) // k
	if (n * k) ** 2 + ((n + 1) * k) ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


from math import sqrt
r2 = sqrt(2)
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	rk = int(d / r2 // k)
	if (rk * k) ** 2 + (k * (rk + 1)) ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(d, k) = list(map(int, input().split()))
	limit = d ** 2
	current = 0
	ans = True
	while 2 * (current + k) ** 2 <= limit:
		current += k
	if (current + k) ** 2 + current ** 2 > limit:
		ans = False
	if ans:
		print('Ashish')
	else:
		print('Utkarsh')


from sys import stdin
from collections import deque
input = stdin.readline
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	(nowx, nowy) = (0, 0)
	while True:
		nowx += k
		if nowx * nowx + nowy * nowy > d * d:
			print('Utkarsh')
			break
		nowy += k
		if nowx * nowx + nowy * nowy > d * d:
			print('Ashish')
			break


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
ALPHA = 'abcdefghijklmnopqrstuvwxyz/'
M = 998244353
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

def value():
	return tuple(map(int, input().split()))

def array():
	return [int(i) for i in input().split()]

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
for _ in range(Int()):
	(d, k) = value()
	x = int(sqrt(d ** 2 / 2))
	x -= x % k
	if not (x + k) ** 2 + x ** 2 <= d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


import math
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	(outer_x, outer_y) = (math.floor(math.sqrt(d ** 2 / 2)) // k * k, math.floor(math.sqrt(d ** 2 / 2)) // k * k)
	if math.sqrt((outer_x + k) ** 2 + outer_y ** 2) <= d:
		print('Ashish')
	else:
		print('Utkarsh')


import math
import sys
input = sys.stdin.readline
t = int(input())
while t:
	t -= 1
	(d, k) = [int(x) for x in input().split()]
	max_point = int(math.sqrt(d ** 2 / (2 * k ** 2)))
	point1 = k * max_point
	point2 = k * (max_point + 1)
	if point1 ** 2 + point2 ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


from sys import stdin, stdout
input = stdin.readline
mp = lambda : map(int, input().split())
it = lambda : int(input())
test = it()
for i in range(test):
	(a, b) = mp()
	k = int((a ** 2 / 2) ** 0.5 // b * b)
	print(['Utkarsh', 'Ashish'][a ** 2 >= 2 * k ** 2 + b ** 2 + 2 * k * b])


import sys
import time
import os
from math import sqrt, log, log2, ceil, log10, gcd, floor, pow, sin, cos, tan, pi, inf, factorial
from copy import copy, deepcopy
from sys import exit, stdin, stdout
from collections import Counter, defaultdict, deque
from itertools import permutations
import heapq
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
mod = 1000000007
iinp = lambda : int(sys.stdin.readline())
inp = lambda : sys.stdin.readline().strip()
strl = lambda : list(inp().strip().split(' '))
intl = lambda : list(map(int, inp().split(' ')))
mint = lambda : map(int, inp().split())
flol = lambda : list(map(float, inp().split(' ')))
flush = lambda : stdout.flush()

def permute(nums):

	def fun(arr, nums, cur, v):
		if len(cur) == len(nums):
			arr.append(cur.copy())
		i = 0
		while i < len(nums):
			if v[i]:
				i += 1
				continue
			else:
				cur.append(nums[i])
				v[i] = 1
				fun(arr, nums, cur, v)
				cur.pop()
				v[i] = 0
				i += 1
		return arr
	res = []
	nums.sort()
	v = [0] * len(nums)
	return fun(res, nums, [], v)

def subsets(res, index, arr, cur):
	res.append(cur.copy())
	for i in range(index, len(arr)):
		cur.append(arr[i])
		subsets(res, i + 1, arr, cur)
		cur.pop()
	return res

def sieve(N):
	root = int(sqrt(N))
	primes = [1] * (N + 1)
	(primes[0], primes[1]) = (0, 0)
	for i in range(2, root + 1):
		if primes[i]:
			for j in range(i * i, N + 1, i):
				primes[j] = 0
	return primes

def bs(arr, l, r, x):
	if x < arr[0] or x > arr[len(arr) - 1]:
		return -1
	while l <= r:
		mid = l + (r - l) // 2
		if arr[mid] == x:
			return mid
		elif arr[mid] < x:
			l = mid + 1
		else:
			r = mid - 1
	return -1

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	p = int(sqrt(n))
	for i in range(5, p + 1, 6):
		if n % i == 0 or n % (i + 2) == 0:
			return False
	return True

def solve():
	(d, k) = mint()
	p = 0
	q = 0
	chance = 1
	while 1:
		if (p + k) * (p + k) + q * q <= d * d and (q + k) * (q + k) + p * p <= d * d:
			if p <= q:
				p += k
			else:
				q += k
			chance ^= 1
		elif (p + k) * (p + k) + q * q <= d * d:
			p += k
			chance ^= 1
		elif (q + k) * (q + k) + p * p <= d * d:
			q += k
			chance ^= 1
		elif chance == 1:
			print('Utkarsh')
			return
		else:
			print('Ashish')
			return
start_time = time.time()
for _ in range(iinp()):
	solve()


import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
	(d, k) = map(int, input().split())
	OK = 0
	NG = 10 ** 5 + 1
	while NG - OK > 1:
		mid = (OK + NG) // 2
		if (k * mid) ** 2 * 2 > d ** 2:
			NG = mid
		else:
			OK = mid
	MAX = OK * k
	if MAX ** 2 + (MAX + k) ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


t = int(input())
import math
for _ in range(t):
	(n, k) = map(int, input().split())
	x = n / math.sqrt(2) / k
	print('Ashish' if int(x) ** 2 + int(x + 1) ** 2 <= (n / k) ** 2 else 'Utkarsh')


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	x = d ** 2 // k ** 2
	aa = x
	x = int((x // 2) ** 0.5)
	q = x
	while 1:
		if x ** 2 + q ** 2 > aa:
			break
		x += 1
	if (q + (x - 1)) % 2 != 0:
		print('Ashish')
	else:
		print('Utkarsh')


import io, os
JJJ = input
input = lambda : JJJ().encode()
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	j = 0
	while 2 * j * j <= d * d:
		j += k
	if j * j + (j - k) * (j - k) > d * d:
		print('Utkarsh')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(d, k) = [int(v) for v in input().split()]
	c = int(2 * d / 3) // k * k
	while (c + k) ** 2 + (c + k) ** 2 <= d ** 2:
		c += k
	if (c + k) ** 2 + c ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


t = int(input())
for a0 in range(t):
	(d, k) = list(map(int, input().split(' ')))
	x = d * d / (k * k)
	a = int(x) / 2
	a = int(pow(a, 0.5))
	b = a
	if (a + 1) * (a + 1) + b * b <= x:
		a += 1
	if (b + 1) * (b + 1) + a * a <= x:
		b += 1
	ans = a + b
	if ans % 2 == 0:
		print('Utkarsh')
	else:
		print('Ashish')


import sys
input = lambda : sys.stdin.readline().strip()
inp = lambda : list(map(int, sys.stdin.readline().strip().split()))
(t,) = inp()
while t > 0:
	(d, k) = inp()
	x = 0
	y = 0
	while True:
		if x <= y and (x + k) * (x + k) + y * y <= d * d:
			x += k
		elif x > y and (y + k) * (y + k) + x * x <= d * d:
			y += k
		else:
			break
	if x == y:
		print('Utkarsh')
	else:
		print('Ashish')
	t -= 1


t = int(input())
for _ in range(t):
	(d, k) = map(int, input().split())
	x = 0
	y = 0
	cur = 0
	d *= d
	while x * x + y * y <= d:
		if x > y:
			y += k
		else:
			x += k
		cur ^= 1
	if not cur:
		print('Ashish')
	else:
		print('Utkarsh')


a = int(input())
import math

def flip(n):
	if n == 0:
		return 1
	else:
		return 0
d = 0
k = 0

def mind(x, y):
	a = math.sqrt(d * d - y * y) - x
	b = math.sqrt(d * d - x * x) - y
	print(a, b, k)
	if a < k and b < k:
		return -1
	if a >= k and b >= k:
		if a < b:
			return 1
		else:
			return 0
	if a >= k:
		return 1
	else:
		return 0
for i in range(a):
	(d, k) = map(int, input().split())
	rem = d / math.sqrt(2) // k
	x = rem * k
	y = rem * k
	if x * x + (y + k) ** 2 <= d * d:
		print('Ashish')
	else:
		print('Utkarsh')


from math import *
from itertools import *
from decimal import *
from fractions import *
from sys import *
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	z = int(sqrt(d * d // (k * k * 2)))
	print(['Ashish', 'Utkarsh'][k * k * (z * z + z * z + 2 * z + 1) > d * d])


import sys
import math
from collections import Counter
from collections import OrderedDict
from collections import defaultdict
from functools import reduce
sys.setrecursionlimit(10 ** 6)

def inputt():
	return sys.stdin.readline().strip()

def printt(n):
	sys.stdout.write(str(n) + '\n')

def listt():
	return [int(i) for i in inputt().split()]

def gcd(a, b):
	return math.gcd(a, b)

def lcm(a, b):
	return a * b // gcd(a, b)

def factors(n):
	step = 2 if n % 2 else 1
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(math.sqrt(n)) + 1, step) if n % i == 0)))

def comb(n, k):
	factn = math.factorial(n)
	factk = math.factorial(k)
	fact = math.factorial(n - k)
	ans = factn // (factk * fact)
	return ans

def is_prime(n):
	if n <= 1:
		return False
	if n == 2:
		return True
	if n > 2 and n % 2 == 0:
		return False
	max_div = math.floor(math.sqrt(n))
	for i in range(3, 1 + max_div, 2):
		if n % i == 0:
			return False
	return True

def maxpower(n, x):
	B_max = int(math.log(n, x)) + 1
	return B_max
t = int(inputt())
for _ in range(t):
	(d, k) = map(int, inputt().split())
	a = d / k
	z = int(a / math.sqrt(2))
	ans = ((z + 1) * k) ** 2 + (z * k) ** 2
	if ans <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


for _ in range(int(input())):
	(r, n) = map(int, input().split())
	x = 0
	y = 0
	ans = 0
	while x * x + y * y <= r * r:
		if (x + n) * (x + n) + y * y <= r * r:
			x += n
			ans = 'Ashish'
		else:
			break
		if x * x + (y + n) * (y + n) <= r * r:
			y += n
			ans = 'Utkarsh'
		else:
			break
	print(ans)


import math
for v in range(int(input())):
	(d, k) = map(int, input().split())
	z = int((d ** 2 / (2 * k ** 2)) ** 0.5)
	z = z * k
	if z ** 2 + (z + k) ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


import math
for i in range(int(input())):
	(d, k) = map(int, input().split())
	a = int(d / math.sqrt(2))
	a = a // k * k
	b = int(math.sqrt(d * d - a * a)) // k * k
	if (a // k + b // k) % 2 == 0:
		print('Utkarsh')
	else:
		print('Ashish')


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import math
for j in range(int(input())):
	(d, k) = map(int, input().split())
	a1 = math.floor(math.sqrt(d ** 2 / 2))
	a2 = a1 // k
	maxy = 0
	if (k * a2) ** 2 + (k * (a2 + 1)) ** 2 <= d ** 2:
		maxy += 1
	if maxy % 2 == 0:
		print('Utkarsh')
	else:
		print('Ashish')


import math
tc = int(input())
z = []
for i in range(tc):
	(d, k) = map(int, input().split())
	n = d // (math.sqrt(2) * k)
	if math.sqrt(n * k * n * k + (n + 1) * k * (n + 1) * k) <= d:
		z.append('Ashish')
	else:
		z.append('Utkarsh')
for i in range(tc):
	print(z[i])


import sys
input = sys.stdin.readline
import math

def ceil(U, V):
	return (U + V - 1) // V
t = int(input())
for _ in range(t):
	(d, k) = map(int, input().split())
	ok = 0
	ng = d
	while ng - ok > 1:
		m = (ok + ng) // 2
		if m ** 2 * 2 <= d ** 2:
			ok = m
		else:
			ng = m
	u = ok - ok % k
	if u ** 2 + (u + k) ** 2 > d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


import sys, os
import heapq, functools, collections
import math, random
from collections import Counter, defaultdict

def solve_(a, b):
	steps = a / b / math.sqrt(2)
	steps2 = a ** 2 / b ** 2
	equal = math.floor(steps)
	upper = equal + 1
	console(steps, equal, upper ** 2 + equal ** 2, steps2)
	if upper ** 2 + equal ** 2 > steps2:
		return 'Utkarsh'
	return 'Ashish'

def console(*args):
	print('\x1b[36m', *args, '\x1b[0m', file=sys.stderr)
	pass
ONLINE_JUDGE = False
if os.path.exists('input.txt'):
	ONLINE_JUDGE = True
if ONLINE_JUDGE:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def console(*args):
		pass

def solve(*args):
	if not ONLINE_JUDGE:
		console('----- solving ------')
		console(*args)
		console('----- ------- ------')
	return solve_(*args)
if True:
	inp = iter(sys.stdin.buffer.readlines())
	input = lambda : next(inp)
else:
	input = sys.stdin.buffer.readline
for case_num in range(int(input())):
	(a, b) = list(map(int, input().split()))
	res = solve(a, b)
	print(res)


l = lambda : map(int, input().split())
p = lambda : int(input())
ss = lambda : input()
from math import log10 as c
for _ in range(p()):
	(d, k) = l()
	if k >= 1:
		ans = d // k
		y = d // k * k
		i = y
		j = k
		while i >= 0 and j <= y:
			if i * i + j * j > d * d:
				i -= k
			else:
				ans = max(ans, i // k + j // k)
				j += k
	if ans % 2:
		print('Ashish')
	else:
		print('Utkarsh')


t = int(input())
while t > 0:
	t = t - 1
	(d, k) = [int(x) for x in input().split()]
	Ashish = 'Ashish'
	Utkarsh = 'Utkarsh'
	(x, y, c) = (0, 0, 0)
	p = 0
	while p <= d * d:
		if c % 2 == 0:
			c += 1
			x = x + k
		else:
			c += 1
			y = y + k
		p = x * x + y * y
	if c % 2 == 1:
		print(Utkarsh)
	else:
		print(Ashish)


from math import sqrt
for __ in range(int(input())):
	[d, k] = [int(x) for x in input().split()]
	z = int(sqrt(d ** 2 / (2 * k ** 2)))
	if (k * z + k) ** 2 + (k * z) ** 2 > d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


from math import sqrt
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	n = d // (sqrt(2) * k)
	x = n * k
	if x ** 2 + (x + k) ** 2 > d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


def solve(k, d):
	n = int((d ** 2 / (2 * k * k)) ** (1 / 2))
	if n * n * k * k + (n + 1) * (n + 1) * k * k <= d ** 2:
		return 'Ashish'
	else:
		return 'Utkarsh'
n = int(input())
for _ in range(n):
	(d, k) = map(int, input().split())
	print(solve(k, d))


t = int(input())
for _ in range(t):
	(d, k) = map(int, input().split())
	ans = d // k
	ans1 = ans
	while k * ans * (k * ans) + k * ans1 * (ans1 * k) > d * d:
		if ans == ans1:
			ans1 -= 1
		else:
			ans -= 1
	if ans != ans1:
		print('Ashish')
	else:
		print('Utkarsh')


for t in range(int(input())):
	(d, k) = map(int, input().split())
	x = int(int(d / 2 ** (1 / 2)) / k) * k
	if x ** 2 + (x + k) ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def discrete_binary_search(func, lo, hi):
	while lo < hi:
		mi = lo + (hi - lo) // 2
		if func(mi):
			hi = mi
		else:
			lo = mi + 1
	return lo

def main():
	t = int(input())
	for _ in range(t):
		(d, k) = map(int, input().split())
		d2 = d ** 2
		out = discrete_binary_search(lambda x: 2 * (x * k) ** 2 > d2, 0, d) * k
		print('Utkarsh' if out ** 2 + (out - k) ** 2 > d2 else 'Ashish')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from math import sqrt
t = int(input())
while t:
	t -= 1
	(d, k) = map(int, input().split(' '))
	s = int(sqrt(d * d / (k * k * 2)))
	if s * s * k * k + (s + 1) ** 2 * k * k > d * d:
		print('Utkarsh')
	else:
		print('Ashish')


from math import sqrt

def cal(x, y, k):
	a = sqrt(d ** 2 - y ** 2) - abs(x)
	b = sqrt(d ** 2 - x ** 2) - abs(y)
	return (a, b)
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	n = d ** 2 // (2 * k ** 2)
	n = int(sqrt(n))
	x = n * k
	if x ** 2 + (x + k) ** 2 > d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


import math
for _ in range(int(input())):
	(d, k) = [int(x) for x in input().split()]
	p = 2 * d ** 2 / k ** 2
	ash = math.floor(math.sqrt(p) / 2) * 2 - 1
	bash = math.floor((math.sqrt(p - 1) - 1) / 2) * 2
	if ash < bash:
		print('Ashish')
	else:
		print('Utkarsh')


for t in range(int(input())):
	(d, k) = map(int, input().split(' '))
	s = int((d * d / (k * k * 2)) ** 0.5)
	if (s * k) ** 2 + (s + 1) ** 2 * k * k > d * d:
		print('Utkarsh')
	else:
		print('Ashish')


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	(x, y) = (0, 0)
	ans = ['Ashish', 'Utkarsh']
	flag = 0
	d *= d
	while d >= x * x + y * y:
		if flag == 0:
			y += k
			flag = 1
		else:
			x += k
			flag = 0
	print(ans[flag])


t = int(input())
for _ in range(t):
	(d, k) = [int(x) for x in input().split()]
	n = int(pow(d * d / (2 * k * k), 0.5))
	if ((n + 1) * k) ** 2 + (n * k) ** 2 <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


import sys
input = sys.stdin.readline
s = [0]
for i in range(100001):
	s.append(s[-1] + (-1 + (i + 1) * 2))
t = int(input())
for i in range(t):
	(n, k) = map(int, input().split())
	(i, j) = (0, n)
	ans = []
	while True:
		while s[i] + s[j] <= n * n:
			ans.append([i, j])
			i += 1
		j -= 1
		if i > j:
			break
	kz = ans[-1][0] // k * k
	kz1 = k * (ans[-1][0] // k + 1)
	if kz ** 2 + kz1 ** 2 <= n * n:
		print('Ashish')
	else:
		print('Utkarsh')


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key
from heapq import *
from math import gcd, factorial, floor, ceil, sqrt
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
from types import GeneratorType

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def testcase(t):
	for pp in range(t):
		solve(pp)

def google(p):
	print('Case #' + str(p) + ': ', end='')

def lcm(a, b):
	return a * b // gcd(a, b)

def power(x, y, p):
	y %= p - 1
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True
inf = pow(10, 20)
mod = 10 ** 9 + 7

def solve(case):
	(d, k) = sep()
	x = 0
	y = 0
	cnt = 0
	while x * x + y * y <= d * d:
		if cnt % 2 == 0:
			x += k
		else:
			y += k
		cnt += 1
	print('Utkarsh' if cnt % 2 else 'Ashish')
testcase(int(inp()))


import math
for w in range(int(input())):
	(d, k) = tuple(map(int, input().split()))
	x = math.floor(d / (math.sqrt(2) * k))
	if 2 * x ** 2 + 2 * x + 1 <= (d / k) ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(d, k) = map(int, input().split())
	x = d / 2 ** 0.5
	moves = int(x // k)
	dis = moves * k
	m = (dis + k) ** 2 + dis ** 2
	if m > d ** 2:
		sys.stdout.write('Utkarsh\n')
	else:
		sys.stdout.write('Ashish\n')


t = int(input())
for _ in range(t):
	(d, k) = (int(number) for number in input().split(' '))
	diagonal_point = int((d ** 2 / 2) ** 0.5 / k + 1)
	if ((diagonal_point - 1) * k) ** 2 + (diagonal_point * k) ** 2 > d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


import sys
import math
input = sys.stdin.readline
t = int(input())
for test in range(t):
	[d, k] = list(map(int, input().split(' ')))
	h = []
	m = math.floor(math.sqrt(d ** 2 / 2)) // k * k
	x = math.floor(math.sqrt(d ** 2 - m ** 2))
	if x >= m + k:
		print('Ashish')
	else:
		print('Utkarsh')


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	val = d / pow(2, 0.5)
	ans = 0
	q = val // k
	r = val % k
	if r == 0:
		if pow(val + k, 2) + pow(val, 2) <= pow(d, 2):
			ans = 1
		else:
			ans = 2
		if ans == 1:
			print('Ashish')
		else:
			print('Utkarsh')
	else:
		val1 = (q + 1) * k
		val2 = k * q
		val3 = pow(val1, 2) + pow(val2, 2)
		if val3 <= pow(d, 2):
			ans = 1
		else:
			ans = 2
		if ans == 1:
			print('Ashish')
		else:
			print('Utkarsh')


from math import sqrt
for _ in range(int(input())):
	(r, n) = map(int, input().split())
	ans = 0
	t = 0
	while (t + n) * (t + n) * 2 < r * r:
		t += n
	if t * t + (t + n) * (t + n) <= r * r:
		print('Ashish')
	else:
		print('Utkarsh')


import math
t = int(input())
for h in range(t):
	(d, k) = [int(x) for x in input().split(' ')]
	thingy = math.floor(math.sin(math.pi / 4) * d / k)
	output = 2 * thingy
	if (thingy + 1) ** 2 + thingy ** 2 <= (d / k) ** 2:
		output += 1
	if output % 2 == 0:
		print('Utkarsh')
	else:
		print('Ashish')


from sys import stdin, stdout

def solve():
	(d, k) = map(int, input().split())
	for x in range(0, d, k):
		y = x + k
		if x * x + x * x > d * d:
			break
		if x * x + y * y > d * d:
			print('Utkarsh')
			return
	print('Ashish')

def main():
	t = int(input())
	for _ in range(t):
		solve()
main()


def whowin(r, k=1):
	r = r / k
	m = r // 2 ** 0.5
	if (m + 1) ** 2 + m ** 2 <= r * r:
		print('Ashish')
	else:
		print('Utkarsh')
n = int(input())
lst = []
for i in range(n):
	lst.append(input().split())
for i in lst:
	whowin(int(i[0]), int(i[1]))


import sys
input = sys.stdin.readline
from math import sqrt, floor
t = int(input())
for _ in range(t):
	(d, k) = map(int, input().split())
	target = floor(sqrt(d ** 2 / (2 * k ** 2)))
	p = k * target
	q = k * (target + 1)
	if p ** 2 + q ** 2 > d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


import sys, math
import io, os
from bisect import bisect_left as bl, bisect_right as br, insort
from heapq import heapify, heappush, heappop
from collections import defaultdict as dd, deque, Counter
from itertools import permutations, combinations

def data():
	return sys.stdin.readline().strip()

def mdata():
	return list(map(int, data().split()))

def outl(var):
	sys.stdout.write('\n'.join(map(str, var)) + '\n')

def out(var):
	sys.stdout.write(str(var) + '\n')
sys.setrecursionlimit(100000)
INF = float('inf')
mod = 998244353
for t in range(int(data())):
	(d, k) = mdata()
	a = 0
	while 2 * (a + k) ** 2 <= d * d:
		a += k
	if a ** 2 + (a + k) ** 2 <= d * d:
		out('Ashish')
	else:
		out('Utkarsh')


import collections as cc
import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
f = cc.defaultdict(int)
for tc in range(int(input())):
	(d, k) = I()
	cnt = 0
	x = y = 0
	while 1:
		if cnt % 2:
			x += k
		else:
			y += k
		if x * x + y * y > d * d:
			break
		cnt += 1
	print('UAtskhairsshh'[cnt % 2::2])


def inside(x, y, d):
	return x * x + y * y <= d * d
tc = int(input())
while tc > 0:
	tc -= 1
	(d, k) = map(int, input().split())
	(x, y) = (0, 0)
	while inside(x + k, y + k, d):
		x += k
		y += k
	if inside(x, y + k, d):
		print('Ashish')
	else:
		print('Utkarsh')


from math import ceil, sqrt
for _ in range(int(input())):
	(d, k) = map(int, input().split(' '))
	d1 = d / sqrt(2)
	x = ceil(d / (k * sqrt(2)))
	(x1, y1) = (x * k, (x - 1) * k)
	if x1 ** 2 + y1 ** 2 - d ** 2 <= 0:
		ans = 'Ashish'
	else:
		ans = 'Utkarsh'
	print(ans)


import sys, functools, collections, bisect, math, heapq
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(d, k) = map(int, input().strip().split())
	z = d // (2 ** 0.5 * k)
	dis = (k * z) ** 2 + (k * (z + 1)) ** 2
	if dis <= d * d:
		print('Ashish')
	else:
		print('Utkarsh')


t = int(input())
for _ in range(t):
	(d, k) = map(int, input().split())
	d2 = d * d
	z = 0
	while 2 * z * z < d2:
		z += k
	z -= k
	nl = (z + k) ** 2 + z ** 2
	print('Ashish') if nl <= d2 else print('Utkarsh')


import sys
input = sys.stdin.readline

def main():
	(d, k) = map(int, input().split())
	n = d // k + 1
	i = d / 2 ** 0.5 // k
	dd = d ** 2
	kk = (i * k) ** 2
	cnt = int((dd - kk) ** 0.5) // k
	if (cnt - i) % 2 != 0:
		print('Ashish')
	else:
		print('Utkarsh')
	return
for _ in range(int(input())):
	main()


t = int(input())
for _t in range(t):
	(d, k) = map(int, input().split())
	q = int(d / 2 ** 0.5)
	q -= q % k
	if (q + k) * (q + k) + q * q <= d * d:
		print('Ashish')
	else:
		print('Utkarsh')


t = int(input())
while t:
	t -= 1
	(d, k) = map(int, input().split())
	x = d ** 2
	x = x // 2
	y = x ** 0.5
	y = y - y % k
	z = y + k
	if z * z + y * y <= d ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


import math
from collections import defaultdict
from sys import stdin
input = stdin.readline
T = int(input())
for _ in range(T):
	(d, k) = map(int, input().split())
	(x, y) = (0, 0)
	curr = 0
	i = 0
	while True:
		if i % 2 == 0:
			x += k
			if x * x + y * y <= d * d:
				curr = curr ^ 1
			else:
				break
		else:
			y += k
			if x * x + y * y <= d * d:
				curr = curr ^ 1
			else:
				break
		i += 1
	if curr:
		print('Ashish')
	else:
		print('Utkarsh')


for _ in range(int(input())):
	(d, k) = map(int, input().split())
	t = k * 2 ** 0.5
	a = d // t
	x = 2 * a
	p = k * a
	if ((p + k) ** 2 + p ** 2) ** 0.5 <= d:
		x += 1
	if x % 2 == 1:
		print('Ashish')
	else:
		print('Utkarsh')


def solve():
	(d, k) = map(int, input().split())
	(left, right) = (0, int(100000000000.0))
	while right - left > 1:
		mid = (left + right) // 2
		if k * k * mid * mid * 2 <= d * d:
			left = mid
		else:
			right = mid
	if k * k * left * left + k * k * (left + 1) * (left + 1) <= d * d:
		print('Ashish')
	else:
		print('Utkarsh')
q = int(input())
while q:
	solve()
	q -= 1


q = int(input())

def f(d, k):
	l = 0
	r = 100011
	if k == d:
		return 'Ashish'
	while r - l > 1:
		mid = (l + r) // 2
		if k * mid * (k * mid) * 2 <= d * d:
			l = mid
		else:
			r = mid
	if k * l * (k * l) + k * (l + 1) * (k * (l + 1)) > d * d:
		return 'Utkarsh'
	return 'Ashish'
while q != 0:
	q -= 1
	(d, k) = tuple(map(int, input().split()))
	print(f(d, k))


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline()

def RL():
	return map(int, sys.stdin.readline().split())

def RLL():
	return list(map(int, sys.stdin.readline().split()))

def N():
	return int(input())

def print_list(l):
	print(' '.join(map(str, l)))
for _ in range(N()):
	(d, k) = RL()
	d2 = d ** 2
	r = k
	while r ** 2 * 2 <= d2:
		r += k
	r -= k
	if r ** 2 + (r + k) ** 2 <= d2:
		print('Ashish')
	else:
		print('Utkarsh')


t = int(input())
for ti in range(t):
	(n, k) = map(int, input().split())
	x = int(n / k / 2 ** 0.5)
	if (x + 1) ** 2 + x ** 2 <= (n / k) ** 2:
		print('Ashish')
	else:
		print('Utkarsh')


import math
t = int(input())
for r in range(t):
	(d, k) = list(map(int, input().split()))
	p = 0
	q = 0
	w = ''
	m = -2 + math.pow(4 - 8 * (1 - math.pow(d / k, 2)), 0.5)
	n = -2 - math.pow(4 - 8 * (1 - math.pow(d / k, 2)), 0.5)
	a = m / 4
	b = n / 4
	if a > b:
		(a, b) = (b, a)
	for i in range(int(a), math.ceil(b)):
		if i > 0:
			p += 1
	if math.pow(int(b + 1) * k, 2) + math.pow(int(b + 1) * k, 2) <= d ** 2:
		w = 'Utkarsh'
	else:
		w = 'Ashish'
	print(w)


t = int(input())
for nbt in range(t):
	(d, k) = [int(i) for i in input().split()]
	tt = 1 << 20
	mi = 0
	while tt:
		if (mi + tt) * (mi + tt) * k * k * 2 <= d * d:
			mi += tt
		tt >>= 1
	if mi * k * k * mi + ((mi + 1) * k) ** 2 <= d * d:
		print('Ashish')
	else:
		print('Utkarsh')


cnt = int(input())
for cont in range(cnt):
	(r, k) = input().split()
	r = int(r)
	k = int(k)
	xy = int(r / 2 ** 0.5)
	nn = int(xy / k)
	val = (nn * k) ** 2 + ((nn + 1) * k) ** 2
	if val > r ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


MOD = 1000000007
from collections import defaultdict as dd, Counter, deque

def si():
	return input()

def ii():
	return int(input())

def li():
	return list(map(int, input().split()))

def mi():
	return map(int, input().split())

def out(v):
	print(v)

def spout():
	print(v, end=' ')

def d2b(n):
	return bin(n).replace('0b', '')

def twod(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def vow():
	return ['a', 'e', 'i', 'o', 'u']

def let():
	return [chr(i) for i in range(97, 123)]

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def ispow2(x):
	return x and (not x & x - 1)

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return list(factors)
t = ii()
while t:
	t -= 1
	(d, k) = mi()
	x = y = i = 0
	n = int(d / pow(2, 0.5))
	n = n // k
	n = n * k
	while True:
		if pow(n, 2) + pow(n + k, 2) <= pow(d, 2):
			print('Ashish')
			break
		elif pow(n, 2) + pow(n, 2) <= pow(d, 2):
			print('Utkarsh')
			break
		elif pow(n, 2) + pow(n - k, 2) <= pow(d, 2):
			print('Ashish')
			break
		n = n - k


for i in range(int(input())):
	(d, k) = map(int, input().split())
	z = 0
	x = 0
	y = 0
	v = d ** 2
	l = 2 * k ** 2
	c = int((v / l) ** 0.5)
	v1 = (c * k) ** 2 + (c * k + k) ** 2
	if v1 > d ** 2:
		print('Utkarsh')
	else:
		print('Ashish')


from sys import stdin, stdout
from math import gcd, sqrt, factorial, pi, inf
from collections import deque, defaultdict
from bisect import bisect, bisect_left
from time import time
from itertools import permutations as per
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\r\n')
L = lambda : list(R())
P = lambda x: stdout.write(str(x) + '\n')
lcm = lambda x, y: x * y // gcd(x, y)
nCr = lambda x, y: f[x] * inv(f[y] * f[x - y] % N) % N
inv = lambda x: pow(x, N - 2, N)
sm = lambda x: (x ** 2 + x) // 2
N = 10 ** 9 + 7
p = [0] * (int(200000.0) + 1)
for i in range(int(200000.0)):
	p[i + 1] = (i + 1) ** 2
for i in range(I()):
	(n, k) = R()
	(x, y) = (0, 0)
	d = ['Utkarsh', 'Ashish']
	for i in range(n * 2):
		if i & 1:
			y += k
		else:
			x += k
		if p[x] + p[y] > p[n]:
			print(d[i & 1])
			break


import os
import sys
from io import BytesIO, IOBase
_str = str
BUFSIZE = 8192

def str(x=b''):
	return x if type(x) is bytes else _str(x).encode()

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def inp():
	return sys.stdin.readline().rstrip()

def mpint():
	return map(int, inp().split(' '))

def itg():
	return int(inp())
SQRT_2 = 2 ** 0.5

def solve():
	(d, k) = mpint()
	x = d // (k * SQRT_2)
	return (k * x) ** 2 + (k * (x + 1)) ** 2 <= d * d

def main():
	for _ in range(itg()):
		print('Ashish' if solve() else 'Utkarsh')
DEBUG = 0
URL = 'https://codeforces.com/contest/1451/problem/D'
if DEBUG == 1:
	import requests
	from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
	runner = TestCaseRunner(main, URL)
	inp = runner.input_stream
	print = runner.output_stream
	runner.checking()
elif DEBUG == 2:
	main()
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	main()