Ayush and Ashish play a game on an unrooted tree consisting of $n$ nodes numbered $1$ to $n$. Players make the following move in turns:   Select any leaf node in the tree and remove it together with any edge which has this node as one of its endpoints. A leaf node is a node with degree less than or equal to $1$. 

A tree is a connected undirected graph without cycles.

There is a special node numbered $x$. The player who removes this node wins the game. 

Ayush moves first. Determine the winner of the game if each player plays optimally.


-----Input-----

The first line of the input contains a single integer $t$ $(1 \leq t \leq 10)$ — the number of testcases. The description of the test cases follows.

The first line of each testcase contains two integers $n$ and $x$ $(1\leq n \leq 1000, 1 \leq x \leq n)$ — the number of nodes in the tree and the special node respectively.

Each of the next $n-1$ lines contain two integers $u$, $v$ $(1 \leq u, v \leq n, \text{ } u \ne v)$, meaning that there is an edge between nodes $u$ and $v$ in the tree.


-----Output-----

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


-----Examples-----
Input
1
3 1
2 1
3 1

Output
Ashish

Input
1
3 2
1 2
1 3

Output
Ayush



-----Note-----

For the $1$st test case, Ayush can only remove node $2$ or $3$, after which node $1$ becomes a leaf node and Ashish can remove it in his turn.

For the $2$nd test case, Ayush can remove node $2$ in the first move itself.

Source: codeforces | Difficulty: MEDIUM_HARD
Tags: Tree algorithms

Game theory


Solutions:
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	x -= 1
	e = [[] for _ in range(n)]
	for _ in range(n - 1):
		(a, b) = map(int, input().split())
		a -= 1
		b -= 1
		e[a].append(b)
		e[b].append(a)
	if len(e[x]) <= 1:
		print('Ayush')
		continue
	if (n - 1) % 2:
		print('Ayush')
	else:
		print('Ashish')


from collections import deque
for tt in range(int(input())):
	(n, s) = map(int, input().split())
	adj = [[] for i in range(n)]
	s -= 1
	q = deque([s])
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		adj[a - 1].append(b - 1)
		adj[b - 1].append(a - 1)
	if len(adj[s]) <= 1:
		print('Ayush')
		continue
	if n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	ab = [list(map(int, input().split())) for i in range(n - 1)]
	graph = [[] for i in range(n + 1)]
	for (a, b) in ab:
		graph[a].append(b)
		graph[b].append(a)
	if len(graph[x]) == 1 or n == 1:
		print('Ayush')
		continue
	if n % 2:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	deg_of_x = 0
	for j in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			deg_of_x += 1
	if deg_of_x <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for tt in range(t):
	(n, x) = map(int, input().strip().split())
	l = [[] for i in range(n + 1)]
	deg = [0] * (n + 1)
	if n == 1 and x == n:
		print('Ayush')
		continue
	for i in range(n - 1):
		(a, b) = map(int, input().strip().split())
		l[a].append(b)
		l[b].append(a)
		deg[a] += 1
		deg[b] += 1
	nod = 0
	if deg[x] == 1:
		print('Ayush')
		continue
	if n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


def leaves(m, n):
	count = 0
	for i in m:
		if count >= 2:
			break
		if i[0] == n or i[1] == n:
			count += 1
	if len(m) <= 1 or count == 1:
		return 'Ayush'
	elif (len(m) - 2) % 2 == 0:
		return 'Ashish'
	else:
		return 'Ayush'
for i in range(int(input().strip())):
	mass = []
	t = [int(d) for d in input().strip().split()]
	for j in range(t[0] - 1):
		g = [int(d) for d in input().strip().split()]
		mass.append(g)
	print(leaves(mass, t[1]))


t = int(input())
while t > 0:
	t -= 1
	(n, x) = map(int, input().split())
	deg = [0 for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		deg[u] += 1
		deg[v] += 1
	if deg[x] <= 1:
		print('Ayush')
	elif n & 1:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
from collections import defaultdict
for i in range(t):
	(n, k) = map(int, input().split())
	dic = defaultdict(list)
	for j in range(0, n - 1):
		(a, b) = map(int, input().split())
		dic[a].append(b)
		dic[b].append(a)
	if len(dic[k]) <= 1:
		print('Ayush')
	elif (n - 3) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


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')

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

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

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

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush

def main():
	for _ in range(N()):
		(n, x) = RL()
		ind = [0] * (n + 1)
		c = sum((x in RL() for _ in range(n - 1)))
		(a, b) = ('Ayush', 'Ashish')
		print(a if c <= 1 or n % 2 == 0 else b)
main()


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
(t,) = I()
for _ in range(t):
	(n, x) = I()
	de = 0
	for i in range(n - 1):
		(a, b) = I()
		if x == a or b == x:
			de += 1
	if de <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	a = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			a += 1
	print(['Ashish', 'Ayush'][(n - 3) % 2 or a < 2])


from collections import defaultdict
for _ in range(int(input())):
	(n, s) = map(int, input().split())
	d = defaultdict(lambda : 0)
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		d[a] += 1
		d[b] += 1
	if d[s] <= 1 or (n - 1) % 2:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	data = [[] for i in range(n + 1)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		data[u].append(v)
		data[v].append(u)
	if len(data[x]) <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())

def dfs(x, cnt):
	vis[x] = 1
	for i in dic[x]:
		if vis[i] == 0:
			cnt = dfs(i, cnt)
	return cnt + 1
for _ in range(t):
	(n, x) = [int(a) for a in input().split(' ')]
	if n == 1:
		print('Ayush')
		continue
	dic = {}
	vis = [0] * (n + 1)
	vis[0] = 1
	for _ in range(n - 1):
		(u, v) = [int(a) for a in input().split(' ')]
		if u not in dic:
			dic[u] = []
		if v not in dic:
			dic[v] = []
		dic[u].append(v)
		dic[v].append(u)
	if len(dic[x]) <= 1:
		print('Ayush')
		continue
	cnt = dfs(x, 0)
	if cnt % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


def sol(arr):
	ans = 0
	good = 1
	for i in arr:
		if i == 1:
			good = 0
		elif good == 0:
			ans += 1
	return ans
for i in range(int(input())):
	(n, p) = [int(s) for s in input().split()]
	root = 0
	for i in range(n - 1):
		(p1, p2) = [int(s) for s in input().split()]
		if p1 == p or p2 == p:
			root += 1
	if root < 2 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys, math
from collections import defaultdict as dd, deque, Counter

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

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

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

def out(var):
	sys.stdout.write(str(var) + '\n')
sys.setrecursionlimit(100000)
INF = float('inf')
mod = int(1000000000.0) + 7

def main():
	for t in range(int(data())):
		(n, x) = mdata()
		cnt = 0
		for i in range(n - 1):
			(u, v) = mdata()
			if u == x or v == x:
				cnt += 1
		if cnt <= 1:
			out('Ayush')
		elif n % 2 == 0:
			out('Ayush')
		else:
			out('Ashish')
main()


def add_edge(a, b):
	adjlist[a].append(b)
	adjlist[b].append(a)
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	x -= 1
	adjlist = [[] for i in range(n)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		a -= 1
		b -= 1
		add_edge(a, b)
	cnt = 0
	if len(adjlist[x]) <= 1:
		print('Ayush')
		continue
	for i in range(n):
		if i == x:
			cnt += len(adjlist[i])
		elif len(adjlist[i]) >= 1:
			cnt += len(adjlist[i]) - 1
	if cnt % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	cnt = 0
	for j in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x:
			cnt += 1
		if b == x:
			cnt += 1
	if cnt <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	xs = {1: set()}
	(n, x) = map(int, input().split())
	for _ in range(n - 1):
		(i, j) = map(int, input().split())
		if i not in xs:
			xs[i] = {j}
		if j not in xs:
			xs[j] = {i}
		xs[i].add(j)
		xs[j].add(i)
	if len(xs[x]) <= 1:
		print('Ayush')
	else:
		print('Ayush') if len(xs) % 2 == 0 else print('Ashish')


t = int(input())
for s in range(t):
	(n, m) = map(int, input().split())
	list = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(x, y) = map(int, input().split())
		list[x].append(y)
		list[y].append(x)
	c = len(list[m])
	if c == 1 or c == 0:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for a in range(t):
	(n, x) = map(int, input().split())
	edges = dict()
	turn = 'Ayush'
	for b in range(n - 1):
		(n1, n2) = map(int, input().split())
		if n1 in edges:
			edges[n1].add(n2)
		else:
			edges[n1] = set([n2])
		if n2 in edges:
			edges[n2].add(n1)
		else:
			edges[n2] = set([n1])
	if n > 1:
		while len(edges[x]) > 1:
			hadMove = False
			for key in edges:
				if len(edges[key]) == 1:
					if x not in edges[key]:
						val = edges[key].pop()
						del edges[key]
						edges[val].remove(key)
						hadMove = True
						break
					elif len(edges[x]) > 2:
						del edges[key]
						edges[x].remove(key)
						hadMove = True
						break
			if turn == 'Ayush':
				turn = 'Ashish'
			else:
				turn = 'Ayush'
			if not hadMove:
				break
	print(turn)


t = int(input())
for tc in range(t):
	s = input().split()
	(n, x) = (int(s[0]), int(s[1]))
	num = [[] for i in range(n + 1)]
	for i in range(n - 1):
		s1 = input().split()
		(si, ei) = (int(s1[0]), int(s1[1]))
		num[si].append(ei)
		num[ei].append(si)
	di = len(num[x])
	if di <= 1:
		print('Ayush')
	else:
		re = n - di - 1
		if re % 2 == 0:
			if di % 2 == 0:
				print('Ashish')
			else:
				print('Ayush')
		elif di % 2 != 0:
			print('Ashish')
		else:
			print('Ayush')


t = int(input())
for ii in range(t):
	(n, x) = map(int, input().split())
	graph = [[] for i in range(n)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		graph[a - 1].append(b - 1)
		graph[b - 1].append(a - 1)
	if len(graph[x - 1]) <= 1:
		print('Ayush')
	elif (n - 1) % 2:
		print('Ayush')
	else:
		print('Ashish')


for p in range(int(input())):
	(n, x) = input().split()
	n = int(n)
	x = int(x)
	arr = [0] * n
	flag = 0
	for i in range(n - 1):
		(u, v) = input().split()
		v = int(v)
		u = int(u)
		arr[u - 1] += 1
		arr[v - 1] += 1
	if arr[x - 1] <= 1:
		print('Ayush')
	else:
		deg = arr[x - 1]
		flag2 = (n - deg - 1) % 2
		n -= deg + 1
		if deg >= 2:
			flag2 = (deg % 2 + flag2) % 2
		if flag2 == 0:
			print('Ashish')
		else:
			print('Ayush')


import sys

def I():
	return sys.stdin.readline().rstrip()
for tc in range(1, 1 + int(I())):
	(n, x) = map(int, I().split())
	c = 0
	for _ in range(n - 1):
		(u, v) = map(int, I().split())
		if x in [u, v]:
			c += 1
	if c > 1:
		print('Ayush' if n % 2 == 0 else 'Ashish')
	else:
		print('Ayush')


from collections import defaultdict
import math
import heapq
from collections import defaultdict, deque
from decimal import *

def r():
	return int(input())

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

def rl():
	return list(map(int, input().split()))
for _ in range(r()):
	(n, x) = rm()
	child = defaultdict(list)
	deg = defaultdict(int)
	for i in range(n - 1):
		(a, b) = rm()
		if b < a:
			(a, b) = (b, a)
		deg[a] += 1
		deg[b] += 1
		child[a].append(b)
	if deg[x] <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


[t] = [int(i) for i in input().split()]
for _ in range(t):
	[n, x] = [int(i) for i in input().split()]
	degx = 0
	for _ in range(n - 1):
		[v1, v2] = [int(i) for i in input().split()]
		if v1 == x or v2 == x:
			degx += 1
	if n == 1:
		print('Ayush')
	elif degx == 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


for t in range(int(input())):
	(n, x) = map(int, input().split())
	s = 0
	for i in range(n - 1):
		if x in list(map(int, input().split())):
			s += 1
	if n < 3 or s == 1 or (n - 3) % 2 != 0:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	nodes = dict()
	(n, x) = list(map(int, input().split()))
	if n == 1:
		print('Ayush')
		continue
	for i in range(n - 1):
		(node1, node2) = tuple(map(int, input().split()))
		if node1 not in nodes:
			nodes[node1] = [node2]
		else:
			nodes[node1].append(node2)
		if node2 not in nodes:
			nodes[node2] = [node1]
		else:
			nodes[node2].append(node1)
	leaf_nodes = []
	for key in nodes.keys():
		if len(nodes[key]) <= 1:
			leaf_nodes.append(key)
	currentPlayer = 'Ayush'
	while True:
		if x in leaf_nodes:
			print(currentPlayer)
			break
		else:
			removed = False
			for leaf in leaf_nodes:
				if x in nodes[leaf]:
					continue
				else:
					leaf_nodes.remove(leaf)
					nodes[nodes[leaf][0]].remove(leaf)
					if len(nodes[nodes[leaf][0]]) == 1:
						leaf_nodes.append(nodes[leaf][0])
						leaf_nodes = list(set(leaf_nodes))
					removed = True
					nodes.pop(leaf)
					break
			if removed:
				currentPlayer = 'Ashish' if currentPlayer == 'Ayush' else 'Ayush'
				continue
			else:
				removed_leaf = leaf_nodes.pop()
				nodes[nodes[removed_leaf][0]].remove(removed_leaf)
				if len(nodes[nodes[removed_leaf][0]]) == 1:
					leaf_nodes.append(nodes[removed_leaf][0])
					leaf_nodes = list(set(leaf_nodes))
				nodes.pop(removed_leaf)
				removed = True
			if removed:
				currentPlayer = 'Ashish' if currentPlayer == 'Ayush' else 'Ayush'


import math, sys, bisect, heapq
from collections import defaultdict, Counter, deque
from itertools import groupby, accumulate
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__
ilele = lambda : map(int, input().split())
alele = lambda : list(map(int, input().split()))

def Y(c):
	print(['NO', 'YES'][c])

def y(c):
	print(['no', 'yes'][c])

def Yy(c):
	print(['No', 'Yes'][c])
for _ in range(int(input())):
	(n, x) = ilele()
	G = defaultdict(list)
	for i in range(n - 1):
		(u, v) = ilele()
		G[u].append(v)
		G[v].append(u)
	if len(G.get(x, [])) <= 1:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


T = int(input())
while T:
	(n, x) = map(int, input().split())
	G = {}
	for i in range(1, n + 1):
		G[i] = []
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		G[a].append(b)
		G[b].append(a)
	if len(G[x]) == 1 or n == 1:
		print('Ayush')
	else:
		c = n - 1 - len(G[x])
		if c % 2 == len(G[x]) % 2:
			print('Ashish')
		else:
			print('Ayush')
	T = T - 1


from collections import deque
for _ in range(int(input())):
	graph = dict()
	(n, z) = map(int, input().split())
	if n == 1:
		print('Ayush')
	else:
		for i in range(n - 1):
			(x, y) = map(int, input().split())
			graph.setdefault(x, set()).add(y)
			graph.setdefault(y, set()).add(x)
		dist = [-1 for _ in range(n + 1)]
		ch = []
		q = deque()
		q.append(z)
		dist[z] = 0
		while len(q) != 0:
			v = q.popleft()
			chh = 0
			for u in graph[v]:
				if dist[u] == -1:
					dist[u] = dist[v] + 1
					q.appendleft(u)
					chh += 1
			if chh == 0:
				ch.append(dist[v])
		summ = n - 2
		if len(graph[z]) == 1:
			print('Ayush')
		elif summ % 2 == 1:
			print('Ashish')
		else:
			print('Ayush')


from collections import defaultdict
for _ in range(int(input())):
	(n, target) = map(int, input().split())
	degree = 0
	dic = defaultdict(list)
	c = 0
	for i in range(n - 1):
		x = list(map(int, input().split()))
		if x[0] == x[1]:
			c += 1
			continue
		dic[x[0]].append(x[1])
		dic[x[1]].append(x[0])
	if n == 1 or n == 2:
		print('Ayush')
		continue
	if len(dic[target]) == 1:
		print('Ayush')
		continue
	if (n - c - 1) % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


import sys
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__

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())
import collections as col
from types import GeneratorType

def solve():
	(N, X) = getInts()
	graph = col.defaultdict(set)
	for n in range(N - 1):
		(u, v) = getInts()
		graph[u].add(v)
		graph[v].add(u)
	if N == 1 or len(graph[X]) == 1:
		return 'Ayush'

	def bootstrap(f, stack=[]):

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

	@bootstrap
	def numberOfNodes(s, e):
		subtree[s] = 1
		for u in graph[s]:
			if u == e:
				continue
			yield numberOfNodes(u, s)
			subtree[s] += subtree[u]
		yield
	subtree = [0] * (N + 1)
	numberOfNodes(X, 0)
	sum_subtrees = 0
	for neighbour in graph[X]:
		sum_subtrees += subtree[neighbour]
	if sum_subtrees % 2 == 0:
		return 'Ashish'
	return 'Ayush'
T = getInt()
for t in range(T):
	print(solve())


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	count = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			count += 1
	if n == 1 and x == 1:
		print('Ayush')
	elif count == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')


import sys
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

def dfs(cur, par):
	ans = 1
	for child in g[cur]:
		if child == par:
			continue
		ans += dfs(child, cur)
	return ans
for _ in range(int(ri())):
	(n, x) = Ri()
	g = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(a, b) = Ri()
		g[a].append(b)
		g[b].append(a)
	arr = []
	for i in g[x]:
		arr.append(dfs(i, x) - 1)
	if len(g[x]) == 1 or len(g[x]) == 0:
		print('Ayush')
	else:
		cnt = 0
		cnt = sum(arr)
		cnt2 = len(arr)
		cnt += cnt2 - 1
		if cnt % 2 == 1:
			print('Ashish')
		else:
			print('Ayush')


t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	neighborsToX = 0
	for i in range(n - 1):
		if x in map(int, input().split()):
			neighborsToX += 1
	if neighborsToX <= 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	l = []
	d = defaultdict(lambda : 0)
	for _ in range(n - 1):
		(i, j) = map(int, input().split())
		d[i] += 1
		d[j] += 1
	for i in d:
		if d[i] == 1:
			l.append(i)
	if n == 1:
		print('Ayush')
	elif n % 2 == 0 or x in l:
		print('Ayush')
	else:
		print('Ashish')


import math as mt
import sys, string
input = sys.stdin.readline
from collections import defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())

def solve():
	(n, x) = M()
	c = 0
	for i in range(n - 1):
		(a, b) = M()
		if a == x or b == x:
			c += 1
	if n == 1 or c == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')
t = I()
for _ in range(t):
	solve()


from decimal import *
import sys, re, math
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, gcd, floor
from heapq import heappush, heappop, heapify, nlargest, nsmallest

def STR():
	return list(input())

def INT():
	return int(input())

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

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def sortListWithIndex(listOfTuples, idx):
	return sorted(listOfTuples, key=lambda x: x[idx])

def sortDictWithVal(passedDic):
	temp = sorted(passedDic.items(), key=lambda kv: (kv[1], kv[0]))
	toret = {}
	for tup in temp:
		toret[tup[0]] = tup[1]
	return toret

def sortDictWithKey(passedDic):
	return dict(OrderedDict(sorted(passedDic.items())))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
T = INT()
while T != 0:
	(n, x) = MAP()
	graph = defaultdict(list)
	numChild = defaultdict(int)
	for _ in range(n - 1):
		(u, v) = MAP()
		graph[u].append(v)
		graph[v].append(u)
		numChild[u] += 1
		numChild[v] += 1
	if len(graph[x]) <= 1:
		print('Ayush')
	elif (n - 3) % 2 != 0:
		print('Ayush')
	else:
		print('Ashish')
	T -= 1


def solve(test):
	(n, x) = map(int, input().split(' '))
	degree = [0 for i in range(n + 1)]
	for i in range(n - 1):
		(a, b) = map(int, input().split(' '))
		degree[a] += 1
		degree[b] += 1
	if degree[x] <= 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')

def main():
	test_case = int(input())
	for test in range(test_case):
		solve(test + 1)
main()


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

def ri():
	return int(input())

def rm():
	return map(int, input().split())
t = ri()

def solve():
	(n, x) = rm()
	a = 0
	for i in range(n - 1):
		(u, v) = rm()
		if u == x or v == x:
			a += 1
	if a == 1 or n == 1:
		return 'Ayush'
	if (n - 2) % 2 == 0:
		return 'Ayush'
	else:
		return 'Ashish'
for i in range(t):
	print(solve())


def bfs(s):
	global n, x, e, vis
	c = 0
	q = []
	c += 1
	q.append(s)
	vis[s] = True
	while q:
		u = q.pop()
		for v in e[u]:
			if vis[v]:
				continue
			c += 1
			q.append(v)
			vis[v] = True
	return c

def solve():
	global n, x, e, vis
	(n, x) = map(int, input().split())
	vis = [False] * (n + 1)
	vis[x] = True
	e = [list() for _ in range(n + 1)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		e[u].append(v)
		e[v].append(u)
	if n <= 2:
		print('Ayush')
		return
	a = []
	o = 0
	for u in e[x]:
		a.append(bfs(u))
		if a[-1] % 2 == 1:
			o += 1
	if len(a) <= 1:
		print('Ayush')
		return
	if o % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')
t = int(input())
for _ in range(t):
	solve()


from collections import Counter
for r in range(int(input())):
	(n, x) = map(int, input().split())
	l = []
	for u in range(n - 1):
		(a, b) = map(int, input().split())
		l.append(a)
		l.append(b)
	l = Counter(l)
	if l[x] < 2:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


import sys
input = sys.stdin.readline
for f in range(int(input())):
	(n, x) = map(int, input().split())
	dx = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			dx += 1
	if dx <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin, stdout
int_in = lambda : int(stdin.readline())
arr_in = lambda : [int(x) for x in stdin.readline().split()]
mat_in = lambda rows: [arr_in() for y in range(rows)]
str_in = lambda : stdin.readline().strip()
out = lambda o: stdout.write('{}\n'.format(o))
arr_out = lambda o: out(' '.join(map(str, o)))
bool_out = lambda o: out('YES' if o else 'NO')
tests = lambda : range(1, int_in() + 1)
case_out = lambda i, o: out('Case #{}: {}'.format(i, o))

def solve(n, x, edges):
	count = 0
	for item in edges:
		if item[0] == x or item[1] == x:
			count += 1
			if count > 1:
				return (n - 1) % 2 == 1
	return True
for i in tests():
	(n, x) = arr_in()
	edges = mat_in(n - 1)
	out('Ayush' if solve(n, x, edges) else 'Ashish')


def main():
	for i in range(int(input())):
		solve()

def solve():
	(n, x) = map(int, input().split())
	a = []
	c = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			c += 1
	if c == 1 or n == 1:
		print('Ayush')
		return
	if n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')
main()


from collections import defaultdict

def findLeaf(root, parent):
	if len(Dict[root]) == 1:
		return 1
	else:
		curr = Dict[root]
		Add = 1
		for i in curr:
			if i != parent:
				Add += findLeaf(i, root)
		return Add
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	if n == 1:
		print('Ayush')
		continue
	Dict = defaultdict(list)
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		Dict[a].append(b)
		Dict[b].append(a)
	Neigh = Dict[x]
	Array = []
	for i in Neigh:
		Array.append(findLeaf(i, x))
	if len(Array) == 1:
		print('Ayush')
		continue
	if sum(Array) & 1:
		print('Ayush')
	else:
		print('Ashish')


import sys
import math
from collections import defaultdict

def solve(test):
	(n, x) = map(int, input().split())
	rec = defaultdict(int)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		rec[u] += 1
		rec[v] += 1
	if n == 1 or rec[x] == 1:
		print('Ayush')
	elif not n - 2 & 1:
		print('Ayush')
	else:
		print('Ashish')
test_cases = int(input())
for t in range(1, test_cases + 1):
	solve(t)


for i in range(int(input())):
	(n, x) = map(int, input().split())
	xbonds = 0
	for j in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			xbonds += 1
	if n == 1:
		print('Ayush')
	elif xbonds == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
Q = int(input())
Query = []
for _ in range(Q):
	(N, X) = map(int, input().split())
	graph = [[] for _ in range(N)]
	for _ in range(N - 1):
		(a, b) = map(int, input().split())
		graph[a - 1].append(b - 1)
		graph[b - 1].append(a - 1)
	Query.append((N, X - 1, graph))
for (N, s, graph) in Query:
	checked = [False] * N
	checked[s] = True
	odd = 0
	for b in graph[s]:
		q = [b]
		checked[b] = True
		Count = 1
		while q:
			qq = []
			for p in q:
				for np in graph[p]:
					if not checked[np]:
						checked[np] = True
						qq.append(np)
						Count += 1
			q = qq
		if Count % 2 == 1:
			odd += 1
	if len(graph[s]) <= 1 or odd % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	deg = [0] * (n + 1)
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		deg[a] += 1
		deg[b] += 1
	if deg[x] <= 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict
for T in range(int(input())):
	(n, x) = list(map(int, input().split()))
	if n % 2 == 0 or n == 1:
		print('Ayush')
		for i in range(n - 1):
			(u, v) = list(map(int, input().split()))
	else:
		d = defaultdict(int)
		for i in range(n - 1):
			(u, v) = list(map(int, input().split()))
			d[u] += 1
			d[v] += 1
		leaf = []
		for j in d:
			if d[j] == 1:
				leaf.append(j)
		if x in leaf:
			print('Ayush')
		else:
			print('Ashish')


t = int(input())
while t:
	t -= 1
	(n, x) = map(int, input().split())
	l = [[] for i in range(n + 1)]
	for _ in range(n - 1):
		(a, b) = map(int, input().split())
		l[a].append(b)
		l[b].append(a)
	leng = len(l[x])
	if leng == 1 or n == 1:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	from collections import defaultdict
	gr = defaultdict(list)
	for i in range(n - 1):
		(i, j) = map(int, input().split())
		gr[i].append(j)
		gr[j].append(i)
	if len(gr[x]) <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
readline = sys.stdin.readline
ns = lambda : readline().rstrip()
ni = lambda : int(readline().rstrip())
nm = lambda : map(int, readline().split())
nl = lambda : list(map(int, readline().split()))

def solve():
	(n, k) = nm()
	k -= 1
	G = [list() for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = nm()
		u -= 1
		v -= 1
		G[u].append(v)
		G[v].append(u)
	if len(G[k]) <= 1:
		print('Ayush')
		return
	print('Ayush' if n + 1 & 1 else 'Ashish')
	return
T = int(input())
for _ in range(T):
	solve()


def solve():
	(n, x) = input().split()
	n = int(n)
	x = int(x)
	cnt = 0
	if n == 1:
		return 'Ayush'
	for i in range(0, n - 1):
		(u, v) = input().split()
		u = int(u)
		v = int(v)
		if u == x or v == x:
			cnt += 1
	if cnt == 1:
		return 'Ayush'
	elif (n - 3) % 2 == 0:
		return 'Ashish'
	else:
		return 'Ayush'
T = int(input())
for i in range(T):
	print(solve())


t = int(input())
while t:
	t += -1
	(n, x) = map(int, input().split())
	leaf = [0] * 1005
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		leaf[a] -= -1
		leaf[b] -= -1
	if leaf[x] == 1 or leaf[x] == 0:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict as dd
import math
import sys

def nn():
	return int(input())

def li():
	return list(input())

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

def lm():
	return list(map(int, input().split()))
q = nn()
for _ in range(q):
	(n, x) = mi()
	edgedict = dd(list)
	for i in range(n - 1):
		(e1, e2) = mi()
		edgedict[e1].append(e2)
		edgedict[e2].append(e1)
	nodecount = []
	if len(edgedict[x]) <= 1:
		print('Ayush')
		continue
	if n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


def add_vertex(graph, v):
	if v not in graph:
		graph[v] = []

def add_edge(graph, v1, v2):
	graph[v1].append(v2)
	graph[v2].append(v1)
for i in range(int(input())):
	graph = {}
	(n, x) = [int(x) for x in input().split()]
	for j in range(1, n + 1):
		add_vertex(graph, j)
	for k in range(n - 1):
		(a, b) = [int(x) for x in input().split()]
		add_edge(graph, a, b)
	if len(graph[x]) == 1 or n == 1:
		print('Ayush')
	elif (n - 2) % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for _ in range(t):
	(n, node) = map(int, input().split())
	deg = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == node or b == node:
			deg += 1
	if deg == 1 or n == 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


for i in range(int(input())):
	deg = [0] * 100000
	(n, x) = map(int, input().split())
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		deg[u] += 1
		deg[v] += 1
	if deg[x] <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import math
import os
import random
import re
import sys
t = int(input())
while t > 0:
	t -= 1
	(n, x) = map(int, input().split())
	x_child = 0
	for i in range(n - 1):
		(p, c) = map(int, input().split())
		if p == x or c == x:
			x_child += 1
	if x_child < 2:
		print('Ayush')
		continue
	if (n - 3) % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())

def numberOfNodes(s, e):
	global count1, adj
	count1[s] = 1
	for u in adj[s]:
		if u == e:
			continue
		numberOfNodes(u, s)
		count1[s] += count1[u]

def addEdge(a, b):
	global adj
	adj[a].append(b)
	adj[b].append(a)
for test in range(t):
	(N, x) = [int(x) for x in input().split()]
	count1 = [0] * (N + 1)
	adj = [[] for i in range(N + 1)]
	for i in range(N - 1):
		(a, b) = [int(x) for x in input().split()]
		addEdge(a, b)
	numberOfNodes(x, 0)
	final = []
	for i in adj[x]:
		final.append(count1[i])
	nzc = 0
	for i in final:
		if i != 0:
			nzc += 1
	if nzc <= 1:
		print('Ayush')
		continue
	ans = sum(final) - 1
	if ans % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	v = [[] for i in range(n + 1)]
	c = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == k or b == k:
			c += 1
		v[b].append(a)
	if c < 2:
		print('Ayush')
	elif n % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


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

def solve():
	(n, x) = inp()
	a = [[] for _ in range(n + 1)]
	for i in range(n - 1):
		(z, y) = inp()
		a[z].append(y)
		a[y].append(z)
	if len(a[x]) <= 1 or n % 2 == 0:
		return 'Ayush'
	return 'Ashish'

def main():
	t = int(input())
	while t:
		print(solve())
		t -= 1
main()


from collections import defaultdict
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	d = defaultdict(list)
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		d[a].append(b)
		d[b].append(a)
	if n <= 2 or len(d[x]) == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


for tc in range(int(input())):
	(n, k) = map(int, input().split())
	deg = [0] * (n + 1)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		deg[u] += 1
		deg[v] += 1
	print('Ayush' if deg[k] <= 1 or n % 2 == 0 else 'Ashish')


T = int(input())
for t in range(T):
	(n, x) = map(int, input().rstrip().split())
	counter = 0
	for l in range(n - 1):
		(a, b) = map(int, input().rstrip().split())
		if a == x or b == x:
			counter += 1
	if n % 2 == 0 or counter <= 1:
		print('Ayush')
	else:
		print('Ashish')


import os
import sys
if os.path.exists('/mnt/c/Users/Square/square/codeforces'):
	f = iter(open('C.txt').readlines())

	def input():
		return next(f).strip()
else:
	input = lambda : sys.stdin.readline().strip()
fprint = lambda *args: print(*args, flush=True)
import itertools
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	g = {i + 1: [] for i in range(n)}
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		g[u].append(v)
		g[v].append(u)
	if len(g[x]) <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep='\n')

def II():
	return int(sys.stdin.readline())

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

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

def LLI(rows_number):
	return [LI() for _ in range(rows_number)]

def SI():
	return sys.stdin.readline()[:-1]

def main():
	for _ in range(II()):
		(n, x) = MI()
		deg = 0
		for _ in range(n - 1):
			(u, v) = MI()
			if u == x or v == x:
				deg += 1
		if deg < 2 or n - 3 & 1:
			print('Ayush')
		else:
			print('Ashish')
main()


import math
t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	xnbrs = 0
	nbrs = set()
	for j in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			xnbrs += 1
	if xnbrs <= 1:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys, math
from collections import deque

def solve():
	(n, x) = map(int, input().split())
	x -= 1
	edgeList = [[] for _ in range(n)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		edgeList[a - 1].append(b - 1)
		edgeList[b - 1].append(a - 1)
	if len(edgeList[x]) <= 1:
		print('Ayush')
		return
	if n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')
for _ in range(int(input())):
	solve()


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

def print_list(l):
	print(' '.join(map(str, l)))
N = int(input())
for _ in range(N):
	(n, x) = read_list()
	xx = str(x)
	tmp = 0
	for _ in range(n - 1):
		s = set(input().split(' '))
		if xx in s:
			tmp += 1
	if tmp < 2:
		print('Ayush')
	elif n & 1:
		print('Ashish')
	else:
		print('Ayush')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	d = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if x == u or x == v:
			d += 1
	if d < 2 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	mat = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		mat[a].append(b)
		mat[b].append(a)
	if len(mat[x]) < 2:
		print('Ayush')
	elif n - 2 & 1:
		print('Ashish')
	else:
		print('Ayush')


from sys import stdin
from math import sqrt, gcd
from collections import deque
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\n')
lcm = lambda x, y: x * y // gcd(x, y)
hg = lambda x, y: (y + x - 1) // x * x
for _ in range(I()):
	(n, x) = R()
	v = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(a, b) = R()
		v[a] += (b,)
		v[b] += (a,)
	print('Ayush' if len(v[x]) < 2 or n % 2 == 0 else 'Ashish')


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	xL = [0] * (n + 1)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		xL[u] += 1
		xL[v] += 1
	if xL[x] <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import collections

def solve(n, x, graph):

	def remove(graph, leaf):
		newleaves = set()
		for child in graph[leaf]:
			graph[child].remove(leaf)
			if len(graph[child]) <= 1:
				newleaves.add(child)
		return newleaves

	def restore(graph, leaf):
		for child in graph[leaf]:
			graph[child].add(leaf)

	def recur(x, graph, leaves):
		if x in leaves:
			return True
		for leaf in leaves:
			newleaves = leaves | remove(graph, leaf)
			newleaves.remove(leaf)
			if not recur(x, graph, newleaves):
				restore(graph, leaf)
				return True
			restore(graph, leaf)
		return False
	if n <= 2:
		return 'Ayush'
	leaves = set()
	for key in graph.keys():
		if len(graph[key]) <= 1:
			leaves.add(key)
	x = recur(x, graph, leaves)
	if x:
		return 'Ayush'
	return 'Ashish'

def solve2(n, x, graph):
	if n <= 2:
		return 'Ayush'
	q = collections.deque([x])
	visited = set([x])
	hts = []
	ht = 0
	while q:
		q2 = collections.deque()
		while q:
			pop = q.popleft()
			if len(graph[pop]) <= 1:
				hts.append(ht)
			for child in graph[pop]:
				if child not in visited:
					q2.append(child)
					visited.add(child)
		q = q2
		ht += 1
	print(hts)
	if hts[0] == 0:
		return 'Ayush'
	evens = 0
	for ht in hts:
		if ht % 2 == 0:
			evens += 1
	if evens % 2 == 1:
		return 'Ayush'
	return 'Ashish'

def solve3(n, x, graph):

	def dfs(node, graph, visited):
		if node in visited:
			return 0
		visited.add(node)
		ans = 0
		for child in graph[node]:
			ans += dfs(child, graph, visited)
		return 1 + ans
	if n <= 2:
		return 'Ayush'
	if len(graph[x]) <= 1:
		return 'Ayush'
	cnts = []
	visited = set([x])
	for child in graph[x]:
		cnts.append(dfs(child, graph, visited) - 1)
	print(cnts)
	print(graph)
	if sum(cnts) % 2 == 1:
		return 'Ayush'
	return 'Ashish'

def solve4(n, x, graph):
	if n <= 2:
		return 'Ayush'
	if len(graph[x]) <= 1:
		return 'Ayush'
	if n % 2 == 0:
		return 'Ayush'
	return 'Ashish'
t = int(input())
for _ in range(t):
	inp = input().split()
	(n, x) = (int(inp[0]), int(inp[1]))
	graph = collections.defaultdict(set)
	for _ in range(n - 1):
		(u, v) = input().split()
		graph[int(u)].add(int(v))
		graph[int(v)].add(int(u))
	print(solve4(n, x, graph))


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	dp = [0] * (n + 1)
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		dp[a] += 1
		dp[b] += 1
	if dp[x] < 2 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


def solve():
	(x, y) = [int(x) for x in input().split()]
	p = 0
	for j in range(x - 1):
		(n, m) = [int(x) for x in input().split()]
		if n == y or m == y:
			p += 1
	if p <= 1:
		return 'Ayush'
	return ['Ayush ', 'Ashish'][x % 2]
test = int(input())
for i in range(test):
	print(solve())


import os
import sys
from io import BytesIO, IOBase

def iin():
	return int(input())

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

def main():
	T = iin()
	while T:
		T -= 1
		(n, x) = lin()
		ans = ['Ashish', 'Ayush']
		adj = [[] for i in range(n + 1)]
		for _ in range(n - 1):
			(i, j) = lin()
			adj[i].append(j)
			adj[j].append(i)
		if len(adj[x]) <= 1:
			print(ans[1])
		else:
			print(ans[(n - 1) % 2])
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')
main()


from collections import defaultdict
import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	graph = defaultdict(list)
	(n, x) = map(int, input().split())
	for j in range(n - 1):
		(u, v) = map(int, input().split())
		graph[u].append(v)
		graph[v].append(u)
	if len(graph[x]) == 1 or n == 1:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


k = int(input())
for _ in range(k):
	(n, x) = map(int, input().split())
	hk = [list(map(int, input().split())) for i in range(n - 1)]
	graph = [[] for i in range(n + 1)]
	for (h, k) in hk:
		graph[h].append(k)
		graph[k].append(h)
	if len(graph[x]) == 1 or n == 1:
		print('Ayush')
		continue
	if n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	x -= 1
	degree = [0] * n
	edges = [(0, 0)] * (n - 1)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		edges[i] = (u - 1, v - 1)
		degree[u - 1] += 1
		degree[v - 1] += 1
	if degree[x] == 1 or degree[x] == 0:
		print('Ayush')
	else:
		print('Ashish' if n % 2 else 'Ayush')


from sys import stdin, stdout
import math, queue, heapq
fastinput = stdin.readline
fastout = stdout.write

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

def computeLPSArray(pat, M, lps):
	len = 0
	lps[0]
	i = 1
	while i < M:
		if pat[i] == pat[len]:
			len += 1
			lps[i] = len
			i += 1
		elif len != 0:
			len = lps[len - 1]
		else:
			lps[i] = 0
			i += 1
t = int(fastinput())
while t:
	t -= 1
	(n, m) = map(int, fastinput().split())
	count = 0
	for _ in range(n - 1):
		(x, y) = map(int, fastinput().split())
		if x == m or y == m:
			count += 1
	if n == 1 and m == 1:
		print('Ayush')
	elif count == 1:
		print('Ayush')
	elif (n - 2) % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for test in range(t):
	(n, x) = map(int, input().split())
	degree = [0] * (n + 1)
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		degree[a] += 1
		degree[b] += 1
	if n == 1:
		print('Ayush')
	else:
		fl = 0
		for i in range(1, n + 1):
			if degree[i] == 1 and i == x:
				fl = 1
				break
		if fl == 1:
			print('Ayush')
		elif n % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	degree = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			degree += 1
	if degree <= 1:
		print('Ayush')
	elif (n - 3) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	graph = defaultdict(list)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		graph[u].append(v)
		graph[v].append(u)
	degree = [0] * (n + 1)
	for i in range(1, n + 1):
		total = len(graph[i])
		degree[i] = total
	if degree[x] <= 1:
		print('Ayush')
		continue
	if n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin

def dfs(s):
	stk = [s]
	vis[s] = 1
	ct = 0
	while len(stk) != 0:
		k = stk[-1]
		stk.pop()
		for i in range(len(adj[k])):
			if vis[adj[k][i]] == 0:
				vis[adj[k][i]] = 1
				ct += 1
				stk.append(adj[k][i])
	return ct
for t in range(int(input())):
	(n, x) = map(int, stdin.readline().split())
	adj = [[] for i in range(n + 1)]
	ct = []
	for q in range(n - 1):
		(a, b) = map(int, stdin.readline().split())
		adj[a].append(b)
		adj[b].append(a)
	vis = [0] * (n + 1)
	count = 0
	for i in range(len(adj[x])):
		count += dfs(adj[x][i])
	if count & 1 or len(adj[x]) <= 1:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin
input = stdin.readline
import bisect
import math
for xoxo in range(1):

	def dfs(x, y):
		d = 0
		for i in tr[x]:
			if i == y:
				continue
			d += dfs(i, x)
		p[x] = d
		return d + 1
	for _ in range(int(input())):
		ans = ['Ayush', 'Ashish']
		(n, x) = map(int, input().split())
		tr = [[] for i in range(n)]
		for i in range(n - 1):
			(u, v) = map(int, input().split())
			tr[u - 1].append(v - 1)
			tr[v - 1].append(u - 1)
		if len(tr[x - 1]) == 1 or n < 3:
			print(ans[0])
		else:
			print(ans[n % 2])
			leaf = []
			p = [0] * n


from sys import stdin, stdout
import collections, heapq, bisect, math
input = stdin.readline

def rint():
	return int(input())

def rstr():
	return input().strip()

def rlstr():
	return list(input().strip().split())

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

def main():
	(n, x) = rlint()
	indegree = [0] * n
	for _ in range(n - 1):
		(u, v) = rlint()
		indegree[v - 1] += 1
		indegree[u - 1] += 1
	if indegree[x - 1] <= 1 or (n - 1) % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')
for _ in range(rint()):
	main()


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	a = [[] for i in range(n)]
	for i in range(n - 1):
		(f, t) = map(int, input().split())
		a[f - 1].append(t - 1)
		a[t - 1].append(f - 1)
	x -= 1
	if len(a[x]) <= 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	adj = {i + 1: [] for i in range(n)}
	for z in range(n - 1):
		(u, v) = map(int, input().split())
		adj[u].append(v)
		adj[v].append(u)
	if len(adj[x]) == 1 or len(adj[x]) == 0:
		print('Ayush')
		continue
	if n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


T = int(input())
ile = 0

def dfs(v, p, TREE):
	global ile
	ile += 1
	for w in TREE[v]:
		if w != p:
			dfs(w, v, TREE)
for _ in range(T):
	(n, x) = map(int, input().split())
	TREE = [[] for _ in range(n + 1)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		TREE[a].append(b)
		TREE[b].append(a)
	ile = 0
	dfs(x, -1, TREE)
	if len(TREE[x]) in [0, 1]:
		print('Ayush')
	else:
		ile -= 3
		print('Ayush' if ile % 2 == 1 else 'Ashish')


from math import inf, log2

class SegmentTree:

	def __init__(self, array, func=max):
		self.n = len(array)
		self.size = 2 ** (int(log2(self.n - 1)) + 1) if self.n != 1 else 1
		self.func = func
		self.default = 0 if self.func != min else inf
		self.data = [self.default] * (2 * self.size)
		self.process(array)

	def process(self, array):
		self.data[self.size:self.size + self.n] = array
		for i in range(self.size - 1, -1, -1):
			self.data[i] = self.func(self.data[2 * i], self.data[2 * i + 1])

	def query(self, alpha, omega):
		if alpha == omega:
			return self.data[alpha + self.size]
		res = self.default
		alpha += self.size
		omega += self.size + 1
		while alpha < omega:
			if alpha & 1:
				res = self.func(res, self.data[alpha])
				alpha += 1
			if omega & 1:
				omega -= 1
				res = self.func(res, self.data[omega])
			alpha >>= 1
			omega >>= 1
		return res

	def update(self, index, value):
		index += self.size
		self.data[index] = value
		index >>= 1
		while index:
			self.data[index] = self.func(self.data[2 * index], self.data[2 * index + 1])
			index >>= 1
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')
from math import gcd, ceil

def pre(s):
	n = len(s)
	pi = [0] * n
	for i in range(1, n):
		j = pi[i - 1]
		while j and s[i] != s[j]:
			j = pi[j - 1]
		if s[i] == s[j]:
			j += 1
		pi[i] = j
	return pi

def prod(a):
	ans = 1
	for each in a:
		ans = ans * each
	return ans

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

def binary(x, length=16):
	y = bin(x)[2:]
	return y if len(y) >= length else '0' * (length - len(y)) + y
for _ in range(int(input()) if True else 1):
	(n, x) = map(int, input().split())
	graph = [0] * (n + 69)
	graph2 = [0] * (n + 69)
	for _ in range(n - 1):
		(p, q) = map(int, input().split())
		graph[p] += 1
		graph[q] += 1
		if p != x and q != x:
			graph2[p] += 1
			graph2[q] += 1
	if graph[x] <= 1:
		print('Ayush')
		continue
	print('Ayush' if (sum(graph2) - n) % 2 == 0 else 'Ashish')


t = int(input())
for _ in range(t):
	(n, s) = list(map(int, input().split()))
	graph = {i: [] for i in range(1002)}
	for _ in range(n - 1):
		(a, b) = list(map(int, input().split()))
		graph[a].append(b)
		graph[b].append(a)
	winner = ['Ayush', 'Ashish']
	if len(graph[s]) <= 1:
		print(winner[0])
	elif n % 2 == 1:
		print(winner[1])
	else:
		print(winner[0])


mod = int(1000000000.0) + 7

def sp(n):
	if n == 1:
		return input()
	else:
		return map(str, input().split())

def np(n):
	if n == 1:
		return int(input())
	else:
		return map(int, input().split())
w = ['Ayush', 'Ashish']
for _ in range(0, int(input())):
	(n, x) = np(2)
	k = 0
	for i in range(0, n - 1):
		(a, b) = np(2)
		if a == x or b == x:
			k += 1
	ans = 0
	if n == 1 or k == 1:
		print(w[0])
	else:
		t = (n - k - 1) % 2 + k % 2
		print(w[1 - t % 2])


def input_tokenizer():

	def generator():
		while True:
			yield from input().split()
	gen = generator()
	return lambda : next(gen)
read = input_tokenizer()

def go():
	(n, x) = (int(read()), int(read()))
	gr = [[] for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = (int(read()), int(read()))
		gr[u - 1].append(v - 1)
		gr[v - 1].append(u - 1)

	def size(v, p):
		c = 1
		for n in gr[v]:
			if n != p:
				c += size(n, v)
		return c
	neig = []
	for v in gr[x - 1]:
		neig.append(size(v, x - 1))
	if len(neig) <= 1:
		print('Ayush')
		return
	turns = 0
	for x in neig:
		turns += x % 2
	if turns % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')
t = int(read())
for _ in range(t):
	go()


t = int(input())
for z in range(t):
	(n, s) = list(map(int, input().split()))
	arr = [[] for i in range(n)]
	s -= 1
	for i in range(n - 1):
		(u, v) = list(map(int, input().split()))
		u -= 1
		v -= 1
		arr[u].append(v)
		arr[v].append(u)
	leaf = []
	for i in range(n):
		if len(arr[i]) == 1:
			leaf.append(i)
	if s in leaf or n == 1:
		print('Ayush')
	else:
		c = 0
		while len(leaf) > 0:
			flag = False
			for i in leaf:
				j = arr[i][0]
				if j != s or len(arr[j]) != 2:
					flag = True
					leaf.remove(i)
					arr[j].remove(i)
					if len(arr[j]) == 1:
						leaf.append(j)
					break
			if flag == False:
				break
			c = 1 - c
		if c == 0:
			print('Ashish')
		else:
			print('Ayush')


for _ in range(int(input())):
	(n, x) = list(map(int, input().split()))
	arr = []
	child = []
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		arr.append(a)
		arr.append(b)
		if a == x:
			child.append(b)
		elif b == x:
			child.append(a)
	arr = list(set(arr))
	if len(child) == 0 or len(child) == 1:
		print('Ayush')
	elif (len(arr) - 2) % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


for test in range(int(input())):
	(n, x) = map(int, input().split())
	adj = {}
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a not in adj:
			adj[a] = []
		if b not in adj:
			adj[b] = []
		adj[a].append(b)
		adj[b].append(a)
	if len(adj.get(x, [])) <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin, setrecursionlimit, stdout
from collections import deque
from math import sqrt, floor, ceil, log, log2, log10, pi, gcd, sin, cos, asin

def ii():
	return int(stdin.readline())

def fi():
	return float(stdin.readline())

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

def fmi():
	return map(float, stdin.readline().split())

def li():
	return list(mi())

def si():
	return stdin.readline().rstrip()

def lsi():
	return list(si())
res = ['YES', 'NO']
test_case = ii()
while test_case:
	test_case -= 1
	(n, k) = mi()
	a = [[] for _ in range(n + 1)]
	for _ in range(n - 1):
		(u, v) = mi()
		a[u].append(v)
		a[v].append(u)
	f = 0
	for i in a[1:]:
		f += len(i) - 1
	f %= 2
	if len(a[k]) < 2:
		f = 0
	print(['Ayush', 'Ashish'][f])


from sys import stdin, exit
input = stdin.readline

def i():
	return input()

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

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

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

def print_array(a):
	print(' '.join(map(str, a)))
t = ii()
for _ in range(t):
	(n, x) = iis()
	tree = [[] for i in range(n + 1)]
	nodes = {}
	for i in range(n - 1):
		(u, v) = iis()
		if u not in nodes:
			nodes[u] = 0
		if v not in nodes:
			nodes[v] = 0
		nodes[u] += 1
		nodes[v] += 1
		tree[u].append(v)
		tree[v].append(u)
	if x not in nodes or nodes[x] == 1:
		print('Ayush')
	elif (n - 2) % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, x) = list(map(int, input().split()))
	arr = [0 for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = list(map(int, input().split()))
		arr[u] += 1
		arr[v] += 1
	if arr[x] <= 1:
		print('Ayush')
	elif n % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	l = [0] * 10000
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		l[a] += 1
		l[b] += 1
	if n == 1 or l[x] == 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict
from collections import deque
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	g = defaultdict(set)
	for _ in range(n - 1):
		(a, b) = map(int, input().split())
		g[a].add(b)
		g[b].add(a)
	if len(g[x]) <= 1:
		print('Ayush')
	else:
		print('Ayush' if n % 2 == 0 else 'Ashish')


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

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')

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()]
p1 = 'Ayush'
p2 = 'Ashish'
for _ in range(Int()):
	adj = defaultdict(list)
	(n, sp) = value()
	for i in range(n - 1):
		(s, d) = value()
		adj[s].append(d)
		adj[d].append(s)
	con = len(adj[sp])
	if con <= 1:
		print(p1)
	elif n % 2 == 0:
		print(p1)
	else:
		print(p2)


from collections import defaultdict
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	adj = defaultdict(list)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		adj[u].append(v)
		adj[v].append(u)
	if n <= 2 or len(adj[x]) == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = list(map(int, input().split()))
	deg_x = 0
	for a in range(n - 1):
		(u, v) = list(map(int, input().split()))
		if u == x or v == x:
			deg_x += 1
	if deg_x in [0, 1]:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


def solve():
	(n, x) = map(int, input().split())
	data = [0 for _ in range(n + 1)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		data[u] += 1
		data[v] += 1
	if data[x] == 0 or data[x] == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')
for _ in range(int(input())):
	solve()


def modinv(n, p):
	return pow(n, p - 2, p)

def main():
	for case in range(int(input())):
		(n, x) = [int(x) for x in input().split()]
		adj_list = {}
		for i in range(1, n + 1):
			adj_list[i] = []
		for i in range(n - 1):
			(u, v) = [int(x) for x in input().split()]
			adj_list[u].append(v)
			adj_list[v].append(u)
		a = len(adj_list[x])
		if a == 0 or a == 1:
			print('Ayush')
		else:
			rem = (n - 1 - 2) % 2
			if rem == 0:
				print('Ashish')
			else:
				print('Ayush')
py2 = round(0.5)
if py2:
	from future_builtins import ascii, filter, hex, map, oct, zip
	range = xrange
import os, sys
from io import IOBase, BytesIO
BUFSIZE = 8192

class FastIO(BytesIO):
	newlines = 0

	def __init__(self, file):
		self._file = file
		self._fd = file.fileno()
		self.writable = 'x' in file.mode or 'w' in file.mode
		self.write = super(FastIO, self).write if self.writable else None

	def _fill(self):
		s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
		self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
		return s

	def read(self):
		while self._fill():
			pass
		return super(FastIO, self).read()

	def readline(self):
		while self.newlines == 0:
			s = self._fill()
			self.newlines = s.count(b'\n') + (not s)
		self.newlines -= 1
		return super(FastIO, self).readline()

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		if py2:
			self.write = self.buffer.write
			self.read = self.buffer.read
			self.readline = self.buffer.readline
		else:
			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')
main()


T = int(input())
for _ in range(T):
	(n, x) = map(int, input().split())
	count = 0
	for _ in range(n - 1):
		(p, q) = map(int, input().split())
		if p == x or q == x:
			count += 1
	if count <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	elif n % 2 != 0:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = [int(i) for i in input().split()]
	degree = 0
	for i in range(n - 1):
		(x1, y) = [int(i) for i in input().split()]
		if x1 == x or y == x:
			degree += 1
	if degree <= 1:
		print('Ayush')
	elif (n - 3) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
results = []
for case in range(t):
	(n, x) = map(int, input().split())
	xd = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		xd += int(a == x or b == x)
	ans = 'Ayush'
	if xd > 1:
		if n % 2 == 1:
			ans = 'Ashish'
	results.append(ans)
for result in results:
	print(result)


T = int(input())

def dfs(D, edges, n, curr):
	if D[n] != -1:
		return
	D[n] = curr
	for neighbour in edges[n]:
		dfs(D, edges, neighbour, curr + 1)
for t in range(T):
	(N, x) = [int(_) for _ in input().split()]
	x -= 1
	edges = [[] for _ in range(N)]
	for i in range(N - 1):
		(u, v) = [int(_) for _ in input().split()]
		edges[u - 1].append(v - 1)
		edges[v - 1].append(u - 1)
	if len(edges[x]) <= 1:
		print('Ayush')
	else:
		D = [-1] * N
		dfs(D, edges, x, 0)
		nb_greater_2 = len([el for el in D if el >= 2])
		nb_1 = len([el for el in D if el == 1])
		if nb_greater_2 % 2:
			if nb_1 % 2:
				print('Ashish')
			else:
				print('Ayush')
		elif nb_1 % 2:
			print('Ayush')
		else:
			print('Ashish')


import sys
input = sys.stdin.readline
from math import ceil, floor

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0):
	hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	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 swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(1000000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
for _ in range(int(input())):
	(n, x) = int_array()
	graph = [[] for _ in range(n + 1)]
	for __ in range(n - 1):
		(a, b) = int_array()
		graph[a].append(b)
		graph[b].append(a)
	num = len(graph[x])
	if num <= 1:
		print('Ayush')
	elif (n - 3) % 2 != 0:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	s = sum((x in map(int, input().split()) for _ in range(n - 1)))
	print('Ayush' if s <= 1 or n % 2 == 0 else 'Ashish')


import sys
from collections import defaultdict as dd
import heapq
import math
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = sys.stdin.readline
import queue

def printLevels(graph, V, x):
	level = [None] * V
	marked = [False] * V
	que = queue.Queue()
	que.put(x)
	level[x] = 0
	marked[x] = True
	while not que.empty():
		x = que.get()
		for i in range(len(graph[x])):
			b = graph[x][i]
			if not marked[b]:
				que.put(b)
				level[b] = level[x] + 1
				marked[b] = True
	return level
for i in range(int(input())):
	(n, x) = map(int, input().split())
	g = [[] for j in range(n)]
	for j in range(n - 1):
		(e, r) = map(int, input().split())
		g[e - 1].append(r - 1)
		g[r - 1].append(e - 1)
	for k in range(n):
		if len(g[k]) > 1:
			l = k
			break
	t = printLevels(g, n, x - 1)
	t = sorted(t)
	p = 0
	for k in t:
		if k == 0 or k == 1:
			p += 1
		else:
			break
	if len(g[x - 1]) > 1 and n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


from sys import stdin, stdout
for i in range(int(input())):
	(n, x) = map(int, input().split())
	l = [[] for i in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		l[u - 1].append(v - 1)
		l[v - 1].append(u - 1)
	le = len(l[x - 1])
	if le == 0 or le == 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for x in range(t):
	[n, x] = list(map(int, input().split()))
	if n == 1:
		print('Ayush')
		continue
	dd = {}
	count = []
	count.append(0)
	l = [False] * (n + 1)
	for i in range(n - 1):
		temp = list(map(int, input().split()))
		if not l[temp[0]]:
			dd[temp[0]] = [temp[1]]
			l[temp[0]] = True
		else:
			dd[temp[0]].append(temp[1])
		if not l[temp[1]]:
			dd[temp[1]] = [temp[0]]
			l[temp[1]] = True
		else:
			dd[temp[1]].append(temp[0])
	if len(dd[x]) == 1:
		print('Ayush')
		continue
	if n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


from sys import stdin
input = stdin.readline
for __ in range(int(input())):
	(n, root) = map(int, input().split())
	cnt = 0
	for _ in range(n - 1):
		t = [int(x) for x in input().split()]
		if root in t:
			cnt += 1
	if n <= 2 or cnt == 1:
		print('Ayush')
		continue
	print('Ashish' if n % 2 else 'Ayush')


ipnl = lambda n: [int(input()) for _ in range(n)]
inp = lambda : int(input())
ip = lambda : [int(w) for w in input().split()]
for _ in range(inp()):
	(n, node) = ip()
	graph = {i: [] for i in range(1, n + 1)}
	for i in range(n - 1):
		(a, b) = ip()
		graph[a].append(b)
		graph[b].append(a)
	if len(graph[node]) == 1 or n <= 2:
		print('Ayush')
		continue
	t = n - 2
	if t % 2:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for _ in range(t):
	(n, X) = [int(x) for x in input().split()]
	deg = 0
	for _ in range(n - 1):
		(x, y) = [int(x) for x in input().split()]
		if x == X or y == X:
			deg += 1
	if deg <= 1:
		winner = 'Ayush'
	elif (n - 3) % 2 == 0:
		winner = 'Ashish'
	elif (n - 3) % 2 == 1:
		winner = 'Ayush'
	print(winner)


import random
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	deg = [0] * n
	dic = {}
	turn = 0
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		deg[u - 1] += 1
		deg[v - 1] += 1
		if u in dic:
			dic[u].append(v)
		else:
			dic[u] = [v]
		if v in dic:
			dic[v].append(u)
		else:
			dic[v] = [u]
	one = set()
	for i in range(n):
		if deg[i] == 1:
			one.add(i + 1)
	if n == 1 or n == 2:
		print('Ayush')
	else:
		while deg[x - 1] != 1:
			turn += 1
			while 1:
				node = random.sample(one, 1)[0]
				Node = dic[node][0]
				if n != 3:
					if Node != x or deg[x - 1] > 2:
						deg[node - 1] -= 1
						deg[Node - 1] -= 1
						one.discard(node)
						if deg[Node - 1] == 1:
							one.add(Node)
						n -= 1
						dic[Node].remove(node)
						dic[node] = []
						break
					continue
				deg[x - 1] = 1
				break
		if turn % 2:
			print('Ashish')
		else:
			print('Ayush')


t = int(input())
for _ in range(t):
	(n, X) = [int(x) for x in input().split()]
	ctr = 0
	for i in range(n - 1):
		(u, v) = [int(x) for x in input().split()]
		if u == X or v == X:
			ctr += 1
	if ctr == 1:
		print('Ayush')
	elif n == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


testing_mode = True
import sys, traceback
test_data = ''
final_output = ''

def input(input_format=0, multi=0):
	if multi > 0:
		return [input(input_format) for x in range(multi)]
	else:
		next_line = next(test_data, None).strip() if test_data else sys.stdin.readline()
		if input_format == 0:
			formatted_input = [next_line]
		elif input_format == 1:
			formatted_input = list(map(int, next_line.split()))
		elif input_format == 2:
			formatted_input = list(map(float, next_line.split()))
		elif input_format == 3:
			formatted_input = next_line.split()
		elif input_format == 4:
			formatted_input = (lambda x: [x[0], list(map(int, x[1:]))])(next_line.split())
		elif input_format == 5:
			formatted_input = (lambda x: [x[0], list(map(float, x[1:]))])(next_line.split())
		else:
			formatted_input = [next_line]
		return formatted_input

def log(*args):
	if testing_mode:
		print(*args)

def out(output_line, output_format=0, newline=True):
	global final_output
	formatted_output = ''
	if output_format == 0:
		formatted_output = str(output_line)
	elif output_format == 1:
		formatted_output = ' '.join(map(str, output_line))
	elif output_format == 1:
		formatted_output = '\n'.join(map(str, output_line))
	if testing_mode:
		final_output += formatted_output + '\n' * newline
	else:
		print(formatted_output, end='\n' if newline else '')
test_inputs = ['\n1\n3 1\n2 1\n3 1\n\n', '\n1\n3 2\n1 2\n1 3\n\n', '\n1\n6 4\n1 5\n2 4\n3 4\n4 5\n5 6\n', '\n$$$\n']
test_outputs = ['\nAshish\n\n', '\nAyush\n\n', '\nAyush\n', '\n$$$\n']

def solve():
	for z in range(input(1)[0]):
		(n, x) = input(1)
		t = []
		for i in range(n + 1):
			t.append([])
		for i in range(n - 1):
			(a, b) = input(1)
			t[a].append(b)
			t[b].append(a)
		if n == 1:
			out('Ayush')
		elif len(t[x]) == 1:
			out('Ayush')
		elif n % 2 == 1:
			out('Ashish')
		else:
			out('Ayush')
		log(t)
	return

def run_all(overwrite_testing=False):
	global testing_mode, final_output, test_data
	testing_mode = overwrite_testing and testing_mode
	if testing_mode:
		tests_failed = 0
		for (test_number, (test_in, test_out)) in enumerate(zip(test_inputs, test_outputs)):
			final_output = ''
			if test_in.lstrip()[:3] == '$$$':
				continue
			test_data = iter([i for i in test_in.split('\n') if i])
			print(f'Test Case #{test_number + 1}:')
			print('<' * 20)
			fail = False
			verdict = '\x1b[92m\x1b[1mPASS\x1b[0m'
			try:
				solve()
				final = final_output.rstrip('\n')
				raw_out = iter(map(str, final.split('\n'))) if final else iter(())
			except Exception:
				raw_out = ''
				fail = True
				print('\x1b[95m')
				traceback.print_exc()
				print('\x1b[0m')
			if raw_out:
				if test_out.lstrip()[:3] == '$$$':
					verdict = '\x1b[94m\x1b[1mSKIP\x1b[0m'
					print('\x1b[94m' + '\n'.join(list(raw_out)) + '\x1b[0m')
				else:
					for line_out in [i for i in test_out.split('\n') if i]:
						line_raw = next(raw_out, '% None %')
						if line_raw == line_out.strip():
							print(f'\x1b[92m{line_raw}\x1b[0m')
						else:
							print(f'\x1b[91m{line_raw}\x1b[0m')
							fail = True
					line_raw = next(raw_out, None)
					while line_raw:
						print(f'\x1b[91m{line_raw}\x1b[0m')
						line_raw = next(raw_out, None)
						fail = True
			print('>' * 20)
			if fail:
				verdict = '\x1b[91m\x1b[1mFAIL\x1b[0m'
				tests_failed += 1
			print(verdict + '\n')
		if tests_failed:
			print(f"\x1b[91m\x1b[1m{tests_failed} TEST{('S' if tests_failed > 1 else '')} FAILED!\x1b[0m")
		else:
			print(f'\x1b[92m\x1b[1mALL TESTS PASSED!\x1b[0m')
	else:
		test_data = False
		solve()
run_all(False)


import sys
input = sys.stdin.readline
for i in range(int(input())):
	(n, x) = map(int, input().split())
	s = 0
	for i in range(n - 1):
		num = map(int, input().split())
		if x in num:
			s += 1
	if s <= 1 or (n - 3) % 2:
		print('Ayush')
	else:
		print('Ashish')


import sys
import math
from collections import defaultdict, deque
import heapq
t = int(sys.stdin.readline())
for _ in range(t):
	(n, x) = map(int, sys.stdin.readline().split())
	tree = defaultdict(list)
	for i in range(n - 1):
		(u, v) = map(int, sys.stdin.readline().split())
		tree[u].append(v)
		tree[v].append(u)
	if n == 1:
		print('Ayush')
		continue
	q = deque()
	dis = 0
	vis = defaultdict(int)
	for i in tree[x]:
		q.append(i)
		vis[i] = 1
	if len(tree[x]) == 1:
		print('Ayush')
		continue
	vis[x] = 1
	while q:
		cur = q.popleft()
		for a in tree[cur]:
			if vis[a] == 0:
				vis[a] += 1
				q.append(a)
				dis += 1
	l = len(tree[x])
	if dis % 2 == 0:
		turn = 'Ayush'
	else:
		turn = 'Ashish'
	if l % 2 == 0:
		if turn == 'Ashish':
			turn = 'Ayush'
		else:
			turn = 'Ashish'
	print(turn)


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	u = []
	for i in range(n - 1):
		(U, V) = map(int, input().split())
		u.append(U)
		u.append(V)
	if u.count(x) < 2:
		print('Ayush')
	elif n % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict
T = int(input())
FIRST_PLAYER = 'Ayush'
SECOND_PLAYER = 'Ashish'

def ans(neighbours, x, n):
	if len(neighbours[x]) <= 1:
		return FIRST_PLAYER
	assert n >= 3
	n -= 3
	if n % 2 == 0:
		return SECOND_PLAYER
	return FIRST_PLAYER
for t in range(T):
	(n, x) = input().split(' ')
	(x, n) = (int(x), int(n))
	neighbours = defaultdict(set)
	for _ in range(n - 1):
		(u, v) = input().split(' ')
		(u, v) = (int(u), int(v))
		neighbours[u].add(v)
		neighbours[v].add(u)
	print(ans(neighbours, x, n))


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	f = list()
	for i in range(n - 1):
		f.append(set(map(int, input().split())))
	front = {x}
	n_front = set()
	for p in f[:]:
		c = front & p
		if c:
			n_front.add((p - c).pop())
			f.remove(p)
	front = n_front
	if len(front) <= 1:
		print('Ayush')
		continue
	if (n - 1) % 2:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin, stdout

def game_on_leaves(dic, x):
	if x not in dic or len(dic[x]) == 1:
		return 'Ayush'
	res = (count_nodes(dic, x, -1) - 1) % 2
	if res > 0:
		return 'Ayush'
	else:
		return 'Ashish'

def count_nodes(dic, node, parent):
	res = 0
	for i in dic[node]:
		if i != parent:
			res += count_nodes(dic, i, node)
	return res + 1
t = int(stdin.readline())
for i in range(t):
	dic = {}
	(n, x) = list(map(int, stdin.readline().split()))
	for j in range(n - 1):
		(u, v) = list(map(int, stdin.readline().split()))
		if u not in dic:
			dic[u] = []
		if v not in dic:
			dic[v] = []
		dic[u].append(v)
		dic[v].append(u)
	stdout.write(str(game_on_leaves(dic, x)) + '\n')


def dfs(u):
	vis[u] = 1
	count[u] = 1
	for v in edges[u]:
		if v != x and (not vis[v]):
			dfs(v)
			count[u] += count[v]
t = int(input())
for _ in range(0, t):
	cnt = 0
	(n, x) = map(int, input().split())
	x -= 1
	edges = [[] for i in range(0, n)]
	count = [0] * n
	for _ in range(0, n - 1):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		edges[u].append(v)
		edges[v].append(u)
	if len(edges[x]) <= 1:
		print('Ayush')
	else:
		vis = [0] * n
		cnt = 0
		for neighbours in edges[x]:
			if len(edges[neighbours]) == 1:
				continue
			dfs(neighbours)
		for neighbours in edges[x]:
			if count[neighbours] > 0:
				cnt += count[neighbours]
			else:
				cnt += 1
		print(['Ashish', 'Ayush'][cnt % 2])


def dfs(v):
	global graph, distances, weights
	weights[v] = 1
	for u in graph[v]:
		if distances[u] != -1:
			continue
		distances[u] = distances[v] + 1
		dfs(u)
		weights[v] += weights[u]
for _ in range(int(input())):
	(n, x) = tuple(map(int, input().split()))
	x -= 1
	if n == 1:
		print('Ayush')
		continue
	graph = [[] for _ in range(n)]
	for _ in range(n - 1):
		(a, b) = tuple(map(int, input().split()))
		a -= 1
		b -= 1
		graph[a].append(b)
		graph[b].append(a)
	if len(graph[x]) == 1:
		print('Ayush')
		continue
	distances = [-1 for _ in range(n)]
	distances[x] = 0
	weights = [0 for _ in range(n)]
	dfs(x)
	cnt = 0
	for v in graph[x]:
		if weights[v] % 2 == 1:
			cnt += 1
	if cnt % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin, stdout

def main():
	t = int(stdin.readline())
	for _ in range(t):
		(n, x) = list(map(int, stdin.readline().split()))
		tree = [list() for _ in range(n + 1)]
		for i in range(n - 1):
			(a, b) = list(map(int, stdin.readline().split()))
			tree[a].append(b)
			tree[b].append(a)
		stack = [x]
		visited = [False] * (n + 1)
		visited[x] = True
		count = 0
		while stack:
			cur = stack[-1]
			processed = True
			for child in tree[cur]:
				if visited[child]:
					continue
				processed = False
				visited[child] = True
				stack.append(child)
				count += 1
			if processed:
				stack.pop()
			else:
				pass
		if count % 2 == 1 or count == 0 or len(tree[x]) <= 1:
			stdout.write('Ayush\n')
		else:
			stdout.write('Ashish\n')
main()


import sys
readline = sys.stdin.readline
T = int(readline())
Ans = [None] * T
for qu in range(T):
	(N, X) = map(int, readline().split())
	X -= 1
	Edge = [[] for _ in range(N)]
	Dim = [0] * N
	for _ in range(N - 1):
		(u, v) = map(int, readline().split())
		u -= 1
		v -= 1
		Dim[u] += 1
		Dim[v] += 1
		Edge[u].append(v)
		Edge[v].append(u)
	if Dim[X] <= 1:
		Ans[qu] = 'Ayush'
		continue
	dist = [0] * N
	stack = [X]
	used = set([X])
	while stack:
		vn = stack.pop()
		for vf in Edge[vn]:
			if vf not in used:
				dist[vf] = 1 + dist[vn]
				used.add(vf)
				stack.append(vf)
	parity = 0
	one = 0
	for i in range(N):
		if dist[i] >= 2:
			parity += 1
		if dist[i] == 1:
			one += 1
	Ans[qu] = 'Ashish' if (parity + one) % 2 == 0 else 'Ayush'
print('\n'.join(Ans))


from collections import Counter
import math
import sys
from bisect import bisect, bisect_left, bisect_right

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

def INT():
	return int(input())

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

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def mod():
	return 10 ** 9 + 7
for _ in range(INT()):
	(n, x) = MAP()
	if n == 1:
		print('Ayush')
	else:
		d = [0 for i in range(n)]
		for i in range(n - 1):
			(u, v) = MAP()
			d[u - 1] += 1
			d[v - 1] += 1
		if d[x - 1] == 1:
			print('Ayush')
		elif n % 2 != 0:
			print('Ashish')
		else:
			print('Ayush')


import sys
import os
if os.environ.get('DEBUGSTER_PYTHON'):
	sys.stdin = open('in.txt', 'r')
	sys.stdout = open('out.txt', 'w')
MAX = 1005
Ayush = False
Ashish = True
adjList = dict()
deg = dict()
tempDeg = dict()

def copyDeg(n):
	for i in range(n):
		tempDeg[i] = deg[i]
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	x -= 1
	adjList.clear()
	deg.clear()
	tempDeg.clear()
	for i in range(n):
		adjList[i] = list()
		deg[i] = tempDeg[i] = 0
	for i in range(1, n):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		adjList[u].append(v)
		adjList[v].append(u)
		deg[u] += 1
		deg[v] += 1
	remain = list()
	degOne = list()
	for i in range(n):
		remain.append(i)
	turn = Ayush
	win = False
	f = False
	cut = -1
	while True:
		degOne.clear()
		for u in remain:
			if deg[u] == 1:
				degOne.append(u)
		if len(degOne) == 0:
			break
		f = False
		for u in degOne:
			copyDeg(n)
			for v in adjList[u]:
				tempDeg[v] -= 1
			tempDeg[u] = 0
			if tempDeg[x] == 0:
				win = True
				break
			elif tempDeg[x] == 1:
				pass
			else:
				cut = u
				degOne.remove(u)
				f = True
				break
		if win:
			break
		if f:
			for v in adjList[cut]:
				deg[v] -= 1
				adjList[v].remove(cut)
				remain.remove(cut)
			adjList[cut].clear()
			deg[cut] = 0
			turn = not turn
		else:
			turn = not turn
			win = True
			break
	if not turn:
		print('Ayush')
	else:
		print('Ashish')


from sys import *
input = stdin.readline
for _ in range(int(input())):
	(n, s) = map(int, input().split())
	sp = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if s == a or s == b:
			sp += 1
	if sp <= 1 or (n - 1) % 2:
		print('Ayush')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline

def prog():
	for _ in range(int(input())):
		(n, x) = map(int, input().split())
		x_neighbors = set()
		for i in range(n - 1):
			(a, b) = map(int, input().split())
			if a == x:
				x_neighbors.add(b)
			if b == x:
				x_neighbors.add(a)
		if n == 1:
			print('Ayush')
		elif len(x_neighbors) == 1:
			print('Ayush')
		elif (n - 1) % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')
prog()


from collections import defaultdict
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	graph = defaultdict(list)
	if n == 1:
		print('Ayush')
		continue
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		graph[u].append(v)
		graph[v].append(u)
	if len(graph[k]) == 1:
		print('Ayush')
		continue
	if n % 2 == 0:
		print('Ayush')
		continue
	print('Ashish')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	m = {}
	ans = []
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		m[a] = 0
		m[b] = 0
		ans.append(a)
		ans.append(b)
	for i in ans:
		m[i] += 1
	if n == 1 or m[x] == 1:
		print('Ayush')
	elif (n - 2) % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
sys.setrecursionlimit(10 ** 8)
T = int(input())
for _ in range(T):
	(N, X) = map(int, input().split())
	X -= 1
	UV = [tuple(map(int, input().split())) for i in range(N - 1)]
	es = [[] for _ in range(N)]
	for (u, v) in UV:
		(u, v) = (u - 1, v - 1)
		es[u].append(v)
		es[v].append(u)
	if len(es[X]) == 1:
		print('Ayush')
		continue
	ch = [0] * N

	def dfs(v, p=-1):
		if len(es[v]) == 1:
			ch[v] = 1
			return 1
		c = 1
		for to in es[v]:
			if to == p:
				continue
			c += dfs(to, v)
		ch[v] = c
		return c
	dfs(X)
	odd = even = 0
	for to in es[X]:
		if ch[to] % 2:
			odd += 1
		else:
			even += 1
	if odd <= 1 and even <= 1:
		print('Ayush')
		continue
	print('Ashish' if odd % 2 == 0 else 'Ayush')


def degree(x, edges):
	return len([edge for edge in edges if x in edge])

def solve(n, x, edges):
	d = degree(x, edges)
	if d <= 1 or n % 2 == 0:
		return 'Ayush'
	return 'Ashish'
numberofcases = int(input())
for _ in range(numberofcases):
	(n, x) = [int(t) for t in input().split()]
	edges = []
	for _ in range(n - 1):
		edges.append([int(t) for t in input().split()])
	print(solve(n, x, edges))


from collections import Counter
T = int(input().strip())
for t in range(T):
	hh = Counter()
	(n, x) = list(map(int, input().split()))
	for i in range(n - 1):
		(a, b) = list(map(int, input().split()))
		hh[a] += 1
		hh[b] += 1
	if hh[x] <= 1:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


for t in range(int(input())):
	(n, x) = (int(i) for i in input().split(' '))
	edges = set()
	iedges = set()
	for i in range(n - 1):
		(e0, e1) = (int(i) for i in input().split(' '))
		if e0 == x:
			iedges.add(e1)
		elif e1 == x:
			iedges.add(e0)
		edges.add(e0)
		edges.add(e1)
	if len(iedges) == 1:
		print('Ayush')
	else:
		print(['Ayush', 'Ashish'][len(edges) % 2])


def win(n, x):
	if n == 1:
		return 'Ayush'
	deg = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			deg += 1
	if deg == 1:
		return 'Ayush'
	return ['Ayush', 'Ashish'][n % 2]
t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	print(win(n, x))


from sys import stdin
input = stdin.readline
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	nbr = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		nbr[a].append(b)
		nbr[b].append(a)
	if n == 1:
		print('Ayush')
	elif len(nbr[x]) == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from sys import setrecursionlimit

def dfs(now, prev):
	summ = 1
	for j in tree[now]:
		if j != prev:
			summ += dfs(j, now)
	return summ
setrecursionlimit(100000)
t = int(input())
ans = []
for i in range(t):
	(n, x) = map(int, input().split())
	tree = [[] for j in range(n)]
	for j in range(n - 1):
		(u1, u2) = map(int, input().split())
		tree[u1 - 1].append(u2 - 1)
		tree[u2 - 1].append(u1 - 1)
	if len(tree[x - 1]) <= 1:
		ans.append('Ayush')
	elif dfs(x - 1, -1) % 2 == 0:
		ans.append('Ayush')
	else:
		ans.append('Ashish')
for i in ans:
	print(i)


from collections import deque

def bfs(root):
	vis = [0] * n
	queue = [root]
	queue = deque(queue)
	while len(queue) != 0:
		e = queue.popleft()
		vis[e] = 1
		for i in graph[e]:
			if vis[i] == 0:
				queue.append(i)
				vis[i] = 1
for nt in range(int(input())):
	(n, x) = map(int, input().split())
	x -= 1
	graph = [[] for i in range(n)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		graph[a - 1].append(b - 1)
		graph[b - 1].append(a - 1)
	bfs(x)
	count = len(graph[x])
	if count <= 1:
		print('Ayush')
		continue
	left = n - (count + 1)
	if left % 2:
		turn = 1
	else:
		turn = 0
	if count % 2:
		if turn == 1:
			print('Ashish')
		else:
			print('Ayush')
	elif turn == 0:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
while t:
	t = t - 1
	(n, x) = map(int, input().split())
	l = []
	leaf = 0
	for w in range(n - 1):
		edge = list(map(int, input().split()))
		(u, v) = (edge[0], edge[1])
		if v == x or u == x:
			leaf += 1
		l.append(edge)
	if n == 1:
		print('Ayush')
	elif leaf == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = list(map(int, input().split()))
	degree = set()
	for __ in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x:
			degree.add(v)
		if v == x:
			degree.add(u)
	if len(degree) <= 1:
		print('Ayush')
	elif (n - 3) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	v = 0
	if n == 1:
		print('Ayush')
	else:
		for i in range(n - 1):
			(a, b) = map(int, input().split())
			if a == x or b == x:
				v = v + 1
		if v != 1:
			mv = n - 1
		else:
			mv = 1
		if mv % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


t = int(input())
for ab in range(t):
	(n, x) = list(map(int, input().split()))
	al = [0] * (n + 1)
	for ty in range(n - 1):
		tt = list(map(int, input().split()))
		al[tt[0]] += 1
		al[tt[1]] += 1
	if al[x] == 1 or al[x] == 0:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	adj = {}
	ht = [1000000000.0] * (n + 1)
	ht[x] = 0
	for i in range(1, n + 1):
		adj[i] = []
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		adj[u].append(v)
		adj[v].append(u)
	leaf_nodes = []
	for i in range(1, n + 1):
		if len(adj[i]) <= 1:
			leaf_nodes.append(i)

	def get_dist(s, h):
		ht[s] = min(ht[s], h)
		if ht[s] == h:
			for i in adj[s]:
				get_dist(i, ht[s] + 1)
		return
	ht_leaf_nodes = []
	get_dist(x, 0)
	for i in leaf_nodes:
		ht_leaf_nodes.append(ht[i])
	if x in leaf_nodes:
		print('Ayush')
	else:
		s = sum(ht_leaf_nodes)
		if (n - 1) % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


for _ in range(int(input())):
	(n, x) = map(int, input().strip().split())
	dc = 0
	for _ in range(1, n):
		(u, v) = map(int, input().strip().split())
		if u == x or v == x:
			dc += 1
	if dc <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, tar) = map(int, input().split())
	tr = [0 for i in range(n + 1)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		tr[a] += 1
		tr[b] += 1
	if tr[tar] <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, x) = list(map(int, input().split()))
	neighbors = [[] for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = list(map(int, input().split()))
		neighbors[u - 1].append(v - 1)
		neighbors[v - 1].append(u - 1)
	x -= 1
	if len(neighbors[x]) < 2:
		print('Ayush')
		continue
	if n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
while t != 0:
	(n, k) = map(int, input().split())
	dicto = {}
	for i in range(n):
		dicto[i + 1] = []
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		dicto[a].append(b)
		dicto[b].append(a)
	visited = [0] * n
	stack = []
	count = 0
	temp = []
	for i in range(len(dicto[k])):
		temp.append([len(dicto[dicto[k][i]]), dicto[k][i]])
	temp.sort(key=lambda x: x[0])
	for i in range(len(temp) - 1):
		if visited[temp[i][0] - 1] == 0:
			stack.append(temp[i][0])
			count += 1
			visited[temp[i][0] - 1] = 1
	while len(stack) > 0:
		p = stack.pop()
		for i in range(len(dicto[p])):
			if visited[dicto[p][i] - 1] == 0:
				stack.append(dicto[p][i])
				count += 1
				visited[dicto[p][i] - 1] = 1
	if count % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')
	t -= 1


from collections import defaultdict
t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	f = 0
	g = defaultdict(list)
	for j in range(n - 1):
		(u, v) = map(int, input().split())
		g[u].append(v)
		g[v].append(u)
	if n == 1 or len(g[x]) == 1:
		f = 1
	elif (n - 1) % 2 == 0:
		f = 0
	else:
		f = 1
	if f == 1:
		print('Ayush')
	else:
		print('Ashish')


import sys

def answer(n, x, u, v):
	adj_list = [[] for _ in range(n + 1)]
	visited = [False for _ in range(n + 1)]
	for i in range(n - 1):
		adj_list[u[i]].append(v[i])
		adj_list[v[i]].append(u[i])
	if len(adj_list[x]) <= 1:
		return 'Ayush'
	if n % 2 == 0:
		return 'Ayush'
	return 'Ashish'

def main():
	t = int(sys.stdin.readline())
	while t:
		(n, x) = map(int, sys.stdin.readline().split())
		u = [0 for _ in range(n - 1)]
		v = [0 for _ in range(n - 1)]
		for i in range(n - 1):
			(u[i], v[i]) = map(int, sys.stdin.readline().split())
		print(answer(n, x, u, v))
		t -= 1
	return
main()


import bisect
import sys
import math
input = sys.stdin.readline
from collections import defaultdict

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

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

def solve(case):
	[n, x] = inlt()
	edgs = n - 1
	adj = 0
	for i in range(n - 1):
		[u, v] = inlt()
		if u == x or v == x:
			adj += 1
	if adj <= 1:
		return 'Ayush'
	if (edgs - 2) % 2 == 0:
		return 'Ashish'
	else:
		return 'Ayush'
if len(sys.argv) > 1 and sys.argv[1].startswith('input'):
	f = open('./' + sys.argv[1], 'r')
	input = f.readline
T = inp()
for i in range(T):
	res = solve(i + 1)
	print(str(res))


for i in range(int(input())):
	(n, x) = map(int, input().split())
	deg_x = 0
	for j in range(n - 1):
		(temp1, temp2) = map(int, input().split())
		if temp1 == x or temp2 == x:
			deg_x += 1
	if deg_x <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
from functools import reduce
read = sys.stdin.buffer.readline
mi = lambda : map(int, read().split())
cin = lambda : int(read())
for _ in range(cin()):
	(n, x) = mi()
	deg = [0] * (n + 1)
	for i in range(n - 1):
		(u, v) = mi()
		deg[u] += 1
		deg[v] += 1
	if deg[x] == 1 or n == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


for cas in range(int(input())):
	(n, x) = map(int, input().split())
	dgr = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			dgr += 1
	if dgr <= 1:
		print('Ayush')
	elif (n - 3) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

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

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 19
MOD = 10 ** 9 + 7

def rec(u, prev):
	res = 0
	for v in nodes[u]:
		if v == prev:
			continue
		res += rec(v, u)
	cnt[u] = res + 1
	return res + 1
for _ in range(INT()):
	(N, K) = MAP()
	K -= 1
	nodes = [[] for i in range(N)]
	for i in range(N - 1):
		(a, b) = MAP()
		a -= 1
		b -= 1
		nodes[a].append(b)
		nodes[b].append(a)
	if len(nodes[K]) <= 1:
		print('Ayush')
		continue
	cnt = [0] * N
	rec(K, -1)
	ans = 0
	for v in nodes[K]:
		ans += cnt[v]
	if ans % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, x) = [int(i) for i in input().split()]
	x_deg = 0
	for j in range(n - 1):
		edge = [int(i) for i in input().split()]
		if edge[0] == x or edge[1] == x:
			x_deg += 1
	if n % 2 == 0 or n == 1 or x_deg == 1:
		print('Ayush')
	else:
		print('Ashish')


import sys
from collections import deque
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	tree = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		tree[a].append(b)
		tree[b].append(a)
	q = deque([x])
	d = [-1] * (n + 1)
	d[x] = 0
	while q:
		now = q.popleft()
		for next in tree[now]:
			if d[next] == -1:
				d[next] = d[now] + 1
				q.append(next)
	node = 0
	for i in range(1, n + 1):
		if d[i] >= 1:
			node += 1
	if len(tree[x]) <= 1:
		print('Ayush')
	elif node % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
	(n, x) = list(map(int, input().split()))
	ANS = 0
	for i in range(n - 1):
		(u, v) = list(map(int, input().split()))
		if u == x or v == x:
			ANS += 1
	if ANS <= 1:
		print('Ayush')
		continue
	if n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
sys.setrecursionlimit(10000)
T = int(input())

def traverse(node, parent, dp, X, dd):
	result = 1
	if node not in dd:
		return result
	for neighbour in dd[node]:
		if neighbour != parent:
			now = traverse(neighbour, node, dp, X, dd)
			if node == X:
				dp.append(now)
			result += now
	return result
for _ in range(T):
	(N, X) = map(int, input().split())
	dd = {}
	for _ in range(N - 1):
		(u, v) = map(int, input().split())
		if u not in dd:
			dd[u] = []
		if v not in dd:
			dd[v] = []
		dd[u].append(v)
		dd[v].append(u)
	dp = []
	traverse(X, None, dp, X, dd)
	if len(dp) == 1:
		print('Ayush')
	elif len(dp) == 0:
		print('Ayush')
	else:
		som = sum(dp)
		if som % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


from collections import defaultdict

def dfs(u, graph, prev):
	size = 0
	for v in graph[u]:
		if v != prev:
			size += 1 + dfs(v, graph, u)
	return size

def solve():
	(n, x) = [int(x) for x in input().split()]
	graph = defaultdict(list)
	for _ in range(n - 1):
		(u, v) = [int(x) for x in input().split()]
		graph[u].append(v)
		graph[v].append(u)
	if len(graph[x]) <= 1:
		return 0
	subtrees = []
	for v in graph[x]:
		subtrees.append(1 + dfs(v, graph, x))
	total = sum(subtrees)
	return (total - 1) % 2
T = int(input())
players = ['Ayush', 'Ashish']
for case in range(T):
	print(players[solve()])


t = int(input())
while t != 0:
	t -= 1
	(n, x) = map(int, input().split())
	if n == 1:
		print('Ayush')
	else:
		lt = [[] for _ in range(n)]
		for _ in range(n - 1):
			(a, b) = map(int, input().split())
			(a, b) = (a - 1, b - 1)
			lt[a].append(b)
			lt[b].append(a)
		if len(lt[x - 1]) == 1:
			print('Ayush')
		elif n % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')


import sys, math, itertools, collections, copy
input = sys.stdin.readline
adj = []

def dfs(vertex, vis, ans):
	vis[vertex] = True
	ans += 1
	for u in adj[vertex]:
		if not vis[u]:
			ans += dfs(u, vis, 0)
	return ans

def solve():
	global adj
	adj = []
	(n, x) = map(int, input().split())
	adj = [[] for i in range(n)]
	cnt = 0
	x -= 1
	vis = [False] * n
	vis[x] = True
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		(u, v) = (u - 1, v - 1)
		adj[u].append(v)
		adj[v].append(u)
	if len(adj[x]) <= 1:
		print('Ayush')
		return
	for ver in adj[x]:
		if not vis[ver]:
			cnt += dfs(ver, vis, 0)
	if cnt & 1:
		print('Ayush')
	else:
		print('Ashish')
for _ in range(int(input())):
	solve()


import sys

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

def readInts():
	return list(map(int, readStr().split(' ')))
(t,) = readInts()
for i in range(t):
	(n, x) = readInts()
	c = 0
	for j in range(n - 1):
		(u, v) = readInts()
		if u == x or v == x:
			c += 1
	if c <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, f) = map(int, input().split())
	st = 0
	for i in range(n - 1):
		(x, y) = map(int, input().split())
		if x == f or y == f:
			st += 1
	if n % 2 == 0 or st < 2:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	if n == 1:
		print('Ayush')
	else:
		d = {}
		for j in range(n - 1):
			(a, b) = map(int, input().split())
			if a in d:
				d[a] += 1
			else:
				d[a] = 1
			if b in d:
				d[b] += 1
			else:
				d[b] = 1
		if d[x] == 1:
			print('Ayush')
		elif n % 2 != 0:
			print('Ashish')
		else:
			print('Ayush')


t = int(input())
while t:
	x = input().split()
	(n, x) = (int(x[0]), int(x[1]))
	cnt = [0 for i in range(n + 1)]
	for i in range(n - 1):
		u = input().split()
		(u, v) = (int(u[0]), int(u[1]))
		cnt[u] += 1
		cnt[v] += 1
	if cnt[x] <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')
	t -= 1


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

def read_ints():
	return map(int, input().split(' '))
A_WIN = 'Ayush'
B_WIN = 'Ashish'
t = read_int()
for case_num in range(t):
	(n, x) = read_ints()
	adj = [[] for i in range(n + 1)]
	degree = [0 for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = read_ints()
		degree[u] += 1
		degree[v] += 1
	if degree[x] <= 1:
		print(A_WIN)
	else:
		print(A_WIN if n % 2 == 0 else B_WIN)


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	count = 0
	for i in range(n - 1):
		(xx, yy) = map(int, input().split())
		if xx == x or yy == x:
			count += 1
	if count < 2 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict, deque
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	adj = defaultdict(list)
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		adj[a].append(b)
		adj[b].append(a)
	if len(adj[x]) <= 1:
		print('Ayush')
	elif n & 1:
		print('Ashish')
	else:
		print('Ayush')


import sys
input = sys.stdin.buffer.readline

def main():
	t = int(input())
	from collections import deque
	for _ in range(t):
		(n, x) = map(int, input().split())
		x -= 1
		g = [[] for _ in range(n)]
		for i in range(n - 1):
			(u, v) = map(int, input().split())
			(u, v) = (u - 1, v - 1)
			g[u].append(v)
			g[v].append(u)
		if n == 1:
			print('Ayush')
			continue
		if len(g[x]) == 1:
			print('Ayush')
		elif (n - 2) % 2 == 1:
			print('Ashish')
		else:
			print('Ayush')
main()


for i in range(int(input())):
	(n, x) = map(int, input().split())
	d = [0] * 1234567
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		d[a] += 1
		d[b] += 1
	if d[x] <= 1:
		print('Ayush')
	elif n & 1:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for i in range(t):
	(n, x) = [int(m) for m in input().split()]
	depth = 0
	for j in range(n - 1):
		(a, b) = [int(m) for m in input().split()]
		if a == x or b == x:
			depth += 1
	if depth <= 1:
		print('Ayush')
	elif (n - 3) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


for _ in range(int(input())):
	count = 0
	countleaf = 0
	(n, x) = map(int, input().split())
	if n == 1:
		print('Ayush')
	else:
		for _ in range(n - 1):
			(one, two) = map(int, input().split())
			if one == x or two == x:
				countleaf += 1
			if one != x or two != x:
				count += 1
		if countleaf == 1:
			print('Ayush')
		elif count % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


import sys
import string
input = sys.stdin.readline
import math
from decimal import Decimal
t = int(input())
for i in range(t):
	(n, x) = input().split()
	(n, x) = (int(n), int(x))
	in_degree = 0
	for j in range(n - 1):
		(a, b) = input().split()
		(a, b) = (int(a), int(b))
		if a == x or b == x:
			in_degree += 1
	if (n - 1) % 2 == 1 or in_degree < 2:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange

def print_case_iterable(case_num, iterable):
	print('Case #{}: {}'.format(case_num, ' '.join(map(str, iterable))))

def print_case_number(case_num, iterable):
	print('Case #{}: {}'.format(case_num, iterable))

def print_iterable(A):
	print(' '.join(A))

def read_int():
	return int(f.readline().strip())

def read_int_array():
	return [int(x) for x in f.readline().strip().split(' ')]

def rns():
	a = [x for x in f.readline().split(' ')]
	return (int(a[0]), a[1].strip())

def read_string():
	return list(f.readline().strip())

def bi(x):
	return bin(x)[2:]
from collections import deque
import math
NUMBER = 10 ** 9 + 7

def factorial(n):
	M = NUMBER
	f = 1
	for i in range(1, n + 1):
		f = f * i % M
	return f

def mult(a, b):
	return a * b % NUMBER

def minus(a, b):
	return (a - b) % NUMBER

def plus(a, b):
	return (a + b) % NUMBER

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		(g, y, x) = egcd(b % a, a)
		return (g, x - b // a * y, y)

def modinv(a):
	m = NUMBER
	(g, x, y) = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m

def choose(n, k):
	if n < k:
		assert false
	return mult(factorial(n), modinv(mult(factorial(k), factorial(n - k))))
from collections import deque, defaultdict
import heapq

def solution(n, x, adj):
	if n == 1 or len(adj[x]) == 1 or (n - 2) % 2 == 0:
		return 'Ayush'
	return 'Ashish'

def main():
	T = read_int()
	for i in range(T):
		(n, x) = read_int_array()
		adj = defaultdict(list)
		for j in range(n - 1):
			(u, v) = read_int_array()
			adj[u].append(v)
			adj[v].append(u)
		x = solution(n, x, adj)
		if 'xrange' not in dir(__builtins__):
			print(x)
		else:
			(print >> output, str(x))
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()
if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()
main()


t = int(input())
for _ in range(t):
	(n, x) = list(map(int, input().split()))
	count = 0
	for _ in range(n - 1):
		(a, b) = list(map(int, input().split()))
		if a == x or b == x:
			count += 1
	if count <= 1:
		print('Ayush')
	elif (n - 2) % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import atexit
import io
import sys
import math
from collections import defaultdict, Counter

def add(u, v):
	l[u].append(v)
	l[v].append(u)
t = int(input())
for i in range(t):
	l = defaultdict(list)
	(n, x) = map(int, input().split())
	if n == 1:
		print('Ayush')
		continue
	for j in range(n - 1):
		(u, v) = map(int, input().split())
		add(u, v)
	if len(l[x]) == 1:
		print('Ayush')
	elif len(l[x]) == n - 1:
		if (n - 1) % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')
	elif n - len(l[x]) - 1 & 1:
		if len(l[x]) % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
	elif len(l[x]) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import sqrt, ceil, factorial, inf
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from decimal import Decimal
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
for _ in range(int(data())):
	(n, x) = sp()
	graph = dd(set)
	for i in range(n - 1):
		(u, v) = sp()
		graph[u].add(v)
		graph[v].add(u)
	if len(graph[x]) <= 1:
		out('Ayush')
		continue
	if n & 1:
		out('Ashish')
		continue
	out('Ayush')


import sys
from collections import defaultdict as dd
import heapq
import math
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = sys.stdin.readline
for i in range(int(input())):
	(n, x) = map(int, input().split())
	g = [[] for j in range(n)]
	for j in range(n - 1):
		(e, r) = map(int, input().split())
		g[e - 1].append(r - 1)
		g[r - 1].append(e - 1)
	if len(g[x - 1]) > 1 and n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


import sys
sys.setrecursionlimit(10 ** 6)
t = int(input())
for x in range(t):
	s = input()
	s1 = s.split()
	n = int(s1[0])
	x = int(s1[1])
	from collections import defaultdict
	g = defaultdict(list)
	for i in range(n - 1):
		s = input()
		s1 = s.split()
		g[int(s1[0])].append(int(s1[1]))
		g[int(s1[1])].append(int(s1[0]))
	visited = [False for i in range(n + 1)]
	cnt = 0

	def fun(i):
		global cnt
		visited[i] = True
		for j in g[i]:
			if visited[j] == False:
				cnt = cnt + 1
				fun(j)
	if len(g[x]) <= 1:
		print('Ayush')
	else:
		fun(x)
		for i in visited:
			if visited[i] == False:
				cnt = cnt + 1
		cnt = cnt - 1
		if cnt % 2 == 1:
			print('Ayush')
		else:
			print('Ashish')


from collections import defaultdict as dd
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	graph = dd(list)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		graph[u].append(v)
		graph[v].append(v)
	degree = [0 for x in range(n + 1)]
	for i in range(1, n + 1):
		degree[i] = len(graph[i])
	if n % 2 == 0 or degree[x] <= 1:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = input().split()
	x = int(x)
	n = int(n)
	y = 0
	for _ in range(n - 1):
		(u, v) = input().split()
		u = int(u)
		v = int(v)
		if u == x or v == x:
			y += 1
	if y <= 1 or (n - 1) % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin, stdout
from collections import deque
t = int(stdin.readline())
for _ in range(t):
	(n, special) = map(int, stdin.readline().strip().split())
	adj_list = dict()
	vis = dict()
	for i in range(n - 1):
		(n1, n2) = map(int, stdin.readline().strip().split())
		if adj_list.get(n1) == None:
			adj_list[n1] = []
		if vis.get(n1) == None:
			vis[n1] = False
		adj_list[n1].append(n2)
		if adj_list.get(n2) == None:
			adj_list[n2] = []
		if vis.get(n2) == None:
			vis[n2] = False
		adj_list[n2].append(n1)
	raj = deque()
	level = []
	raj.append((0, special))
	tot = 0
	while len(raj) != 0:
		x = raj.popleft()
		level.append(x)
		lvl = x[0]
		node = x[1]
		vis[node] = True
		if adj_list.get(node) != None:
			for i in adj_list[node]:
				if vis[i] == False:
					raj.append((lvl + 1, i))
					if lvl + 1 == 1:
						tot += 1
	level = sorted(level, reverse=True)
	flg = 0
	for i in level:
		lvl = i[0]
		node = i[1]
		if tot <= 1:
			break
		if lvl == 1:
			tot -= 1
		flg = not flg
	if flg == 0:
		print('Ayush')
	else:
		print('Ashish')


T = int(input())
for _ in range(T):
	(n, x) = list(map(int, input().split()))
	m = 0
	for i in range(n - 1):
		(u, v) = list(map(int, input().split()))
		if u == x or v == x:
			m += 1
	if m <= 1:
		ans = 'Ayush'
	else:
		ans = 'Ayush' if (n - 2) % 2 == 0 else 'Ashish'
	print(ans)


from sys import stdin
inp = lambda : stdin.readline().strip()
t = int(inp())
for _ in range(t):
	(n, x) = [int(x) for x in inp().split()]
	counter = 0
	for i in range(n - 1):
		(u, v) = [int(x) for x in inp().split()]
		if u == x or v == x:
			counter += 1
	ans = n - 2
	if ans <= 0 or counter < 2:
		print('Ayush')
	elif ans % 2:
		print('Ashish')
	else:
		print('Ayush')


test = int(input())
from collections import defaultdict

def dfs(c, p, level):
	level[c] = level[p] + 1
	for i in graph[c]:
		if i != p:
			dfs(i, c, level)
for i in range(test):
	(n, x) = [int(i) for i in input().split()]
	graph = defaultdict(list)
	level = [0] * (n + 1)
	for i in range(n - 1):
		(p, c) = [int(i) for i in input().split()]
		graph[p].append(c)
		graph[c].append(p)
	leaf = 0
	if len(graph[x]) == 1:
		leaf = 1
	else:
		leaf = 0
	if n == 1 or leaf:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


def readTree(n):
	adj = [set() for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		adj[u].add(v)
		adj[v].add(u)
	return adj

def solve():
	(n, x) = map(int, input().split())
	adj = readTree(n)
	if len(adj[x]) <= 1:
		print('Ayush ')
		return
	elif (n - 3) % 2 == 0:
		print('Ashish')
		return
	else:
		print('Ayush')
		return
t = int(input())
for i in range(t):
	solve()


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	ar = [0] * n
	for _ in range(n - 1):
		(t, v) = map(int, input().split())
		ar[t - 1] += 1
		ar[v - 1] += 1
	if ar[x - 1] <= 1:
		print('Ayush')
	else:
		print('Ayush' if not n % 2 else 'Ashish')


from math import *
t = int(input())

def solve():
	(n, s) = map(int, input().split())
	deg = [0 for _ in range(n)]
	s -= 1
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		deg[u] += 1
		deg[v] += 1
	if deg[s] <= 1:
		print('Ayush')
	elif (n - 2) % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')
for _ in range(t):
	solve()


for t in range(int(input())):
	(n, x) = list(map(int, input().split()))
	childs = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			childs += 1
	print('Ayush' if childs < 2 or (n - 1) % 2 else 'Ashish')


import sys
input = sys.stdin.readline

def dfs(v, p, g):
	tofind = tree[v]
	if len(tofind) == 1:
		return 1
	ansum = 0
	for i in tofind:
		if i != p:
			ansum += dfs(i, v, g + 1)
	return ansum + 1
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	if n == 1:
		print('Ayush')
	else:
		tree = {}
		for _ in range(n - 1):
			(a, b) = map(int, input().split())
			if tree.get(a):
				tree[a].append(b)
			else:
				tree[a] = [b]
			if tree.get(b):
				tree[b].append(a)
			else:
				tree[b] = [a]
		if len(tree[x]) == 1:
			print('Ayush')
		elif dfs(x, -1, 0) % 2:
			print('Ashish')
		else:
			print('Ayush')


from sys import stdin
T = int(stdin.readline().strip())
for caso in range(T):
	(n, m) = map(int, stdin.readline().strip().split())
	c = 0
	for i in range(n - 1):
		(a, b) = map(int, stdin.readline().strip().split())
		if a == m or b == m:
			c += 1
	if c <= 1:
		print('Ayush')
		continue
	else:
		x = n - 2
		if x % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')


t = lambda : map(int, input().split())
for _ in range(int(input())):
	(n, x) = t()
	w = 0
	for i in range(n - 1):
		if x in list(t()):
			w += 1
	print('Ayush' if w <= 1 or n % 2 == 0 else 'Ashish')


class Node:

	def __init__(self):
		self.adj = []

def solve():
	(n, x) = list(map(int, input().split()))
	x -= 1
	nodes = [Node() for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = list(map(int, input().split()))
		u -= 1
		v -= 1
		nodes[u].adj.append(v)
		nodes[v].adj.append(u)
	if len(nodes[x].adj) == 1 or n == 1:
		return 'Ayush'
	return 'Ashish' if n % 2 == 1 else 'Ayush'
t = int(input())
for _ in range(t):
	print(solve())


t = int(input())
for cases in range(t):
	(n, x) = map(int, input().split())
	x -= 1
	lst = [0 for i in range(n)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		a -= 1
		b -= 1
		lst[a] += 1
		lst[b] += 1
	if lst[x] == 0 or lst[x] == 1:
		print('Ayush')
	else:
		print('Ayush') if n % 2 == 0 else print('Ashish')


import sys
input = sys.stdin.readline
from collections import deque
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	graph = [[] for i in range(n + 1)]
	leaf = []
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		graph[u].append(v)
		graph[v].append(u)
	if len(graph[x]) <= 1:
		print('Ayush')
		continue
	if n % 2:
		print('Ashish')
	else:
		print('Ayush')


class Graph:

	def __init__(self, vertices):
		self.vertices = [[] for i in range(vertices)]

	def addedge(self, node1, node2):
		self.vertices[node1].append(node2)
		self.vertices[node2].append(node1)

	def removeedge(self, node1, node2):
		self.vertices[node1].remove(node2)
		self.vertices[node2].remove(node1)
t = int(input().strip())
while t:
	(n, target) = map(int, input().strip().split(' '))
	gph = Graph(n)
	for i in range(n - 1):
		(node1, node2) = map(int, input().strip().split(' '))
		gph.addedge(node1 - 1, node2 - 1)
	if n == 1 or len(gph.vertices[target - 1]) == 1:
		print('Ayush')
		t -= 1
		continue
	target -= 1
	flag = 1
	turn = 0
	while flag:
		flag = 0
		for i in range(0, n):
			if i == target:
				continue
			elif len(gph.vertices[i]) == 1:
				if gph.vertices[i][0] != target:
					gph.removeedge(i, gph.vertices[i][0])
					flag = 1
					turn = (turn + 1) % 2
	if (turn + len(gph.vertices[target])) % 2:
		print('Ayush')
	else:
		print('Ashish')
	t -= 1


T = int(input())
for t in range(T):
	(N, X) = map(int, input().split())
	val = 0
	for n in range(N - 1):
		(u, v) = map(int, input().split())
		if u == X or v == X:
			val += 1
	if val == 1 or val == 0:
		print('Ayush')
	elif (N - 3) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for _ in range(t):
	(n, x) = [int(x) for x in input().split()]
	l = [0 for j in range(n + 1)]
	for i in range(n - 1):
		(a, b) = [int(x) for x in input().split()]
		l[a] += 1
		l[b] += 1
	if l[x] == 1 or l[x] == 0:
		print('Ayush')
		continue
	else:
		n -= 3
		if n % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	xd = 0
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		if x in (u, v):
			xd += 1
	if xd < 2 or not n % 2:
		print('Ayush')
	else:
		print('Ashish')


import sys
ints = (int(x) for x in sys.stdin.read().split())
sys.setrecursionlimit(3000)

def f(root, win):
	if not children[root]:
		return win
	return

def main():
	ntc = next(ints)
	for tc in range(1, ntc + 1):
		(n, x) = (next(ints) for i in range(2))
		k = sum((1 for i in range(2 * n - 2) if x == next(ints)))
		win = 1 if k <= 1 else (n - 1) % 2
		print('Ayush' if win else 'Ashish')
	return
main()


def count_nodes(graph, source, x):
	if len(graph[source]) == 1:
		return 1
	size = 1
	for neighbor in graph[source]:
		if neighbor != x:
			size += count_nodes(graph, neighbor, source)
	return size

def game_on_leaves(graph, n, x):
	if len(graph) == 0:
		return 'Ayush'
	if len(graph[x]) in [1, 0]:
		return 'Ayush'
	size = count_nodes(graph, x, x)
	value = size - 2
	if n > size:
		value += n - size
	if value % 2 == 0:
		return 'Ayush'
	return 'Ashish'
test_cases = int(input())
for k in range(test_cases):
	(n, x) = (int(i) for i in input().split(' '))
	graph = {}
	for i in range(n - 1):
		(a, b) = (int(i) for i in input().split(' '))
		if a in graph:
			graph[a].add(b)
		else:
			graph[a] = {b}
		if b in graph:
			graph[b].add(a)
		else:
			graph[b] = {a}
	print(game_on_leaves(graph, n, x))


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	xcntr = 0
	for j in range(n - 1):
		lst = list(map(int, input().split()))
		if lst[0] == x or lst[1] == x:
			xcntr += 1
	if xcntr == 1 or xcntr == 0:
		print('Ayush')
	elif (n - 2) % 2:
		print('Ashish')
	else:
		print('Ayush')


import sys
import math
import heapq
import collections

def inputnum():
	return int(input())

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

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

def inputstring():
	return [x for x in input()]

def inputmatrix(rows):
	arr2d = [[j for j in input().strip()] for i in range(rows)]
	return arr2d
t = int(input())
for q in range(t):
	(n, x) = inputnums()
	cnt = 0
	for i in range(n - 1):
		(u, v) = inputnums()
		if u == x or v == x:
			cnt += 1
	if cnt == 1 or n == 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for case in range(t):
	(n, x) = map(int, input().split())
	degree = [0] * (n + 1)
	for _ in range(n - 1):
		(a, b) = map(int, input().split())
		degree[a] += 1
		degree[b] += 1
	if degree[x] <= 1:
		print('Ayush')
	else:
		print('Ashish' if (n - 3) % 2 == 0 else 'Ayush')


t = int(input())
for T in range(t):
	(n, x) = [int(x) for x in input().split()]
	d = [0] * 1005
	for i in range(1, n):
		(u, v) = [int(y) for y in input().split()]
		d[u] += 1
		d[v] += 1
	if d[x] <= 1:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


import sys
from collections import defaultdict as dd
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

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

def form_graph(n, edges):
	degree = {i: 0 for i in range(1, n + 1)}
	for [u, v] in edges:
		degree[u] += 1
		degree[v] += 1
	return degree
num_tests = inp()
for _ in range(num_tests):
	num_nodes_and_target = inlt()
	num_nodes = num_nodes_and_target[0]
	target = num_nodes_and_target[1]
	edges = []
	for _ in range(num_nodes - 1):
		edges.append(inlt())
	degree = form_graph(num_nodes, edges)
	if len(degree) == 1:
		print('Ayush')
	elif degree[target] == 1:
		print('Ayush')
	elif num_nodes % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
import heapq
import copy
import math
import decimal

class Node:

	def _init_(self, val):
		self.data = val
		self.left = None
		self.right = None

class fen_tree:

	def __init__(self, list):
		self.array = [0] + list
		for idx in range(1, len(self.array)):
			idx2 = idx + (idx & -idx)
			if idx2 < len(self.array):
				self.array[idx2] += self.array[idx]

	def prefix_query(self, idx):
		result = 0
		while idx:
			result += self.array[idx]
			idx -= idx & -idx
		return result

	def prints(self):
		print(self.array)
		return

	def range_query(self, from_idx, to_idx):
		return self.prefix_query(to_idx) - self.prefix_query(from_idx - 1)

	def update(self, idx, add):
		while idx < len(self.array):
			self.array[idx] += add
			idx += idx & -idx

def pre_sum(arr):
	p = [0]
	for i in arr:
		p.append(p[-1] + i)
	p.pop(0)
	return p

def pre_back(arr):
	p = [0]
	for i in arr:
		p.append(p[-1] + i)
	p.pop(0)
	return p

def bin_search(arr, l, r, val):
	if arr[r] <= val:
		return r + 1
	if r - l < 2:
		if arr[l] > val:
			return l
		else:
			return r
	mid = int((l + r) / 2)
	if arr[mid] <= val:
		return bin_search(arr, mid, r, val)
	else:
		return bin_search(arr, l, mid, val)

def search_leftmost(arr, val):

	def helper(arr, l, r, val):
		print(l, r)
		if arr[l] == val:
			return l
		if r - l <= 1:
			if arr[r] == val:
				return r
			else:
				print('not found')
				return
		mid = int((r + l) / 2)
		if arr[mid] >= val:
			return helper(arr, l, mid, val)
		else:
			return helper(arr, mid, r, val)
	return helper(arr, 0, len(arr) - 1, val)

def search_rightmost(arr, val):

	def helper(arr, l, r, val):
		print(l, r)
		if arr[r] == val:
			return r
		if r - l <= 1:
			if arr[l] == val:
				return r
			else:
				print('not found')
				return
		mid = int((r + l) / 2)
		if arr[mid] > val:
			return helper(arr, l, mid, val)
		else:
			return helper(arr, mid, r, val)
	return helper(arr, 0, len(arr) - 1, val)

def preorder_postorder(root, paths, parent, left, level):
	l = 0
	queue = [root]
	while queue != []:
		node = queue[-1]
		flag = 0
		for i in paths[node]:
			if i != parent[node] and level[i] == sys.maxsize:
				parent[i] = node
				level[i] = level[node] + 1
				flag = 1
				queue.append(i)
		if flag == 0:
			left[parent[node]] += 1 + left[node]
			queue.pop()
	return [parent, left, level]

def nCr(n, r, p):
	if r == 0:
		return 1
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

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

def pr_list(a):
	print(*a, sep=' ')

def main():
	tests = inp()
	mod = 1000000007
	limit = 10 ** 18
	for test in range(tests):
		[n, x] = inlt()
		adj = [{} for i in range(n + 1)]
		for i in range(n - 1):
			[a, b] = inlt()
			adj[a][b] = 1
			adj[b][a] = 1
		done = [0 for i in range(n + 1)]
		dist = [0 for i in range(n + 1)]
		l = [x]
		done[x] = 1
		level = 1
		while l != []:
			n_l = []
			for i in l:
				for j in adj[i]:
					if done[j] == 0:
						done[j] = 1
						dist[j] = level
						n_l.append(j)
			l = n_l
			level = level + 1
		ans = 0
		ones = 0
		for i in range(1, n + 1):
			if dist[i] > 1:
				ans = ans + 1
			elif dist[i] == 1:
				ones += 1
		ans = ans + max(ones - 2, 0)
		if len(adj[x]) == 1 or adj[x] == {}:
			print('Ayush')
		elif ans % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')
main()


from sys import stdin
from math import ceil
for _ in range(int(stdin.readline())):
	(n, x) = map(int, stdin.readline().split())
	d = {}
	for i in range(n - 1):
		(u, v) = map(int, stdin.readline().split())
		if u in d:
			d[u].append(v)
		else:
			d[u] = [v]
		if v in d:
			d[v].append(u)
		else:
			d[v] = [u]
	if len(d) == 0:
		print('Ayush')
		continue
	leaves = set()
	for ele in d:
		if len(d[ele]) == 1:
			leaves.add(ele)
	if x in leaves:
		print('Ayush')
		continue
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict
T = int(input())

def solve():
	(n, x) = map(int, input().split())
	edges = [tuple(map(int, input().split())) for i in range(n - 1)]
	if len(list(filter(lambda e: e[0] == x or e[1] == x, edges))) <= 1:
		return True
	else:
		return n % 2 == 0
for t in range(T):
	if solve():
		print('Ayush')
	else:
		print('Ashish')


we = int(input())
for erw in range(we):
	(n, x) = list(map(int, input().split(' ')))
	gr = []
	for i in range(n + 1):
		gr.append([])
	for i in range(n - 1):
		(a, b) = list(map(int, input().split(' ')))
		gr[a].append(b)
		gr[b].append(a)
	if len(gr[x]) < 2:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush, heappop
import math
from collections import *
from functools import reduce, cmp_to_key, lru_cache
import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
M = mod = 10 ** 9 + 7

def factors(n):
	return sorted(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def inv_mod(n):
	return pow(n, mod - 2, mod)

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

def st():
	return str(input().rstrip())[2:-1]

def val():
	return int(input().rstrip())

def li2():
	return [str(i)[2:-1] for i in input().rstrip().split()]

def li3():
	return [int(i) for i in st()]
for _ in range(val()):
	(n, x) = li()
	g = defaultdict(set)
	for _ in range(n - 1):
		(a, b) = li()
		g[a].add(b)
		g[b].add(a)
	if len(g[x]) == 1 or not len(g[x]):
		print('Ayush')
		continue
	print('Ayush' if n - 1 & 1 else 'Ashish')


import io
import os
from collections import Counter, defaultdict, deque
players = ['Ayush', 'Ashish']

def solve(N, X, edges):
	g = defaultdict(list)
	for (u, v) in edges:
		g[u].append(v)
		g[v].append(u)
	if len(g[X]) <= 1:
		return players[0]
	children = len(g[X])
	others = N - children - 1
	parity = others % 2
	if children % 2 == 0:
		return players[1 ^ parity]
	else:
		return players[0 ^ parity]
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
	(N, X) = [int(x) for x in input().split()]
	edges = [[int(x) for x in input().split()] for i in range(N - 1)]
	ans = solve(N, X, edges)
	print(ans)


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')
from math import ceil

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

def inin():
	return int(input())

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

def ar(element, size):
	return [element for i in range(size)]

def yes():
	print('Yes')

def no():
	print('No')
Testcase = inin()
for _ in range(Testcase):
	lnodes = 0
	(n, x) = inar()
	for i in range(n - 1):
		(u, v) = inar()
		if u == x or v == x:
			lnodes += 1
	if lnodes <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict

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

def inputArray():
	return input().rstrip().split()

def inputVars():
	return map(int, input().rstrip().split())

def inputNum():
	return int(input())

def main():
	for _ in range(inputNum()):
		(totalNode, targetNode) = inputVars()
		vertex = defaultdict(list)
		for pos in range(totalNode - 1):
			(vert1, vert2) = inputVars()
			vertex[vert1].append(vert2)
			vertex[vert2].append(vert1)
		if len(vertex[targetNode]) <= 1:
			print('Ayush')
		elif totalNode % 2 == 0:
			print('Ayush')
		else:
			print('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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


from __future__ import division, print_function
import itertools
import sys
import os
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	input = raw_input
	range = xrange
	filter = itertools.ifilter
	map = itertools.imap
	zip = itertools.izip

def is_it_local():
	script_dir = str(os.getcwd()).split('/')
	username = 'dipta007'
	return username in script_dir

def READ(fileName):
	if is_it_local():
		sys.stdin = open(f'./{fileName}', 'r')
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')
if not is_it_local():
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	input = lambda : sys.stdin.readline().rstrip('\r\n')

def input1(type=int):
	return type(input())

def input2(type=int):
	[a, b] = list(map(type, input().split()))
	return (a, b)

def input3(type=int):
	[a, b, c] = list(map(type, input().split()))
	return (a, b, c)

def input_array(type=int):
	return list(map(type, input().split()))

def input_string():
	s = input()
	return list(s)

def main():
	t = input1()
	for ci in range(t):
		(n, m) = input2()
		deg = 0
		for i in range(n - 1):
			(a, b) = input2()
			if a == m or b == m:
				deg += 1
		if deg <= 1:
			print('Ayush')
			continue
		rem = n - deg - 1
		if rem % 2 == 0:
			if deg % 2 == 1:
				print('Ayush')
			else:
				print('Ashish')
		elif deg % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
	pass
main()


T = int(input())
for case in range(T):
	(n, x) = map(int, input().split())
	degx = 0
	for i in range(n - 1):
		(l, r) = map(int, input().split())
		degx += (l == x) + (r == x)
	print('Ayush' if degx <= 1 or n % 2 == 0 else 'Ashish')


t = int(input())
for _ in range(t):
	(n, x) = [int(i) for i in input().split()]
	edges = []
	for i in range(n - 1):
		(a, b) = [int(i) for i in input().split()]
		edges.append((a, b))
	count = 0
	for e in edges:
		if e[0] == x or e[1] == x:
			count += 1
	if count <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


def main():
	SIN = lambda : map(int, input().split())
	LIN = lambda : list(map(int, input().split()))
	t = int(input())
	for _ in range(t):
		(n, x) = SIN()
		deg = [0] * (n + 1)
		for i in range(n - 1):
			(j, k) = SIN()
			deg[j] += 1
			deg[k] += 1
		if deg[x] == 1 or n % 2 == 0 or n == 1:
			print('Ayush')
		else:
			print('Ashish')
	return
main()


import sys, bisect, string, math, time, functools, random, fractions
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
from itertools import permutations, combinations, groupby
rep = range

def Golf():
	(n, *t) = map(int, open(0).read().split())

def I():
	return int(input())

def S_():
	return input()

def IS():
	return input().split()

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

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

def LI_():
	return [int(i) - 1 for i in input().split()]

def NI(n):
	return [int(input()) for i in range(n)]

def NI_(n):
	return [int(input()) - 1 for i in range(n)]

def StoLI():
	return [ord(i) - 97 for i in input()]

def ItoS(n):
	return chr(n + 97)

def LtoS(ls):
	return ''.join([chr(i + 97) for i in ls])

def RA():
	return map(int, open(0).read().split())

def GI(V, E, ls=None, Directed=False, index=1):
	org_inp = []
	g = [[] for i in range(V)]
	FromStdin = True if ls == None else False
	for i in range(E):
		if FromStdin:
			inp = LI()
			org_inp.append(inp)
		else:
			inp = ls[i]
		if len(inp) == 2:
			(a, b) = inp
			c = 1
		else:
			(a, b, c) = inp
		if index == 1:
			a -= 1
			b -= 1
		aa = (a, c)
		bb = (b, c)
		g[a].append(bb)
		if not Directed:
			g[b].append(aa)
	return (g, org_inp)

def GGI(h, w, search=None, replacement_of_found='.', mp_def={'#': 1, '.': 0}, boundary=1):
	mp = [boundary] * (w + 2)
	found = {}
	for i in range(h):
		s = input()
		for char in search:
			if char in s:
				found[char] = (i + 1) * (w + 2) + s.index(char) + 1
				mp_def[char] = mp_def[replacement_of_found]
		mp += [boundary] + [mp_def[j] for j in s] + [boundary]
	mp += [boundary] * (w + 2)
	return (h + 2, w + 2, mp, found)

def TI(n):
	return GI(n, n - 1)

def accum(ls):
	rt = [0]
	for i in ls:
		rt += [rt[-1] + i]
	return rt

def bit_combination(n, base=2):
	rt = []
	for tb in range(base ** n):
		s = [tb // base ** bt % base for bt in range(n)]
		rt += [s]
	return rt

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

def show(*inp, end='\n'):
	if show_flg:
		print(*inp, end=end)
YN = ['YES', 'NO']
Yn = ['Yes', 'No']
mo = 10 ** 9 + 7
inf = float('inf')
FourNb = [(-1, 0), (1, 0), (0, 1), (0, -1)]
EightNb = [(-1, 0), (1, 0), (0, 1), (0, -1), (1, 1), (-1, -1), (1, -1), (-1, 1)]
compas = dict(zip('WENS', FourNb))
cursol = dict(zip('LRUD', FourNb))
l_alp = string.ascii_lowercase
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
input = lambda : sys.stdin.readline().rstrip()

class Tree:

	def __init__(self, inp_size=None, ls=None, init=True, index=1):
		self.LCA_init_stat = False
		self.ETtable = []
		if init:
			if ls == None:
				self.stdin(inp_size, index=index)
			else:
				self.size = len(ls) + 1
				(self.edges, _) = GI(self.size, self.size - 1, ls, index=index)
		return

	def stdin(self, inp_size=None, index=1):
		if inp_size == None:
			self.size = int(input())
		else:
			self.size = inp_size
		(self.edges, _) = GI(self.size, self.size - 1, index=index)
		return

	def listin(self, ls, index=0):
		self.size = len(ls) + 1
		(self.edges, _) = GI(self.size, self.size - 1, ls, index=index)
		return

	def __str__(self):
		return str(self.edges)

	def dfs(self, x, func=lambda prv, nx, dist: prv + dist, root_v=0):
		q = deque()
		q.append(x)
		v = [-1] * self.size
		v[x] = root_v
		while q:
			c = q.pop()
			for (nb, d) in self.edges[c]:
				if v[nb] == -1:
					q.append(nb)
					v[nb] = func(v[c], nb, d)
		return v

	def EulerTour(self, x):
		q = deque()
		q.append(x)
		self.depth = [None] * self.size
		self.depth[x] = 0
		self.ETtable = []
		self.ETdepth = []
		self.ETin = [-1] * self.size
		self.ETout = [-1] * self.size
		cnt = 0
		while q:
			c = q.pop()
			if c < 0:
				ce = ~c
			else:
				ce = c
				for (nb, d) in self.edges[ce]:
					if self.depth[nb] == None:
						q.append(~ce)
						q.append(nb)
						self.depth[nb] = self.depth[ce] + 1
			self.ETtable.append(ce)
			self.ETdepth.append(self.depth[ce])
			if self.ETin[ce] == -1:
				self.ETin[ce] = cnt
			else:
				self.ETout[ce] = cnt
			cnt += 1
		return

	def LCA_init(self, root):
		self.EulerTour(root)
		self.st = SparseTable(self.ETdepth, init_func=min, init_idl=inf)
		self.LCA_init_stat = True
		return

	def LCA(self, root, x, y):
		if self.LCA_init_stat == False:
			self.LCA_init(root)
		(xin, xout) = (self.ETin[x], self.ETout[x])
		(yin, yout) = (self.ETin[y], self.ETout[y])
		a = min(xin, yin)
		b = max(xout, yout, xin, yin)
		id_of_min_dep_in_et = self.st.query_id(a, b + 1)
		return self.ETtable[id_of_min_dep_in_et]

class SparseTable:

	def __init__(self, ls, init_func=min, init_idl=float('inf')):
		self.func = init_func
		self.idl = init_idl
		self.size = len(ls)
		self.N0 = self.size.bit_length()
		self.table = [ls[:]]
		self.index = [list(range(self.size))]
		self.lg = [0] * (self.size + 1)
		for i in range(2, self.size + 1):
			self.lg[i] = self.lg[i >> 1] + 1
		for i in range(self.N0):
			tmp = [self.func(self.table[i][j], self.table[i][min(j + (1 << i), self.size - 1)]) for j in range(self.size)]
			tmp_id = [self.index[i][j] if self.table[i][j] == self.func(self.table[i][j], self.table[i][min(j + (1 << i), self.size - 1)]) else self.index[i][min(j + (1 << i), self.size - 1)] for j in range(self.size)]
			self.table += [tmp]
			self.index += [tmp_id]

	def query(self, l, r):
		if r > self.size:
			r = self.size
		N = self.lg[r - l]
		return self.func(self.table[N][l], self.table[N][max(0, r - (1 << N))])

	def query_id(self, l, r):
		if r > self.size:
			r = self.size
		N = self.lg[r - l]
		(a, b) = (self.index[N][l], self.index[N][max(0, r - (1 << N))])
		if self.table[0][a] == self.func(self.table[N][l], self.table[N][max(0, r - (1 << N))]):
			b = a
		return b

	def right_bound(self, pos, x):
		k = (self.size - pos).bit_length()
		for j in range(k)[::-1]:
			nx = pos + (1 << j)
			if nx < n and self.query(pos, nx + 1) <= x:
				pos += 1 << j
		return pos

	def left_bound(self, pos, x):
		k = pos.bit_length()
		for j in range(k)[::-1]:
			nx = pos - (1 << j)
			if 0 <= nx and self.query(nx, pos + 1) <= x:
				pos -= 1 << j
		return pos

	def __str__(self):
		return str(self.table[0])

	def print(self):
		for i in self.table:
			print(*i)

def primeFactor(N):
	(i, n) = (2, N)
	ret = {}
	(d, sq) = (2, 99)
	while i <= sq:
		k = 0
		while n % i == 0:
			(n, k, ret[i]) = (n // i, k + 1, k + 1)
		if k > 0 or i == 97:
			sq = int(n ** (1 / 2) + 0.5)
		if i < 4:
			i = i * 2 - 1
		else:
			(i, d) = (i + d, d ^ 6)
	if n > 1:
		ret[n] = 1
	return ret

def PrimeNumSet(N):
	Max = int(N ** 0.5)
	seachList = [i for i in range(2, N + 1)]
	primeNum = []
	while seachList:
		if seachList[0] <= Max:
			break
		primeNum.append(seachList[0])
		tmp = seachList[0]
		seachList = [i for i in seachList if i % tmp != 0]
	primeNum.extend(seachList)
	return primeNum

def LCM(b, mo=10 ** 9 + 7):
	prs = PrimeNumSet(max(b))
	M = dict(zip(prs, [0] * len(prs)))
	for i in b:
		dc = primeFactor(i)
		for (j, k) in dc.items():
			M[j] = max(M[j], k)
	r = 1
	for (j, k) in M.items():
		if k != 0:
			r *= pow(j, k, mo)
			r %= mo
	return r

def topological_sort(G):
	n = len(G)
	rt = []
	indeg = [0] * n
	for i in range(n):
		for j in G[i]:
			indeg[j] += 1
	q = deque()
	for i in range(n):
		if indeg[i] == 0:
			q.append(i)
	while q:
		c = q.popleft()
		rt.append(c)
		for nb in G[c]:
			indeg[nb] -= 1
			if indeg[nb] == 0:
				q.append(nb)
	return rt
show_flg = False
show_flg = True
ans = 0
T = I()
w = ['Ayush', 'Ashish']
for _ in range(T):
	ans = 0
	(n, x) = LI()
	x -= 1
	tr = Tree(n, index=1)
	if n == 1:
		ans = 0
	elif len(tr.edges[x]) == 1:
		ans = 0
	elif n % 2 == 0:
		ans = 0
	else:
		ans = 1
	print(w[ans])


import math
import sys
import collections
from collections import defaultdict
from sys import stdin, stdout
sys.setrecursionlimit(10 ** 9)
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	nodes = [0] * (n + 1)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		nodes[u] += 1
		nodes[v] += 1
	if nodes[x] == 1 or nodes[x] == 0:
		print('Ayush')
	elif n % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


from sys import stdin

def solve():
	(n, x) = map(int, stdin.readline().split())
	cnt = 0
	for i in range(n - 1):
		(u, v) = map(int, stdin.readline().split())
		if u == x or v == x:
			cnt += 1
	if cnt <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')
tt = int(stdin.readline())
for _ in range(tt):
	solve()


import sys
input = sys.stdin.readline
from collections import defaultdict as dd
t = int(input())
while t:
	d = dd(list)
	(n, x) = map(int, input().split())
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		d[u].append(v)
		d[v].append(u)
	child = len(d[x])
	lol = 0
	if child == 1 or child == 0:
		lol = 0
	else:
		nn = n - 1
		nn -= 2
		if nn % 2 == 0:
			lol = 1
		else:
			lol = 0
	if lol:
		print('Ashish')
	else:
		print('Ayush')
	t -= 1


T = int(input())
for _ in range(T):
	(N, X) = map(int, input().split())
	connects = 0
	for _ in range(N - 1):
		(U, V) = map(int, input().split())
		if U == X or V == X:
			connects += 1
	if connects <= 1:
		print('Ayush')
	elif N % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict
T = int(input())
for t in range(T):
	(n, x) = [int(i) for i in input().split()]
	x -= 1
	G = defaultdict(set)
	for j in range(n - 1):
		(u, v) = [int(i) for i in input().split()]
		G[u - 1].add(v - 1)
		G[v - 1].add(u - 1)
	leaves = set()
	for i in range(n):
		if len(G[i]) == 1:
			leaves.add(i)
	if n == 1:
		print('Ayush')
	elif x in leaves:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = [int(c) for c in input().split()]
	degree = [0 for i in range(n + 1)]
	edges = {i: [] for i in range(1, n + 1)}
	for i in range(n - 1):
		(a, b) = [int(c) for c in input().split()]
		degree[a] += 1
		degree[b] += 1
		edges[a].append(b)
	if degree[x] <= 1:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
import math
import collections
t = int(sys.stdin.readline().strip())
for i in range(t):
	adj = collections.defaultdict(list)
	(n, x) = list(map(int, sys.stdin.readline().strip().split(' ')))
	for e in range(n - 1):
		(u, v) = list(map(int, sys.stdin.readline().strip().split(' ')))
		adj[u].append(v)
		adj[v].append(u)
	voisins = len(adj[x])
	if voisins <= 1:
		print('Ayush')
	else:
		rest = n - 1 - voisins
		player = True
		if rest % 2 != 0:
			player = False
		if voisins % 2 == 0:
			player = not player
		if player:
			print('Ayush')
		else:
			print('Ashish')


import sys
input = lambda : sys.stdin.readline().strip()
t = int(input())
while t:
	t -= 1
	(n, x) = map(int, input().split())
	adj = [[] for _ in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		adj[u].append(v)
		adj[v].append(u)
	if len(adj[x - 1]) == 1 or n <= 2:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	d = 0
	for _ in range(n - 1):
		if x in map(int, input().split()):
			d += 1
	if d > 1:
		print('Ashish' if n % 2 else 'Ayush')
	else:
		print('Ayush')


tests = int(input())
for i in range(tests):
	numbers = input().split(' ')
	n = int(numbers[0])
	point = int(numbers[1])
	point_degree = 0
	for x in range(n - 1):
		points = input().split(' ')
		if point == int(points[0]) or point == int(points[1]):
			point_degree += 1
	if point_degree < 2:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


from sys import stdin
input = stdin.buffer.readline
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	cnt = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			cnt += 1
	if cnt < 2 or n & 1 == 0:
		print('Ayush')
	else:
		print('Ashish')


def solve(n, x, tree):
	if len(tree[x]) <= 1:
		return True
	return n % 2 == 0
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	tree = [set() for _ in range(n)]
	for _ in range(n - 1):
		(f, t) = map(int, input().split())
		tree[f - 1].add(t - 1)
		tree[t - 1].add(f - 1)
	print('Ayush' if solve(n, x - 1, tree) else 'Ashish')


t = int(input())
for i in range(t):
	s = input().split(' ')
	n = int(s[0])
	x = int(s[1])
	c = 0
	for j in range(n - 1):
		s = input().split(' ')
		u = int(s[0])
		v = int(s[1])
		if x == u or x == v:
			c += 1
	if c > 1:
		if n % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
	else:
		print('Ayush')


testcases = int(input())
for testcase in range(testcases):
	temparr = input()
	temparr = temparr.split()
	n = int(temparr[0])
	special = int(temparr[1])
	dicts = {}
	for i in range(n - 1):
		temparr = input()
		temparr = temparr.split()
		first = int(temparr[0])
		second = int(temparr[1])
		if first not in dicts:
			dicts[first] = set()
		if second not in dicts:
			dicts[second] = set()
		dicts[first].add(second)
		dicts[second].add(first)
	if special not in dicts:
		print('Ayush')
		continue
	if len(dicts[special]) == 1:
		print('Ayush')
		continue

	def dfs(node, parent):
		global dicts
		if node not in dicts:
			return 1
		arr = dicts[node]
		best = 1
		for i in arr:
			if i != parent:
				best += dfs(i, node)
		return best
	specialneight = dicts[special]
	output = []
	for i in specialneight:
		output.append(dfs(i, special))
	output = sorted(output)
	output = output[::-1]
	sums = sum(output)
	if len(output) >= 2:
		sums -= 1
	if sums & 1 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for you in range(t):
	l = input().split()
	n = int(l[0])
	x = int(l[1])
	adj = [[] for i in range(n + 1)]
	for i in range(n - 1):
		l = input().split()
		u = int(l[0])
		v = int(l[1])
		adj[u].append(v)
		adj[v].append(u)
	if n == 1 or len(adj[x]) == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
buff_readline = sys.stdin.readline
readline = sys.stdin.readline
INF = 2 ** 62 - 1

def read_int():
	return int(buff_readline())

def read_int_n():
	return list(map(int, buff_readline().split()))

def read_float():
	return float(buff_readline())

def read_float_n():
	return list(map(float, buff_readline().split()))

def read_str():
	return readline().strip()

def read_str_n():
	return readline().strip().split()

def error_print(*args):
	print(*args, file=sys.stderr)

def mt(f):
	import time

	def wrap(*args, **kwargs):
		s = time.time()
		ret = f(*args, **kwargs)
		e = time.time()
		error_print(e - s, 'sec')
		return ret
	return wrap

def slv(N, X, UV):
	c = 0
	for (u, v) in UV:
		if u == X or v == X:
			c += 1
	if c <= 1:
		return 'Ayush'
	m = N - 1
	return 'Ayush' if m % 2 == 1 else 'Ashish'

def main():
	T = read_int()
	for _ in range(T):
		(N, X) = read_int_n()
		UV = [read_int_n() for _ in range(N - 1)]
		print(slv(N, X, UV))
main()


import sys
input = sys.stdin.readline

def dfs(x, k=0):
	vis[x] = 1
	for v in g[x]:
		if vis[v] == 0:
			k = 1 + dfs(v, k)
	return k
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	g = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		g[u].append(v)
		g[v].append(u)
	vis = [0] * (n + 1)
	vis[x] = 1
	if len(g[x]) <= 1:
		print('Ayush')
		continue
	c = dfs(x)
	if c % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


from sys import stdin, stdout
import math
from collections import Counter, deque
L = lambda : list(map(int, stdin.readline().strip().split()))
M = lambda : map(int, stdin.readline().strip().split())
I = lambda : int(stdin.readline().strip())
IN = lambda : stdin.readline().strip()
C = lambda : stdin.readline().strip().split()
mod = 1000000007

def s(a):
	print(' '.join(list(map(str, a))))
for i in range(I()):
	(n, x) = M()
	a = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = M()
		a[u].append(v)
		a[v].append(u)
	x = len(a[x])
	if x < 2 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = list(map(int, input().split(' ')))
	adj = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = list(map(int, input().split(' ')))
		adj[u].append(v)
		adj[v].append(u)

	def dfs(r):
		size = 0
		visited = set([x])

		def helper(r):
			nonlocal size, visited
			if r in visited:
				return
			visited.add(r)
			size += 1
			for neighbor in adj[r]:
				helper(neighbor)
		helper(r)
		return size
	numOdd = 0
	for subtree in adj[x]:
		numOdd += dfs(subtree) % 2 == 1
	if len(adj[x]) <= 1 or numOdd % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin, stdout

def find(arr, K, N):
	Z = len(arr[K])
	if Z == 1:
		return 'Ayush'
	if Z == 0:
		return 'Ayush'
	Y = N - 1
	if not Y % 2:
		return 'Ashish'
	else:
		return 'Ayush'

def main():
	for _ in range(int(stdin.readline())):
		(N, K) = list(map(int, stdin.readline().split()))
		graph = [[] for _ in range(N)]
		for i in range(N - 1):
			(a, b) = list(map(int, stdin.readline().split()))
			graph[a - 1].append(b - 1)
			graph[b - 1].append(a - 1)
		stdout.write(str(find(graph, K - 1, N)) + '\n')
main()


from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def LS():
	return [list(x) for x in sys.stdin.readline().split()]

def S():
	res = list(sys.stdin.readline())
	if res[-1] == '\n':
		return res[:-1]
	return res

def IR(n):
	return [I() for i in range(n)]

def LIR(n):
	return [LI() for i in range(n)]

def SR(n):
	return [S() for i in range(n)]

def LSR(n):
	return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
	t = I()
	for _ in range(t):
		(n, x) = LI()
		x -= 1
		v = [[] for i in range(n)]
		f = [0] * n
		for _ in range(n - 1):
			(a, b) = LI()
			a -= 1
			b -= 1
			v[a].append(b)
			v[b].append(a)
			f[a] += 1
			f[b] += 1
		if f[x] <= 1:
			print('Ayush')
			continue
		d = [1] * n
		d[x] = 0
		s = [1] * n
		q = deque([x])
		q2 = []
		while q:
			x = q.popleft()
			for y in v[x]:
				if d[y]:
					d[y] = 0
					q.append(y)
					q2.append((x, y))
		while q2:
			(x, y) = q2.pop()
			s[x] += s[y]
		g = 0
		for y in v[x]:
			g ^= s[y] & 1
		if g == 0:
			print('Ashish')
		else:
			print('Ayush')
	return
solve()


t = int(input())
for _ in range(t):
	from collections import defaultdict
	store = defaultdict(list)
	(n, k) = map(int, input().split())
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		store[a].append(b)
		store[b].append(a)
	if store[k] == [] or len(store[k]) == 1:
		print('Ayush')
		continue
	if (n - 2) % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
from math import log2, floor, ceil, sqrt
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()

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

def list2d(a, b, c):
	return [[c] * b for i in range(a)]

def list3d(a, b, c, d):
	return [[[d] * c for j in range(b)] for i in range(a)]

def list4d(a, b, c, d, e):
	return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]

def ceil(x, y=1):
	return int(-(-x // y))

def INT():
	return int(input())

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

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def Yes():
	print('Yes')

def No():
	print('No')

def YES():
	print('YES')

def NO():
	print('NO')
INF = 10 ** 18
MOD = 10 ** 9 + 7

def dfs(cur, par):
	ans = 1
	for child in g[cur]:
		if child == par:
			continue
		ans += dfs(child, cur)
	return ans
for _ in range(int(ri())):
	(n, x) = Ri()
	g = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(a, b) = Ri()
		g[a].append(b)
		g[b].append(a)
	arr = []
	for i in g[x]:
		arr.append(dfs(i, x) - 1)
	if len(g[x]) == 1 or len(g[x]) == 0:
		print('Ayush')
	else:
		cnt = 0
		cnt = sum(arr)
		cnt2 = len(arr)
		cnt += cnt2 - 1
		if cnt % 2 == 1:
			print('Ashish')
		else:
			print('Ayush')


def cal(tree, nod, x):
	visited[nod - 1] = True
	if len(tree[nod]) == 1:
		return 1
	ans = 0
	for i in tree[nod]:
		if visited[i - 1] or i == x:
			continue
		ans += cal(tree, i, x)
	return ans + 1
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	tree = {}
	for i in range(n):
		tree[i + 1] = []
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		tree[a].append(b)
		tree[b].append(a)
	an = []
	boo = True
	for i in tree[x]:
		visited = [False] * n
		temp = cal(tree, i, x)
		an += [temp]
	for i in an:
		if (i - 1) % 2 == 1:
			boo ^= 1
	if len(an) % 2 == 0:
		boo ^= 1
	if boo or len(tree[x]) <= 1:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())

def solve():
	(n, x) = map(int, input().split())
	d = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			d += 1
	if d <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')
for i in range(t):
	solve()


for _ in range(int(input())):
	(n, x) = map(int, input().split(' '))
	cnt = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split(' '))
		if a == x or b == x:
			cnt += 1
	if n == 1:
		print('Ayush')
		continue
	if cnt == 1:
		print('Ayush')
	elif cnt == 2:
		if (n - 2) % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
	elif (n - 3) % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


import sys, os
import math

def linput():
	return list(minput())

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

def dfs(v):
	vis[v] = True
	for i in adj[v]:
		if i != 0 and vis[i] == False:
			parent[i] = v
			dfs(i)
adj = []
parent = []
vis = []

def main():
	(n, m) = minput()
	if n == 1:
		return 'Ayush'
	global adj, parent, vis
	adj = [[0] for _ in range(n + 1)]
	parent = [0] * (n + 1)
	vis = [False] * (n + 1)
	for _ in range(n - 1):
		(u, v) = minput()
		adj[u].append(v)
		adj[v].append(u)
	dfs(m)
	clm = 0
	for _ in range(1, n + 1):
		if parent[_] == m:
			clm += 1
	if clm == 1:
		return 'Ayush'
	elif clm >= 2:
		if (n - 1 - 2) % 2 == 1:
			return 'Ayush'
		else:
			return 'Ashish'
tc = int(input())
while tc != 0:
	tc -= 1
	print(main())


import os
import sys
from io import BytesIO, IOBase
from collections import defaultdict

def main():
	for _ in range(int(input())):
		(n, x) = map(int, input().split(' '))
		dic = defaultdict(lambda : [])
		for xx in range(n - 1):
			(a, b) = map(int, input().split(' '))
			dic[a].append(b)
			dic[b].append(a)
		if len(dic[x]) == 1 or n == 1:
			print('Ayush')
		elif n % 2 != 0:
			print('Ashish')
		else:
			print('Ayush')
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')
main()


kl = int(input())
for l in range(kl):
	(n, x) = map(int, input().split())
	kx = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			kx += 1
	if n == 1 or n == 2 or kx == 1 or (n % 2 == 0):
		print('Ayush')
	else:
		print('Ashish')


for i in range(int(input())):
	(n, x) = map(int, input().split())
	matrix = list((list() for j in range(n)))
	for j in range(n - 1):
		(u, v) = map(int, input().split())
		matrix[v - 1].append(u - 1)
		matrix[u - 1].append(v - 1)
	if len(matrix[x - 1]) <= 1:
		print('Ayush')
		continue
	n -= 3
	if n % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


cases = int(input())
for t in range(cases):
	(n, x) = list(map(int, input().split()))
	d = {i: [] for i in range(1, n + 1)}
	for i in range(n - 1):
		(u, v) = list(map(int, input().split()))
		d[u].append(v)
		d[v].append(u)
	if len(d[x]) <= 1:
		print('Ayush')
	else:
		s = -1
		stack = [x]
		visited = {i: True for i in range(1, n + 1)}
		while stack:
			node = stack.pop()
			visited[node] = False
			s += 1
			for i in d[node]:
				if visited[i]:
					stack.append(i)
		if s % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


import sys
max_int = 1000000001
min_int = -max_int
t = int(input())
for _t in range(t):
	(n, x) = map(int, sys.stdin.readline().split())
	x -= 1
	G = [[] for _ in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, sys.stdin.readline().split())
		u -= 1
		v -= 1
		G[u].append(v)
		G[v].append(u)
	components = []
	for neighbor in G[x]:
		visited = {x}
		contestants = [neighbor]
		c = 0
		while contestants:
			new_contestants = []
			for contestant in contestants:
				if contestant not in visited:
					visited.add(contestant)
					new_contestants += G[contestant]
			contestants = new_contestants
		components.append(len(visited) - 1)
	if len(components) == 0 or len(components) == 1:
		print('Ayush')
		continue
	print('Ashish' if sum(components) % 2 == 0 else 'Ayush')


t = int(input())

def solve():
	(N, X) = [int(x) for x in input().split()]
	adj = {i: [] for i in range(1, N + 1)}
	for _ in range(N - 1):
		(u, v) = [int(x) for x in input().split()]
		adj[u].append(v)
		adj[v].append(u)
	if len(adj[X]) <= 1:
		return 'Ayush'
	if (N - 1) % 2 == 0:
		return 'Ashish'
	return 'Ayush'
for _ in range(t):
	print(solve())


for t in range(int(input())):
	(n, x) = map(int, input().split())
	s = sum((x in map(int, input().split()) for a in range(n - 1)))
	print('Ashish' if s > 1 & n % 2 == 1 else 'Ayush')


def countLeaf(n, a, x):
	graph = []
	x_connected = []
	numLeaf = 0
	x = x - 1
	for _ in range(n):
		graph.append(0)
	for s in a:
		e = s.split(' ')
		e[0] = int(e[0]) - 1
		e[1] = int(e[1]) - 1
		graph[e[0]] += 1
		graph[e[1]] += 1
		if e[0] == x:
			x_connected.append(e[1])
			numLeaf += 1
		elif e[1] == x:
			x_connected.append(e[0])
			numLeaf += 1
	if graph[x] <= 1:
		return -1
	return numLeaf
nt = int(input())
result = []
for _ in range(nt):
	(nodes, x) = input().split(' ')
	arr = []
	nodes = int(nodes)
	if nodes < 3:
		for _ in range(nodes - 1):
			arr.append(input())
		result.append(True)
	else:
		x = int(x)
		for _ in range(nodes - 1):
			arr.append(input())
		cL = countLeaf(nodes, arr, x)
		if cL < 0:
			result.append(True)
		else:
			r_edge = nodes - 1 - 2
			result.append(r_edge % 2 == 1)
for re in result:
	if re:
		print('Ayush')
	else:
		print('Ashish')


for lo in range(int(input())):
	(n, x) = map(int, input().split())
	c = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if x == u or x == v:
			c += 1
	if c <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	numE = [0] * n
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		numE[u - 1] += 1
		numE[v - 1] += 1
	if n <= 2:
		print('Ayush')
		continue
	if numE[x - 1] == 1:
		print('Ayush')
		continue
	elif (n - 2) % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for test in range(t):
	(n, x) = map(int, input().split(' '))
	deg = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split(' '))
		if a == x or b == x:
			deg += 1
	if deg <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


def main():
	(n, x) = map(int, input().split())
	x -= 1
	edges = [list(map(lambda v: int(v) - 1, input().split())) for _ in range(n - 1)]
	res = 0
	for edge in edges:
		if x in edge:
			res += 1
	if res <= 1:
		print('Ayush')
		return
	if (n - 1) % 2:
		print('Ayush')
	else:
		print('Ashish')
for _ in range(int(input())):
	main()


t = int(input())
for _ in range(t):
	(n, x) = [int(x) for x in input().split()]
	x -= 1
	edges = [[] for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = [int(x) - 1 for x in input().split()]
		edges[u].append(v)
		edges[v].append(u)
	odds = 0
	for branch in edges[x]:
		count = 1
		visited = [False] * n
		visited[x] = True
		visited[branch] = True
		children = edges[branch].copy()
		while len(children) > 0:
			parent = children.pop()
			if visited[parent]:
				continue
			visited[parent] = True
			count += 1
			children.extend(edges[parent])
		if count % 2 == 1:
			odds += 1
	print('Ayush' if odds % 2 == 1 or len(edges[x]) < 2 else 'Ashish')


t = int(input())
for ez in range(t):
	X = input()
	X1 = X.split()
	n = int(X1[0])
	x = X1[1]
	deg = 0
	if n == 1:
		print('Ayush')
	else:
		for i in range(n - 1):
			a = input()
			a1 = a.split()
			if a1[0] == x or a1[1] == x:
				deg = deg + 1
		if deg == 1:
			print('Ayush')
		elif (n - 1) % 2 == 1:
			print('Ayush')
		else:
			print('Ashish')


from math import ceil

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

def inin():
	return int(input())

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

def ar(element, size):
	return [element for i in range(size)]

def yes():
	print('Yes')

def no():
	print('No')
Testcase = inin()
for _ in range(Testcase):
	lnodes = 0
	(n, x) = inar()
	for i in range(n - 1):
		(u, v) = inar()
		if u == x or v == x:
			lnodes += 1
	if lnodes <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	if n == 1:
		print('Ayush')
		continue
	xcount = 0
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			xcount += 1
	if xcount == 1:
		print('Ayush')
		continue
	elif n % 2 == 0:
		print('Ayush')
		continue
	else:
		print('Ashish')
		continue


import sys
import math
import collections

def set_debug(debug_mode=False):
	if debug_mode:
		fin = open('input.txt', 'r')
		sys.stdin = fin

def int_split_input():
	return list(map(int, input().split()))
t = int(input())
for ti in range(1, t + 1):
	(n, x) = list(map(int, input().split()))
	if n == 1:
		print('Ayush')
		continue
	else:
		degree = 0
		for l in range(n - 1):
			(s, e) = int_split_input()
			if s == x or e == x:
				degree += 1
		if degree == 1:
			print('Ayush')
		elif n % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')


ans = []
tests_count = int(input())
for test in range(tests_count):
	tree = dict()
	(n, x) = map(int, input().split())
	for edge in range(n - 1):
		(u, v) = map(int, input().split())
		tree[u] = tree.get(u, [])
		tree[u].append(v)
		tree[v] = tree.get(v, [])
		tree[v].append(u)
	global_count = max(len(tree.get(x, [])) - 2, 0)
	last_node = set()
	last_node.add(x)
	for node_near_x in tree.get(x, []):
		count = 0
		curr = [node_near_x]
		while True:
			new_curr = []
			for node in curr:
				last_node.add(node)
				count += 1
				for child in tree[node]:
					if child in last_node:
						continue
					new_curr.append(child)
			curr = new_curr
			if len(curr) == 0:
				break
		global_count += count - 1
	if len(tree.get(x, [])) <= 1 or global_count % 2 == 1:
		ans.append('Ayush')
	else:
		ans.append('Ashish')
print(*ans, sep='\n')


from collections import defaultdict
f = 'Ayush'
g = 'Ashish'

def func(n, x, adj):
	m = len(adj[x])
	q = n - 2
	if n == 1:
		return f
	if n == 2:
		return f
	if m == 1:
		return f
	if q & 1:
		return g
	else:
		return f
for _ in range(int(input())):
	(n, x) = list(map(int, input().split()))
	adj = defaultdict(list)
	for i in range(n - 1):
		(u, v) = list(map(int, input().split()))
		adj[u].append(v)
		adj[v].append(u)
	print(func(n, x, adj))


t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	a = [[] for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		a[u - 1].append(v - 1)
		a[v - 1].append(u - 1)
	if (n - 1) % 2 == 1 or len(a[x - 1]) <= 1:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	c = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			c += 1
	f = 0
	if c == 1 or c == 0:
		print('Ayush')
		continue
	elif (n - c - 1) % 2 == 0:
		f = 0
	else:
		f = 1
	if (c - 1) % 2 == 0 and f == 0 or ((c - 1) % 2 == 1 and f == 1):
		print('Ayush')
	elif (c - 1) % 2 == 0 and f == 1 or ((c - 1) % 2 == 1 and f == 0):
		print('Ashish')


from sys import stdin
input = stdin.readline

def main():
	test = int(input())
	for t in range(test):
		l = [int(i) for i in input().split(' ')]
		a = 0
		n = l[0]
		x = l[1]
		for i in range(n - 1):
			(u, v) = [int(i) for i in input().split(' ')]
			if u == x or v == x:
				a += 1
		if a <= 1:
			print('Ayush')
		elif n % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
main()


for t in range(int(input())):
	(n, x) = map(int, input().split())
	d = [0] * (n + 1)
	a = {}
	m = n - 1
	for i in range(m):
		(u, v) = map(int, input().split())
		d[u] += 1
		d[v] += 1
	if d[x] == 1 or n == 1:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


import sys

def input():
	return sys.stdin.readline().rstrip()
t = int(input())
answers = []
for _ in range(t):
	(n, x) = [int(i) for i in input().split()]
	x -= 1
	edges = [[] for i in range(n)]
	for _ in range(n - 1):
		(u, v) = [int(i) for i in input().split()]
		u -= 1
		v -= 1
		edges[u].append(v)
		edges[v].append(u)
	if len(edges[x]) <= 1:
		ans = 'Ayush'
	elif (n - 3) % 2 == 0:
		ans = 'Ashish'
	else:
		ans = 'Ayush'
	answers.append(ans)
print(*answers, sep='\n')


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	if n == 1:
		print('Ayush')
		continue
	dic = {}
	for j in range(n - 1):
		(a, b) = map(int, input().split())
		if dic.get(a) != None:
			dic[a].append(b)
		else:
			dic[a] = [b]
		if dic.get(b) != None:
			dic[b].append(a)
		else:
			dic[b] = [a]
	if len(dic[x]) <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


def main():
	inp = lambda : [int(x) for x in input().split()]
	inn = lambda : int(input())
	t = inn()
	p1 = 'Ayush'
	p2 = 'Ashish'
	for _ in range(t):
		(n, x) = inp()
		cnt = 0
		for __ in range(n - 1):
			(u, v) = inp()
			if u == x or v == x:
				cnt += 1
		if cnt <= 1:
			print(p1)
		elif (n - 3) % 2:
			print(p1)
		else:
			print(p2)
main()


t = int(input())
for i in range(t):
	dict = {}
	s = input().split()
	n = int(s[0])
	x = int(s[1])
	for j in range(n):
		dict[j + 1] = []
	for j in range(n - 1):
		s = input().split()
		a = int(s[0])
		b = int(s[1])
		dict[a].append(b)
		dict[b].append(a)
	count = 0
	if len(dict[x]) <= 1:
		print('Ayush')
		count += 1
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


def get_dfs_path_len(adj_mat, vertex):
	n = len(adj_mat)
	visited_list = [False] * n
	visited_list[vertex] = True
	dfs_list = []
	for i in range(n):
		if adj_mat[vertex, i] == 1 and (not visited_list[i]):
			dfs_list.append(dfs_visit_mat(adj_mat, i, visited_list))
	return dfs_list

def dfs_visit_mat(adj_mat, v_index, visited_list):
	visited_list[v_index] = True
	size = 1
	for i in range(len(adj_mat)):
		if adj_mat[v_index, i] == 1 and (not visited_list[i]):
			size += dfs_visit_mat(adj_mat, i, visited_list)
	return size

def process_test_case(i_t):
	(n, x) = map(int, input().split())
	deg_vec = [0] * n
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		deg_vec[u - 1] += 1
		deg_vec[v - 1] += 1
	is_leaf = deg_vec[x - 1] <= 1
	winner = 'Ayush' if is_leaf or n % 2 == 0 else 'Ashish'
	print(winner)
	return None
n_tests = int(input())
for i_test in range(1, n_tests + 1):
	process_test_case(i_test)


for t in range(int(input())):
	level_1_nodes = 0
	(n, x) = map(int, input().split(' '))
	deg = [0] * (n + 1)
	for i in range(n - 1):
		(u, v) = map(int, input().split(' '))
		if u == x or v == x:
			level_1_nodes += 1
			deg[u] += 1
			deg[v] += 1
	if deg[x] <= 1:
		print('Ayush')
	else:
		other_nodes = n - 1 - level_1_nodes
		if other_nodes % 2 == 0:
			if level_1_nodes % 2 == 0:
				print('Ashish')
			else:
				print('Ayush')
		elif level_1_nodes % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')


a = int(input())
from collections import defaultdict
for i in range(a):
	al = defaultdict(list)
	(n, x) = map(int, input().split())
	if n == 1:
		print('Ayush')
		continue
	elif n == 2:
		(x, y) = map(int, input().split())
		print('Ayush')
	else:
		for i in range(n - 1):
			(r, q) = map(int, input().split())
			al[r].append(q)
			al[q].append(r)
		if len(al[x]) == 1:
			print('Ayush')
		elif (n - 3) % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


def solve():
	a = input().split(' ')
	a[0] = int(a[0])
	a[1] = int(a[1])
	if a[0] == 1:
		print('Ayush')
		return
	p = 0
	for i in range(a[0] - 1):
		x = input().split(' ')
		if int(x[0]) == a[1] or int(x[1]) == a[1]:
			p += 1
	if p == 1:
		print('Ayush')
	elif a[0] & 1:
		print('Ashish')
	else:
		print('Ayush')
t = int(input())
for i in range(t):
	solve()


import sys
import math
import operator as op
from functools import reduce

def read_line():
	return sys.stdin.readline()[:-1]

def read_int():
	return int(sys.stdin.readline())

def read_int_line():
	return [int(v) for v in sys.stdin.readline().split()]

def read_float_line():
	return [float(v) for v in sys.stdin.readline().split()]

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer / denom
t = read_int()
for i in range(t):
	(n, x) = read_int_line()
	l = {}
	for i in range(n - 1):
		(u, v) = read_int_line()
		if v - 1 in l:
			l[v - 1] += 1
		else:
			l[v - 1] = 1
		if u - 1 in l:
			l[u - 1] += 1
		else:
			l[u - 1] = 1
	if n == 1:
		print('Ayush')
		continue
	if l[x - 1] == 1:
		print('Ayush')
		continue
	if n % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


a = int(input())
for i in range(a):
	b = [int(x) for x in input().split()]
	cnt = 0
	for j in range(1, b[0]):
		c = [int(x) for x in input().split()]
		if c[0] == b[1] or c[1] == b[1]:
			cnt += 1
	if b[0] == 1 or cnt == 1:
		print('Ayush')
	elif (b[0] - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for i in range(t):
	(n, x) = map(int, input().strip().split())
	xconn = 0
	for i in range(1, n):
		(n1, n2) = map(int, input().strip().split())
		if n1 == x or n2 == x:
			xconn += 1
	if xconn <= 1:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
import os
import heapq
import math
try:
	path = './file/input.txt'
	if os.path.exists(path):
		sys.stdin = open(path, 'r')
except:
	pass
t = int(input())

def printd(value):
	pass
graph = []
x = 0

def dfs(depth, index):
	global graph
	if len(graph[index]) <= 1 and index == x:
		return 1
	if len(graph[index]) == 0:
		return 1
	sumvalue = 1
	maxvalue = 0
	for value in graph[index]:
		graph[value].remove(index)
		result = dfs(depth + 1, value)
		sumvalue += result
	if x == index:
		sumvalue -= 1
	return sumvalue

def case():
	global x
	arr = list(map(int, input().split(' ')))
	(n, x) = (arr[0], arr[1])
	global graph
	graph = []
	for _ in range(n + 1):
		graph.append([])
	for _ in range(n - 1):
		arr = list(map(int, input().split(' ')))
		(a, b) = (arr[0], arr[1])
		graph[a].append(b)
		graph[b].append(a)
	print('Ayush' if dfs(1, x) % 2 == 1 else 'Ashish')
for _ in range(t):
	case()


def main():
	t = int(input())
	for _ in range(t):
		(n, x) = map(int, input().split())
		degree = 0
		for i in range(n - 1):
			(a, b) = map(int, input().split())
			if a == x or b == x:
				degree += 1
		if degree < 2:
			print('Ayush')
			continue
		elif (n - (degree + 1)) % 2 == 0:
			if degree % 2 == 0:
				print('Ashish')
			else:
				print('Ayush')
		elif degree % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
main()


from math import inf as inf
from math import *
from collections import *
import sys
input = sys.stdin.readline
t = int(input())
while t:
	t -= 1
	(n, x) = map(int, input().split())
	s = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			s += 1
	if n == 1 or s == 1:
		print('Ayush')
		continue
	if n % 2:
		print('Ashish')
	else:
		print('Ayush')


def tree(l, arr, n):
	if l == 1:
		return 'Ayush'
	paths = {}
	cnts = {}
	for (x, y) in arr:
		paths[x] = paths.get(x, []) + [y]
		paths[y] = paths.get(y, []) + [x]
		cnts[x] = cnts.get(x, 0) + 1
		cnts[y] = cnts.get(y, 0) + 1
	ans = 0
	for i in range(1, l + 1):
		if i != n and i not in paths[n]:
			ans += 1
	if cnts[n] == 1:
		return 'Ayush'
	ans += cnts[n]
	if ans % 2 != 0:
		return 'Ayush'
	else:
		return 'Ashish'
for i in range(int(input())):
	blanck = []
	(a, b) = map(int, input().strip().split())
	for x in range(a - 1):
		(m, n) = map(int, input().strip().split())
		blanck.append([m, n])
	print(tree(a, blanck, b))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
mod2 = 998244353
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

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

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def IF(c, t, f):
	return t if c else f

def YES(c):
	return IF(c, 'YES', 'NO')

def Yes(c):
	return IF(c, 'Yes', 'No')

def main():
	t = I()
	rr = []
	for _ in range(t):
		(n, x) = LI()
		uv = [LI() for _ in range(n - 1)]
		c = 0
		for (u, v) in uv:
			if u == x or v == x:
				c += 1
		rr.append(IF(c < 2 or n % 2 == 0, 'Ayush', 'Ashish'))
	return JA(rr, '\n')
print(main())


import os.path
from math import gcd, floor, ceil
from collections import *
import sys
mod = 1000000007
INF = float('inf')

def st():
	return list(sys.stdin.readline().strip())

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

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

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

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

def prl(n):
	return sys.stdout.write(str(n) + ' ')
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def solve():
	(n, x) = mp()
	d = defaultdict(list)
	for _ in range(n - 1):
		(a, b) = mp()
		d[a].append(b)
		d[b].append(a)
	if len(d[x]) == 1 or n == 1:
		pr('Ayush')
		return
	stack = [x]
	visited = defaultdict(int)
	visited[x] = 1
	sub = defaultdict(lambda : 1)
	par = defaultdict(lambda : -1)
	while stack:
		f = 0
		a = stack[-1]
		for i in d[a]:
			if not visited[i]:
				f = 1
				stack.append(i)
				visited[i] = 1
				par[i] = a
		if f == 0:
			a = stack.pop()
			if stack:
				sub[par[a]] += sub[a]
			else:
				break
	ans = -1
	for i in d[x]:
		ans += sub[i]
	if ans % 2:
		pr('Ashish')
	else:
		pr('Ayush')
for _ in range(inp()):
	solve()


t = int(input())
for _ in range(t):
	(n, x) = list(map(int, input().rstrip().split()))
	al = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = list(map(int, input().rstrip().split()))
		al[u].append(v)
		al[v].append(u)
	if len(al[x]) == 1:
		print('Ayush')
		continue
	if n == 1:
		print('Ayush')
		continue
	if (n - 2) % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	nodes_count = 0
	x_nodes = set()
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x and v not in x_nodes:
			x_nodes.add(v)
			nodes_count += 1
		elif v == x and u not in x_nodes:
			x_nodes.add(u)
			nodes_count += 1
	if nodes_count == 1 or nodes_count == 0:
		print('Ayush')
	elif (n - 2) % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


def f(l, x, visited):
	dep = list(l[x])
	cnt = 0
	for i in dep:
		if visited[i]:
			continue
		visited[i] = True
		cnt += 1
		temp = f(l, i, visited)
		cnt += temp
	return cnt
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	x -= 1
	l = []
	if n == 1:
		print('Ayush')
		continue
	for i in range(n):
		l.append(set([i]))
		l[i].remove(i)
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		a -= 1
		b -= 1
		l[a].add(b)
		l[b].add(a)
	visited = [False] * n
	visited[x] = True
	if len(l[x]) == 1:
		print('Ayush')
		continue
	cnt = f(l, x, visited)
	if cnt % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
ash = 'Ashish'
ays = 'Ayush'
for _ in range(int(input())):
	(n, k) = map(int, sys.stdin.readline().split())
	a = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(x, y) = map(int, sys.stdin.readline().split())
		a[x].append(y)
		a[y].append(x)
	if n <= 2:
		print(ays)
	elif n == 3:
		if len(a[k]) == 2:
			print(ash)
		else:
			print(ays)
	elif len(a[k]) == 1:
		print(ays)
	elif n % 2:
		print(ash)
	else:
		print(ays)


def cou(root):
	c = 1
	visited[root] = True
	for nei in nodearr[root]:
		if visited[nei] == False:
			c += cou(nei)
	return c
t = int(input())
for test in range(t):
	(n, sp) = map(int, input().split())
	nodearr = []
	for i in range(n):
		nodearr.append([])
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		nodearr[u - 1].append(v - 1)
		nodearr[v - 1].append(u - 1)
	visited = [False] * n
	visited[sp - 1] = True
	s = 0
	for nei in nodearr[sp - 1]:
		s += cou(nei)
	if (s + 1) % 2 == 0 or len(nodearr[sp - 1]) <= 1:
		print('Ayush')
	else:
		print('Ashish')


import sys
import math
import heapq

def I():
	return int(sys.stdin.readline())

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

def ILS():
	return list(map(str, sys.stdin.readline().strip().split()))
t = I()
for iii in range(t):
	(n, x) = IL()
	l = []
	for i in range(n + 1):
		l.append([0] * (n + 1))
	tot = n - 1
	deg = 0
	for ii in range(n - 1):
		(s, d) = IL()
		if s == x or d == x:
			deg += 1
	if deg <= 1:
		print('Ayush')
		continue
	if tot % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
input = sys.stdin.readline

def degree(node, adj, deg):
	if node in deg:
		return deg[node]
	else:
		deg[node] = 0
		for child in adj[node]:
			adj[child].remove(node)
			deg[node] += degree(child, adj, deg)
		deg[node] += len(adj[node])
		return deg[node]
t = int(input())
for test in range(t):
	(n, x) = list(map(int, input().split()))
	adj = {}
	deg = {}
	if n == 1:
		print('Ayush')
		continue
	for i in range(n - 1):
		(u, v) = list(map(int, input().split()))
		if u in adj:
			adj[u].append(v)
		else:
			adj[u] = [v]
		if v in adj:
			adj[v].append(u)
		else:
			adj[v] = [u]
	for i in range(1, n + 1):
		if i != x and len(adj[i]) <= 1:
			deg[i] = 0
	if len(adj[x]) <= 1:
		print('Ayush')
		continue
	ans = degree(x, adj, deg)
	if ans % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys, math
Tests = int(input())
for _ in range(Tests):
	(n, x) = map(int, sys.stdin.readline().split())
	ans = 0
	deg = 0
	for i in range(n - 1):
		(a, b) = map(int, sys.stdin.readline().split())
		if a == x or b == x:
			deg += 1
	if deg <= 1:
		print('Ayush')
	elif (n - 2) % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


import sys, math
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	edgeList = [[] for i in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		edgeList[u - 1].append(v - 1)
		edgeList[v - 1].append(u - 1)
	if len(edgeList[x - 1]) <= 1:
		print('Ayush')
		continue
	if n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


for _ in range(int(input())):
	(n, k) = map(int, input().split(' '))
	state = 0
	for _ in range(n - 1):
		(u, v) = map(int, input().split(' '))
		if u == k or v == k:
			state += 1
	if n == 1:
		print('Ayush')
	elif state == 1:
		print('Ayush')
	else:
		x = n - (state + 1)
		if x % 2 != 0:
			curr = 'Ayush'
			p = 'Ashish'
		else:
			curr = 'Ashish'
			p = 'Ayush'
		if state % 2 == 0:
			ans = curr
		else:
			ans = p
		print(ans)


def task(n, x, u, v):
	tree = {}
	for i in range(0, n - 1):
		if not u[i] in tree:
			tree[u[i]] = set()
		if not v[i] in tree:
			tree[v[i]] = set()
		tree[u[i]].add(v[i])
		tree[v[i]].add(u[i])
	if not x in tree or len(tree[x]) < 2:
		print('Ayush')
		return
	traversed = {}
	traversed[x] = True
	nodes = list(tree[x])
	for node in nodes:
		traversed[node] = True
	count = len(nodes) - 1
	while len(nodes) > 0:
		current = nodes.pop()
		for node in tree[current]:
			if not node in traversed:
				traversed[node] = True
				nodes.append(node)
				count += 1
	if count % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')
t = int(input())
for i in range(0, t):
	(n, x) = map(int, input().split())
	u = []
	v = []
	for j in range(0, n - 1):
		(uu, vv) = map(int, input().split())
		u.append(uu)
		v.append(vv)
	task(n, x, u, v)


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	deg = [0] * (n + 1)
	adj = {}
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		deg[u] += 1
		deg[v] += 1
	if deg[x] == 1 or n == 1:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


from sys import stdin, stdout
t = int(stdin.readline())
for _ in range(t):
	(n, x) = map(int, stdin.readline().split())
	cnt = 0
	seen = set()
	for _ in range(n - 1):
		(a, b) = map(int, stdin.readline().split())
		if a > b:
			(a, b) = (b, a)
		if (a, b) in seen:
			continue
		seen.add((a, b))
		if a == x or b == x:
			cnt += 1
	if cnt <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict
from sys import stdin

def put():
	return map(int, stdin.readline().split())
t = int(input())
for _ in range(t):
	(n, x) = put()
	cnt = 0
	for i in range(n - 1):
		(a, b) = put()
		if x in [a, b]:
			cnt += 1
	s = n - 2
	if cnt < 2 or s % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
T = int(input())

def getLeaves(edges, n):
	flat = []
	leaves = []
	for i in range(0, len(edges)):
		[flat.append(el) for el in edges[i]]
	for i in range(1, n + 1):
		if flat.count(i) == 1:
			leaves.append(i)
	if edges == []:
		leaves.append(1)
	return leaves

def solve(edges, n, x):
	if getLeaves(edges, n).count(x) == 0:
		if (n - 2) % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
	else:
		print('Ayush')
while T > 0:
	edges = []
	(n, x) = [int(el) for el in input().split(' ')]
	for i in range(0, n - 1):
		data = input().rstrip().split(' ')
		edges.append([int(el) for el in data])
	solve(edges, n, x)
	T -= 1


from collections import defaultdict
t = int(input())
for i in range(t):
	(n, x) = list(map(int, input().split()))
	deg = defaultdict(int)
	for i in range(n - 1):
		con = list(map(int, input().split()))
		deg[con[0]] += 1
		deg[con[1]] += 1
	got = deg[x]
	if got <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import sys
import math
import collections
import heapq
import queue
import itertools
import functools
import operator
import time
readline = sys.stdin.readline
IPS = lambda : readline().rstrip()
IP = lambda : int(readline().rstrip())
MP = lambda : map(int, readline().split())
LS = lambda : list(map(int, readline().split()))

def solve():
	for _ in range(IP()):
		(n, x) = MP()
		child = [0] * (n + 1)
		for i in range(n - 1):
			(u, v) = MP()
			child[u] += 1
			child[v] += 1
		print('Ayush') if child[x] <= 1 else print('Ashish') if n & 1 else print('Ayush')
solve()


(T,) = map(int, input().split())
for _ in range(T):
	(N, x) = map(int, input().split())
	G = [0] * (N + 1)
	for _ in range(N - 1):
		(u, v) = map(int, input().split())
		G[u] += 1
		G[v] += 1
	if G[x] == 1:
		print('Ayush')
	elif G[x] == 0:
		print('Ayush')
	elif N % 2:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split(' '))
	adj = []
	deg = [0] * (n + 1)
	for j in range(n - 1):
		li = list(map(int, input().split(' ')))
		deg[li[0]] += 1
		deg[li[1]] += 1
		adj.append(li)
	if n == 1 or deg[x] == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from __future__ import division, print_function
from sys import stdin, stdout
import bisect
import math
import heapq
i_m = 9223372036854775807

def inin():
	return int(input())

def stin():
	return input()

def spin():
	return map(int, stin().split())

def lin():
	return list(map(int, stin().split()))

def matrix(n):
	return [list(map(int, input().split())) for i in range(n)]

def count2D(i, list):
	return sum((c.count(i) for c in list))

def modinv(n, p):
	return pow(n, p - 2, p)

def GCD(x, y):
	x = abs(x)
	y = abs(y)
	if min(x, y) == 0:
		return max(x, y)
	while y:
		(x, y) = (y, x % y)
	return x

def Divisors(n):
	l = []
	for i in range(1, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
	return l
prime = []

def SieveOfEratosthenes(n):
	global prime
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	f = []
	for p in range(2, n):
		if prime[p]:
			f.append(p)
	return f
q = []

def dfs(n, d, v, c):
	global q
	v[n] = 1
	x = d[n]
	q.append(n)
	j = c
	for i in x:
		if i not in v:
			f = dfs(i, d, v, c + 1)
			j = max(j, f)
	return j
for _ in range(inin()):
	(n, x) = spin()
	m = matrix(n - 1)
	c = count2D(x, m)
	if c <= 1:
		print('Ayush')
	elif n % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


for i in range(int(input())):
	(n, x) = map(int, input().split())
	d = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		d[u].append(v)
		d[v].append(u)
	d = len(d[x])
	if d < 2 or not n & 1:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict

def Winner(degree, n, x):
	if n == 1:
		return 'Ayush'
	if degree[x] <= 1:
		return 'Ayush'
	if n % 2 != 0:
		return 'Ashish'
	return 'Ayush'
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	degree = dict()
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		degree[v] = degree.get(v, 0) + 1
		degree[u] = degree.get(u, 0) + 1
	print(Winner(degree, n, x))


t = int(input())
for jack in range(t):
	(n, x) = map(int, input().split())
	adj = [[] for _ in range(n)]
	for _ in range(n - 1):
		(a, b) = map(int, input().split())
		adj[a - 1].append(b - 1)
		adj[b - 1].append(a - 1)
	if len(adj[x - 1]) <= 1 or n % 2 == 0:
		print('Ayush', flush=True)
	else:
		print('Ashish', flush=True)


from heapq import heappush as pu
from heapq import heappop as po
t = int(input())

def dfs():
	s = [x]
	par[x] = -1
	dep[x] = 0
	while s:
		w = s.pop()
		for y in tree[w]:
			if y == par[w]:
				continue
			par[y] = w
			dep[y] = dep[w] + 1
			s.append(y)
for _ in range(t):
	(n, x) = map(int, input().split())
	x = x - 1
	tree = [set() for i in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		tree[u].add(v)
		tree[v].add(u)
	par = {}
	dep = {}
	dfs()
	pr = []
	ir = []
	for i in range(n):
		if len(tree[i]) <= 1:
			if dep[i] % 2 == 0:
				pu(pr, (dep[i], i))
			else:
				pu(ir, (-dep[i], i))
	ww = ['Ayush', 'Ashish']
	win = 0
	while pr or ir:
		if pr:
			(d, i) = po(pr)
			if i == x:
				break
			pa = par[i]
			tree[pa].remove(i)
			if len(tree[pa]) <= 1:
				pu(ir, (-dep[pa], pa))
		else:
			(d, i) = po(ir)
			pa = par[i]
			tree[pa].remove(i)
			if len(tree[pa]) <= 1:
				pu(pr, (dep[pa], pa))
		win += 1
	print(ww[win % 2])


import sys
import collections
input = sys.stdin.readline

def main():
	t = int(input())
	for _ in range(t):
		(N, X) = [int(x) for x in input().split()]
		UV = [[int(x) for x in input().split()] for _ in range(N - 1)]
		edge = [[] for j in range(N + 1)]
		for (u, v) in UV:
			edge[u].append(v)
			edge[v].append(u)
		if len(edge[X]) == 1 or N == 1:
			print('Ayush')
		elif (N - 1 - 2) % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')
main()


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')

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

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

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

def comb(n, m):
	return factorial(n) / (factorial(m) * factorial(n - m)) if n >= m else 0

def perm(n, m):
	return factorial(n) // factorial(n - m) if n >= m else 0

def mdis(x1, y1, x2, y2):
	return abs(x1 - x2) + abs(y1 - y2)
mod = 998244353
INF = float('inf')
from math import factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush

def main():
	for _ in range(N()):
		(n, x) = RL()
		dead = [0] * (n + 1)
		eds = [0] * (n + 1)
		nei = [[] for _ in range(n + 1)]
		for _ in range(n - 1):
			(f, t) = RL()
			if f == x or t == x:
				if f != x:
					dead[f] = 1
				if t != x:
					dead[t] = 1
			eds[f] += 1
			eds[t] += 1
			nei[f].append(t)
			nei[t].append(f)
		can = deque()
		tag = False
		for i in range(1, n + 1):
			if eds[i] <= 1 and dead[i] == 0:
				can.append(i)
				if i == x:
					tag = True
		num = 0
		while can and tag == False:
			nd = can.popleft()
			eds[nd] -= 1
			num += 1
			for nex in nei[nd]:
				eds[nex] -= 1
				if 0 <= eds[nex] <= 1 and dead[nex] == 0:
					can.append(nex)
		(a, b) = ('Ayush', 'Ashish')
		num += max(0, eds[x] - 2)
		if num % 2 == 1 or tag == True:
			print(a)
		else:
			print(b)
main()


from collections import deque
import sys
input = sys.stdin.readline
MOD = 10 ** 9 + 7
for t in range(int(input())):
	(n, x) = map(int, input().split())
	tree = [0] * (n + 1)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		tree[u] += 1
		tree[v] += 1
	if tree[x] <= 1 or not n & 1:
		print('Ayush')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, x) = [int(i) for i in input().split()]
	lst = [[] for i in range(n + 1)]
	for _ in range(n - 1):
		(a, b) = [int(j) for j in input().split()]
		lst[a].append(b)
		lst[b].append(a)
	m = len(lst[x])
	if m == 1 or n == 1:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


def rs():
	return input().strip()

def ri():
	return int(input())

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

def ia_to_s(a):
	return ' '.join([str(s) for s in a])
from collections import deque

def solve(n, x, ee):
	if n == 1:
		return 'Ayush'
	dx = 0
	for e in ee:
		if e[0] == x or e[1] == x:
			dx += 1
	if dx == 1:
		return 'Ayush'
	return 'Ashish' if (n - 1) % 2 == 0 else 'Ayush'

def main():
	for _ in range(ri()):
		(n, x) = ria()
		ee = []
		for __ in range(n - 1):
			ee.append(ria())
		print(solve(n, x, ee))
main()


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	c = 0
	for i in range(n - 1):
		b = list(map(int, input().split()))
		c += x in b
	if c == 1 or n < 3:
		print('Ayush')
		continue
	print(['Ashish', 'Ayush'][n - 3 & 1])


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
from math import sqrt, floor, factorial, gcd, log
from collections import deque, Counter, defaultdict
from itertools import permutations, combinations
from math import gcd
from bisect import bisect
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
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')
read = lambda : list(map(int, input().strip().split(' ')))

def solution():
	for _ in range(int(input())):
		(n, x) = read()
		count = 0
		for _ in range(n - 1):
			(u, v) = map(int, input().split())
			if u == x or v == x:
				count += 1
		if count <= 1:
			print('Ayush')
		elif n % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
solution()


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	a = [0] * (n + 1)
	for j in range(n - 1):
		(q, w) = map(int, input().split())
		a[q] += 1
		a[w] += 1
	print('Ayush' if n == 1 or a[x] == 1 or n % 2 == 0 else 'Ashish')


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	node = 0
	for _ in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			node += 1
	if node <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


def findWinner(graph, targetNode):
	if len(graph[targetNode]) <= 1:
		return 'Ayush'
	nodeCount = len(graph.keys())
	if (nodeCount - 3) % 2 == 0:
		return 'Ashish'
	else:
		return 'Ayush'
t = int(input())
for _ in range(t):
	(n, targetNode) = [int(_x) for _x in input().split()]
	graph = dict()
	for _abc in range(n - 1):
		(u, v) = [int(_y) for _y in input().split()]
		if u not in graph.keys():
			graph[u] = []
		if v not in graph.keys():
			graph[v] = []
		graph[u].append(v)
		graph[v].append(u)
	if n == 1:
		print('Ayush')
		continue
	res = findWinner(graph, targetNode)
	print(res)


t = int(input())
for w in range(t):
	(n, x) = map(int, input().split())
	count = 0
	c = list()
	for i in range(n - 1):
		b = list(map(int, input().split()))
		if x in b and (not b in c):
			count += 1
		c.append(b)
		c.append(b[::-1])
	if count == 0 or count == 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict

def solve():
	(n, special) = map(int, input().split())
	edges = [tuple(map(int, input().split())) for _ in range(n - 1)]

	def play():
		tree = defaultdict(set)
		for (x, y) in edges:
			tree[x].add(y)
			tree[y].add(x)
		if len(tree[special]) <= 1:
			return 'Ayush'
		return 'Ayush' if len(edges) & 1 else 'Ashish'
	print(play())
for _ in range(int(input())):
	solve()


import sys
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	degree = 0
	for __ in range(n - 1):
		(u, v) = map(int, input().split())
		degree += 1 if u == x or v == x else 0
	if degree == 1 or not degree or n - 1 & 1:
		print('Ayush')
	else:
		print('Ashish')


import sys
from collections import defaultdict as dd
from collections import deque
from fractions import Fraction as f

def eprint(*args):
	print(*args, file=sys.stderr)
zz = 1
from math import *
import copy
if zz:
	input = sys.stdin.readline
else:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('all.txt', 'w')

def li():
	return [int(x) for x in input().split()]

def fi():
	return int(input())

def si():
	return list(input().rstrip())

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

def bo(i):
	return ord(i) - ord('a')
from copy import *
from bisect import *
t = fi()

def dfs(i):
	vis[i] = 1
	for j in a[i]:
		if vis[j] == 0:
			dfs(j)
			child[i] += 1 + child[j]
while t > 0:
	t -= 1
	(n, x) = mi()
	a = [[] for i in range(n + 1)]
	vis = [0 for i in range(n + 1)]
	child = [0 for i in range(n + 1)]
	for i in range(n - 1):
		(xx, y) = mi()
		a[xx].append(y)
		a[y].append(xx)
	dfs(x)
	p = child[x]
	if p % 2 or len(a[x]) <= 1:
		print('Ayush')
	else:
		print('Ashish')


def first(n, x, edges):
	degree = sum([1 if e[0] == x or e[1] == x else 0 for e in edges])
	if degree <= 1:
		return True
	return n % 2 == 0
t = int(input().strip())
for _ in range(t):
	(n, x) = list(map(int, input().strip().split()))
	edges = []
	for _ in range(n - 1):
		edges.append(list(map(int, input().strip().split())))
	print('Ayush' if first(n, x, edges) else 'Ashish')


for _ in [0] * int(input()):
	(n, x) = map(int, input().split())
	core = 0
	for pair in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			core += 1
	if core < 2:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict
import heapq
n = int(input())

def solve(n, x, edges):
	if edges[x] <= 1:
		return 'Ayush'
	if n & 1 == 1:
		return 'Ashish'
	else:
		return 'Ayush'
for _ in range(n):
	(n, x) = list(map(int, input().split()))
	edges = defaultdict(int)
	for _ in range(n - 1):
		(u, v) = list(map(int, input().split()))
		edges[u] += 1
		edges[v] += 1
	print(solve(n, x, edges))


for q in range(int(input())):
	(n, x) = map(int, input().split())
	G = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		G[a].append(b)
		G[b].append(a)
	if len(G[x]) <= 1:
		print('Ayush')
	elif (n - 1) % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


for tc in range(int(input())):
	(n, x) = map(int, input().split())
	degree = [0 for i in range(n + 1)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		degree[u] += 1
		degree[v] += 1
	if degree[x] <= 1:
		print('Ayush')
	elif n & 1:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict
from copy import copy
n = int(input())

def bfs(G, start):
	li = [start]
	ret = 0
	while len(li) != 0:
		ret += 1
		cur = li.pop()
		neis = copy(G[cur])
		for nei in neis:
			G[cur].remove(nei)
			G[nei].remove(cur)
			li.append(nei)
	return ret

def solution(G, start):
	li = copy(G[start])
	sizes = []
	for b in li:
		G[b].remove(start)
		G[start].remove(b)
		sizes.append(bfs(G, b))
	total = sum(sizes)
	if len(sizes) == 1:
		return 'Ayush'
	else:
		return 'Ayush' if total % 2 == 1 else 'Ashish'
for t in range(n):
	(N, start) = map(int, input().split())
	G = defaultdict(list)
	for _ in range(N - 1):
		(a, b) = map(int, input().split())
		G[a].append(b)
		G[b].append(a)
	if N == 1:
		print('Ayush')
		continue
	print(solution(G, start))


from fractions import Fraction
import bisect
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate
from queue import Queue

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

def iinput():
	return int(input())

def tinput():
	return input().split()

def rinput():
	return map(int, tinput())

def rlinput():
	return list(rinput())
mod = int(1000000000.0) + 7

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
t = 1
t = iinput()
for _ in range(t):
	(n, x) = rinput()
	deg = [0] * (n + 1)
	for i in range(n - 1):
		(u, v) = rinput()
		deg[v] += 1
		deg[u] += 1
	print(['Ashish', 'Ayush'][deg[x] <= 1 or n % 2 == 0])


import os
os_input = os.read(0, int(10000000.0)).split()
os_input_pos = -1
answer_list = []

def read_s():
	global os_input_pos
	os_input_pos += 1
	return os_input[os_input_pos].decode()

def read_i():
	return int(read_s())

def write_s(v):
	answer_list.append(v)

def write_i(v):
	write_s(str(v))

def print_ans():
	os.write(1, '\n'.join(answer_list).encode())
	os.write(1, '\n'.encode())
T = read_i()
while T:
	T -= 1
	n = read_i()
	x = read_i()
	deg = [0 for i in range(n + 1)]
	for i in range(n - 1):
		deg[read_i()] += 1
		deg[read_i()] += 1
	if deg[x] <= 1 or n % 2 == 0:
		write_s('Ayush')
	else:
		write_s('Ashish')
print_ans()


from collections import defaultdict

def solution(G, n, x):
	if len(G[x]) <= 1:
		return 'Ayush'
	cnt = 0
	for v in G:
		cnt += len(G[v])
	cnt /= 2
	if cnt % 2 == 0:
		return 'Ashish'
	return 'Ayush'
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split(' '))
	G = defaultdict(list)
	for _ in range(n - 1):
		(u, v) = map(int, input().split(' '))
		G[u].append(v)
		G[v].append(u)
	print(solution(G, n, x))


import sys
input = sys.stdin.readline
tcs = int(input())
for tc in range(tcs):
	(n, x) = map(int, input().split())
	c = 0
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			c += 1
	if c == 1 or n == 1:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
input = sys.stdin.readline
import math

def inp():
	return int(input())

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

def insr():
	s = input().strip()
	return list(s[:len(s)])

def invr():
	return map(int, input().strip().split())

def from_file(f):
	return f.readline

def solution(n, x, edges):
	degree = len(edges[x])
	if degree <= 1:
		return 'Ayush'
	if (n - 1) % 2 == 0:
		return 'Ashish'
	return 'Ayush'
t = inp()
for _ in range(t):
	(n, x) = invr()
	edges = [[] for _ in range(n + 1)]
	for _ in range(n - 1):
		(u, v) = invr()
		edges[u].append(v)
		edges[v].append(u)
	print(solution(n, x, edges))


t = int(input())
for kek in range(t):
	(n, x) = map(int, input().split())
	N = 0
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a == x or b == x:
			N += 1
	if N <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


MOD = 10 ** 9 + 7
INT_MAX = 10 ** 20 + 7

def INPUT():
	return list((int(i) for i in input().split()))

def LIST_1D_ARRAY(n):
	return [0 for _ in range(n)]

def LIST_2D_ARRAY(m, n):
	return [[0 for _ in range(n)] for _ in range(m)]

def power(a, x):
	res = 1
	while x > 0:
		if x & 1:
			res = res * a % MOD
		a = a * a % MOD
		x //= 2
	return res % MOD

def NCR_MOD(n, r):
	num = 1
	for i in range(n, n - r, -1):
		num = num * i % MOD
	for j in range(1, r + 1):
		num = num * power(j, MOD - 2) % MOD
	return num
import math
from collections import deque
for _ in range(int(input())):
	(n, x) = INPUT()
	A = LIST_2D_ARRAY(n, n)
	for i in range(n - 1):
		(s, e) = INPUT()
		A[s - 1][e - 1] = 1
		A[e - 1][s - 1] = 1
	leaves = []
	for i in range(n):
		count = 0
		for j in range(n):
			if A[i][j] == 1:
				count += 1
		if count == 1:
			leaves.append(i + 1)
	if x in leaves or n % 2 == 0 or n == 1:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin, stdout
for case in range(int(stdin.readline())):
	(n, x) = [int(b) for b in stdin.readline().split()]
	x -= 1
	rGraph = [set() for a in range(n)]
	graph = [set() for a in range(n)]
	leaves = set([a for a in range(n)])
	for a in range(n - 1):
		(u, v) = [int(b) for b in stdin.readline().split()]
		u -= 1
		v -= 1
		graph[u].add(v)
		graph[v].add(u)
		if len(graph[u]) > 1 and u in leaves:
			leaves.remove(u)
		if len(graph[v]) > 1 and v in leaves:
			leaves.remove(v)
	ayush = True
	while not x in leaves:
		ayush = not ayush
		valid = False
		for leaf in leaves:
			if len(graph[x]) > 2 or not x in graph[leaf]:
				valid = True
				leaves.remove(leaf)
				for node in graph[leaf]:
					graph[node].remove(leaf)
					if len(graph[node]) == 1:
						leaves.add(node)
				break
		if not valid:
			break
	if ayush:
		print('Ayush')
	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')

def fact(x):
	if x == 0:
		return 1
	else:
		return x * fact(x - 1)

def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def abs(x):
	return x if x >= 0 else -x

def binary_search(li, val, lb, ub):
	ans = 0
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = 1
			break
	return ans

def sieve_of_eratosthenes(n):
	ans = []
	arr = [1] * (n + 1)
	(arr[0], arr[1], i) = (0, 0, 2)
	while i * i <= n:
		if arr[i] == 1:
			j = i + i
			while j <= n:
				arr[j] = 0
				j += i
		i += 1
	for k in range(n):
		if arr[k] == 1:
			ans.append(k)
	return ans
from math import *
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	li = [0] * n
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		li[u - 1] += 1
		li[v - 1] += 1
	if li[x - 1] <= 1:
		print('Ayush')
	else:
		print('AAysuhsihs h'[n % 2::2])


t = int(input())
for i in range(t):
	(n, x) = [int(i) for i in input().split()]
	x -= 1
	nodes = [[] for i in range(n)]
	for i in range(n - 1):
		inp = [int(i) for i in input().split()]
		inp[0] -= 1
		inp[1] -= 1
		nodes[inp[0]].append(inp[1])
		nodes[inp[1]].append(inp[0])
	if len(nodes[x]) <= 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


def f(x, d):
	d += 1
	c[x] = 0
	if d > maxd[0]:
		maxd[0] = d
	if d >= 2:
		maxd[1] += 1
	if len(p[x]) == 1:
		return
	for i in p[x]:
		if c[i] == 1:
			f(i, d)
rw = int(input())
for ewq in range(rw):
	n1 = 'Ayush'
	n2 = 'Ashish'
	(n, x) = map(int, input().split())
	if n == 1:
		print(n1)
		continue
	x -= 1
	g = [[] for i in range(n - 1)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		g[i] = [a - 1, b - 1]
	p = {}
	for i in range(n):
		p[i] = []
	for i in g:
		p[i[0]].append(i[1])
		p[i[1]].append(i[0])
	l = []
	c = [1] * n
	maxd = [0, 0]
	f(x, 0)
	if len(p[x]) == 1:
		print(n1)
		continue
	if (maxd[1] - 1) % 2 == 0:
		print(n1)
	else:
		print(n2)


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')

def main():
	for j in range(int(input())):
		(n1, x) = map(int, input().split())
		n = 0
		cons = 0
		for s in range(n1 - 1):
			(u, v) = map(int, input().split())
			if u != x and v != x:
				n += 1
			else:
				cons += 1
		if cons >= 2:
			if (n + cons - 1) % 2 == 1:
				print('Ashish')
			else:
				print('Ayush')
		else:
			print('Ayush')
main()


def f(n, x, A):
	if n == 1:
		return 'Ayush'
	degx = 0
	for i in A:
		for j in i:
			if j == x:
				degx += 1
	if degx == 1:
		return 'Ayush'
	elif n % 2 == 0:
		return 'Ayush'
	else:
		return 'Ashish'
t = int(input())
for i in range(t):
	[n, x] = input().split(' ')
	A = []
	for i in range(int(n) - 1):
		A.append(input().split(' '))
	print(f(int(n), x, A))


def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())
entries = inp()
for i in range(entries):
	dict = {}
	l = inlt()
	n = l[0]
	x = l[1]
	for j in range(n - 1):
		l = inlt()
		a = l[0]
		b = l[1]
		if a not in dict:
			dict[a] = [1, [b]]
		else:
			dict[a][0] += 1
			dict[a][1].append(b)
		if b not in dict:
			dict[b] = [1, [a]]
		else:
			dict[b][0] += 1
			dict[b][1].append(a)
	cnt = 0
	if n == 1:
		print('Ayush')
	elif dict[x][0] == 1:
		print('Ayush')
	else:
		while True:
			flag = 1
			for j in dict:
				if j == x:
					continue
				if len(dict[j][1]) == 1 and (len(dict[x][1]) != 2 or j not in dict[x][1]):
					if len(dict[j][1]) != 0:
						parent_node = dict[j][1][0]
						dict[j][1].remove(parent_node)
						if j in dict[parent_node][1]:
							dict[parent_node][1].remove(j)
						dict[j][0] = 0
						flag = 0
						break
			if flag:
				break
			else:
				cnt = (cnt + 1) % 2
		if cnt % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


from math import *
from collections import *
from operator import itemgetter
import bisect
from heapq import *
i = lambda : input()
ii = lambda : int(input())
iia = lambda : list(map(int, input().split()))
isa = lambda : list(input().split())
I = lambda : list(map(int, input().split()))
chrIdx = lambda x: ord(x) - 96
idxChr = lambda x: chr(96 + x)
t = ii()
for _ in range(t):
	(n, x) = iia()
	edges = []
	for i in range(n - 1):
		(xx, yy) = iia()
		edges.append(xx)
		edges.append(yy)
	d = Counter(edges)
	if d[x] == 1 or n == 1:
		print('Ayush')
	elif (n - 3) % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline

def inp():
	return int(input())

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

def instr():
	s = input()
	return list(s[:len(s) - 1])

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

def main():
	t = inp()
	for l in range(t):
		(n, x) = invr()
		deg = [0] * n
		for i in range(n - 1):
			(u, v) = invr()
			deg[u - 1] += 1
			deg[v - 1] += 1
		if n == 1:
			print('Ayush')
		elif deg[x - 1] == 1:
			print('Ayush')
		elif n % 2 != 0:
			print('Ashish')
		else:
			print('Ayush')
main()


from fractions import Fraction
import sys
import bisect
import heapq
from math import *
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
mod = 1000000007

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

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 graph(vertex):
	return [[] for i in range(0, vertex + 1)]

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

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

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

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

def bfs(v, visited, st):
	visited[st] = 0
	new = [st]
	j = 0
	while j < len(v) - 1:
		st = new[j]
		for i in v[st]:
			if visited[i] == -1:
				new.append(i)
				visited[i] = visited[st] + 1
		j += 1
	return new

def solve():
	(n, x) = sep()
	g = graph(n)
	for i in range(0, n - 1):
		(u, v) = sep()
		g[u].append(v)
		g[v].append(u)
	if len(g[x]) <= 1:
		print('Ayush')
	elif (n - 3) % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')
testcase(int(inp()))


from collections import defaultdict
itl = lambda : list(map(int, input().strip().split()))

def dfs(u, p, edges):
	count = 1
	for v in edges[u]:
		if v != p:
			count += dfs(v, u, edges)
	return count

def solve():
	(n, x) = itl()
	edges = defaultdict(list)
	for _ in range(n - 1):
		(u, v) = itl()
		edges[u].append(v)
		edges[v].append(u)
	if len(edges[x]) <= 1:
		return 'Ayush'
	ans = 0
	for u in edges[x]:
		ans += dfs(u, x, edges)
	if len(edges[x]) == 2:
		return 'Ashish' if (ans - 2) % 2 == 0 else 'Ayush'
	else:
		return 'Ayush' if (ans - 3) % 2 == 0 else 'Ashish'
T = int(input())
for _ in range(T):
	print(solve())


from collections import deque

def bfs(special):
	count = 0
	seen = {special: 0}
	q = deque()
	q.appendleft(special)
	while q:
		curr = q.pop()
		for node in adj[curr]:
			if node not in seen:
				seen[node] = 0
				q.appendleft(node)
		count += 1
	return count
for i in range(int(input())):
	(nodes, special) = map(int, input().split())
	adj = [[] for i in range(nodes + 1)]
	for i in range(nodes - 1):
		(u, v) = map(int, input().split())
		adj[u].append(v)
		adj[v].append(u)
	if len(adj[special]) <= 1:
		print('Ayush')
	else:
		count = bfs(special)
		if (count - 2) % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')


from sys import stdin
input = stdin.readline
from collections import defaultdict
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	g = defaultdict(set)
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		g[u].add(v)
		g[v].add(u)
	if n == 1:
		print('Ayush')
		continue
	t = 0
	for i in g[x]:
		t += 1
	if t == 1:
		print('Ayush')
	elif (n - 3) % 2:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin
inp = lambda : stdin.readline().strip()

def dfs(a, b, graph):
	visited[a] = 1
	b += 1
	start = b
	dfs_order.append(a)
	for it in graph[a]:
		if not visited[it]:
			b = dfs(it, b, adj)
	for child in range(start, b):
		subTree[a].append(dfs_order[child])
	return b
t = int(inp())
for _ in range(t):
	(n, x) = [int(x) for x in inp().split()]
	adj = [[] for i in range(n)]
	visited = [0] * n
	dfs_order = []
	subTree = [[] for x in range(n)]
	for i in range(n - 1):
		(u, v) = [int(x) for x in inp().split()]
		adj[u - 1].append(v - 1)
		adj[v - 1].append(u - 1)
	dfs(x - 1, 0, adj)
	ans = len(subTree[x - 1]) - 1
	if ans <= 0 or len(adj[x - 1]) == 1:
		print('Ayush')
	elif ans % 2:
		print('Ashish')
	else:
		print('Ayush')


import sys
from sys import stdin
input = iter(sys.stdin.buffer.read().decode().splitlines()).__next__

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

def Neo():
	return list(map(int, input().split()))
for _ in range(int(input())):
	(n, x) = neo()
	mark = {}
	for i in range(n - 1):
		(u, v) = neo()
		if mark.get(u, 0) == 0:
			mark[u] = [v]
		else:
			mark[u].append(v)
		if mark.get(v, 0) == 0:
			mark[v] = [u]
		else:
			mark[v].append(u)
	if n == 1 or len(mark[x]) == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


T = int(input())
for _ in range(T):
	(n, x) = [int(a) for a in input().split()]
	edge = dict([(i, []) for i in range(1, n + 1)])
	for i in range(n - 1):
		(u, v) = [int(a) for a in input().split()]
		edge[u].append(v)
		edge[v].append(u)
	if len(edge[x]) <= 1:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


from collections import Counter
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')
from bisect import bisect_right
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	d = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u == k or v == k:
			d += 1
	if n == 1 or n == 2 or d == 1:
		print('Ayush')
	elif (n - 3) % 2 == 0:
		print('Ashish')
	elif (n - 3) % 2 == 1:
		print('Ayush')


for _ in range(int(input())):
	(n, xe) = map(int, input().split())
	adj = [[] for _ in range(n + 1)]
	for i in range(n - 1):
		(x, y) = map(int, input().split())
		adj[x].append(y)
		adj[y].append(x)
	if len(adj[xe]) <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin
for _ in range(int(stdin.readline())):
	(n, x) = map(int, stdin.readline().split())
	ed = 0
	for _ in range(n - 1):
		(u, v) = map(int, stdin.readline().split())
		if u == x or v == x:
			ed += 1
	if ed >= 2 and (n - 3) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


MOD = 1000000007
ii = lambda : int(input())
si = lambda : input()
dgl = lambda : list(map(int, input()))
f = lambda : map(int, input().split())
il = lambda : list(map(int, input().split()))
ls = lambda : list(input())
from collections import *
from collections import defaultdict
for _ in range(ii()):
	(n, x) = f()
	g = defaultdict(list)
	for i in range(0, n - 1):
		(u, v) = f()
		g[u].append(v)
		g[v].append(u)
	if len(g[x]) <= 1:
		print('Ayush')
	elif n % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict
t = int(input())
for _ in range(t):
	(n, x) = list(map(int, input().split()))
	deg = [0] * (n + 1)
	for _ in range(n - 1):
		(u, v) = list(map(int, input().split()))
		deg[u] += 1
		deg[v] += 1
	if deg[x] <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import math
z = int(input())
for contorr in range(z):
	(n, x) = list(map(int, input().split()))
	cate = 0
	for i in range(n - 1):
		(a, b) = list(map(int, input().split()))
		if a == x or b == x:
			cate += 1
	if cate == 1 or n == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin as cin
from itertools import accumulate
lmap = lambda f, it: list(map(f, it))

def main():
	t = int(next(cin).strip())
	for i in range(t):
		(n, x) = lmap(int, next(cin).strip().split())
		nbrs = 0
		for j in range(n - 1):
			(u, v) = lmap(int, next(cin).strip().split())
			if u == x or v == x:
				nbrs += 1
		if nbrs <= 1:
			print('Ayush')
		else:
			print('Ayush' if n % 2 == 0 else 'Ashish')
main()


def solve(indegree, x, n):
	if indegree[x] <= 1:
		print('Ayush')
		return
	if n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')

def main():
	t = int(input())
	for j in range(t):
		(n, x) = tuple(map(int, input().split(' ')))
		indegree = [0] * (n + 1)
		for i in range(n - 1):
			a = list(map(int, input().split(' ')))
			indegree[a[0]] += 1
			indegree[a[1]] += 1
		solve(indegree, x, n)
main()


from collections import defaultdict
from collections import Counter
import bisect
import sys
input = sys.stdin.readline

def solve():
	(n, x) = map(int, input().split())
	degx = 0
	for i in range(n - 1):
		e = map(int, input().split())
		if x in e:
			degx += 1
	if degx <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')

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


from math import *
import heapq
from dataclasses import dataclass, field
from typing import Any
mm = []
nn = []
t = int(input())
for i in range(t):
	nn.append(list(map(int, input().split())))
	mm.append([])
	for j in range(int(nn[i][0]) - 1):
		x = list(map(int, input().split()))
		mm[i].append(x)
for i in range(t):
	m = mm[i]
	n = nn[i][0]
	x = nn[i][1]
	deg = 0
	for j in range(len(m)):
		if m[j][0] == x or m[j][1] == x:
			deg = deg + 1
			if deg > 1:
				break
	if deg <= 1:
		print('Ayush')
		continue
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


from collections import defaultdict

def solve(n, x, deg):
	if deg[x] <= 1:
		print('Ayush')
		return
	if n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')

def read():
	t = int(input())
	for i in range(t):
		(n, x) = list(map(int, input().split()))
		mapka = defaultdict(int)
		for i in range(n - 1):
			(u, v) = list(map(int, input().split()))
			mapka[u] += 1
			mapka[v] += 1
		solve(n, x, mapka)
read()


import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 5)

def dfs(x, visited, graph):
	if x not in visited:
		som = 0
		visited.add(x)
		for i in graph[x]:
			if i not in visited:
				e = dfs(i, visited, graph)
				z = e + 1
				som = som + z
		return som
	return 0
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	if n == 1 and x == 1:
		sys.stdout.write('Ayush\n')
		continue
	d = {}
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u in d:
			d[u].append(v)
		else:
			d[u] = [v]
		if v in d:
			d[v].append(u)
		else:
			d[v] = [u]
	ans = 0
	if len(d[x]) == 1:
		sys.stdout.write('Ayush\n')
		continue
	for i in d[x]:
		visited = {x}
		ans += dfs(i, visited, d) + 1
	if ans % 2 == 1:
		sys.stdout.write('Ayush\n')
	else:
		sys.stdout.write('Ashish\n')


for test_i in range(int(input())):
	(n, x) = map(int, input().split())
	num_outs = 0
	for i in range(n - 1):
		if x in map(int, input().split()):
			num_outs += 1
	if num_outs <= 1:
		print('Ayush')
	else:
		print('Ayush' if n % 2 == 0 else 'Ashish')


def strLine():
	return input().split()

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

def readInt():
	return int(input())

def readStr():
	return input()

def readArr():
	arr = input()
	return [int(n) for n in arr.split()]

def __main():
	t = readInt()
	for case in range(t):
		t -= 1
		(n, x) = lotInt()
		deg = [0] * (n + 1)
		for i in range(n - 1):
			(u, v) = lotInt()
			deg[u] += 1
			deg[v] += 1
		if deg[x] <= 1 or n % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
__main()


import sys, io, os, time
ONLINE_JUDGE = __debug__
if not ONLINE_JUDGE:
	sys.stdin = open('../input.txt', 'r')
	sys.stdout = open('../output.txt', 'w')
start_time = time.time()
if ONLINE_JUDGE:
	input = sys.stdin.readline
from collections import defaultdict
from collections import OrderedDict
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect, math, heapq
alphabet = 'abcdefghijklmnopqrstuvwxyz'
for ii in range(int(input())):
	(n, x) = map(int, input().split())
	t = defaultdict(list)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		t[u].append(v)
		t[v].append(u)
	if n == 1 or len(t[x]) == 1:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')
if not ONLINE_JUDGE:
	print('Time Elapsed :', time.time() - start_time, 'seconds')
sys.stdout.close()


def solve(n, x, edges):
	x_is_leaf = sum((u == x or v == x for (u, v) in edges)) <= 1
	if x_is_leaf:
		return 'Ayush'
	if n % 2 == 0:
		return 'Ayush'
	return 'Ashish'

def main():
	T = int(input())
	for _ in range(T):
		(n, x) = map(int, input().split())
		edges = [list(map(int, input().split())) for _ in range(n - 1)]
		print(solve(n, x, edges))
main()


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import sys

def solve(n, x, Edges):
	if n == 1 or n == 2:
		return 'Ayush'
	if len(Edges[x]) == 1:
		return 'Ayush'
	if n % 2 == 0:
		return 'Ayush'
	return 'Ashish'

def main():
	t = int(input())
	for _ in range(t):
		(n, x) = map(int, input().split())
		x -= 1
		Edges = [[] for _ in range(n)]
		for _ in range(n - 1):
			(u, v) = map(lambda x: int(x) - 1, input().split())
			Edges[u].append(v)
			Edges[v].append(u)
		ans = solve(n, x, Edges)
		sys.stdout.write(ans + '\n')
main()


from sys import stdin, stdout
import sys
t = int(stdin.readline().strip())
for _ in range(t):
	(n, x) = stdin.readline().strip().split(' ')
	(n, x) = (int(n), int(x))
	x -= 1
	adjli = [[] for i in range(n)]
	vis = [False for i in range(n)]
	for i in range(n - 1):
		(u, v) = stdin.readline().strip().split(' ')
		(u, v) = (int(u), int(v))
		u -= 1
		v -= 1
		adjli[u].append(v)
		adjli[v].append(u)
	if len(adjli[x]) <= 1:
		stdout.write('Ayush\n')
	elif n % 2 == 0:
		stdout.write('Ayush\n')
	else:
		stdout.write('Ashish\n')


import sys
LI = lambda : list(map(int, sys.stdin.readline().strip('\n').split()))
MI = lambda : map(int, sys.stdin.readline().strip('\n').split())
SI = lambda : sys.stdin.readline().strip('\n')
II = lambda : int(sys.stdin.readline().strip('\n'))
for _ in range(II()):
	(n, x) = MI()
	deg = [0 for i in range(n + 1)]
	for __ in range(n - 1):
		(u, v) = MI()
		deg[u] += 1
		deg[v] += 1
	print('Ayush' if deg[x] <= 1 or n % 2 == 0 else 'Ashish')


import sys
input = lambda : sys.stdin.readline().rstrip()
inp = sys.stdin.buffer.readline

def I():
	return list(map(int, inp().split()))
from math import inf

def dfs(k):
	global st
	st.add(k)
	for j in g[k]:
		if j in st:
			continue
		dfs(j)
for _ in range(I()[0]):
	(n, xy) = I()
	g = [[] for i in range(n + 1)]
	for i in range(n - 1):
		(x, y) = I()
		g[x].append(y)
		g[y].append(x)
	cld = []
	for i in g[xy]:
		st = {xy}
		dfs(i)
		cld.append(len(st) - 1)
	if len(cld) <= 1:
		print('Ayush')
	elif sum(cld) & 1 == 0:
		print('Ashish')
	else:
		print('Ayush')


from sys import stdin, stdout
import sys
from math import *
sys.setrecursionlimit(10 ** 5)

def dfs(s, p, g):
	ans = 1
	for i in g[s]:
		if i != p:
			ans += dfs(i, s, g)
	return ans
for __ in range(int(input())):
	(n, x) = map(int, input().split())
	g = []
	for i in range(n):
		g.append([])
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		a -= 1
		b -= 1
		g[a].append(b)
		g[b].append(a)
	x -= 1
	ans = 0
	for i in g[x]:
		ans += dfs(i, x, g)
	if ans % 2 == 1 or len(g[x]) < 2:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
while t > 0:
	(n, x) = [int(x) for x in input().split()]
	arr = []
	for i in range(n - 1):
		(a, p) = [int(x) for x in input().split()]
		if a == x or p == x:
			arr.append([a, p])
	if len(arr) < 2:
		print('Ayush')
	elif (n - 3) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')
	t -= 1


import sys
input = sys.stdin.readline
T = int(input())
for testcase in range(T):
	(n, x) = map(int, input().split())
	cnt = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if x in [u, v]:
			cnt += 1
	if cnt == 1 or n == 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


import heapq

def dfs(u, dist, g, vis, d):
	vis[u] = True
	dist[u] = d
	for child in g[u]:
		if not vis[child]:
			dfs(child, dist, g, vis, d + 1)
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	g = [set() for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		g[u].add(v)
		g[v].add(u)
	vis = [False] * n
	dist = [0] * n
	leaves = []
	for i in range(n):
		if len(g[i]) == 1:
			leaves.append(i)
	x -= 1
	dfs(x, dist, g, vis, 0)
	leaves = [(-dist[i], i) for i in leaves]
	heapq.heapify(leaves)
	turn = True
	while len(g[x]) > 1:
		rmv = heapq.heappop(leaves)
		par = g[rmv[1]]
		for p in par:
			g[p].remove(rmv[1])
			if len(g[p]) == 1:
				heapq.heappush(leaves, (-dist[p], p))
		turn = not turn
		if len(g[x]) == 1:
			break
	if turn:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	d = defaultdict(int)
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		d[u] += 1
		d[v] += 1
	if d[x] <= 1:
		print('Ayush')
	elif n & 1:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
while t:
	t -= 1
	(n, x) = [int(i) for i in input().split()]
	x -= 1
	graph = [[] for i in range(n)]
	for i in range(n - 1):
		(u, v) = [int(i) for i in input().split()]
		graph[u - 1].append(v - 1)
		graph[v - 1].append(u - 1)
	if len(graph[x]) == 1 or n == 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


T = int(input())
for _ in range(T):
	(N, s) = map(int, input().split())
	s -= 1
	X = [[] for _ in range(N)]
	for i in range(N - 1):
		(a, b) = map(int, input().split())
		(a, b) = (a - 1, b - 1)
		X[a].append(b)
		X[b].append(a)
	if len(X[s]) <= 1:
		print('Ayush')
		continue
	if (N - 3) % 2:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict
t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	adj = defaultdict(list)
	e = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		adj[u].append(v)
		adj[v].append(u)
		e += 1
	deg = len(adj[x])
	if deg <= 1:
		print('Ayush')
	else:
		num = n - 1
		if num % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


import sys
import math
from bisect import bisect_right as br
import threading

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

def str_arr():
	return list(map(str, sys.stdin.readline().strip().split()))

def input():
	return sys.stdin.readline().strip()
for _ in range(int(input())):
	(n, e) = int_arr()
	cnt = 0
	for i in range(n - 1):
		(x, y) = int_arr()
		if e == x or e == y:
			cnt += 1
	if cnt == 1 or n - 1 == 0:
		print('Ayush')
	elif (n - 2) % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = [int(x) for x in input().split()]
	indeg_x = 0
	for i in range(n - 1):
		edge = [int(x) for x in input().split()]
		if x in edge:
			indeg_x += 1
	if indeg_x <= 1 or n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


tests = int(input())
for test in range(tests):
	(n, x) = map(int, input().split())
	c = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			c += 1
	print('Ayush' if c <= 1 or (n - 1) % 2 == 1 else 'Ashish')


import math
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')
for ik in range(int(input())):
	(n, x) = map(int, input().split())
	v = [[] for i in range(n)]
	tot = set()

	def addEdge(x, y):
		v[x].append(y)
		v[y].append(x)

	def printPath(stack):
		for i in range(len(stack)):
			tot.add(stack[i])

	def DFS(vis, x, y, stack):
		stack.append(x)
		if x == y:
			printPath(stack)
			return
		vis[x] = True
		flag = 0
		if len(v[x]) > 0:
			for j in v[x]:
				if vis[j] == False:
					DFS(vis, j, y, stack)
					flag = 1
		del stack[-1]

	def DFSCall(x, y, n, stack):
		vis = [0 for i in range(n + 1)]
		DFS(vis, x, y, stack)
	vis = [0] * n
	s = set()
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		addEdge(a - 1, b - 1)
		vis[a - 1] += 1
		vis[b - 1] += 1
	for i in range(n):
		if vis[i] <= 1:
			s.add(i)
	if x - 1 in s:
		print('Ayush')
		continue
	for i in s:
		stack = []
		DFSCall(x - 1, i, n, stack)
	if len(tot) % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


def main():
	t = int(input())
	for _ in range(t):
		(n, x) = map(int, input().split())
		x_children = 0
		for __ in range(n - 1):
			(u, v) = map(int, input().split())
			if u == x or v == x:
				x_children += 1
		nodes_to_remove = n - 2
		if x_children <= 1:
			print('Ayush')
		elif nodes_to_remove % 2 == 0:
			print('Ayush')
		else:
			print('Ashish')
main()


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	d = {}
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if u in d:
			d[u].append(v)
		else:
			d[u] = [v]
		if v in d:
			d[v].append(u)
		else:
			d[v] = [u]
	leaf = []
	for (u, v) in d.items():
		if len(v) <= 1:
			leaf.append(u)
	if x in leaf or n <= 2:
		print('Ayush')
		continue
	if (n - 2) % 2 != 0:
		print('Ashish')
	else:
		print('Ayush')


def dfs(v):
	global used
	global cnt
	used[v] = True
	cnt += 1
	for i in u[v]:
		if not used[i]:
			dfs(i)
ans = []
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	x -= 1
	u = []
	for i in range(n):
		u.append([])
	for i in range(n - 1):
		(a, b) = map(lambda z: int(z) - 1, input().split())
		u[a].append(b)
		u[b].append(a)
	if len(u[x]) <= 1:
		ans.append('Ayush')
		continue
	used = [False] * n
	d = [0] * len(u[x])
	used[x] = True
	for i in range(len(u[x])):
		cnt = 0
		dfs(u[x][i])
		d[i] = cnt
	nm = 0
	for i in range(len(d)):
		if d[i] % 2 == 0:
			nm += 1
	if (len(d) - nm) % 2 == 0:
		ans.append('Ashish')
	else:
		ans.append('Ayush')
print('\n'.join(ans))


import sys
pprint = lambda s: print(' '.join(map(str, s)))
input = lambda : sys.stdin.readline().strip()
ipnut = input
for i in range(int(input())):
	(n, x) = map(int, input().split())
	g = [[] for i in range(n)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		a -= 1
		b -= 1
		g[a].append(b)
		g[b].append(a)
	if len(g[x - 1]) <= 1:
		print('Ayush')
	elif (n - 3) % 2:
		print('Ayush')
	else:
		print('Ashish')


from collections import defaultdict as dd
for _ in range(int(input())):
	g = dd(list)
	(n, x) = map(int, input().split())
	for i in range(n - 1):
		(v, u) = map(int, input().split())
		g[v].append(u)
		g[u].append(v)
	if len(g[x]) <= 1:
		print('Ayush')
	else:
		print(['Ashish', 'Ayush'][(n - 1) % 2])


t = int(input())
for _ in range(t):
	(n, x) = list(map(int, input().split(' ')))
	coun = 0
	for i in range(n - 1):
		(u, v) = list(map(int, input().split(' ')))
		if u == x or v == x:
			coun += 1
	if coun <= 1:
		print('Ayush')
	elif n & 1 == 0:
		print('Ayush')
	else:
		print('Ashish')


test = int(input())
while test:
	nx = input().split()
	n = int(nx[0])
	x = int(nx[1])
	deg = 0
	for i in range(0, n - 1):
		uv = input().split()
		u = int(uv[0])
		v = int(uv[1])
		if u == x or v == x:
			deg += 1
	if deg <= 1:
		print('Ayush\n')
	elif (n - 3) % 2 == 0:
		print('Ashish\n')
	else:
		print('Ayush\n')
	test -= 1


from collections import deque
from sys import stdin, stdout
import math
input = stdin.readline
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	k -= 1
	leaves = []
	path = [[] for i in range(n)]
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		path[a - 1].append(b - 1)
		path[b - 1].append(a - 1)
	for i in range(n):
		if len(path[i]) <= 1:
			leaves.append(i)
	sm = n - 1
	if k in leaves:
		sm = 1
	print('Ashish' if not sm % 2 else 'Ayush')


from collections import defaultdict

def traverse(di, node, visited, count):
	flag = 0
	arr = []
	for i in di[node]:
		if i not in visited:
			flag = 1
			tem = set()
			tem.add(i)
			arr.append(traverse(di, i, visited.union(tem), count + 1) - count)
	if flag == 0:
		return count
	if node == x:
		return arr
	else:
		return sum(arr) + count
global x
t = int(input())
for _ in range(t):
	ls = []
	(n, x) = map(int, input().split())
	di = defaultdict(list)
	for i in range(n - 1):
		(src, dest) = map(int, input().split())
		di[src].append(dest)
		di[dest].append(src)
	if di == {}:
		print('Ayush')
	elif len(di[x]) == 1:
		print('Ayush')
	else:
		s = set()
		s.add(x)
		ls = traverse(di, x, s, 0)
		rem = sum(ls)
		if rem % 2 == 0:
			print('Ashish')
		else:
			print('Ayush')


import math
t = int(input())
for s in range(t):
	(n, x) = [int(x) for x in input().split()]
	v = []
	for i in range(n + 1):
		v.append([])
	for i in range(n - 1):
		(a, b) = [int(x) for x in input().split()]
		v[a].append(b)
		v[b].append(a)
	val = 0
	if len(v[x]) == 1 or len(v[x]) == 0:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


import sys
input = sys.stdin.readline

def I():
	return input().strip()

def II():
	return int(input().strip())

def LI():
	return [*map(int, input().strip().split())]
import string, math, time, functools, random, fractions
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
from collections import deque, defaultdict, Counter, OrderedDict
from itertools import permutations, combinations, groupby
for _ in range(II()):
	(n, x) = LI()
	z = 0
	for i in range(n - 1):
		(u, v) = LI()
		if u == x or v == x:
			z += 1
	if z <= 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


from collections import Counter
from collections import defaultdict
from collections import deque
import math
import heapq
import sys
input = sys.stdin.readline
from bisect import *
rs = lambda : input().strip()
ri = lambda : int(input())
rl = lambda : list(map(int, input().split()))
rls = lambda : list(map(str, input().split()))

def find(i):
	vis[i] = 1
	ans = 0
	for j in d[i]:
		if vis[j] == 0:
			ans = ans + 1 + find(j)
	return ans
t = int(input())
for _ in range(0, t):
	(n, x) = rl()
	x = x - 1
	d = [0] * n
	total = 0
	for i in range(0, n - 1):
		(a, b) = rl()
		a = a - 1
		b = b - 1
		d[a] = d[a] + 1
		d[b] = d[b] + 1
		total += 1
	if d[x] == 1 or d[x] == 0:
		print('Ayush')
		continue
	ans = total - d[x]
	ans = ans + d[x] - 1
	if ans % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


t = int(input())
First = 'Ayush'
Second = 'Ashish'
for _ in range(t):
	(n, x) = map(int, input().split())
	st = 0
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		if x == u or x == v:
			st += 1
	if n <= 2:
		print(First)
	elif st == 1:
		print(First)
	elif n % 2 == 0:
		print(First)
	else:
		print(Second)


def solve():
	(n, x) = input().split()
	n = int(n)
	x = int(x)
	cnt = 0
	y = n - 1
	while y > 0:
		(a, b) = input().split()
		a = int(a)
		b = int(b)
		if a == x or b == x:
			cnt += 1
		y -= 1
	if cnt <= 1 or n < 3:
		print('Ayush')
		return
	else:
		x = (n - 3) % 2
		if x:
			print('Ayush')
		else:
			print('Ashish')
t = int(input())
while t:
	solve()
	t -= 1


for _ in range(int(input())):
	(n, special) = map(int, input().split())
	count = 0
	n -= 1
	for _ in range(n):
		(a, b) = map(int, input().split())
		if a == special or b == special:
			count += 1
	if count <= 1 or n % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, x) = map(int, input().split())
	child = [0] * (n + 1)
	for _ in range(n - 1):
		(x1, y1) = map(int, input().split())
		child[x1] += 1
		child[y1] += 1
	if child[x] <= 1:
		print('Ayush')
	elif (n - 1) % 2 == 0:
		print('Ashish')
	else:
		print('Ayush')


from sys import *
setrecursionlimit(100000)
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	A = {}
	A[m] = set()
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		if a in A:
			A[a].add(b)
		else:
			A[a] = set()
			A[a].add(b)
		if b in A:
			A[b].add(a)
		else:
			A[b] = set()
			A[b].add(a)
	if len(A[m]) == 0 or len(A[m]) == 1:
		print('Ayush')
	elif (n - 2) % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


for _ in range(int(input())):
	(n, x) = list(map(int, input().split()))
	graph = [[] for i in range(1002)]
	for _ in range(n - 1):
		(u, v) = list(map(int, input().split()))
		graph[u].append(v)
		graph[v].append(u)
	if len(graph[x]) <= 1:
		print('Ayush')
	elif n % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')


import sys
input = sys.stdin.buffer.readline

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

def sieve(n):
	a = [1] * n
	for i in range(2, n):
		if a[i]:
			for j in range(i * i, n, i):
				a[j] = 0
	return a
for __ in range(int(input())):
	(n, x) = I()
	neighs = 0
	for i in range(n - 1):
		(u, v) = I()
		if u == x or v == x:
			neighs += 1
	if neighs <= 1:
		print('Ayush')
	elif n % 2:
		print('Ashish')
	else:
		print('Ayush')


from sys import stdin, gettrace

def readTree(n):
	adj = [set() for _ in range(n)]
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		adj[u - 1].add(v - 1)
		adj[v - 1].add(u - 1)
	return adj

def main():

	def solve():
		(n, x) = map(int, input().split())
		x -= 1
		adj = readTree(n)
		if len(adj[x]) <= 1:
			print('Ayush')
			return
		if n % 2 == 1:
			print('Ashish')
		else:
			print('Ayush')
	q = int(input())
	for _ in range(q):
		solve()
main()


import bisect
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate

def primeFactors(n):
	prime = set()
	while n % 2 == 0:
		prime.add(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			prime.add(i)
			n = n // i
	if n > 2:
		prime.add(n)
	return list(prime)

def getFactors(n):
	factors = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				factors.append(i)
			else:
				factors.append(i)
				factors.append(n // i)
		i = i + 1
	return factors

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	num = []
	for p in range(2, n + 1):
		if prime[p]:
			num.append(p)
	return num

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

def sort_dict(key_value):
	return sorted(key_value.items(), key=lambda kv: (kv[1], kv[0]))

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

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

def string_list():
	return list(input())

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

def binaryToDecimal(n):
	return int(n, 2)

def solve():
	adjacency_list = {}
	(n, x) = num_input()
	for _ in range(n - 1):
		(u, v) = num_input()
		try:
			adjacency_list[u].append(v)
		except KeyError:
			adjacency_list[u] = [v]
		try:
			adjacency_list[v].append(u)
		except KeyError:
			adjacency_list[v] = [u]
	if n == 1:
		print('Ayush')
		return
	if len(adjacency_list[x]) == 1:
		print('Ayush')
		return
	if n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')
t = int(input())
for _ in range(t):
	solve()


T = int(input())
for _ in range(T):
	(n, x) = input().split()
	n = int(n)
	x = int(x)
	temp = [0] * n
	for i in range(n - 1):
		(t1, t2) = input().split()
		t1 = int(t1)
		t2 = int(t2)
		temp[t1 - 1] += 1
		temp[t2 - 1] += 1
	if temp[x - 1] == 1 or n == 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


import collections
t = int(input())
ans = ['Ayush', 'Ashish']
for _ in range(t):
	(n, x) = map(int, input().split())
	x -= 1
	G = [set() for i in range(n)]
	for i in range(n - 1):
		(u, v) = map(int, input().split())
		u -= 1
		v -= 1
		G[u].add(v)
		G[v].add(u)
	ans_id = 0
	if len(G[x]) > 1:
		ans_id = n % 2
	print(ans[ans_id])


t = int(input())

def count(l, p, parent):
	if len(l[p - 1]) == 1:
		return 1
	else:
		ans = 1
		for i in range(len(l[p - 1])):
			if l[p - 1][i] != parent - 1:
				ans += count(l, l[p - 1][i] + 1, p)
		return ans
for _ in range(t):
	(n, p) = map(int, input().split())
	l = []
	for i in range(n):
		l.append([])
	for i in range(n - 1):
		(a, b) = map(int, input().split())
		l[a - 1].append(b - 1)
		l[b - 1].append(a - 1)
	ans = 0
	temp = 0
	for i in range(len(l[p - 1])):
		ans += count(l, l[p - 1][i] + 1, p)
	if len(l[p - 1]) <= 1:
		print('Ayush')
	elif ans % 2 == 1:
		print('Ayush')
	else:
		print('Ashish')


N = int(input())
for i in range(N):
	(n, X) = map(int, input().split())
	L = [[] for i in range(n + 1)]
	for j in range(n - 1):
		(a, b) = map(int, input().split())
		L[a].append(b)
		L[b].append(a)
	M = len(L[X])
	if M <= 1:
		print('Ayush')
	elif n % 2 == 0:
		print('Ayush')
	else:
		print('Ashish')


from sys import stdin
from collections import Counter, deque
from bisect import bisect_left
input = stdin.buffer.readline
T = int(input())
for _ in range(T):
	(n, x) = map(int, input().split())
	ls = [0] * (n + 1)
	for _ in range(n - 1):
		(a, b) = map(int, input().split())
		ls[a] += 1
		ls[b] += 1
	print('Ayush' if ls[x] <= 1 or n % 2 == 0 else 'Ashish')


def solve():
	(n, x) = map(int, input().split())
	adj = 0
	for _ in range(n - 1):
		(u, v) = map(int, input().split())
		if u == x or v == x:
			adj += 1
	if adj <= 1:
		return 'Ayush'
	if n % 2 == 1:
		return 'Ashish'
	else:
		return 'Ayush'

def main():
	T = int(input())
	ANS = []
	for _ in range(T):
		ANS.append(solve())
	print('\n'.join(ANS))
main()


t = int(input())
for l in range(t):
	(n, x) = list(map(int, input().split()))
	N = n + 1
	count1 = [0] * N
	adj = [[] for i in range(N)]

	def numberOfNodes(s, e):
		count1[s] = 1
		for u in adj[s]:
			if u == e:
				continue
			numberOfNodes(u, s)
			count1[s] += count1[u]

	def addEdge(a, b):
		adj[a].append(b)
		adj[b].append(a)

	def printNumberOfNodes(node):
		return count1[node]
	for j in range(n - 1):
		(u, v) = list(map(int, input().split()))
		addEdge(u, v)
	numberOfNodes(x, 0)
	if len(adj[x]) <= 1:
		print('Ayush')
	else:
		a = len(adj[x])
		b = 0
		for j in range(a):
			b += printNumberOfNodes(adj[x][j])
			b -= 1
		b += a
		if b % 2 == 1:
			print('Ayush')
		else:
			print('Ashish')


import sys
import math
import collections
from sys import stdin, stdout, setrecursionlimit
import bisect as bs
setrecursionlimit(2 ** 20)
M = 10 ** 9 + 7
T = int(stdin.readline())
for _ in range(T):
	(n, x) = list(map(int, stdin.readline().split()))
	g = []
	for i in range(n + 1):
		g.append([])
	for i in range(n - 1):
		(u, v) = list(map(int, stdin.readline().split()))
		g[u].append(v)
		g[v].append(u)
	if len(g[x]) == 1:
		print('Ayush')
		continue
	if n == 1:
		print('Ayush')
		continue
	if (n - 2) % 2 == 1:
		print('Ashish')
	else:
		print('Ayush')