Ashish and Vivek play a game on a matrix consisting of $n$ rows and $m$ columns, where they take turns claiming cells. Unclaimed cells are represented by $0$, while claimed cells are represented by $1$. The initial state of the matrix is given. There can be some claimed cells in the initial state.

In each turn, a player must claim a cell. A cell may be claimed if it is unclaimed and does not share a row or column with any other already claimed cells. When a player is unable to make a move, he loses and the game ends.

If Ashish and Vivek take turns to move and Ashish goes first, determine the winner of the game if both of them are playing optimally.

Optimal play between two players means that both players choose the best possible strategy to achieve the best possible outcome for themselves.


-----Input-----

The first line consists of a single integer $t$ $(1 \le t \le 50)$ — the number of test cases. The description of the test cases follows.

The first line of each test case consists of two space-separated integers $n$, $m$ $(1 \le n, m \le 50)$ — the number of rows and columns in the matrix.

The following $n$ lines consist of $m$ integers each, the $j$-th integer on the $i$-th line denoting $a_{i,j}$ $(a_{i,j} \in \{0, 1\})$.


-----Output-----

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


-----Example-----
Input
4
2 2
0 0
0 0
2 2
0 0
0 1
2 3
1 0 1
1 1 0
3 3
1 0 0
0 0 0
1 0 0

Output
Vivek
Ashish
Vivek
Ashish



-----Note-----

For the first case: One possible scenario could be: Ashish claims cell $(1, 1)$, Vivek then claims cell $(2, 2)$. Ashish can neither claim cell $(1, 2)$, nor cell $(2, 1)$ as cells $(1, 1)$ and $(2, 2)$ are already claimed. Thus Ashish loses. It can be shown that no matter what Ashish plays in this case, Vivek will win. 

For the second case: Ashish claims cell $(1, 1)$, the only cell that can be claimed in the first move. After that Vivek has no moves left.

For the third case: Ashish cannot make a move, so Vivek wins.

For the fourth case: If Ashish claims cell $(2, 3)$, Vivek will have no moves left.

Difficulty: EASY
Tags: Game theory

Implementation

Greedy algorithms
Skill types: Greedy algorithms

Starter code:

Solutions:
import sys

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

def main():
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		B = [list(map(int, input().split())) for k in range(n)]
		R = [B[k].count(1) for k in range(n)]
		C = [0] * m
		for l in range(m):
			f = 0
			for k in range(n):
				f += B[k][l]
			C[l] = f
		count = 0
		while True:
			prev = count
			for l in range(m):
				for k in range(n):
					if R[k] == 0 and C[l] == 0:
						count += 1
						R[k] = 1
						C[l] = 1
			if count == prev:
				break
		print('Ashish' if count % 2 == 1 else 'Vivek')
main()


def ip():
	return int(input())

def sip():
	return input()

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

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

def matip(n, m):
	lst = []
	for i in range(n):
		arr = lip()
		lst.append(arr)
	return lst
t = ip()
while t:
	t -= 1
	(n, m) = mip()
	arr = matip(n, m)
	row = col = 0
	for i in range(n):
		if arr[i].count(0) == m:
			row += 1
	for i in range(m):
		p = 0
		for j in range(n):
			if arr[j][i] == 0:
				p += 1
		if p == n:
			col += 1
	if min(row, col) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(m, n) = list(map(int, input().split()))
	lst = []
	for i in range(m):
		lst.append(list(map(int, input().split())))
	row = set()
	col = set()
	for i in range(m):
		for j in range(n):
			if lst[i][j] == 1:
				row.add(i)
				col.add(j)
	chang = True
	c = 0
	while chang:
		for i in range(m):
			for j in range(n):
				if lst[i][j] == 0 and i not in row and (j not in col):
					c += 1
					row.add(i)
					col.add(j)
					continue
		else:
			chang = False
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def check(grid, x, y, n, m):
	for i in range(n):
		if i != x and grid[i][y] == 1:
			return False
	for i in range(m):
		if i != y and grid[x][i] == 1:
			return False
	return True
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	grid = []
	for i in range(n):
		grid.append(list(map(int, input().split())))
	cur = 0
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 0 and check(grid, i, j, n, m):
				cur += 1
				grid[i][j] = 1
				break
	if cur % 2:
		print('Ashish')
	else:
		print('Vivek')


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):
	(m, n) = int_split_input()
	(m_one, n_one) = (0, set())
	for i in range(m):
		cur = int_split_input()
		if cur.count(1) > 0:
			m_one += 1
		for i in range(len(cur)):
			if cur[i] == 1:
				n_one.add(i)
	c = min(m - m_one, n - len(n_one))
	if c % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


x = int(input())
for it in range(x):
	y = input().split()
	n = int(y[0])
	m = int(y[1])
	h = 0
	j = 0
	l = []
	for r in range(n):
		a = input().split()
		l.append(a)
		if not '1' in a:
			h += 1
	for z in range(m):
		for c in range(n):
			if l[c][z] == '1':
				j += 1
				break
	if min(h, m - j) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input('').split())
	matrix = []
	for i in range(n):
		matrix.append(list(map(int, input('').split())))
	check = list()
	(i, j) = (0, 0)
	while i < n:
		if 1 not in matrix[i]:
			j = 0
			while j < m:
				flag = 0
				for k in range(n):
					if matrix[k][j] == 1:
						flag = 1
						break
				if flag == 0:
					check.append([i, j])
					matrix[i][j] = 1
					j += 1
					break
				else:
					j += 1
		i += 1
	if len(check) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in ' ' * int(input()):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		lst = list(map(int, input().split()))
		a.append(lst)
	s = 'Vivek'
	row = []
	col = []
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row.append(i)
				col.append(j)
	row = list(set(row))
	col = list(set(col))
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0:
				if i not in row and j not in col:
					if s == 'Vivek':
						s = 'Ashish'
					else:
						s = 'Vivek'
					row.append(i)
					col.append(j)
	print(s)


from collections import defaultdict
import math
from functools import reduce
from heapq import heapify, heappush, heappop
import sys
from sys import stdin, stdout
from random import seed
from random import randint
mod = 10 ** 9 + 7

def mul_mod(a, b):
	return a % mod * (b % mod) % mod

def add_mod(a, b):
	return (a % mod + b % mod) % mod

def sub_mod(a, b):
	return (a % mod - b % mod + mod) % mod

def modInverse(b):
	return pow(b, mod - 2, mod)

def div_mod(a, b):
	a = a % mod
	inv = modInverse(b)
	return inv * a % mod

class Graph:

	def __init__(self, vertices):
		self.V = vertices + 1
		self.graph = defaultdict(set)
		self.Time = 0
		self.P = 0
		self.Q = 0

	def addEdge(self, u, v):
		self.graph[u].add(v)
		self.graph[v].add(u)

	def bridgeUtil(self, u):
		self.count[u] += 1
		self.disc[u] = self.Time
		self.low[u] = self.Time
		self.Time += 1
		for v in self.graph[u]:
			if self.count[v] == 0:
				self.parent[v] = u
				self.bridgeUtil(v)
				self.count[u] += self.count[v]
				self.low[u] = min(self.low[u], self.low[v])
				if self.low[v] > self.disc[u]:
					self.Q += 1
					if self.count[v] % 2 == 0:
						self.P += 1
			elif v != self.parent[u]:
				self.low[u] = min(self.low[u], self.disc[v])

	def bridge(self):
		self.disc = [float('Inf')] * self.V
		self.low = [float('Inf')] * self.V
		self.parent = [-1] * self.V
		self.count = [0] * self.V
		for i in range(1, self.V):
			if self.count[i] == 0:
				self.bridgeUtil(i)
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	empty_rows = 0
	for i in range(n):
		empty = True
		for j in range(m):
			if mat[i][j] == 1:
				empty = False
				break
		empty_rows += int(empty)
	empty_cols = 0
	for j in range(m):
		empty = True
		for i in range(n):
			if mat[i][j] == 1:
				empty = False
				break
		empty_cols += int(empty)
	ans = min(empty_rows, empty_cols)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	matrix = []
	for i in range(n):
		row = list(map(int, input().split()))
		matrix.append(row)
	qty_rows = 0
	qty_columns = 0
	for i in range(n):
		if list(set(matrix[i]))[0] == 0 and len(list(set(matrix[i]))) == 1:
			qty_rows += 1
	for j in range(m):
		check_column = []
		k = 0
		while k < n:
			check_column.append(matrix[k][j])
			k += 1
		if list(set(check_column))[0] == 0 and len(list(set(check_column))) == 1:
			qty_columns += 1
	res = min(qty_rows, qty_columns)
	if res % 2:
		print('Ashish')
	else:
		print('Vivek')


def main():
	(n, m) = map(int, input().split())
	lst_vert = [0 for _ in range(n)]
	lst_hor = [0 for _ in range(m)]
	for i in range(n):
		line = list(map(int, input().split()))
		if 1 in line:
			lst_vert[i] = 1
		for i in range(m):
			if line[i] == 1:
				lst_hor[i] = 1
	vert = n
	hor = m
	for i in lst_hor:
		if i == 1:
			hor -= 1
	for i in lst_vert:
		if i == 1:
			vert -= 1
	if min(hor, vert) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for i in range(t):
	main()


for testcase in range(int(input())):
	(rows, cols) = map(int, input().split())
	rowset = {i for i in range(rows)}
	colset = {i for i in range(cols)}
	for i in range(rows):
		r = list(map(int, input().split()))
		for (col, binary) in enumerate(r):
			if binary == 1:
				if col in colset:
					colset.remove(col)
				if i in rowset:
					rowset.remove(i)
	intersections = min(len(rowset), len(colset))
	if intersections % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import sys

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

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

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

def ws(s):
	sys.stdout.write(s + '\n')

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

def wia(a):
	sys.stdout.write(' '.join([str(x) for x in a]) + '\n')

def solve(n, m, a):
	rc = 0
	for i in range(n):
		if sum(a[i]) == 0:
			rc += 1
	cc = 0
	for j in range(m):
		if sum([a[k][j] for k in range(n)]) == 0:
			cc += 1
	return min(rc, cc) % 2 == 1

def main():
	for _ in range(ri()):
		(n, m) = ria()
		a = []
		for _ in range(n):
			a.append(ria())
		wi('Ashish' if solve(n, m, a) else 'Vivek')
main()


import sys

def arr():
	return list(map(int, input().split()))
input = sys.stdin.readline
from collections import defaultdict
import math
for _ in range(int(input())):
	(N, M) = map(int, input().split())
	L = []
	p = min(N, M)
	for i in range(N):
		L.append(arr())
	count = 0
	r = 0
	c = 0
	Hash1 = defaultdict(lambda : 0)
	for i in range(N):
		flag = True
		for j in range(M):
			if L[i][j] == 1:
				flag = False
				break
		if flag:
			Hash1[i] = 1
	Hash2 = defaultdict(lambda : 0)
	for i in range(M):
		flag = True
		for j in range(N):
			if L[j][i] == 1:
				flag = False
				break
		if flag:
			Hash2[i] = 1
	for i in range(N):
		for j in range(M):
			if L[i][j] == 0 and Hash1[i] == 1 and (Hash2[j] == 1):
				count += 1
				Hash1[i] = 0
				Hash2[j] = 0
	if count % 2:
		print('Ashish')
	else:
		print('Vivek')


nt = int(input())
for test in range(nt):
	inp = input()
	nr = int(str(inp).split(' ')[0])
	mat = []
	for r in range(nr):
		col = input()
		col = str(col).split(' ')
		col = [int(q) for q in col]
		mat.append(col)
	rows = {}
	cols = {}
	for i in range(len(mat)):
		for j in range(len(mat[0])):
			if mat[i][j] == 1:
				rows[i] = 1
				cols[j] = 1
	frows = 0
	for i in range(len(mat)):
		if i not in rows:
			frows += 1
	fcols = 0
	for j in range(len(mat[0])):
		if j not in cols:
			fcols += 1
	if min(frows, fcols) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout
for test in range(int(stdin.readline())):
	arr = [int(x) for x in stdin.readline().split()]
	n = arr[0]
	m = arr[1]
	ans_row = {}
	ans_column = {i: True for i in range(m)}
	for rows in range(n):
		arr1 = [int(x) for x in stdin.readline().split()]
		if 1 not in arr1:
			ans_row[rows] = True
		for i in range(len(arr1)):
			if arr1[i] == 1 and i in ans_column:
				ans_column.pop(i)
	ans = min(len(ans_column), len(ans_row))
	if ans % 2 == 1:
		stdout.write('Ashish\n')
	else:
		stdout.write('Vivek\n')


import collections

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

def readInt():
	return int(input().strip())

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

def solve(n, m, grid):
	(rowTaken, colTaken) = (set(), set())
	for row in range(n):
		for col in range(m):
			if grid[row][col] == 1:
				rowTaken.add(row)
				colTaken.add(col)
	(availableRows, availableCols) = (n - len(set(rowTaken)), m - len(set(colTaken)))
	minAvailable = min(availableRows, availableCols)
	if minAvailable & 1:
		return 'Ashish'
	else:
		return 'Vivek'
t = readInt()
for i in range(t):
	[n, m] = readList()
	grid = []
	for _ in range(n):
		grid.append(readList())
	print(solve(n, m, grid))


t = int(input())
for _ in range(t):
	inp = [int(x) for x in input().split()]
	(n, m) = (inp[0], inp[1])
	arr = []
	rows = 0
	for i in range(n):
		row = [int(x) for x in input().split()]
		arr.append(row)
		if row.count(0) == m:
			rows += 1
	cols = 0
	for i in range(m):
		cnt = 0
		for j in range(n):
			if arr[j][i] == 0:
				cnt += 1
		if cnt == n:
			cols += 1
	if min(rows, cols) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	r = [0] * n
	c = [0] * m
	for i in range(n):
		T = [int(x) for x in input().split()]
		for t in range(len(T)):
			if T[t] == 1:
				r[i] = 1
				c[t] = 1
	result = min(n - sum(r), m - sum(c))
	print('Vivek' if result % 2 == 0 else 'Ashish')


a = [[0 for i in range(1111)] for j in range(1111)]
temp = int(input())
while temp > 0:
	temp -= 1
	b = list(map(int, input().split()))
	m = b[0]
	n = b[1]
	c = 0
	d = 0
	for i in range(m):
		t = list(map(int, input().split()))
		for j in range(len(t)):
			a[i][j] = t[j]
	for i in range(m):
		for j in range(n):
			if a[i][j] != 0:
				break
		else:
			c += 1
	for j in range(n):
		for i in range(m):
			if a[i][j] != 0:
				break
		else:
			d += 1
	s = min(c, d)
	if s % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


def available_moves(mat):
	moves_available = 0
	for row in mat:
		if len(set(row)) == 1 and row[0] == 0:
			moves_available += 1
	return moves_available

def invert(mat):
	imat = []
	for i in range(len(mat[0])):
		imat.append([row[i] for row in mat])
	return imat

def main():
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		mat = [list(map(int, input().split())) for _ in range(n)]
		moves_available = min(available_moves(mat), available_moves(invert(mat)))
		if moves_available % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


tll = int(input())
while tll > 0:
	tll -= 1
	(n, m) = map(int, input().split())
	l = []
	rows = {}
	cols = {}
	r = [i for i in range(n)]
	c = [i for i in range(m)]
	for i in range(n):
		rows[i] = 1
	for i in range(m):
		cols[i] = 1
	for i in range(n):
		temp = list(map(int, input().split()))
		for j in range(m):
			if temp[j] == 1:
				if i in rows:
					del rows[i]
					r.remove(i)
				if j in cols:
					del cols[j]
					c.remove(j)
		l.append(temp)
	some = 0
	while True:
		if len(r) > 0 and len(c) > 0:
			r.remove(r[0])
			c.remove(c[0])
			if some == 0:
				some = 1
			else:
				some = 0
		elif some == 0:
			print('Vivek')
			break
		else:
			print('Ashish')
			break


import math
import collections
from sys import stdin, stdout, setrecursionlimit
from bisect import bisect_left as bsl
from bisect import bisect_right as bsr
import heapq as hq
setrecursionlimit(2 ** 20)
t = int(stdin.readline())
for _ in range(t):
	(n, m) = list(map(int, stdin.readline().rstrip().split()))
	a = []
	for i in range(n):
		a.append(list(map(int, stdin.readline().rstrip().split())))
	r = {}
	c = {}
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r[i] = True
				c[j] = True
	remr = n - len(r)
	remc = m - len(c)
	rem = min(remr, remc)
	if rem % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


T = int(input())
while T:
	(n, m) = map(int, input().split())
	arr = [[int(x) for x in input().split()] for i in range(n)]
	arrT = [[arr[j][i] for j in range(n)] for i in range(m)]
	row = []
	col = []
	for i in range(len(arr)):
		if 1 not in arr[i]:
			row.append(i)
	for i in range(len(arrT)):
		if 1 not in arrT[i]:
			col.append(i)
	if min(len(row), len(col)) % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')
	T -= 1


def f(r, c):
	if r > c:
		r = c
	if r % 2 == 1:
		return 'Ashish'
	else:
		return 'Vivek'
t = int(input())
for i in range(t):
	[n, m] = input().split(' ')
	n = int(n)
	m = int(m)
	A = []
	Row = []
	Col = []
	for j in range(n):
		A.append(input().split(' '))
	for j in range(n):
		Row.append(1)
	for j in range(m):
		Col.append(1)
	for j in range(n):
		for k in range(m):
			if A[j][k] == '1':
				Row[j] = 0
				Col[k] = 0
	print(f(sum(Row), sum(Col)))


tests = int(input())
for i in range(tests):
	numbers = input().split(' ')
	n = int(numbers[0])
	m = int(numbers[1])
	row_n = [0] * n
	row_m = [0] * m
	for x in range(n):
		line = [int(y) for y in input().split(' ')]
		for y in range(m):
			if line[y] == 1:
				row_n[x] = 1
				row_m[y] = 1
	res = min(n - sum(row_n), m - sum(row_m))
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


I = input
for _ in [0] * int(I()):
	(n, m) = map(int, I().split())
	k = l = 0
	for _ in [0] * n:
		x = int(I()[::2], 2)
		k += x < 1
		l |= x
	print('VAisvheiks h'[min(k, m - bin(l).count('1')) % 2::2])


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	c = 0
	r = 0
	mat = []
	for i in range(n):
		ar = input().split()
		if ar.count('0') == m:
			c += 1
		mat.append(ar)
	for i in range(m):
		x = 0
		for j in range(n):
			if mat[j][i] == '0':
				x += 1
		if x == n:
			r += 1
	a = min(c, r)
	print(['Vivek', 'Ashish'][a % 2])


def solve():
	(n, m) = map(int, input().split())
	row = [True] * n
	col = [True] * m
	arr = []
	c = 0
	for i in range(0, n):
		temp = list(map(int, input().split()))
		arr.append(temp)
		for j in range(0, len(temp)):
			if temp[j] == 1:
				row[i] = False
				col[j] = False
	for i in range(0, n):
		if row[i]:
			for j in range(0, m):
				if col[j]:
					c += 1
					col[j] = False
					break
	if c == 0:
		print('Vivek')
		return
	elif c % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')
t = int(input())
for i in range(0, t):
	solve()


T = int(input())
for t in range(T):
	(n, m) = [int(x) for x in input().split()]
	rows = [0] * n
	lines = [0] * m
	for N in range(n):
		inp = [int(x) for x in input().split()]
		for M in range(m):
			if inp[M] == 1:
				rows[N] = 1
				lines[M] = 1
	free_lines = lines.count(0)
	free_rows = rows.count(0)
	turns = min(free_rows, free_lines)
	if turns % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
input = stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = [[] for _ in range(m)]
	r = c = 0
	for _ in range(n):
		a = list(map(int, input().split()))
		for i in range(m):
			l[i].append(a[i])
		if 1 not in a:
			r += 1
	for a in l:
		if 1 not in a:
			c += 1
	if min(r, c) % 2:
		print('Ashish')
	else:
		print('Vivek')


n = int(input())
for i in range(n):
	(a, b) = [int(i) for i in input().split()]
	e = 0
	d = set()
	for j in range(a):
		c = [int(i) for i in input().split()]
		if 1 in c:
			e = e + 1
		for k in range(0, len(c)):
			if c[k] == 1:
				d.add(k)
	e = a - e
	f = b - len(d)
	g = min(e, f)
	if g % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve():
	(n, m) = [int(v) for v in input().split()]
	matrix = []
	rowbit = [0] * n
	colbit = [0] * m
	for i in range(n):
		row = [int(v) for v in input().split()]
		matrix.append(row)
		for j in range(m):
			if matrix[i][j]:
				rowbit[i] = 1
				colbit[j] = 1
	turn = 0
	while True:
		found = False
		for i in range(n):
			for j in range(m):
				if not (rowbit[i] or colbit[j]):
					found = True
					matrix[i][j] = 1
					rowbit[i] = 1
					colbit[j] = 1
					turn ^= 1
					break
			if found:
				break
		if not found:
			break
	if not turn:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for _ in range(t):
	solve()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	r = n * [0]
	c = m * [0]
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r[i] = 1
				c[j] = 1
	(x, y) = (r.count(1), c.count(1))
	if x == n or y == m:
		k = 0
	else:
		k = min(n - x, m - y)
	if k % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


c = int(input())
for pr in range(c):
	size = input().split()
	n = int(size[0])
	m = int(size[1])
	W = []
	K = []
	for i in range(n):
		inp = input().split()
		for j in range(m):
			if inp[j] == '1':
				if not W.__contains__(i):
					W.append(i)
				if not K.__contains__(j):
					K.append(j)
	n -= len(W)
	m -= len(K)
	ws = min(n, m)
	if ws % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def mg(m, c, d, r):
	a = 0
	for i in range(d):
		res = [sub[i] for sub in m]
		if res.count(0) == r:
			a = a + 1
	p = min(a, c)
	if p % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
	return
t = int(input())
for i in range(t):
	T = input()
	m = []
	l = list(map(int, T.split(' ')))
	c = 0
	for i in range(l[0]):
		t1 = input()
		l1 = list(map(int, t1.split(' ')))
		if l1.count(0) == len(l1):
			c = c + 1
		m.append(l1)
	mg(m, c, l[1], l[0])


import sys
tests = int(sys.stdin.readline().rstrip())
for test in range(tests):
	dim = sys.stdin.readline().rstrip().split(' ')
	claimed_row = [True] * int(dim[0])
	claimed_col = [True] * int(dim[1])
	for i in range(int(dim[0])):
		row = list(map(int, sys.stdin.readline().rstrip().split(' ')))
		for j in range(int(dim[1])):
			if row[j] == 1:
				claimed_col[j] = False
				claimed_row[i] = False
	num_moves = min(sum(claimed_col), sum(claimed_row))
	if num_moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

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

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

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

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

def is_claimable(i, j):
	row_sum = sum(a[i])
	col_sum = 0
	for k in range(n):
		col_sum += a[k][j]
	if row_sum == 0 and col_sum == 0:
		return True
	else:
		return False
t = inp()
for _ in range(t):
	(n, m) = invr()
	a = []
	for i in range(n):
		a.append(inlist())
	res = 1
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0 and is_claimable(i, j):
				a[i][j] = 1
				res += 1
	if res % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


for i in range(int(input())):
	ans = ['Vivek', 'Ashish']
	factor = list(map(int, input().rstrip().split()))
	avail_c = [1 for i in range(factor[1])]
	avail_r = [1 for i in range(factor[0])]
	for i in range(factor[0]):
		row = list(map(int, input().rstrip().split()))
		if sum(row) > 0:
			avail_r[i] = -1
			for j in range(len(row)):
				if row[j] == 1:
					avail_c[j] = -1
	x = min(avail_r.count(1), avail_c.count(1))
	print(ans[x % 2])


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		s = list(map(int, input().split()))
		if any(s):
			arr.append([2 if i == 0 else 1 for i in s])
		else:
			arr.append(s)
	for i in range(m):
		for j in range(n):
			if arr[j][i] == 1:
				for k in range(n):
					if arr[k][i] == 0:
						arr[k][i] = 2
				break
	ans = 0
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 0:
				ans += 1
				arr[i][j] = 1
				for k in range(i + 1, n):
					arr[k][j] = 2
				for k in range(j + 1, m):
					arr[i][k] = 2
	print('Ashish' if ans % 2 else 'Vivek')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	s = [0] * m
	c = [0] * n
	for k in range(n):
		x = list(map(int, input().split()))
		for (i, v) in enumerate(x):
			if v:
				s[i] = 1
		if any(x):
			c[k] = 1
	m = min(m - sum(s), n - sum(c))
	if m % 2:
		print('Ashish')
	else:
		print('Vivek')


def moves(n, row, col):
	col_avoid = []
	row_free = 0
	for x in range(row):
		if '1' not in n[x]:
			row_free += 1
		else:
			for y in range(col):
				if n[x][y] == '1':
					if y not in col_avoid:
						col_avoid.append(y)
	return min(row_free, col - len(col_avoid))
t = int(input())
for x in range(t):
	(r, c) = list(map(int, input().split()))
	n = []
	for y in range(r):
		n.append(input().split())
	if moves(n, r, c) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve():
	(n, m) = [int(x) for x in input().split()]
	arr = []
	for i in range(n):
		arr.append([int(x) for x in input().split()])
	c = 0
	d = {}
	(sr, sc) = [0, 0]
	for i in range(n):
		s = sum(arr[i])
		if s == 0:
			for j in range(m):
				sc = 0
				for k in range(n):
					sc += arr[k][j]
				if sc == 0:
					arr[i][j] = 1
					c += 1
					break
	if c % 2 == 1:
		return 'Ashish'
	else:
		return 'Vivek'
t = int(input())
while t:
	print(solve())
	t -= 1


n = int(input())
for _ in range(n):
	(a, b) = map(int, input().split())
	table = []
	for _ in range(a):
		arr = list(map(int, input().split()))
		table.append(arr)
	rows = set()
	columns = set()
	for i in range(a):
		for j in range(b):
			if table[i][j] == 1:
				rows.add(i)
				columns.add(j)
	b -= len(columns)
	a -= len(rows)
	step = min(a, b)
	if step % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from math import ceil, gcd, trunc
from bisect import bisect_left as bl
from bisect import bisect_right as br
from array import array
from collections import Counter as ctr

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

def arr(a):
	return array('i', a)

def solve():
	for _ in range(int(input())):
		(n, m) = li()
		mn = 0
		mm = [0] * m
		for i in range(n):
			temp = li()
			for i in range(m):
				mm[i] += temp[i]
			if temp.count(1) == 0:
				mn += 1
		print('Ashish' if min(mn, mm.count(0)) % 2 else 'Vivek')
solve()


for _ in range(int(input())):
	(n, m) = [int(x) for x in input().split()]
	a = []
	for i in range(n):
		a.append([int(x) for x in input().split()])
	row = set([x for x in range(n)])
	column = set([x for x in range(m)])
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row.discard(i)
				column.discard(j)
	(l_r, l_c) = (len(row), len(column))
	if l_r == 0 or l_c == 0:
		print('Vivek')
		continue
	if l_r < l_c:
		if l_r % 2:
			print('Ashish')
		else:
			print('Vivek')
	elif l_c % 2:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = [input().split() for i in range(n)]
	x = 'Ashish'
	y = 'Vivek'
	t = list(zip(*a))
	c = 0
	k = 0
	for i in range(n):
		if '1' not in str(a[i]):
			c = c + 1
	for i in range(m):
		if '1' not in str(t[i]):
			k = k + 1
	if k == 0 or c == 0:
		print(y)
	elif k == c:
		if k % 2 == 0:
			print(y)
		else:
			print(x)
	elif c < k:
		if c % 2 == 0:
			print(y)
		else:
			print(x)
	elif c > k:
		if k % 2 == 0:
			print(y)
		else:
			print(x)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = 0
	grid = []
	for i in range(n):
		line = list(map(int, input().split()))
		grid.append(line)
	c = 0
	while True:
		c += 1
		found = False
		for i in range(n):
			for j in range(m):
				if 1 not in grid[i] and 1 not in [grid[x][j] for x in range(n)]:
					grid[i][j] = 1
					found = True
					break
			if found:
				break
		if not found:
			break
	if c % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


def isSafe(i, j, mat):
	for r in range(len(mat)):
		if mat[r][j] == '1':
			return False
	for c in range(len(mat[i])):
		if mat[i][c] == '1':
			return False
	return True
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		ll = list(input().split())
		mat.append(ll)
	turn = True
	while True:
		f = False
		for i in range(n):
			for j in range(m):
				if mat[i][j] == '1':
					continue
				if isSafe(i, j, mat):
					f = True
					mat[i][j] = '1'
					break
			if f:
				break
		if not f:
			break
		turn = not turn
	if not turn:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(a, b) = map(int, input().split())
	mat = []
	for i in range(a):
		arr = list(map(int, input().split()))
		mat.append(arr)
	(r, c) = (set(), set())
	for i in range(a):
		for j in range(b):
			if mat[i][j] == 1:
				r.add(i)
				c.add(j)
	if min(a - len(r), b - len(c)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


arr = []

def sn(n, m):
	s = 0
	for i in range(n):
		j = 0
		while j < m:
			if arr[i][j]:
				break
			j += 1
		if j >= m:
			s += 1
	return s

def snl(n, m):
	s = 0
	for j in range(m):
		i = 0
		while i < n:
			if arr[i][j]:
				break
			i += 1
		if i >= n:
			s += 1
	return s
n = int(input())
for i in range(n):
	(n, m) = map(int, input().split())
	arr.clear()
	for i in range(n):
		a = list(map(int, input().split()))
		arr.append(a)
	s = sn(n, m)
	s = min(s, snl(n, m))
	if s & 1:
		print('Ashish')
	else:
		print('Vivek')


a = int(input())
for i in range(a):
	(x, y) = map(int, input().split())
	ans = []
	c1 = 0
	c2 = 0
	for i in range(x):
		z = list(map(int, input().split()))
		ans.append(z)
	for i in range(len(ans)):
		t = ans[i]
		if t.count(0) == len(t):
			c1 += 1
	for i in range(y):
		flag = 0
		for j in range(x):
			if ans[j][i] != 0:
				flag = 1
				break
		if flag == 0:
			c2 += 1
	if min(c1, c2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	a = []
	rows = 0
	cols = 0
	for j in range(n):
		a.append(list(map(int, input().split())))
		if a[j].count(0) == len(a[j]):
			rows += 1
	for z in range(m):
		cur = [i[z] for i in a]
		if cur.count(0) == len(cur):
			cols += 1
	if min(rows, cols) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for j in range(int(input())):
	ll = []
	(n, m) = map(int, input().split())
	for i in range(n):
		ll.append(list(map(int, input().split())))
	row = 0
	col = 0
	for i in range(n):
		lol = 0
		for j in range(m):
			if ll[i][j] == 1:
				lol = 1
				break
		if lol == 0:
			row += 1
	for i in range(m):
		lol = 0
		for j in range(n):
			if ll[j][i] == 1:
				lol = 1
				break
		if lol == 0:
			col += 1
	mi = min(row, col)
	if mi % 2:
		print('Ashish')
	else:
		print('Vivek')


def fill_ones(matrix, row, col, n, m):
	for k in range(0, n):
		if k != row and matrix[k][col] == 0:
			matrix[k][col] = 2
	for k in range(0, m):
		if k != col and matrix[row][k] == 0:
			matrix[row][k] = 2
t = int(input())
for x in range(t):
	matrix = []
	(n, m) = list(map(int, input().split()))
	for j in range(n):
		matrix.append(list(map(int, input().split())))
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				fill_ones(matrix, i, j, n, m)
	moves = 0
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 0:
				matrix[i][j] = 1
				fill_ones(matrix, i, j, n, m)
				moves += 1
	if moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	count = 0
	c = [0] * b
	r = [0] * a
	for i in range(a):
		st = list(map(int, input().split()))
		for j in range(b):
			if st[j] == 1:
				r[i] = 1
				c[j] = 1
	p = min(r.count(0), c.count(0))
	if p % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	s1 = set(range(m))
	rows = 0
	for i in range(n):
		s2 = set()
		l = input().split()
		if '1' not in l:
			rows += 1
		for i in range(m):
			if l[i] == '0':
				s2.add(i)
		s1 &= s2
	num = min(rows, len(s1))
	if num % 2:
		print('Ashish')
	else:
		print('Vivek')


def A():
	T = int(input())
	for i in range(T):
		(r, c) = input().split(' ')
		(r, c) = (int(r), int(c))
		(numr, numc) = (0, 0)
		m = []
		for row in range(r):
			row = input().split(' ')
			row = [int(j) for j in row]
			m.append(row)
			if sum(row) == 0:
				numr += 1
		for col in range(c):
			tempc = True
			for row in range(r):
				if m[row][col] == 1:
					tempc = False
					break
			if tempc:
				numc += 1
		ans = min(numc, numr)
		if ans % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
A()


import atexit
import statistics
import io
import sys
_INPUT_LINES = sys.stdin.read().splitlines()
input = iter(_INPUT_LINES).__next__
_OUTPUT_BUFFER = io.StringIO()
sys.stdout = _OUTPUT_BUFFER

@atexit.register
def write():
	sys.__stdout__.write(_OUTPUT_BUFFER.getvalue())
odd = 'Ashish'
even = 'Vivek'

def solve_table(n, m):
	rows = [0] * n
	columns = [0] * m
	for i in range(n):
		prepared = list(map(int, input().split()))
		for step in range(m):
			if prepared[step] == 1:
				columns[step] = 1
				rows[i] = 1
	allowed_n = list((i for i in columns if i == 0))
	allowed_m = list((i for i in rows if i == 0))
	max_lines = min(len(allowed_n), len(allowed_m))
	if max_lines % 2 == 0:
		return even
	return odd
iters = int(input())
for i in range(iters):
	(n, m) = map(int, input().split())
	print(solve_table(n, m))


player1 = 'Ashish'
player2 = 'Vivek'

def emptyRows(current_matrix):
	empty_rows = list()
	for (index, row) in enumerate(current_matrix):
		if row.count(1) == 0:
			empty_rows.append(index)
	return empty_rows

def emptyCols(current_matrix):
	current_matrix = list(map(list, zip(*current_matrix)))
	empty_cols = list()
	for (index, col) in enumerate(current_matrix):
		if col.count(1) == 0:
			empty_cols.append(index)
	return empty_cols
for _ in range(int(input())):
	(rows, cols) = tuple(map(int, input().split()))
	matrix = list()
	for i in range(rows):
		matrix.append(list(map(int, input().split())))
	empty_rows = emptyRows(matrix)
	empty_cols = emptyCols(matrix)
	available_moves = min(len(empty_rows), len(empty_cols))
	if available_moves % 2 == 1:
		print(player1)
	else:
		print(player2)


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	l = []
	for __ in range(n):
		l.append(list(map(int, input().split())))
	l1 = []
	for i in range(m):
		x = []
		for j in range(n):
			x.append(l[j][i])
		l1.append(x)
	z = 0
	for i in range(n):
		if 1 not in l[i]:
			for j in range(m):
				if 1 not in l1[j]:
					z += 1
					l[i][j] = 1
					l1[j][i] = 1
					break
	print('Vivek') if z % 2 == 0 else print('Ashish')


t = int(input())
for ingles in range(t):
	X = input()
	x1 = X.split()
	n = int(x1[0])
	m = int(x1[1])
	A = [0] * n
	B = [0] * m
	for i in range(n):
		L = input()
		L1 = L.split()
		for j in range(m):
			if L1[j] == '1':
				A[i] = 1
				B[j] = 1
	a = 0
	b = 0
	for i in range(n):
		a = a + A[i]
	for i in range(m):
		b = b + B[i]
	a = n - a
	b = m - b
	mini = min(a, b)
	if mini % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import sys
import math
from collections import defaultdict

def solve(test):
	(n, m) = map(int, input().split())
	grid = [None for i in range(n)]
	row = 0
	for i in range(n):
		grid[i] = list(map(int, input().split()))
		flag = 0
		for j in range(m):
			if grid[i][j] == 1:
				flag = 1
				break
		if not flag:
			row += 1
	col = 0
	for j in range(m):
		flag = 0
		for i in range(n):
			if grid[i][j] == 1:
				flag = 1
				break
		if not flag:
			col += 1
	res = min(col, row)
	print('Ashish' if res & 1 else 'Vivek')
test_cases = int(input())
for t in range(1, test_cases + 1):
	solve(t)


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	mat = []
	for i in range(n):
		x = list(map(int, input().split()))
		mat.append(x)
	done = False
	turn = 1
	while done == False:
		done = True
		pl = False
		for i in range(n):
			for j in range(m):
				can = 1
				if mat[i][j] == 0:
					for a in range(n):
						if mat[a][j] == 1:
							can = 0
					for a in range(m):
						if mat[i][a] == 1:
							can = 0
				else:
					continue
				if can == 1:
					mat[i][j] = 1
					turn = turn ^ 1
					done = False
					pl = True
					break
			if pl == True:
				break
	if turn == True:
		print('Vivek')
	else:
		print('Ashish')


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

def main():
	testcases = int(input())
	for i in range(testcases):
		(rows, cols) = read_ints()
		row = [1] * rows
		col = [1] * cols
		for r in range(rows):
			tmp = read_ints()
			for (c, i) in enumerate(tmp):
				if i == 1:
					col[c] = 0
					row[r] = 0
		least = min(sum(row), sum(col))
		if least % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


t = int(input())

def noOnes(arr):
	c = 0
	for i in arr:
		if i == 0:
			c += 1
	return c
while t > 0:
	t -= 1
	(n, m) = list(map(int, input().split()))
	arr = []
	r = [0] * n
	c = [0] * m
	for i in range(n):
		arr.append(list(map(int, input().split())))
	for i in range(n):
		for j in range(m):
			if r[i] == 0 and arr[i][j] == 1:
				r[i] = 1
			if c[j] == 0 and arr[i][j] == 1:
				c[j] = 1
	ans = min(noOnes(r), noOnes(c))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	arr = []
	for i in range(n):
		arr.append(list(map(int, input().split())))
	freeAm = 0
	goodW = [True] * m
	goodH = [True] * n
	for i in range(n):
		if sum(arr[i]) > 0:
			goodH[i] = False
	for i in range(m):
		for g in range(n):
			if arr[g][i] == 1:
				goodW[i] = False
				break
	print(['Vivek', 'Ashish'][min(goodW.count(True), goodH.count(True)) & 1])


maxx = 1010
vis = [[0] * 1010 for i in range(1010)]
n = 0
m = 0

def get_h():
	ans = 0
	global n
	global m
	global vis
	for i in range(1, n + 1):
		j = 1
		flag = 1
		for j in range(1, m + 1):
			if vis[i][j] != 0:
				flag = 0
				break
		if flag == 1:
			j = j + 1
		if j > m:
			ans = ans + 1
	return ans

def get_l():
	ans = 0
	global n
	global m
	global vis
	for j in range(1, m + 1):
		i = 1
		flag = 1
		for i in range(1, n + 1):
			if vis[i][j] != 0:
				flag = 0
				break
		if flag == 1:
			i = i + 1
		if i > n:
			ans = ans + 1
	return ans
t = int(input())
for tt in range(t):
	s = input()
	s = [x for x in s.split()]
	n = int(s[0])
	m = int(s[1])
	for i in range(1, n + 1):
		temp = input()
		temp = [x for x in temp.split()]
		for j in range(1, m + 1):
			vis[i][j] = int(temp[j - 1])
	t1 = get_l()
	t2 = get_h()
	cur = min(t1, t2)
	if cur & 1:
		print('Ashish')
	else:
		print('Vivek')


def solution():
	(n, m) = list(map(int, input().split()))
	ar = [0 for i in range(n)]
	ac = [0 for i in range(m)]
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(m):
			if a[j] == 1:
				ar[i] = 1
				ac[j] = 1
	rc = 0
	cc = 0
	for v in ar:
		if v == 0:
			rc += 1
	for v in ac:
		if v == 0:
			cc += 1
	mn = min(rc, cc)
	print('Ashish') if mn % 2 != 0 else print('Vivek')
T = int(input())
for t in range(T):
	solution()


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

def read_ints():
	ints = [int(x) for x in input().split(' ')]
	return ints

def solve(n, m, matrix):
	sr = set()
	sc = set()
	for i in range(n):
		if 1 not in set(matrix[i]):
			sr.add(i)
	for i in range(m):
		col = set()
		for j in range(n):
			col.add(matrix[j][i])
		if 1 not in col:
			sc.add(i)
	moves = min(len(sr), len(sc))
	if moves % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
t = read_int()
for case in range(t):
	(n, m) = read_ints()
	matrix = []
	for i in range(n):
		row = read_ints()
		matrix.append(row)
	sol = solve(n, m, matrix)
	print(sol)


for _ in range(int(input())):
	(row, column) = list(map(int, input().split()))
	coordinate = []
	dict1 = {}
	dict2 = {}
	count = 0
	count1 = 0
	for i in range(row):
		main = list(map(int, input().split()))
		case = True
		for l in range(column):
			if main[l] == 1:
				dict1[l] = 1
				dict2[i] = 1
				case = False
			elif dict1.get(l) == None:
				dict1[l] = 0
		if case:
			dict2[i] = 0
	for i in dict1:
		if dict1[i] == 0:
			count += 1
	for i in dict2:
		if dict2[i] == 0:
			count1 += 1
	if min(count, count1) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


testCases = int(input())
while testCases > 0:
	(row, column) = list(map(int, input().split()))
	grid = []
	for i in range(row):
		grid.append(list(map(int, input().split())))
	rowZeros = 0
	for i in range(row):
		found = False
		for j in range(column):
			if grid[i][j] == 1:
				found = True
				break
		if found is False:
			rowZeros += 1
	columnZeros = 0
	for j in range(column):
		found = False
		for i in range(row):
			if grid[i][j] == 1:
				found = True
				break
		if found is False:
			columnZeros += 1
	minimum = min(rowZeros, columnZeros)
	if minimum % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	testCases -= 1


from sys import stdin

def readline():
	return stdin.readline()
tests = int(readline())

def solve(n, m, arr):
	index = 0
	r = []
	l = []
	for i in range(0, n):
		for j in range(0, m):
			if arr[i][j] == 1:
				r.append(j)
				l.append(i)
	for i in range(0, n):
		for j in range(0, m):
			if j not in r and i not in l:
				r.append(j)
				l.append(i)
				index += 1
				break
	if index % 2 == 0:
		return 'Vivek'
	return 'Ashish'
for t in range(0, tests):
	(n, m) = list(map(int, readline().rstrip('\n').split(' ')))
	arr = []
	for i in range(0, n):
		arr.append(list(map(int, readline().split(' '))))
	print(solve(n, m, arr))


import sys
from collections import Counter

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

def solve():
	pass

def intersection(left, right, mn, mx):
	if right < mn or left > mx:
		return None
	else:
		return [max(left, mn), min(right, mx)]

def main():
	t = int(input())
	for _ in range(t):
		(m, n) = read_ints()
		row = [1] * m
		col = [1] * n
		for r in range(m):
			arr = read_ints()
			for (c, i) in enumerate(arr):
				if i == 1:
					col[c] = 0
					row[r] = 0
		free = min(sum(row), sum(col))
		if free % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		lst = list(map(int, input().split()))
		arr.append(lst.copy())
	row = []
	col = []
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				row.append(i)
				col.append(j)
	lrow = len(set(row))
	lcol = len(set(col))
	n1 = n - lrow
	m1 = m - lcol
	ans1 = min(n1, m1)
	if ans1 % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


def fact(n):
	ans = 1
	for i in range(2, n + 1):
		ans *= i
	return ans

def comb(n, c):
	return fact(n) // (fact(n - c) * c)
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	grid = []
	for i in range(n):
		grid.append(list(map(str, input().split())))
	good = 0
	l = []
	r = []
	for i in range(n):
		if '1' in grid[i]:
			l.append('1')
		else:
			l.append('0')
	for i in range(m):
		ok = 1
		for q in range(n):
			if grid[q][i] == '1':
				ok = 0
				break
		if ok:
			r.append('0')
		else:
			r.append('1')
	cnt = min(l.count('0'), r.count('0'))
	for i in range(n):
		if l[i] == '0':
			w = 1
			for q in range(m):
				if grid[i][q] == '1':
					w = 0
					break
			if w:
				good += 1
	good = min(good, cnt)
	if good % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout
import heapq as hq
from collections import defaultdict
t = int(input())
for tc in range(t):
	(n, m) = list(map(int, stdin.readline().split()))
	mat = []
	for nc in range(n):
		inar = list(map(int, stdin.readline().split()))
		mat.append(inar)
	ecols = 0
	erows = 0
	for row in mat:
		if sum(row) == 0:
			erows += 1
	for i in range(m):
		s = 0
		for row in mat:
			s += row[i]
		if s == 0:
			ecols += 1
	comb = min(ecols, erows) + 1
	res = ['Ashish', 'Vivek'][comb % 2]
	stdout.write(str(res) + '\n')


n = int(input())
for i in range(n):
	(x, y) = [int(k) for k in input().split()]
	row = [1] * x
	col = [1] * y
	for j in range(x):
		a = [int(k) for k in input().split()]
		for q in range(y):
			if a[q]:
				row[j] = 0
				col[q] = 0
	res = min(sum(row), sum(col))
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	emptyRows = 0
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				break
		else:
			emptyRows += 1
	emptyCols = 0
	for j in range(m):
		for i in range(n):
			if l[i][j] == 1:
				break
		else:
			emptyCols += 1
	out = min(emptyCols, emptyRows)
	if out % 2:
		print('Ashish')
	else:
		print('Vivek')


test_cases = int(input())
while test_cases > 0:
	mainData = []
	availRow = 0
	availCol = 0
	avail = 0
	(row, col) = map(int, input().split())
	for i in range(row):
		data = list(map(int, input().split()))
		mainData.append(data)
	for i in range(row):
		flag = True
		for j in range(col):
			if mainData[i][j] == 1:
				flag = False
		if flag == True:
			availCol += 1
	for i in range(col):
		flag = True
		for j in range(row):
			if mainData[j][i] == 1:
				flag = False
		if flag == True:
			availRow += 1
	avail = min(availCol, availRow)
	if avail % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	test_cases -= 1


for j in range(int(input())):
	(n, m) = map(int, input().split())
	ma = [0] * m
	na = [0] * n
	for i in range(n):
		a = list(map(int, input().split()))
		for l in range(len(a)):
			if a[l] == 1:
				na[i] = 1
				ma[l] = 1
	mb = ma.count(0)
	nb = na.count(0)
	if min(mb, nb) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	t -= 1
	(n, m) = [int(i) for i in input().split()]
	matrix = []
	for i in range(n):
		matrix.append([int(i) for i in input().split()])
	total = min(n, m)
	row = 0
	for i in matrix:
		if i.count(1) != 0:
			row += 1
	free_row = n - row
	matrix1 = [[] for i in range(m)]
	for i in range(n):
		for j in range(m):
			matrix1[j].append(matrix[i][j])
	col = 0
	for i in matrix1:
		if i.count(1) != 0:
			col += 1
	free_col = m - col
	moves = min(free_col, free_row)
	if moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = [int(i) for i in input().split()]
	matrix = []
	lin = [0 for i in range(n)]
	col = [1 for i in range(m)]
	for i in range(n):
		flag = True
		for (j, k) in enumerate(input().split()):
			if k == '1':
				col[j] = 0
				flag = False
		if flag:
			lin[i] = 1
	resp = min([sum(lin), sum(col)])
	if resp % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
import math
t = int(sys.stdin.readline().strip())
for i in range(t):
	(n, m) = list(map(int, sys.stdin.readline().strip().split(' ')))
	grid = []
	for _ in range(n):
		l = list(map(int, sys.stdin.readline().strip().split(' ')))
		grid.append(l)
	possibleRows = []
	for a in grid:
		if 1 not in a:
			possibleRows.append(a)
	possibleCols = []
	for b in range(len(grid[0])):
		col = []
		for c in range(len(grid)):
			v = grid[c][b]
			col.append(v)
		if 1 not in col:
			possibleCols.append(b)
	moves = min(len(possibleRows), len(possibleCols))
	if moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for x in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	first = 0
	for i in range(n):
		if 1 in a[i]:
			first += 1
	second = 0
	for i in range(m):
		for j in range(n):
			if a[j][i] == 1:
				second += 1
				break
	ans = ['Vivek', 'Ashish']
	print(ans[min(n - first, m - second) % 2])


t = 1
t = int(input())
while t:
	t -= 1
	(n, m) = list(map(int, input().split()))
	a = []
	for i in range(n):
		aux = list(map(int, input().split()))
		a.append(aux)
	(urows, ucolumns) = (0, 0)
	for i in range(n):
		if 1 not in a[i]:
			urows += 1
	for i in range(m):
		for j in range(n):
			if a[j][i] is 1:
				break
		else:
			ucolumns += 1
	if min(urows, ucolumns) % 2 is 1:
		print('Ashish')
	else:
		print('Vivek')


from sys import stdin, gettrace
if gettrace():
	inputi = input
else:

	def input():
		return next(stdin)[:-1]

	def inputi():
		return stdin.buffer.readline()

def main():

	def solve():
		(n, m) = map(int, inputi().split())
		aa = []
		for _ in range(n):
			aa.append([int(a) for a in inputi().split()])
		cr = [0] * n
		cc = [0] * m
		for i in range(n):
			for j in range(m):
				if aa[i][j] == 1:
					cr[i] = 1
					cc[j] = 1
		diag = min(n - sum(cr), m - sum(cc))
		if diag % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
	q = int(inputi())
	for _ in range(q):
		solve()
main()


t = int(input())
while t:
	t -= 1
	(n, m) = map(int, input().split())
	mat = list()
	for i in range(n):
		mat.append(list(map(int, input().split())))
	toclaim = list()
	for i in range(n):
		for j in range(m):
			rowor = 0
			color = 0
			for k in range(m):
				rowor = rowor or mat[i][k]
			if rowor != 1:
				for l in range(n):
					color = color or mat[l][j]
			if rowor != 1 and color != 1:
				toclaim.append([i, j])
	l = len(toclaim)
	for i in range(l):
		j = i + 1
		while j < l:
			if toclaim[i][0] == toclaim[j][0] or toclaim[i][1] == toclaim[j][1]:
				del toclaim[j]
				l -= 1
			else:
				j += 1
	if l % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


T = int(input())
for _ in range(T):
	(n, m) = map(int, input().split())
	l_n = [1] * n
	l_m = [1] * m
	for i in range(n):
		l = list(map(int, input().split()))
		for j in range(m):
			if l[j] == 1:
				l_n[i] = 0
				l_m[j] = 0
	su_n = sum(l_n)
	su_m = sum(l_m)
	ans = min(su_n, su_m)
	if ans % 2:
		print('Ashish')
	else:
		print('Vivek')


from math import floor, ceil
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	c = 0
	graph = []
	for i in range(n):
		graph.append([*map(int, input().split())])
	r_vis = [0 for i in range(n)]
	c_vis = [0 for j in range(m)]
	for i in range(n):
		for j in range(m):
			if graph[i][j] == 1:
				r_vis[i] = 1
				c_vis[j] = 1
	t = 0
	while 1:
		pos = 0
		for i in range(n):
			for j in range(m):
				if not r_vis[i] and (not c_vis[j]):
					pos = 1
					r_vis[i] = 1
					c_vis[j] = 1
					break
				if pos:
					break
		if not pos:
			if t == 1:
				print('Ashish')
				break
			else:
				print('Vivek')
				break
		if t == 1:
			t = 0
		else:
			t = 1


import sys
import math
from sys import stdin, stdout

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

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

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

def main():
	for t in range(int(input())):
		(n, m) = get_ints()
		l = []
		for i in range(n):
			a = get_list()
			l.append(a)
		c = 1
		for i in range(n):
			for j in range(m):
				if l[i][j] == 1:
					continue
				else:
					g = 0
					for k in range(0, m):
						if l[i][k] == 1:
							g = 1
							break
					if g == 0:
						for k in range(0, n):
							if l[k][j] == 1:
								g = 1
								break
						if g == 0 and c == 1:
							c = 0
							l[i][j] = 1
						elif g == 0 and c == 0:
							c = 1
							l[i][j] = 1
		if c == 1:
			print('Vivek')
		else:
			print('Ashish')
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()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		s = list(map(int, input().split()))
		a.append(s)
	count_row = 0
	for i in range(n):
		flag = 0
		for j in range(m):
			if a[i][j] == 1:
				flag = 1
				break
		if flag == 0:
			count_row += 1
	count_col = 0
	for j in range(m):
		flag = 0
		for i in range(n):
			if a[i][j] == 1:
				flag = 1
				break
		if flag == 0:
			count_col += 1
	m = min(count_row, count_col)
	if m % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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

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, m) = mi()
	mat = []
	for _ in range(n):
		row = lm()
		mat.append(row)
	freerow = 0
	for i in range(n):
		if sum(mat[i]) == 0:
			freerow += 1
	freecol = 0
	for j in range(m):
		free = True
		for i in range(n):
			if mat[i][j] == 1:
				free = False
		if free:
			freecol += 1
	f = min(freerow, freecol)
	if f % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve(n, m, a):
	available_rows = [i for i in range(n)]
	available_columns = [i for i in range(m)]
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				if available_rows.count(i):
					available_rows.remove(i)
				if available_columns.count(j):
					available_columns.remove(j)
	moves = 0
	while len(available_rows) > 0 and len(available_columns) > 0:
		available_rows.pop()
		available_columns.pop()
		moves += 1
	print('Vivek' if moves % 2 == 0 else 'Ashish')
t = int(input())
while t:
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	solve(n, m, a)
	t -= 1


def main():
	(n, m) = list(map(int, input().split()))
	N = [0] * n
	M = [0] * m
	for ni in range(n):
		for (mi, f) in enumerate(input().split(' ')):
			if f == '1':
				N[ni] = 1
				M[mi] = 1
	z = min(n - sum(N), m - sum(M))
	print('Vivek' if z % 2 == 0 else 'Ashish')
for t in range(int(input())):
	main()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	(a, b) = ({}, {})
	for i in range(n):
		for (j, x) in enumerate(input().split()):
			if '1' == x:
				a[i] = 1
				b[j] = 1
	x = min(n - len(a), m - len(b))
	print('Ashish' if x % 2 else 'Vivek')


n = int(input())

def sny(m, n):
	if m == 0:
		return n + 1
	elif m == 1:
		return n + 2
	elif n == 0:
		return 5
	else:
		result = 5
		for i in range(0, n):
			result = result * 2 + 3
		return result

def nb():
	(n, m) = map(int, input().split(' '))
	matrix = []
	for snynb in range(n):
		ren = list(map(int, input().split(' ')))
		matrix.append(ren)
	con = 0
	for snynb in range(n):
		count = 1
		for er in range(m):
			if matrix[snynb][er] == 1:
				count = 0
		con = con + count
	k = 0
	for er in range(m):
		count = 1
		for snynb in range(n):
			if matrix[snynb][er] == 1:
				count = 0
		k += count
	if min(con, k) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
for _ in range(n):
	nb()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	r = {}
	c = {}
	for i in range(n):
		row = list(map(int, input().split()))
		for j in range(m):
			if row[j] == 1:
				r[i] = 1
				c[j] = 1
	print('Ashish' if min(n - len(r), m - len(c)) & 1 else 'Vivek')


from math import *
from sys import stdin, stdout
input = stdin.buffer.readline
t = int(input())
while t > 0:
	(n, m) = [int(x) for x in input().split()]
	a = []
	for i in range(n):
		temp = [int(x) for x in input().split()]
		a.append(temp)
	row = []
	col = []
	for i in range(n):
		row.append(0)
	for i in range(m):
		col.append(0)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row[i] += 1
				col[j] += 1
	ans = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0:
				if row[i] == 0 and col[j] == 0:
					ans += 1
					row[i] += 1
					col[j] += 1
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	ro = set()
	col = set()
	for i in range(n):
		arr = [int(x) for x in input().split()]
		for j in range(m):
			if arr[j] == 1:
				col.add(j)
		if 1 in arr:
			ro.add(i)
	l = min(n - len(ro), m - len(col))
	print('Vivek') if l % 2 == 0 else print('Ashish')


for t in range(int(input())):
	(n, m) = map(int, input().split())
	(l, c) = ([0] * n, [0] * m)
	for i in range(n):
		v = list(map(int, input().split()))
		l[i] |= max(v)
		for j in range(m):
			c[j] |= v[j]
	print('Ashish' if min(n - sum(l), m - sum(c)) & 1 else 'Vivek')


def answer(n, m, A):
	count_g = 0
	for i in range(n):
		count = 0
		for j in range(m):
			if A[i][j] == 1:
				count += 1
		if count == 0:
			for f in range(m):
				count1 = 0
				for k in range(n):
					if A[k][f] == 1:
						count1 += 1
				if count1 == 0:
					A[i][f] = 1
					count_g += 1
					break
	if count_g % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	print(answer(n, m, l))


for t in range(int(input())):
	lstcol = []
	lstrow = []
	(n, m) = map(int, input().split(' '))
	for j in range(n):
		lst = list(map(int, input().split(' ')))
		if 1 in lst:
			indices = [i for (i, x) in enumerate(lst) if x == 1]
			lstrow.append(j)
			for k in indices:
				if k not in lstcol:
					lstcol.append(k)
	f = min(n - len(lstrow), m - len(lstcol))
	if f % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def winner(mat, n, m):
	nxt = 'Ashish'
	for i in range(n):
		for j in range(m):
			block = mat[i][j]
			claimed = False
			for row in range(n):
				cell = mat[row][j]
				if cell:
					claimed = True
					break
			if claimed:
				continue
			for col in range(m):
				cell = mat[i][col]
				if cell:
					claimed = True
					break
			if claimed:
				continue
			mat[i][j] = 2
			if nxt == 'Ashish':
				nxt = 'Vivek'
			else:
				nxt = 'Ashish'
	if nxt == 'Ashish':
		return 'Vivek'
	return 'Ashish'
for tt in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for _ in range(n):
		line = [int(k) for k in input().split()]
		mat.append(line)
	print(winner(mat, n, m))


t = int(input())
for i in range(0, t):
	(n, m) = map(int, input().split())
	row = [False for i in range(n)]
	col = [False for i in range(m)]
	for i in range(n):
		x = []
		x = list(map(int, input().split()))
		for j in range(m):
			if x[j] == 1:
				row[i] = True
				col[j] = True
	cnt_row = 0
	cnt_col = 0
	for i in range(n):
		if row[i] == 0:
			cnt_row += 1
	for j in range(m):
		if col[j] == 0:
			cnt_col += 1
	if min(cnt_row, cnt_col) % 2:
		print('Ashish')
	else:
		print('Vivek')


n = input
for _ in [0] * int(n()):
	(x, y) = map(int, n().split())
	a = b = 0
	for _ in [0] * x:
		r = int(n()[::2], 2)
		a += r < 1
		b |= r
	print('VAisvheiks h'[min(a, y - bin(b).count('1')) % 2::2])


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	(l, r) = ([], [])
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				l.append(i)
				r.append(j)
	D = min(n - len(set(l)), m - len(set(r)))
	if D % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from __future__ import division, print_function
import sys
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
import os, sys, bisect, copy
from collections import defaultdict, Counter, deque
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
if os.path.exists('out.txt'):
	sys.stdout = open('out.txt', 'w')

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

def mapi(arg=0):
	return map(int if arg == 0 else str, input().split())
for _ in range(int(input())):
	(n, m) = mapi()
	mat = []
	for i in range(n):
		mat.append(list(mapi()))
	x = min(m, n)
	cnt = 0
	col = [0] * m
	row = [0] * n
	for i in range(n):
		for j in range(m):
			if mat[i][j]:
				row[i] = 1
				col[j] = 1
	for i in range(n):
		for j in range(m):
			if col[j] == 0 and row[i] == 0:
				cnt += 1
				row[i] = 1
				col[j] = 1
	if cnt % 2:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	row = set({})
	col = set({})
	ar = []
	for i in range(n):
		xx = list(map(int, input().split()))
		for j in range(m):
			if xx[j] == 1:
				col.add(j)
				row.add(i)
	lefr = n - len(row)
	lefc = m - len(col)
	if min(lefr, lefc) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
import sys
import random
from queue import PriorityQueue
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
import heapq
input = lambda : sys.stdin.readline().rstrip()
from sys import stdin, stdout
from heapq import heapify, heappush, heappop
from itertools import permutations
from math import factorial as f

def ncr(n, r, p):
	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
import sys
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	la = []
	for i in range(n):
		l = list(map(int, input().split()))
		la.append(l)
	l1 = [-1] * n
	l2 = [-1] * m
	for i in range(n):
		for j in range(m):
			if la[i][j]:
				l1[i] += 1
				l2[j] += 1
	(x, y) = (0, 0)
	for i in range(n):
		if l1[i] != -1:
			x += 1
	for i in range(m):
		if l2[i] != -1:
			y += 1
	if min(n - x, m - y) % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
while t > 0:
	(n, m) = input().split()
	(n, m) = (int(n), int(m))
	arr = []
	for i in range(n):
		temp = input().split()
		temp = [int(i) for i in temp]
		arr.append(temp)
	count = 0
	for i in range(n):
		for j in range(m):
			if arr[i].count(1) == 0:
				temp = []
				for k in range(n):
					temp.append(arr[k][j])
				if temp.count(1) == 0:
					arr[i][j] = 1
					count += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	data = []
	for _ in range(n):
		data.append(list(map(int, input().split())))
	now = 0
	while True:
		rows = []
		columns = []
		for i in range(n):
			found = True
			for j in range(m):
				if data[i][j] == 1:
					found = False
			if found:
				rows.append(i)
		for j in range(m):
			found = True
			for i in range(n):
				if data[i][j] == 1:
					found = False
			if found:
				columns.append(j)
		if len(rows) == 0 or len(columns) == 0:
			if now == 0:
				print('Vivek')
			else:
				print('Ashish')
			break
		else:
			data[rows[0]][columns[0]] = 1
		if now == 0:
			now = 1
		else:
			now = 0


for test in range(int(input())):
	(n, m) = map(int, input().split())
	ls = []
	for i in range(n):
		ls.append(list(map(int, input().split())))
	row = [1] * n
	col = [1] * m
	for i in range(n):
		for j in range(m):
			if ls[i][j]:
				row[i] = 0
				col[j] = 0
	cnt = min(sum(row), sum(col))
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


test = int(input())
for _ in range(test):
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		row = list(map(int, input().split()))
		matrix.append(row)
	(avail_rows, avail_cols) = (0, 0)
	for i in range(n):
		if 1 not in matrix[i]:
			avail_rows += 1
	for i in range(m):
		cur_col = []
		for j in range(n):
			cur_col.append(matrix[j][i])
		if 1 not in cur_col:
			avail_cols += 1
	winner = min(avail_cols, avail_rows)
	if winner % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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

def solve():
	[n, m] = input_as_list()
	taken_rows = set()
	taken_columns = set()
	for i in range(n):
		row = input_as_list()
		if 1 in row:
			taken_rows.add(i)
			for j in range(m):
				if row[j] == 1:
					taken_columns.add(j)
	free_rows = n - len(taken_rows)
	free_columns = m - len(taken_columns)
	free = free_rows
	if free_columns < free_rows:
		free = free_columns
	if free & 1:
		print('Ashish')
	else:
		print('Vivek')
[tests] = input_as_list()
for _ in range(tests):
	solve()


for t in range(int(input())):
	(n, m) = map(int, input().split())
	a = list()
	for _ in range(n):
		a.append(list(map(int, input().split())))
	(r, c) = (0, 0)
	flag = False
	for i in range(m):
		counter = 0
		for j in range(n):
			if len(set(a[j])) == 1 and a[j][0] == 0 and (not flag):
				r += 1
			if a[j][i] == 0:
				counter += 1
		flag = True
		if counter == n:
			c += 1
	if min(r, c) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
import math
import itertools
import functools
import collections
import operator
import fileinput
import copy
ORDA = 97

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

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

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

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

def revn(n):
	return str(n)[::-1]

def dd():
	return collections.defaultdict(int)

def ddl():
	return collections.defaultdict(list)

def sieve(n):
	if n < 2:
		return list()
	prime = [True for _ in range(n + 1)]
	p = 3
	while p * p <= n:
		if prime[p]:
			for i in range(p * 2, n + 1, p):
				prime[i] = False
		p += 2
	r = [2]
	for p in range(3, n + 1, 2):
		if prime[p]:
			r.append(p)
	return r

def divs(n, start=1):
	r = []
	for i in range(start, int(math.sqrt(n) + 1)):
		if n % i == 0:
			if n / i == i:
				r.append(i)
			else:
				r.extend([i, n // i])
	return r

def divn(n, primes):
	divs_number = 1
	for i in primes:
		if n == 1:
			return divs_number
		t = 1
		while n % i == 0:
			t += 1
			n //= i
		divs_number *= t

def prime(n):
	if n == 2:
		return True
	if n % 2 == 0 or n <= 1:
		return False
	sqr = int(math.sqrt(n)) + 1
	for d in range(3, sqr, 2):
		if n % d == 0:
			return False
	return True

def convn(number, base):
	newnumber = 0
	while number > 0:
		newnumber += number % base
		number //= base
	return newnumber

def cdiv(n, k):
	return n // k + (n % k != 0)

def ispal(s):
	for i in range(len(s) // 2 + 1):
		if s[i] != s[-i - 1]:
			return False
	return True
for _ in range(ii()):
	(n, m) = mi()
	a = [li() for _ in range(n)]
	r = 0
	for s in a:
		if any((s[i] for i in range(m))):
			r += 1
	c = 0
	for i in range(m):
		for j in range(n):
			if a[j][i] == 1:
				c += 1
				break
	if min(n - r, m - c) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for test in range(t):
	(n, m) = map(int, input().split())
	a = []
	for _ in range(n):
		a.append(list(map(int, input().split())))
	(row, col) = ([0] * n, [0] * m)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row[i] = 1
				col[j] = 1
	chances = min(row.count(0), col.count(0))
	if chances % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t != 0:
	(n, m) = map(int, input().split())
	list1 = list()
	for i in range(n):
		temp = list(map(int, input().split()))
		list1.append(temp)
	cout = 0
	rows = list()
	col = list()
	for i in range(n):
		for j in range(m):
			if list1[i][j] == 1:
				rows.append(i)
				col.append(j)
	count = 0
	while 1:
		flag = 0
		for i in range(n):
			if i not in rows:
				for j in range(m):
					if j not in col:
						rows.append(i)
						col.append(j)
						count += 1
						flag = 1
						break
		if flag == 0:
			if count % 2 == 0:
				print('Vivek')
			else:
				print('Ashish')
			break
	t -= 1


def solve(array):
	row = []
	for i in range(len(array)):
		found = False
		for j in range(len(array[i])):
			if array[i][j] == 1:
				found = True
				break
		if found:
			row.append(False)
		else:
			row.append(True)
	col = []
	for i in range(len(array[0])):
		for j in range(len(array)):
			found = False
			if array[j][i] == 1:
				found = True
				break
		if found:
			col.append(False)
		else:
			col.append(True)
	r = 0
	c = 0
	for elem in row:
		if elem:
			r += 1
	for elem in col:
		if elem:
			c += 1
	if min(r, c) % 2 == 1:
		return 'Ashish'
	return 'Vivek'
input()
while True:
	try:
		val = input().split(' ')
		arr = []
		for i in range(int(val[0])):
			temp = input().split(' ')
			for i in range(len(temp)):
				temp[i] = int(temp[i])
			arr.append(temp)
		print(solve(arr))
	except EOFError:
		break


import sys, copy
tc = int(sys.stdin.readline())
for _ in range(tc):
	(n, m) = map(int, sys.stdin.readline().split())
	arr = [list(map(int, sys.stdin.readline().split())) for _ in range(n)]
	row = 0
	for i in range(n):
		cnt = 0
		for j in range(m):
			if not arr[i][j]:
				cnt += 1
		if cnt == m:
			row += 1
	col = 0
	for j in range(m):
		cnt = 0
		for i in range(n):
			if not arr[i][j]:
				cnt += 1
		if cnt == n:
			col += 1
	print('Vivek' if min(row, col) % 2 == 0 else 'Ashish')


from sys import stdin, stdout
for t in range(int(stdin.readline().strip())):
	(n, m) = map(int, stdin.readline().strip().split())
	a = []
	r = n
	c = m
	for i in range(n):
		temp = list(map(int, stdin.readline().strip().split()))
		a.append(temp.copy())
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r -= 1
				break
	for i in range(m):
		for j in range(n):
			if a[j][i] == 1:
				c -= 1
				break
	mn = min(r, c)
	if mn & 1:
		stdout.write('Ashish\n')
	else:
		stdout.write('Vivek\n')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	c = 0
	x = 0
	a = []
	for i in range(n):
		l = list(map(int, input().split()))
		a.append(l)
		if l.count(1) == 0:
			x += 1
	y = 0
	for i in range(m):
		l = [a[j][i] for j in range(n)]
		if l.count(1) == 0:
			y += 1
	if min(x, y) & 1:
		print('Ashish')
	else:
		print('Vivek')


import heapq as hp
import collections
import bisect
import math
import re

def unpack(func=int):
	return map(func, input().split())

def l_unpack(func=int):
	return list(map(func, input().split()))

def s_unpack(func=int):
	return sorted(map(func, input().split()))

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

def range_n():
	return range(int(input()))

def getint():
	return int(input())

def counter(a):
	d = {}
	for x in a:
		if x in d:
			d[x] += 1
		else:
			d[x] = 1
	return d

def main():
	for _ in range_n():
		(n, m) = unpack()
		mat = [l_unpack() for _ in range(n)]
		row = set()
		col = set()
		for i in range(n):
			for j in range(m):
				if mat[i][j]:
					row.add(i)
					col.add(j)
		winner = 'Vivek'
		flag = True
		for i in range(n):
			if i in row:
				continue
			for j in range(m):
				if j in col:
					continue
				if flag:
					winner = 'Ashish'
					flag = False
				else:
					winner = 'Vivek'
					flag = True
				mat[i][j] = 1
				row.add(i)
				col.add(j)
				break
		print(winner)
main()


def answer(n, m, mat):
	valid_rows = 0
	for r in mat:
		if 1 not in r:
			valid_rows += 1
	matt = [[mat[j][i] for j in range(n)] for i in range(m)]
	valid_cols = 0
	for c in matt:
		if 1 not in c:
			valid_cols += 1
	valid_moves = min(valid_rows, valid_cols)
	if valid_moves % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'

def main():
	t = int(input())
	n = [0] * t
	m = [0] * t
	mat = [0] * t
	for j in range(t):
		(n[j], m[j]) = [int(i) for i in input().split()]
		mat[j] = [0] * n[j]
		for i in range(n[j]):
			mat[j][i] = [int(q) for q in input().split()]
	for j in range(t):
		print(answer(n[j], m[j], mat[j]))
main()


def capture(mtr, n, m):
	tmpy = -1
	tmpx = -1
	for j in range(n):
		for k in range(m):
			if mtr[j][k] == 0:
				mtr[j][k] = 1
				tmpy = j
				tmpx = k
				break
	for q in range(n):
		if mtr[q][tmpx] != 1:
			mtr[q][tmpx] = 2
	for q in range(m):
		if mtr[tmpy][q] != 1:
			mtr[tmpy][q] = 2
	if tmpy == -1:
		return False
	return True

def main():
	t = int(input())
	for j in range(t):
		(n, m) = map(int, input().split())
		mtr = [0] * n
		for i in range(n):
			mtr[i] = list(map(int, input().split()))
		for i in range(n):
			for j in range(m):
				if mtr[i][j] == 1:
					for k in range(m):
						if mtr[i][k] == 0:
							mtr[i][k] = 2
					for k in range(n):
						if mtr[k][j] == 0:
							mtr[k][j] = 2
		counter = 0
		while capture(mtr, n, m):
			counter += 1
		print('Ashish' if counter % 2 == 1 else 'Vivek')
main()


T = int(input())
for c in range(T):
	a = []
	(n, m) = map(int, input().split())
	for r in range(n):
		inp = list(map(int, input().split()))
		a.append(inp)
	t = 1
	while True:
		turn = 'ns'
		for i in range(n):
			if max(a[i]) == 0:
				for j in range(m):
					check = 0
					for k in range(n):
						if a[k][j] != 0:
							check = -1
							break
					if check == 0:
						a[i][j] = 1
						turn = 's'
						break
			if turn == 's':
				break
		if turn == 'ns':
			break
		t = t + 1
	if t % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


T = int(input())
for _ in range(T):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		tmp = list(map(int, input().split()))
		mat.append(tmp)
	col = []
	for i in range(m):
		tmp = []
		for j in range(n):
			tmp.append(mat[j][i])
		col.append(tmp)
	a = 0
	b = 0
	for i in mat:
		if 1 not in i:
			a += 1
	for i in col:
		if 1 not in i:
			b += 1
	if min(a, b) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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, m) = rinput()
	rows = [0] * n
	col = [0] * m
	for i in range(n):
		a = rlinput()
		for j in range(m):
			if a[j] == 1:
				rows[i] = 1
				col[j] = 1
	count = min(rows.count(0), col.count(0))
	print(['Ashish', 'Vivek'][count % 2 == 0])


for i in range(int(input())):
	(n, m) = map(int, input().split())
	(fr, fc) = (n, set([i for i in range(m)]))
	for i in range(n):
		r = input().split()
		h1 = 0
		for i in range(m):
			if r[i] == '1':
				h1 = 1
				if i in fc:
					fc.remove(i)
		fr -= h1
	print('Ashish' if min(fr, len(fc)) & 1 else 'Vivek')


import sys
sys.setrecursionlimit(10 ** 5)
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()):
		(h, w) = MI()
		aa = LLI(h)
		for row in aa:
			if sum(row):
				h -= 1
		for row in zip(*aa):
			if sum(row):
				w -= 1
		if min(h, w) % 2:
			print('Ashish')
		else:
			print('Vivek')
main()


t = int(input())
for i in range(t):
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	r = set()
	c = set()
	M = [list(map(int, input().split())) for i in range(n)]
	for i in range(n):
		for j in range(m):
			if M[i][j] == 1:
				r.add(i)
				c.add(j)
	result = min(n - len(r), m - len(c))
	if result % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import gc
t = int(input())
count = 0
while count < t:
	count += 1
	l = list(map(int, input().split(' ')))
	n = l[0]
	m = l[1]
	i = 0
	l = []
	while i < n:
		l.append(list(input().split(' ')))
		i += 1
	availRows = 0
	availCols = 0
	for i in range(n):
		if '1' not in l[i]:
			availRows += 1
	for i in range(m):
		ans = True
		for j in l:
			if j[i] == '1':
				ans = False
				break
		if ans:
			availCols += 1
	x = min(availRows, availCols)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


l = int(input())
for k in range(l):
	(r, c) = map(int, input().split())
	x1 = [0] * r
	x2 = [0] * c
	x1c = 0
	x2c = 0
	for i in range(r):
		y = input().split()
		for j in range(c):
			if y[j] == '1':
				x1[i] = 1
				x2[j] = 1
	for m in x1:
		if m == 0:
			x1c += 1
	for m in x2:
		if m == 0:
			x2c += 1
	print(['Ashish', 'Vivek'][min(x1c, x2c) % 2 == 0])


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = [[int(i) for i in input().split()] for j in range(n)]
	c = 0
	dop = [0] * m
	for i in range(n):
		k = 0
		for j in range(m):
			if a[i][j] == 1:
				dop[j] = 1
				k = 1
			if j == m - 1 and k == 0:
				c += 1
	c = min(dop.count(0), c)
	print('Ashish' if c % 2 != 0 else 'Vivek')


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, m) = list(map(int, stdin.readline().split()))
	M = []
	for i in range(n):
		M.append(list(map(int, stdin.readline().split())))
	er = 0
	ec = 0
	for i in range(n):
		rs = True
		for j in range(m):
			if M[i][j] == 1:
				rs = False
				break
		if rs:
			er += 1
	for i in range(m):
		rs = True
		for j in range(n):
			if M[j][i] == 1:
				rs = False
				break
		if rs:
			ec += 1
	pos = min(er, ec) ** 2
	if pos % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


ll = lambda : list(map(int, input().split()))
s = lambda : input()
v = lambda : map(int, input().split())
ii = lambda : int(input())
import math
from collections import Counter
for _ in range(ii()):
	(n, m) = v()
	l = []
	for i in range(n):
		l.append(ll())
	r = [False] * n
	c = [False] * m
	for i in range(n):
		for j in range(m):
			if l[i][j]:
				r[i] = True
				c[j] = True
	co = 0
	for i in range(n):
		for j in range(m):
			if r[i] == False and c[j] == False:
				co += 1
				r[i] = True
				c[j] = True
	if co % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, k) = map(int, input().split())
	a = []
	for i in range(n):
		l = list(map(int, input().split()))
		a.append(l)
	ans = 0
	for i in range(n):
		for j in range(k):
			temp = False
			for I in range(n):
				if a[I][j] == 1:
					temp = True
					break
			if temp == False:
				for I in range(k):
					if a[i][I] == 1:
						temp = True
						break
			if temp == False:
				ans += 1
				a[i][j] = 1
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().strip().split())
	arr = []
	for _ in range(n):
		tmp = list(map(int, input().strip().split()))
		arr.append(tmp)
	turn = 0
	rows = set()
	cols = set()
	for i in range(n):
		f = 0
		for j in range(m):
			if arr[i][j] == 1:
				f = 1
				break
		if f == 0:
			rows.add(i)
	for i in range(m):
		f = 0
		for j in range(n):
			if arr[j][i] == 1:
				f = 1
				break
		if f == 0:
			cols.add(i)
	x = min(len(rows), len(cols))
	if x % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


def matrix_game():
	for _ in range(int(input())):
		(n, m) = list(map(int, input().split()))
		c = []
		for __ in range(n):
			c.append(list(map(int, input().split())))
		rows = 0
		columns = 0
		for i in range(n):
			ans = ''
			for j in range(m):
				x = c[i][j]
				if c[i][j] == 0:
					ans = 'YES'
				else:
					ans = 'NO'
					break
			if ans == 'YES':
				rows += 1
		for i in range(m):
			ans = ''
			for j in range(n):
				if c[j][i] == 0:
					ans = 'YES'
				else:
					ans = 'NO'
					break
			if ans == 'YES':
				columns += 1
		m = min(rows, columns)
		if m % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
matrix_game()


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, m) = neo()
	row = []
	colm = []
	for i in range(n):
		A = Neo()
		for j in range(m):
			if A[j] == 1:
				if i not in row:
					row.append(i)
				if j not in colm:
					colm.append(j)
	p = min(n - len(row), m - len(colm))
	if p % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	c_row = 0
	A = list()
	for i in range(n):
		a = list(map(int, input().split()))
		if a.count(1) == 0:
			c_row += 1
		A.append(a)
	c_col = 0
	for i in range(m):
		flag = 0
		for j in range(n):
			if A[j][i] == 1:
				flag = 1
		if flag == 0:
			c_col += 1
	mi = min(c_row, c_col)
	if mi & 1 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	mt = [[int(i) for i in input().split()] for _ in range(n)]
	f = 0
	(i, j) = (0, 0)
	r = [1] * n
	c = [1] * m
	for i in range(n):
		for j in range(m):
			if mt[i][j] == 1:
				r[i] = 0
				c[j] = 0
	res = min(sum(r), sum(c))
	if res % 2:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	r = set()
	c = set()
	for i in range(n):
		mat.append(list(map(int, input().split())))
		for j in range(m):
			if mat[i][j] == 1:
				r.add(i)
				c.add(j)
	rLeft = n - len(r)
	cLeft = m - len(c)
	if min(rLeft, cLeft) % 2 == 0:
		print('Vivek')
	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):
	(n, m) = inar()
	arr = [[] for i in range(n)]
	for i in range(n):
		arr[i] = inar()
	cnt = 0
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 0:
				cond = True
				for k in range(m):
					if arr[i][k] == 1:
						cond = False
				for k in range(n):
					if arr[k][j] == 1:
						cond = False
				if cond:
					arr[i][j] = 1
					cnt += 1
	if cnt % 2:
		print('Ashish')
	else:
		print('Vivek')


for ttt in range(int(input())):
	(n, m) = map(int, input().split())
	x = [0] * n
	y = [0] * m
	for i in range(n):
		l = list(map(int, input().split()))
		if 1 in l:
			x[i] = 1
		for j in range(m):
			if l[j] == 1:
				y[j] = 1
	t = min(x.count(0), y.count(0))
	print('Vivek' if t % 2 == 0 else 'Ashish')


import bisect
import decimal
from decimal import Decimal
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq
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
decimal.getcontext().prec = 46

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 DFS(n, s, adj):
	visited = [False for i in range(n)]
	stack = []
	stack.append(s)
	while len(stack):
		s = stack[-1]
		stack.pop()
		if not visited[s]:
			visited[s] = True
		for node in adj[s]:
			if not visited[node]:
				stack.append(node)

def solve():
	(n, m) = num_input()
	mat = []
	for i in range(n):
		mat.append(list_input())
	count = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 0:
				flag = False
				for col in range(m):
					if mat[i][col] == 1:
						flag = True
						break
				for row in range(n):
					if mat[row][j] == 1:
						flag = True
						break
				if not flag:
					mat[i][j] = 1
					count += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for _ in range(t):
	solve()


t = int(input())
result = []
sum = []
row = []
d_row = {}
d_col = {}
sum_r = 0
sum_c = 0
for _ in range(0, t):
	n = input().split()
	index = 0
	d_row = {}
	d_col = {}
	sum_r = 0
	sum_c = 0
	for i in range(0, int(n[0])):
		row = input().split()
		if i == 0:
			if '1' in row:
				d_row[i] = 1
				for j in range(0, len(row)):
					if row[j] == '1':
						d_col[j] = 1
					else:
						d_col[j] = 0
			else:
				d_row[i] = 0
				for j in range(0, len(row)):
					d_col[j] = 0
		elif '1' in row:
			d_row[i] = 1
			for j in range(0, len(row)):
				if row[j] == '1':
					d_col[j] = 1
		else:
			d_row[i] = 0
	for i in d_row.values():
		if i == 0:
			sum_r += 1
	for i in d_col.values():
		if i == 0:
			sum_c += 1
	index = min(sum_r, sum_c)
	if index % 2 == 0:
		result.append('Vivek')
	else:
		result.append('Ashish')
for i in result:
	print(i)


def isavailable(i, j, mat):
	if 1 in mat[i]:
		return False
	else:
		for row in mat:
			if 1 == row[j]:
				return False
	return True

def occupy(i, j, mat):
	mat[i][j] = 1
t = int(input())
ans = []
for i in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append([int(x) for x in input().split()])
	count = 0
	a = True
	while a:
		for i in range(n):
			for j in range(m):
				if isavailable(i, j, mat):
					occupy(i, j, mat)
					count = count + 1
					break
			else:
				continue
			break
		else:
			a = False
	if count % 2 != 0:
		ans.append('Ashish')
	else:
		ans.append('Vivek')
for item in ans:
	print(item)


t = int(input())
for t in range(0, t):
	(n, m) = [int(x) for x in input().split()]
	grid = [[int(x) for x in input().split()] for _ in range(n)]
	rows = sum((1 for x in grid if all((y == 0 for y in x))))
	cols = sum((1 for j in range(m) if all((grid[i][j] == 0 for i in range(n)))))
	res = min(rows, cols)
	print('Ashish' if res % 2 else 'Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	arr = []
	x = []
	y = []
	for i in range(n):
		q = list(map(int, input().split()))
		arr.append(q)
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				x.append(i)
				y.append(j)
	x = list(set(x))
	y = list(set(y))
	if min(n - len(x), m - len(y)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def column(matrix, i):
	return [row[i] for row in matrix]
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	ma = []
	for _ in range(n):
		ma.append(list(map(int, input().split())))
	ro = 0
	for i in ma:
		if 1 in i:
			ro += 1
	ro = n - ro
	co = 0
	for k in range(m):
		if 1 in column(ma, k):
			co += 1
	co = m - co
	ans = min(co, ro)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	t -= 1
	(n, m) = map(int, input().split())
	a = [[0 for x in range(m)] for y in range(n)]
	tem = []
	t1 = set()
	t2 = set()
	for x in range(1, n + 1, 1):
		tem = list(map(int, input().split()))
		for y in range(1, m + 1, 1):
			if tem[y - 1] == 1:
				t1.add(x)
				t2.add(y)
	m = min(n - len(t1), m - len(t2))
	if m % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for p in range(t):
	(n, m) = map(int, input().split())
	r = []
	c = []
	ref1 = []
	ref2 = []
	for k in range(1, n + 1):
		ref1.append(k)
	for l in range(1, m + 1):
		ref2.append(l)
	i = 0
	while i < n:
		j = 0
		a = input().split()
		while j < m:
			if a[j] == '1':
				r.append(i + 1)
				c.append(j + 1)
			j += 1
		i += 1
	r = set(ref1) - set(r)
	c = set(ref2) - set(c)
	x = min(len(r), len(c))
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys

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

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

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

def solve():
	(n, m) = readInts()
	a = [readInts() for _ in range(n)]
	numRows = n
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				numRows -= 1
				break
	numCols = m
	for j in range(m):
		for i in range(n):
			if a[i][j] == 1:
				numCols -= 1
				break
	if min(numRows, numCols) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')

def main():
	t = 1
	t = readInt()
	for _ in range(t):
		solve()
main()


def winner(n, m, a):
	fb_rows = []
	fb_columns = []
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				if i not in fb_rows:
					fb_rows.append(i)
				if j not in fb_columns:
					fb_columns.append(j)
	p = n - len(fb_rows)
	q = m - len(fb_columns)
	if min(p, q) % 2 != 0:
		return 'Ashish'
	else:
		return 'Vivek'
t = int(input())
for k in range(t):
	a = []
	(n, m) = map(int, input().split())
	for i in range(n):
		a.append(list(map(int, input().split())))
	print(winner(n, m, a))


import atexit
import io
import sys
import math
from collections import defaultdict, Counter
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	r = [0] * n
	c = [0] * m
	for j in range(n):
		a = list(map(int, input().split()))
		for k in range(m):
			if a[k] == 1:
				r[j] = 1
				c[k] = 1
	c1 = 0
	for j in range(n):
		if r[j] == 0:
			for k in range(m):
				if c[k] == 0:
					c[k] = 1
					c1 += 1
					break
	if c1 & 1 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	(n, m) = list(map(int, input().split()))
	row = [0 for i in range(n)]
	col = [0 for i in range(m)]
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(len(a)):
			if a[j] == 1:
				row[i] = 1
				col[j] = 1
	num = 0
	for i in range(n):
		for j in range(m):
			if row[i] == 0 and col[j] == 0:
				row[i] = 1
				col[j] = 1
				num += 1
	if num % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	q = [list(map(int, input().split())) for _ in range(n)]
	c = [1] * m
	r = [1] * n
	for i in range(n):
		for j in range(m):
			if q[i][j]:
				c[j] = 0
				r[i] = 0
	w = min(c.count(1), r.count(1))
	if w % 2:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	rows = set()
	cols = set()
	zeroes = set()
	for i in range(n):
		k = list(enumerate(map(int, input().split())))
		rows.add(i) if len(list(map(lambda x: cols.add(x[0]), filter(lambda x: x[1] == 1, k)))) > 0 else None
		list(map(lambda x: zeroes.add((i, x[0])), filter(lambda x: x[1] == 0, k)))
	c = 0
	for (i, j) in zeroes:
		if i not in rows and j not in cols:
			rows.add(i)
			cols.add(j)
			c += 1
	if c == 0:
		print('Vivek')
	else:
		print('Ashish') if c % 2 == 1 else print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	ali = []
	for i in range(n):
		li = list(map(int, input().split()))
		ali.append(li)
	row = 0
	col = 0
	for i in range(n):
		f = 0
		for j in range(m):
			if ali[i][j] == 1:
				f = 1
				break
		if f == 0:
			row += 1
	for i in range(m):
		f = 0
		for j in range(n):
			if ali[j][i] == 1:
				f = 1
				break
		if f == 0:
			col += 1
	q = min(col, row)
	if q % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from os import path
import sys
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd

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

def si():
	return input()

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

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def solve():
	for _ in range(ii()):
		(n, m) = mi()
		a = []
		for i in range(n):
			a.append(li())
		row = [0] * n
		col = [0] * m
		for i in range(n):
			for j in range(m):
				if a[i][j] == 1:
					row[i] = 1
					col[j] = 1
		f = 0
		for i in range(n):
			for j in range(m):
				if a[i][j] == 0 and row[i] == 0 and (col[j] == 0):
					f += 1
					row[i] = 1
					col[j] = 1
		if f & 1:
			print('Ashish')
		else:
			print('Vivek')
solve()


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, m, matrix):
	cols = [True] * m
	rows = [True] * n
	for i in range(n):
		for j in range(m):
			if matrix[i][j] != 0:
				cols[j] = False
				rows[i] = False
	moves = min(sum(cols), sum(rows))
	return moves % 2 == 1
for i in tests():
	(n, m) = arr_in()
	matrix = mat_in(n)
	out('Ashish' if solve(n, m, matrix) else 'Vivek')


for i1 in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		l = list(map(int, input().split()))
		a.append(l)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				for i2 in range(n):
					if a[i2][j] == 0:
						a[i2][j] = 2
				for j2 in range(m):
					if a[i][j2] == 0:
						a[i][j2] = 2
	track = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0:
				for i2 in range(n):
					if a[i2][j] == 0:
						a[i2][j] = 1
				for j2 in range(m):
					if a[i][j2] == 0:
						a[i][j2] = 1
				track += 1
	if track % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def transpose(matrix):
	res = []
	n = len(matrix)
	m = len(matrix[0])
	for j in range(m):
		tmp = []
		for i in range(n):
			tmp = tmp + [matrix[i][j]]
		res = res + [tmp]
	return res
for i in range(int(input())):
	(x, y) = map(int, input().split())
	matrix = []
	for j in range(x):
		matrix.append(input().split())
	rows = 0
	cols = 0
	transparency = transpose(matrix)
	for arr in matrix:
		if '1' not in arr:
			rows += 1
	for row in range(y):
		for col in range(x):
			transparency[row][col] = matrix[col][row]
	for arr in transparency:
		if '1' not in arr:
			cols += 1
	if not min(rows, cols) % 2:
		print('Vivek')
	else:
		print('Ashish')


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

def solve(R, C, grid):
	seenRows = set()
	seenCols = set()
	for r in range(R):
		for c in range(C):
			if grid[r][c]:
				seenRows.add(r)
				seenCols.add(c)
	movesLeft = min(C - len(seenCols), R - len(seenRows))
	if movesLeft % 2 == 0:
		return players[1]
	return players[0]
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input())
for t in range(T):
	(N, M) = [int(x) for x in input().split()]
	grid = [[int(x) for x in input().split()] for i in range(N)]
	ans = solve(N, M, grid)
	print(ans)


for t in range(int(input())):
	(n, m) = map(int, input().split())
	zero_cord = set()
	one_cord = set()
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(m):
			if a[j] == 1:
				one_cord.add(i)
				zero_cord.add(j)
	fr = n - len(one_cord)
	sc = m - len(zero_cord)
	if min(fr, sc) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


T = int(input())
for i in range(T):
	(n, m) = map(int, input().split())
	A = [0] * n
	B = [0] * m
	for i in range(n):
		tmp = list(map(int, input().split()))
		for j in range(m):
			if tmp[j] == 1:
				B[j] = 1
				A[i] = 1
	cnt = min(n - sum(A), m - sum(B))
	if cnt % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	table = []
	for i in range(n):
		table.append(input().split())
	free_rows = 0
	free_cols = 0
	for i in range(n):
		free = True
		for j in range(m):
			if table[i][j] == '1':
				free = False
				break
		if free == True:
			free_rows += 1
	for i in range(m):
		free = True
		for j in range(n):
			if table[j][i] == '1':
				free = False
				break
		if free == True:
			free_cols += 1
	turns = min(free_cols, free_rows)
	if turns % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	x = set()
	y = set()
	otv = 0
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(m):
			if a[j] == 1:
				x.add(i)
				y.add(j)
	otv = min(n - len(x), m - len(y))
	if otv % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	freei = {x: m for x in range(n)}
	freej = {x: n for x in range(m)}
	for i in range(n):
		a = tuple(map(int, input().split()))
		for j in range(m):
			if a[j]:
				freei[i] = 0
				freej[j] = 0
	ans = 0
	for i in range(n):
		for j in range(m):
			if freei[i] > 0 and freej[j] > 0:
				freei[i] = 0
				freej[j] = 0
				ans += 1
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	sn = set()
	sm = set()
	for i in range(n):
		a = [int(s) for s in input().split()]
		j = 0
		for el in a:
			if el == 1:
				sn.add(i)
				sm.add(j)
			j += 1
	n -= len(sn)
	m -= len(sm)
	k = min(m, n)
	if k % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t != 0:
	(n, m) = map(int, input().split())
	matrix = [[0 for x in range(m)] for y in range(n)]
	availableR = n
	availableC = m
	markedR = [False] * n
	markedC = [False] * m
	for i in range(n):
		matrix[i] = list(map(int, input().split()))
		for j in range(m):
			if matrix[i][j] == 1:
				if markedC[j] == False:
					markedC[j] = True
					availableC -= 1
				if markedR[i] == False:
					markedR[i] = True
					availableR -= 1
	result = 'Vivek'
	determineMove = 0
	if availableC > availableR:
		determineMove = availableR
	else:
		determineMove = availableC
	if determineMove == 0:
		print(result)
	elif determineMove % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


def solve():
	(n, m) = map(int, input().split())
	r = []
	c = []
	for i in range(n):
		t = list(map(int, input().split()))
		for j in range(m):
			if t[j] == 1:
				r.append(i)
				c.append(j)
	count = min(n - len(set(r)), m - len(set(c)))
	if count % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
for _ in range(int(input())):
	print(solve())


import math
import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	k = 0
	for i in range(n):
		r = list(map(int, input().split()))
		a.append(r)
	for i in range(n):
		if a[i].count(1) == 0:
			for j in range(m):
				flag = True
				for q in range(n):
					if a[q][j] == 1:
						flag = False
						break
				if flag:
					k += 1
					a[i][j] = 1
					break
	if k % 2:
		print('Ashish')
	else:
		print('Vivek')


test = int(input())
for i in range(test):
	claim_r = set()
	claim_c = set()
	cnt = 0
	(n, m) = [int(i) for i in input().split()]
	dp = [[]] * n
	for i in range(n):
		dp[i] = [int(j) for j in input().split()]
		for j in range(m):
			if dp[i][j]:
				claim_r.add(i)
				claim_c.add(j)
	for i in range(n):
		for j in range(m):
			if not dp[i][j]:
				if i not in claim_r and j not in claim_c:
					cnt += 1
					claim_r.add(i)
					claim_c.add(j)
	if cnt % 2:
		print('Ashish')
	else:
		print('Vivek')


import sys

def p(*_a):
	_s = ' '.join(map(str, _a))
	sys.stderr.write(_s + '\n')
T = int(input())

def solv(t):
	(N, M) = map(int, input().split())
	A = [list(map(int, input().split())) for i in range(N)]
	n = 0
	for ni in range(N):
		for mi in range(M):
			if A[ni][mi] == 1:
				break
		else:
			n += 1
	m = 0
	for mi in range(M):
		for ni in range(N):
			if A[ni][mi] == 1:
				break
		else:
			m += 1
	a = min(n, m)
	if a % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
for t in range(T):
	solv(t)


t = int(input())
for i in range(t):
	(n, m) = list(map(int, input().split()))
	matrix = []
	s = 0
	q = 0
	for j in range(n):
		num1 = list(map(int, input().split()))
		matrix.append(num1)
		if num1.count(1) == 0:
			s += 1
	for j in range(m):
		lis = []
		for k in range(n):
			lis.append(matrix[k][j])
		if lis.count(1) == 0:
			q += 1
	max1 = min(s, q)
	if max1 % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
import string
input = sys.stdin.readline
import math
from operator import xor
p = 10 ** 9 + 7
t = int(input())
for i in range(t):
	(a, b) = list(map(int, input().split()))
	ll = []
	for j in range(a):
		n = list(map(int, input().split()))
		ll.append(n)
	tot_r = 0
	for x in range(a):
		if sum(ll[x][:]) > 0:
			tot_r += 1
	tot_p = 0
	for x in range(b):
		for z in range(a):
			if ll[z][x] > 0:
				tot_p += 1
				break
	ans = min(a - tot_r, b - tot_p)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


try:

	def fun(q, i):
		cnt = 0
		for t in range(len(q)):
			cnt = cnt + q[t][i]
		return cnt
	for _ in range(int(input())):
		(x, y) = map(int, input().split())
		l1 = []
		for _ in range(x):
			l = [int(i) for i in input().split()]
			l1.append(l)
		count = 0
		for i in range(x):
			if sum(l1[i]) == 0:
				for j in range(y):
					if l1[i][j] == 0:
						if fun(l1, j) == 0:
							l1[i][j] = 1
							count = count + 1
							break
		if count % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
except:
	pass


from sys import stdin, stdout
for cases in range(int(stdin.readline())):
	(n, m) = map(int, stdin.readline().split())
	r = set()
	c = set()
	a = []
	b = [0] * m
	for i in range(n):
		b = list(map(int, stdin.readline().split()))
		a.append(b)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r.add(i)
				c.add(j)
	ans = min(n - len(r), m - len(c))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def checkRow(arr, n, m, row):
	for i in range(m):
		if arr[row][i] == 1:
			return False
	return True

def checkCol(arr, n, m, col):
	for i in range(n):
		if arr[i][col] == 1:
			return False
	return True

def MakeClaim(arr, n, m):
	count_claims_made = 0
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 0 and checkRow(arr, n, m, i) and checkCol(arr, n, m, j):
				arr[i][j] = 1
				count_claims_made += 1
	return count_claims_made
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	arr = []
	for _ in range(n):
		arr.append(list(map(int, input().split())))
	num_of_claims = MakeClaim(arr, n, m)
	if num_of_claims % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


T = int(input())

def countFreeRows(arr):
	count = 0
	for row in arr:
		if row.count(1) == 0:
			count += 1
	return count

def countFreeCols(arri, n, m):
	cols = []
	for row in arr:
		for i in range(0, len(row)):
			if row[i] == 1:
				if cols.count(i) == 0:
					cols.append(i)
	return m - len(cols)

def solve(arr, n, m):
	rc = countFreeRows(arr)
	cc = countFreeCols(arr, n, m)
	a = min(rc, cc)
	if a % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
while T > 0:
	arr = []
	(n, m) = [int(el) for el in input().split(' ')]
	for i in range(0, n):
		arr.append([int(el) for el in input().split(' ')])
	solve(arr, n, m)
	T -= 1


import math
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	r = 0
	c = 0
	for i in range(n):
		flag = 0
		l1 = [int(x) for x in input().split()]
		l.append(l1)
		for j in range(m):
			if l1[j] == 1:
				flag = 1
				break
		if flag == 0:
			r += 1
	for i in range(m):
		flag = 0
		for j in range(n):
			if l[j][i] == 1:
				flag = 1
				break
		if flag == 0:
			c += 1
	m = min(c, r)
	if m % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	row_ind_set = set(range(n))
	col_ind_set = set(range(m))
	arr = []
	for row_ind in range(n):
		arr = list(map(int, input().split()))
		for (col_ind, elm) in enumerate(arr):
			if elm > 0:
				row_ind_set.discard(row_ind)
				col_ind_set.discard(col_ind)
	min_size = min(len(row_ind_set), len(col_ind_set))
	if min_size % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def aux(matrix, c, r):
	for i in range(0, n):
		if matrix[i][r] == '0':
			matrix[i][r] = '2'
	for i in range(0, m):
		if matrix[c][i] == '0':
			matrix[c][i] = '2'
t = int(input())
for test in range(0, t):
	(n, m) = input().split()
	(n, m) = (int(n), int(m))
	matrix = []
	for i in range(0, n):
		matrix.append(input().split())
	for i in range(0, n):
		for j in range(0, m):
			if matrix[i][j] == '1':
				matrix[i][j] = '2'
				aux(matrix, i, j)
	res = 0
	for i in range(0, n):
		for j in range(0, m):
			if matrix[i][j] == '0':
				matrix[i][j] = '2'
				res += 1
				aux(matrix, i, j)
	if res % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for case in range(t):
	(n, m) = [int(i) for i in input().split()]
	l = [[int(i) for i in input().split()] for j in range(n)]
	l2 = [[0 for i in range(m)] for j in range(n)]
	r = n
	c = m
	r -= sum([1 in i for i in l])
	for i in range(m):
		c -= 1 in [l[j][i] for j in range(n)]
	t = 1
	while r > 0 and c > 0:
		r -= 1
		c -= 1
		t = 1 - t
	if t == 1:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	rr = [0] * n
	cc = [0] * m
	for r in range(n):
		row = list(map(int, input().split()))
		rr[r] += sum(row)
		for (c, cell) in enumerate(row):
			cc[c] += cell
	win = min(sum((x == 0 for x in rr)), sum((x == 0 for x in cc))) & 1
	print('Ashish' if win else 'Vivek')


import os
import heapq
import sys
import math
import operator
from collections import defaultdict
from io import BytesIO, IOBase

def inar():
	return [int(k) for k in input().split()]

def solve():
	(n, m) = map(int, input().split())
	ar = []
	for i in range(n):
		ar.append(inar())
	count = 0
	for i in range(n):
		for j in range(m):
			if ar[i][j] == 0:
				bl = True
				for k in range(j):
					if ar[i][k] == 1:
						bl = False
						break
				for k in range(j + 1, m):
					if ar[i][k] == 1:
						bl = False
						break
				for k in range(i):
					if ar[k][j] == 1:
						bl = False
						break
				for k in range(i + 1, n):
					if ar[k][j] == 1:
						bl = False
						break
				if bl:
					count += 1
					ar[i][j] = 1
	if count % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')

def main():
	for _ in range(int(input())):
		solve()
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 os
import sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip
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 func(i, j):
	for row in range(n):
		if mat[row][j] == 0:
			mat[row][j] = -1
	for col in range(m):
		if mat[i][col] == 0:
			mat[i][col] = -1

def solve():
	for _ in range(int(input())):
		(n, m) = read()
		mat = []
		for i in range(n):
			mat.append(read())

		def func(i, j):
			for row in range(n):
				if mat[row][j] == 0:
					mat[row][j] = -1
			for col in range(m):
				if mat[i][col] == 0:
					mat[i][col] = -1
		winner = ['Ashish', 'Vivek']
		c = 1
		for i in range(n):
			for j in range(m):
				if mat[i][j] == 1:
					func(i, j)
		while True:
			flag = 0
			for i in range(n):
				for j in range(m):
					if mat[i][j] == 0:
						c += 1
						func(i, j)
						flag = 1
						break
				if flag:
					break
			if not flag:
				break
		print(winner[c % 2])
solve()


for i in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(input().split())
	good_r = len([r for r in mat if '1' not in r])
	good_c = 0
	for i in range(m):
		if '1' not in [row[i] for row in mat]:
			good_c += 1
	print('Vivek' if min(good_c, good_r) % 2 == 0 else 'Ashish')


from collections import Counter
from collections import defaultdict
from collections import deque
import math
import heapq
import sys
import io, os
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()))
t = int(input())
for _ in range(0, t):
	(n, m) = rl()
	ans = 0
	a = []
	mark = []
	for i in range(0, n):
		mark.append([0] * m)
	for i in range(0, n):
		d = rl()
		a.append(d)
	for i in range(0, n):
		s = list(a[i])
		if s.count(1) > 0:
			for j in range(0, m):
				mark[i][j] = mark[i][j] + 1
	for i in range(0, m):
		k = 0
		for j in range(0, n):
			if a[j][i] == 1:
				k = 1
				break
		if k == 1:
			for j in range(0, n):
				mark[j][i] = mark[j][i] + 1
	d1 = defaultdict(lambda : -1)
	d2 = defaultdict(lambda : -1)
	ans = 0
	for i in range(0, n):
		if d1[i] == 1:
			continue
		for j in range(0, m):
			if d2[j] == 1:
				continue
			if d1[i] == 1:
				continue
			if mark[i][j] == 0:
				ans = ans + 1
				d1[i] = 1
				d2[j] = 1
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def matrix(main, n, m):
	moves = 0
	a = 0
	temp = [0] * m
	for i in main:
		c = 0
		for j in range(m):
			if i[j] == 1:
				c = 1
				temp[j] = 1
		if c == 0:
			moves += 1
	ans = min(moves, temp.count(0))
	if ans % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	main = []
	for _ in range(n):
		r = list(map(int, input().split()))
		main.append(r)
	print(matrix(main, n, m))


for i in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append([int(i) for i in input().split()])
	row = set()
	col = set()
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row.add(i)
				col.add(j)
	ans = min(n - len(row), m - len(col))
	print(['Vivek', 'Ashish'][ans & 1])


def calculator(r, c, s):
	if s <= 0:
		return 0
	else:
		new_s = s - c - r + 1
		new_r = r - 1
		new_c = c - 1
		return 1 + calculator(new_r, new_c, new_s)

def game(n, m, array):
	rows = set([])
	columns = set([])
	spaces_remaining = 0
	for i in range(n):
		for j in range(m):
			if array[i][j] == 1:
				rows.add(i)
				columns.add(j)
	spaces_remaining = n * m - (m * len(rows) + (n - len(rows)) * len(columns))
	n_rows_remain = n - len(rows)
	n_columns_remain = m - len(columns)
	return calculator(n_rows_remain, n_columns_remain, spaces_remaining)
t = int(input())
array = []
for i in range(t):
	(n, m) = list(map(int, input().split(' ')))
	matrix = []
	for j in range(n):
		matrix.append(list(map(int, input().split(' '))))
	array.append([n, m, matrix])
for lists in array:
	if game(lists[0], lists[1], lists[2]) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
import sys

def solve(n, m, Map):
	Row = [1] * n
	Col = [1] * m
	for (i, M) in enumerate(Map):
		for (j, k) in enumerate(M):
			if k == 1:
				Row[i] = 0
				Col[j] = 0
	remain = min(sum(Row), sum(Col))
	if remain % 2 == 0:
		return 'Vivek'
	return 'Ashish'

def main():
	t = int(input())
	for _ in range(t):
		(n, m) = map(int, input().split())
		Map = [list(map(int, input().split())) for _ in range(n)]
		ans = solve(n, m, Map)
		sys.stdout.write(str(ans) + '\n')
main()


import sys, math
import io, os

def data():
	return sys.stdin.buffer.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')
mod = int(1000000000.0) + 7

def main():
	for t in range(int(data())):
		(n, m) = mdata()
		row = [0] * n
		col = [0] * m
		for i in range(n):
			l = mdata()
			for j in range(m):
				if l[j] == 1:
					row[i] = 1
					col[j] = 1
		cnt = 0
		for i in range(n):
			if row[i] == 0:
				cnt += 1
		cnt1 = 0
		for i in range(m):
			if col[i] == 0:
				cnt1 += 1
		ans = min(cnt, cnt1)
		if ans % 2 == 0:
			out('Vivek')
		else:
			out('Ashish')
main()


def solve(row, col, matrix):
	row_value = set()
	col_value = set()
	for i in range(row):
		for j in range(col):
			if matrix[i][j] == 1:
				row_value.add(i)
				col_value.add(j)
	count = 0
	for i in range(row):
		for j in range(col):
			if i not in row_value and j not in col_value:
				count += 1
				row_value.add(i)
				col_value.add(j)
	if count % 2 == 0:
		print('Vivek')
		return
	else:
		print('Ashish')
t = int(input())
while t:
	t -= 1
	value = [int(i) for i in input().split()]
	(row, cell) = (value[0], value[1])
	matrix = [[int(i) for i in input().split()] for j in range(row)]
	solve(row, cell, matrix)


t = int(input())
while t:
	t -= 1
	(n, m) = map(int, input().split())
	a = [0] * n
	b = [0] * m
	cr = n
	cc = m
	for i in range(n):
		c = list(map(int, input().split()))
		for j in range(m):
			if c[j] == 1 and a[i] == 0:
				a[i] = 1
				cr = cr - 1
			if c[j] == 1 and b[j] == 0:
				b[j] = 1
				cc -= 1
	m = min(cr, cc)
	if m % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	l = []
	for j in range(n):
		l1 = list(map(int, input().split()))
		l.append(l1)
	for j in range(n):
		for k in range(m):
			if l[j][k] == 1:
				for x in range(m):
					if l[j][x] == 0:
						l[j][x] = -1
				for x in range(n):
					if l[x][k] == 0:
						l[x][k] = -1
	winner = 0
	for j in range(n):
		for k in range(m):
			if l[j][k] == 0:
				winner += 1
				for x in range(m):
					if l[j][x] == 0:
						l[j][x] = -1
				for x in range(n):
					if l[x][k] == 0:
						l[x][k] = -1
	if winner % 2:
		print('Ashish')
	else:
		print('Vivek')


for i in range(int(input())):
	(n, m) = map(int, input().split())
	rows = [0] * n
	columns = [0] * m
	for i in range(n):
		k = list(map(int, input().split()))
		for j in range(m):
			if k[j] == 1:
				rows[i] = 1
				columns[j] = 1
	if min(n - sum(rows), m - sum(columns)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	galatc = []
	galatr = 0
	for j in range(n):
		l = list(map(int, input().split()))
		if 1 in l:
			galatr += 1
			for k in range(m):
				if l[k] == 1 and k not in galatc:
					galatc.append(k)
				else:
					continue
		else:
			continue
	pr = n - galatr
	pc = m - len(galatc)
	turns = min(pr, pc)
	if turns % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		temp = list(map(int, input().split()))
		arr.append(temp)
	rows = 0
	column = 0
	for i in range(n):
		if 1 in arr[i]:
			rows += 1
	for i in range(m):
		for j in range(n):
			if arr[j][i] == 1:
				column += 1
				break
	left = min(n - rows, m - column)
	if left % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math

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

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

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

def swap(list, pos1, pos2):
	(list[pos1], list[pos2]) = (list[pos2], list[pos1])
	return list
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	r = [0 for i in range(n)]
	c = [0 for i in range(m)]
	for i in range(n):
		a.append(list(map(int, input().split())))
	for i in range(n):
		if 1 in a[i]:
			r[i] = 1
	for i in range(m):
		for j in range(n):
			if a[j][i] == 1:
				c[i] = 1
	m = min(r.count(0), c.count(0))
	if m == 0:
		print('Vivek')
	elif m % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.buffer.readline
T = int(input())
for _ in range(1, T + 1):
	(n, m) = map(int, input().split())
	matrix = []
	av_col = 0
	av_row = 0
	for nn in range(n):
		row = [int(x) for x in input().split()]
		if 1 not in row:
			av_row = av_row + 1
		matrix.append(row)
	for i in range(m):
		col_is_av = True
		for j in range(n):
			if matrix[j][i] == 1:
				col_is_av = False
		if col_is_av:
			av_col = av_col + 1
	av = min(av_col, av_row)
	if av % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(x, y) = map(int, input().split())
	rows = [0] * x
	cols = [0] * y
	for i in range(x):
		myList = list(map(int, input().split()))
		for j in range(y):
			if myList[j] == 1:
				rows[i] = 1
				cols[j] = 1
	zeroRow = rows.count(0)
	zeroCols = cols.count(0)
	minn = min(zeroCols, zeroRow)
	if minn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def main():
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		m2 = [list(map(int, input().split())) for i in range(n)]
		(r, c) = (0, 0)
		s = [[], []]
		for i in range(n):
			if not m2[i].count(1) > 0:
				r += 1
				s[0].append(i)
		m1 = list(zip(*m2))
		for j in range(m):
			if not m1[j].count(1) > 0:
				c += 1
				s[1].append(i)
		if min(r, c) % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


t = int(input())
for q in range(t):
	(r, c) = map(int, input().split())
	mat = []
	for i in range(r):
		lst = list(map(int, input().split()))
		mat.append(lst)
	row = [0] * r
	col = [0] * c
	cnt = 0
	for i in range(r):
		for j in range(c):
			if mat[i][j] == 1:
				row[i] = 1
				col[j] = 1
	sm1 = r - sum(row)
	sm2 = c - sum(col)
	if sm1 < 0:
		sm1 = 0
	if sm2 < 0:
		sm2 = 0
	x = min(sm1, sm2)
	if x % 2 == 0 and x != 1:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = [int(i) for i in input().split()]
	a = [[int(i) for i in input().split()] for i in range(n)]
	r = [0 for i in range(n)]
	c = [0 for i in range(m)]
	for i in range(n):
		for j in range(m):
			r[i] = max(r[i], a[i][j])
			c[j] = max(c[j], a[i][j])
	k = min(r.count(0), c.count(0))
	if k % 2:
		print('Ashish')
	else:
		print('Vivek')


test = int(input())
for w in range(test):
	(n, m) = input().split()
	(n, m) = (int(n), int(m))
	matrix = []
	for i in range(n):
		aux = [int(x) for x in input().split()]
		matrix.append(aux)
	matrix_2 = [[0 for i in range(m)] for p in range(n)]
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				for x in range(n):
					matrix_2[x][j] = 1
				for y in range(m):
					matrix_2[i][y] = 1
	counter = 0
	for i in range(n):
		for j in range(m):
			if matrix_2[i][j] == 0:
				for x in range(n):
					matrix_2[x][j] = 1
				for y in range(m):
					matrix_2[i][y] = 1
				counter += 1
	if counter % 2:
		print('Ashish')
	else:
		print('Vivek')


import sys
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 winner(num_rows_unclaimed, num_cols_unclaimed):
	game_min = min(num_rows_unclaimed, num_cols_unclaimed)
	if game_min % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
num_tests = inp()
for _ in range(num_tests):
	(n, m) = inlt()
	matrix = []
	for _ in range(n):
		matrix.append(inlt())
	row_flag = [0 for _ in range(n)]
	col_flag = [0 for _ in range(m)]
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				row_flag[i] = 1
				col_flag[j] = 1
	num_rows_unclaimed = row_flag.count(0)
	num_cols_unclaimed = col_flag.count(0)
	winner(num_rows_unclaimed, num_cols_unclaimed)


for _ in range(int(input())):
	(m, n) = map(int, input().split(' '))
	row_set = set()
	col_set = set()
	for row in range(m):
		val = list(map(int, input().split()))
		if sum(val) != 0:
			row_set.add(row)
		for col in range(n):
			if val[col] == 1:
				col_set.add(col)
	if min(m - len(row_set), n - len(col_set)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	row = [1 for i in range(n)]
	col = [1 for j in range(m)]
	for i in range(n):
		arr = list(map(int, input().split()))
		for j in range(m):
			if arr[j] == 1:
				row[i] = 0
				col[j] = 0
	ans = min(sum(row), sum(col))
	print('Ashish' if ans % 2 else 'Vivek')


for t in range(int(input())):
	(n, m) = map(int, input().split())
	row = [0] * n
	col = [0] * m
	for i in range(n):
		row_in = list(map(int, input().split()))
		for j in range(m):
			if row_in[j] == 1:
				col[j] = 1
		if 1 in row_in:
			row[i] = 1
	claimable = min(row.count(0), col.count(0))
	print('Ashish' if claimable % 2 == 1 else 'Vivek')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	for j in range(n):
		matrix.append(list(map(int, input().split())))
	row = 0
	column = 0
	for j in range(n):
		flagrow = 0
		flagcolumn = 0
		for k in range(m):
			if matrix[j][k] == 1:
				flagrow = 1
		if flagrow == 0:
			row += 1
	for j in range(m):
		flagcolumn = 0
		for k in range(n):
			if matrix[k][j] == 1:
				flagcolumn = 1
		if flagcolumn == 0:
			column += 1
	m = min(row, column)
	if m % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	c = 0
	m1 = m
	aa = set()
	aaa = set()
	for i in range(n):
		a = list(map(int, input().split()))
		if 1 not in a:
			c += 1
		else:
			for j in range(m):
				if a[j] == 1:
					aa.add(i)
					aaa.add(j)
	l = min(n - len(aa), m - len(aaa))
	print('Vivek' if l % 2 == 0 else 'Ashish')


from sys import stdin
input = stdin.readline
import bisect
import math
for xoxo in range(1):
	ans = ['Vivek', 'Ashish']
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		a = []
		ver = []
		hor = []
		for i in range(n):
			t = list(map(int, input().split()))
			a.append(t)
			ver.append(min(sum(t), 1))
		for i in range(m):
			s = 0
			for j in range(n):
				s += a[j][i]
				if s != 0:
					break
			hor.append(s)
		p = 0
		for i in range(n):
			for j in range(m):
				if ver[i] == 1:
					break
				if hor[j] + ver[i] == 0:
					p += 1
					(hor[j], ver[i]) = (1, 1)
		print(ans[p % 2])


def game(matrix, rows, cols):
	i = 0
	col_matrix = [[matrix[i][j] for i in range(rows)] for j in range(cols)]
	while find(matrix, col_matrix) != None:
		play = find(matrix, col_matrix)
		matrix[play[0]][play[1]] = 1
		col_matrix[play[1]][play[0]] = 1
		i += 1
	if i % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'

def find(matrix, col_matrix):
	for (i, row) in enumerate(matrix):
		for (j, val) in enumerate(row):
			if 1 in row or 1 in col_matrix[j]:
				pass
			else:
				return (i, j)
	return None
import sys
starts = set([1])
for (l, line) in enumerate(sys.stdin):
	split = line.split()
	if l == 0:
		num_games = int(split[0])
	elif l in starts:
		(rows, cols) = map(int, split)
		starts.add(l + rows + 1)
		matrix = []
	else:
		matrix.append(list(map(int, split)))
		if l + 1 in starts:
			print(game(matrix, rows, cols))


m = 0
n = 0

def traversing(a, b, li):
	for i in range(0, m):
		if int(li[i][b]) == 1:
			return 2
	for i in range(0, n):
		if int(li[a][i]) == 1:
			return -1
	return 1
t = int(input())
for u in range(0, t):
	(m, n) = input().split()
	m = int(m)
	n = int(n)
	li = [[0 for x in range(n)] for x in range(m)]
	for i in range(0, m):
		li[i] = input().split()
	s = 1
	(i, j) = (0, 0)
	while i < m and j < n:
		k = traversing(i, j, li)
		if k == -1:
			i = i + 1
		elif k == 2:
			j = j + 1
		else:
			i = i + 1
			j = j + 1
		if k == 1:
			s = s + 1
	if s % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		q = list(map(int, input().split()))
		a.append(q)
	r = []
	c = []
	ans = 0
	fg = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r.append(i)
				c.append(j)
	for j in range(n):
		for k in range(m):
			if j not in r and k not in c:
				r.append(j)
				c.append(k)
				ans += 1
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	r = 0
	c = 0
	for i in range(n):
		if sum(l[i]) == 0:
			r += 1
	for i in range(m):
		temp = 0
		for j in range(n):
			temp += l[j][i]
			if temp > 0:
				break
		if temp == 0:
			c += 1
	ans = min(r, c)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
t = int(input())
for w in range(t):
	(n, m) = (int(i) for i in input().split())
	l = [0] * n
	for i in range(n):
		l[i] = [int(i) for i in input().split()]
	moves = 0
	for i in range(n):
		if 1 not in l[i]:
			for j in range(m):
				c = 1
				if l[i][j] == 0:
					for k in range(n):
						if l[k][j] == 1:
							c = -1
							break
				if c == 1:
					break
			if c == 1:
				l[i][j] = 1
				moves += 1
	if moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for bc in range(t):
	(n, m) = list(map(int, input().split()))
	l = []
	for x in range(n):
		l.append(list(input().split()))
	rols = 0
	cols = 0
	moves = 0
	for ab in range(n):
		ax = 1
		for bc in range(m):
			if l[ab][bc] == '1':
				ax = 0
		cols += ax
	for ac in range(m):
		ax = 1
		for bd in range(n):
			if l[bd][ac] == '1':
				ax = 0
		rols += ax
	moves = min(rols, cols)
	if moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	a = []
	b = []
	c = 0
	d = 0
	(m, n) = list(map(int, input().split(' ')))
	for j in range(m):
		b = list(map(int, input().split(' ')))
		r = all((x == 0 for x in b))
		if r == True:
			c += 1
		a.append(b)
	for j in range(n):
		temp = []
		for k in range(m):
			temp.append(a[k][j])
		r = all((x == 0 for x in temp))
		if r == True:
			d += 1
	if c != d:
		c = min(c, d)
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	ans = 0
	a = []
	for i in range(n):
		a += (list(map(int, input().split())),)
	r = [1] * n
	c = [1] * m
	for i in range(n):
		for j in range(m):
			if a[i][j]:
				r[i] = 0
				c[j] = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0:
				if r[i] and c[j]:
					ans += 1
					r[i] = 0
					c[j] = 0
	print(('Vivek', 'Ashish')[ans & 1])


import sys, math
from collections import deque

def solve():
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		matrix.append(list(map(int, input().split())))
	row = [0] * n
	col = [0] * m
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				row[i] = 1
				col[j] = 1
	turn = 0
	while 1 > 0:
		findMove = False
		for i in range(n):
			for j in range(m):
				if matrix[i][j] == 0 and row[i] == 0 and (col[j] == 0):
					matrix[i][j] = 1
					row[i] = 1
					col[j] = 1
					findMove = True
					break
			if findMove:
				break
		if not findMove:
			break
		else:
			turn ^= 1
	if turn == 0:
		print('Vivek')
	else:
		print('Ashish')
for _ in range(int(input())):
	solve()


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

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():
	_v_ = II()
	for _ in range(_v_):
		(n, m) = MI()
		(nx, mx) = ([], [])
		for i in range(n):
			nx.append(False)
		for i in range(m):
			mx.append(False)
		s = []
		for i in range(n):
			s.append(LI())
			for j in range(m):
				if s[i][j] == 1:
					nx[i] = True
					mx[j] = True
		(nxn, mxn) = (nx.count(False), mx.count(False))
		if min(nxn, mxn) & 1 == 1:
			print('Ashish')
		else:
			print('Vivek')
main()


try:

	def sumc(m, i):
		total = 0
		for c in range(len(m)):
			total = total + m[c][i]
		return total
	for _ in range(int(input())):
		(m, n) = map(int, input().split())
		lst = []
		for _ in range(m):
			l = [int(i) for i in input().split()]
			lst.append(l)
		count = 0
		for i in range(m):
			if sum(lst[i]) == 0:
				for j in range(n):
					if lst[i][j] == 0:
						if sumc(lst, j) == 0:
							lst[i][j] = 1
							count = count + 1
							break
		if count % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
except:
	pass


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	(row, col) = (set(), set())
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(m):
			if a[j] == 1:
				row.add(i)
				col.add(j)
	res = min(n - len(row), m - len(col))
	if res % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import sys
import math

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

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

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

def SI():
	return sys.stdin.readline().strip()
t = II()
for q in range(t):
	(n, m) = MI()
	l = []
	for i in range(n):
		l.append(LI())
	x = 0
	y = 0
	for i in range(n):
		count = 0
		for j in range(m):
			if l[i][j] == 1:
				count += 1
				break
		if count == 0:
			x += 1
	for j in range(m):
		count = 0
		for i in range(n):
			if l[i][j] == 1:
				count += 1
				break
		if count == 0:
			y += 1
	print('Vivek' if min(x, y) % 2 == 0 else 'Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	row = dict()
	column = dict()
	for i in range(m):
		column[i] = False
	for i in range(n):
		a = list(map(int, input().split()))
		row[i] = False
		for j in range(m):
			if a[j] == 1:
				row[i] = True
				column[j] = True
	rows = 0
	for i in range(n):
		if not row[i]:
			rows += 1
	columns = 0
	for i in range(m):
		if not column[i]:
			columns += 1
	ans = min(rows, columns)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	t = t - 1
	(n, m) = map(int, input().split())
	cols = []
	rows = []
	for i in range(n):
		a = list(map(int, input().split()))
		if a.count(1) > 0:
			rows.append(i)
		for j in range(len(a)):
			if a[j] == 1:
				cols.append(j)
	cols = set(cols)
	rows = set(rows)
	crem = m - len(cols)
	rrem = n - len(rows)
	left = min(crem, rrem)
	if left % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def is_khali(i, j):
	row = sum(a[i])
	col = 0
	for k in range(n):
		col += a[k][j]
	if row == 0 and col == 0:
		return True
	else:
		return False
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	output = 1
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0 and is_khali(i, j):
				a[i][j] = 1
				output += 1
	if output % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().strip().split()))
	matrix = []
	for _ in range(n):
		matrix.append(list(map(int, input().strip().split())))
	rows = 0
	for row in matrix:
		if sum(row) == 0:
			rows += 1
	cols = 0
	for i in range(m):
		s = 0
		for j in range(n):
			s += matrix[j][i]
		if s == 0:
			cols += 1
	mini = min(cols, rows)
	if mini % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


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 factorial
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop, heappush

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

def main():
	for _ in range(N()):
		(n, m) = RL()
		arr = []
		for _ in range(n):
			arr.append(RLL())
		pos = 0
		v = 'Vivek'
		a = 'Ashish'
		row = [0] * n
		col = [0] * m
		for i in range(n):
			for j in range(m):
				if arr[i][j] == 1:
					row[i] = 1
					col[j] = 1
		pos += min(row.count(0), col.count(0))
		print(v if pos % 2 == 0 else a)
main()


import sys
input = sys.stdin.readline
for T in range(int(input())):
	(n, m) = list(map(int, input().split()))
	arr = []
	for i in range(n):
		arr.append(list(map(int, input().split())))
	row = {}
	col = {}
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				row[i] = 1
				col[j] = 1
	count = 0
	for i in range(n):
		for j in range(m):
			if not row.get(i, 0) and (not col.get(j, 0)):
				arr[i][j] = 1
				count += 1
				row[i] = 1
				col[j] = 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())

def check(mat, n, m):
	for i in range(n):
		if mat[i] == [0 for i in range(m)]:
			for j in range(m):
				s = 0
				for k in range(n):
					s += mat[k][j]
				if s == 0:
					return [True, i, j]
	return [False, 0, 0]
for i in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	s = 'Vivek'
	while check(mat, n, m)[0]:
		mat[check(mat, n, m)[1]][check(mat, n, m)[2]] = 1
		if s == 'Vivek':
			s = 'Ashish'
		else:
			s = 'Vivek'
	print(s)


for i in range(int(input())):
	(n, m) = [int(i) for i in input().split()]
	l = []
	count = 0
	row = 0
	for i in range(n):
		k = [int(j) for j in input().split()]
		if 1 not in k:
			row += 1
		l.append(k)
	col = 0
	for i in range(m):
		flag = False
		for j in range(n):
			if l[j][i] == 1:
				flag = True
				break
		if not flag:
			col += 1
	ans = min(row, col)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = tuple(map(int, input().split()))
	a = []
	for i in range(n):
		a.append([int(j) for j in input().split()])
	faka = 0
	fakarow = 0
	for k in range(n):
		if sum(a[k]) == 0:
			faka += 1
	b = list(map(list, zip(*a)))
	for l in range(m):
		if sum(b[l]) == 0:
			fakarow += 1
	faka = min(faka, fakarow)
	if faka % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


I = lambda : list(map(int, input().split(' ')))
for _ in range(I()[0]):
	(n, m) = I()
	mat = [I() for _ in range(n)]
	row = []
	col = []
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				row.append(i)
				col.append(j)
	total = max(0, min(n - len(set(row)), m - len(set(col))))
	if total % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
output = sys.stdout

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

def solve(a, b, l):
	c1 = 0
	s = 0
	c2 = 0
	res = 0
	for i in range(a):
		if sum(l[i]) == 0:
			c1 += 1
	for i in range(b):
		s = 0
		for j in range(a):
			s += l[j][i]
		if s == 0:
			c2 += 1
	res = min(c1, c2)
	if res % 2 == 0:
		output.write('Vivek' + '\n')
	else:
		output.write('Ashish' + '\n')
t = int(input())
for i in range(t):
	l = inlt()
	my_list = []
	for i in range(l[0]):
		my_list.append(inlt())
	solve(l[0], l[1], my_list)


for _ in range(int(input())):
	(r, c) = map(int, input().split())
	pol_r = []
	pol_c = []
	for i in range(r):
		row = input().split()
		if row.count('1'):
			pol_r.append(i)
		for j in range(c):
			if row[j] == '1' and j not in pol_c:
				pol_c.append(j)
	moves = min(r - len(pol_r), c - len(pol_c))
	print('Ashish') if moves & 1 else print('Vivek')


t = int(input())
while t:
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	r = set()
	c = set()
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				r.add(i)
				c.add(j)
	cnt1 = cnt2 = 0
	for i in range(n):
		if i not in r:
			cnt1 += 1
	for i in range(m):
		if i not in c:
			cnt2 += 1
	if min(cnt1, cnt2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for t in range(int(input())):
	(n, m) = map(int, input().split())
	list1 = []
	list2 = []
	for _ in range(n):
		i = input().split()
		list1.append(i)
	for _ in range(m):
		list2.append([l[_] for l in list1])
	s1 = list1.count(['0' for q in range(m)])
	s2 = list2.count(['0' for q in range(n)])
	c = min(s1, s2)
	if c % 2 == 0 or c == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	(n, m) = map(int, input().split())
	mat = [list(map(int, input().split())) for _ in range(n)]
	r = []
	c = []
	winn = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				r.append(i)
				c.append(j)
	for i in range(n):
		for j in range(m):
			if i not in r and j not in c:
				winn += 1
				r.append(i)
				c.append(j)
	if winn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for i in range(int(input())):
	(n, m) = map(int, input().split())
	matx = []
	an12 = 0
	an21 = 0
	for j in range(n):
		z = [int(x) for x in input().split()]
		f = 0
		for o in range(m):
			if z[o] == 1:
				f = 1
				break
		if not f:
			an12 += 1
		matx.append(z)
	for j in range(m):
		f = 0
		for o in range(n):
			if matx[o][j] == 1:
				f = 1
				break
		if not f:
			an21 += 1
	if min(an12, an21) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	fr = 0
	fc = 0
	for i in a:
		if 1 not in i:
			fr += 1
	for j in range(m):
		ok = True
		for i in range(n):
			if a[i][j] == 1:
				ok = False
				break
		if ok:
			fc += 1
	if min(fr, fc) % 2:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(N, M) = list(map(int, input().split()))
	matrix = []
	rowcount = 0
	for i in range(N):
		s = list(map(int, input().split()))
		matrix.append(s)
		if s.count(0) == M:
			rowcount += 1
	colcount = 0
	for i in range(M):
		t = 0
		for j in range(N):
			if matrix[j][i] == 0:
				t += 1
		if t == N:
			colcount += 1
	y = min(colcount, rowcount)
	if y % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t > 0:
	p = list(map(int, input().split()))
	n = p[0]
	m = p[1]
	rows = {}
	cols = {}
	for i in range(1, n + 1):
		rows[i] = 0
	for i in range(1, m + 1):
		cols[i] = 0
	for i in range(1, n + 1):
		l = list(map(int, input().split()))
		for j in range(1, m + 1):
			if l[j - 1] == 1:
				rows[i] = 1
				cols[j] = 1
	for i in rows:
		if rows[i] == 1:
			n -= 1
	for i in cols:
		if cols[i] == 1:
			m -= 1
	x = min(n, m)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
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 fractions import Fraction
mod = int(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(l()[0]):
	(n, m) = l()
	A = [l() for i in range(n)]
	r = [i for i in range(n)]
	c = [i for i in range(m)]
	for i in range(n):
		for j in range(m):
			if A[i][j] == 1:
				if i in r:
					del r[r.index(i)]
				if j in c:
					del c[c.index(j)]
	x = min(len(r), len(c))
	if x % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(0, t):
	nm = input().split()
	n = int(nm[0])
	m = int(nm[1])
	L = []
	for i in range(0, n):
		M = list(map(int, input().split()))
		L.append(M)
	i = 0
	j = 0
	r = set()
	c = set()
	for i in range(0, n):
		for j in range(0, m):
			if L[i][j] == 1:
				r.add(i)
				c.add(j)
	x = n - len(r)
	y = m - len(c)
	if min(x, y) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for i in range(int(input())):
	(n, m) = map(int, input().split())
	list = []
	y = 0
	k = 0
	for j in range(n):
		list.append([int(a) for a in input().split()][:m])
	for item in list:
		if 1 not in item:
			for z in range(m):
				e = 0
				for p in range(n):
					if 1 != list[p][z]:
						e += 1
				if e == n:
					k += 1
					list[y][z] = 1
					break
		y += 1
	if k % 2 == 0 or k == 0:
		print('Vivek')
	else:
		print('Ashish')


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

def case():
	arr = list(map(int, input().split(' ')))
	(n, m) = (arr[0], arr[1])
	matrix = []
	for row in range(n):
		rows = list(map(int, input().split(' ')))
		matrix.append(rows)
	empty_row_count = 0
	for row in range(n):
		count = 1
		for col in range(m):
			if matrix[row][col] == 1:
				count = 0
		empty_row_count += count
	empty_col_count = 0
	for col in range(m):
		count = 1
		for row in range(n):
			if matrix[row][col] == 1:
				count = 0
		empty_col_count += count
	print('Ashish' if min(empty_row_count, empty_col_count) % 2 == 1 else 'Vivek')
for _ in range(t):
	case()


import sys
import math
from collections import defaultdict

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

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

def input():
	return sys.stdin.readline().strip()
for _ in range(int(input())):
	(n, m) = get_ints()
	a = []
	count = 0
	flag = 0
	ans = 'Ashish'
	for i in range(n):
		a.append(get_array())
	for x in range(n):
		for y in range(m):
			if a[x][y] == 0:
				flag = 0
				count = 0
				tag = 0
				for z in range(m):
					if a[x][z] == 1:
						flag = 1
						break
				for z in range(n):
					if a[z][y] == 1:
						count = 1
						break
				if count == 1 or flag == 1:
					tag = 1
					continue
				else:
					a[x][y] = 1
					if ans == 'Ashish':
						ans = 'Vivek'
					else:
						ans = 'Ashish'
	if ans == 'Ashish':
		print('Vivek')
	else:
		print('Ashish')


def main():
	n = int(input())
	for i in range(n):
		lst = list(map(int, input().split()))
		func(lst[0], lst[1])

def func(n, m):
	table = []
	transp = []
	for j in range(m):
		transp.append([])
	for i in range(n):
		lst = list(map(int, input().split()))
		table.append(lst)
		for j in range(m):
			transp[j].append(lst[j])
	flag = 1
	for i in range(n):
		if 1 not in table[i]:
			for j in range(m):
				if 1 not in transp[j]:
					transp[j][i] = 1
					table[i][j] = 1
					flag *= -1
					break
	print('Vivek' if flag == 1 else 'Ashish')
main()


for q in range(int(input())):
	(n, m) = map(int, input().split())
	a = [[int(x) for x in input().split()] for i in range(n)]
	row = 0
	col = 0
	for i in range(n):
		empty = 1
		for j in range(m):
			if a[i][j] == 1:
				empty = 0
				break
		if empty:
			row += 1
	for j in range(m):
		empty = 1
		for i in range(n):
			if a[i][j] == 1:
				empty = 0
				break
		if empty:
			col += 1
	if min(row, col) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	ma = []
	l = [True for i in range(n)]
	c = [True for i in range(m)]
	for i in range(n):
		d = list(map(int, input().split()))
		ma.append(d)
		for j in range(m):
			if d[j]:
				c[j] = False
				l[i] = False
	x = l.count(True)
	y = c.count(True)
	an = min(x, y)
	if an % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def check(matrix, i, j):
	flag1 = True
	for col in range(m):
		if matrix[i][col] == 1:
			flag1 = False
			break
	for row in range(n):
		if matrix[row][j] == 1:
			flag1 = False
			break
	return flag1
t = int(input())
for k in range(t):
	list1 = list(map(int, input().split()))
	n = list1[0]
	m = list1[1]
	matrix = []
	for j in range(n):
		templist = list(map(int, input().split()))
		matrix.append(templist)
	winner = 'Vivek'
	loser = 'Ashish'
	count = 0
	flag = False
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				break
			if matrix[i][j] == 0 and check(matrix, i, j):
				matrix[i][j] = 1
				(winner, loser) = (loser, winner)
				break
	print(winner)


t = int(input())
for i in range(t):
	op = []
	count = []
	ok = 0
	(n, m) = map(int, input().split())
	for x in range(m):
		count.append(0)
	for k in range(n):
		row = [int(i) for i in input().split()]
		if row.count(1) > 0:
			op.append(1)
		else:
			op.append(0)
		for l in range(m):
			if row[l] == 1:
				count.pop(l)
				count.insert(l, 1)
			else:
				pass
	nums = 2 * min(op.count(0), count.count(0))
	nums = nums // 2
	if nums % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	cols = [0 for i in range(m)]
	strs = []
	for _ in range(n):
		lst = [i for i in map(int, input().split())]
		strs.append(sum(lst))
		for i in range(m):
			cols[i] += lst[i]
	if min(cols.count(0), strs.count(0)) % 2:
		print('Ashish')
	else:
		print('Vivek')


T = int(input())
for t in range(T):
	(n, m) = map(int, input().split())
	lst = []
	gone_rows = []
	gone_columns = []
	for i in range(n):
		temp = list(map(int, input().split()))
		if 1 in temp:
			gone_rows.append(i + 1)
			for j in range(m):
				if temp[j] == 1 and j + 1 not in gone_columns:
					gone_columns.append(j + 1)
	if n - len(gone_rows) == 0 or m - len(gone_columns) == 0:
		print('Vivek')
	else:
		count = min(n - len(gone_rows), m - len(gone_columns))
		if count % 2 == 1:
			print('Ashish')
		else:
			print('Vivek')


t = int(input())
while t > 0:
	raw = input().split(' ')
	n = int(raw[0])
	m = int(raw[1])
	row = [0] * m
	col = [0] * n
	for ln in range(n):
		line = input().split(' ')
		for idx in range(len(line)):
			if col[ln] != 1:
				col[ln] = int(line[idx])
			if row[idx] != 1:
				row[idx] = int(line[idx])
	for idx in row:
		if idx == 1:
			m -= 1
	for idx in col:
		if idx == 1:
			n -= 1
	if min(n, m) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for t in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	rows = 0
	cols = 0
	for ii in range(n):
		l = list(map(int, input().split()))
		new_add = True
		for ll in l:
			if ll == 1:
				new_add = False
		rows += new_add
		mat += [l]
	for ii in range(m):
		new_add = True
		for iii in range(n):
			if mat[iii][ii] == 1:
				new_add = False
		cols += new_add
	if min(rows, cols) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve():
	(a, b) = map(int, input().split())
	x = [[0] * b for i in range(a)]
	l = []
	k = []
	for i in range(a):
		s = list(map(int, input().split()))
		for j in range(b):
			if s[j] == 1:
				l.append(i)
				k.append(j)
			x[i][j] = s[j]
	(p, q) = (set(l), set(k))
	z = [i for i in range(a)]
	v = [i for i in range(b)]
	(z, v) = (set(z), set(v))
	z = z - p
	v = v - q
	h = min(len(z), len(v))
	if h & 1:
		print('Ashish')
	else:
		print('Vivek')
for _ in range(int(input())):
	solve()


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	M = [list(map(int, input().split())) for _ in range(n)]
	rows = [0] * n
	cols = [0] * m
	for i in range(n):
		for j in range(m):
			if M[i][j] == 1:
				rows[i] = 1
				cols[j] = 1
	l = 0
	r = 0
	for i in range(n):
		if rows[i] == 0:
			l += 1
	for i in range(m):
		if cols[i] == 0:
			r += 1
	if min(l, r) % 2:
		print('Ashish')
	else:
		print('Vivek')


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
import bisect
from heapq import *
from math import *
from collections import deque
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
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))
mod = 1000000007

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

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

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

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

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

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

def 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 power(a, b):
	ans = 1
	while b > 0:
		if b % 2 == 1:
			ans *= a
		a *= a
		b //= 2
	return ans

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

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def solve():
	(n, m) = map(int, input().split())
	grid = []
	for i in range(n):
		temp = lis()
		grid.append(temp)
	C = [0] * n
	R = [0] * m
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 1:
				C[i] = 1
				R[j] = 1
	k = 0
	for i in range(n):
		if C[i] == 0:
			k += 1
	l = 0
	for i in range(m):
		if R[i] == 0:
			l += 1
	if min(k, l) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
testcase(int(inp()))


def marchu(m, a, b):
	row = [0 for i in range(a)]
	col = [0 for i in range(b)]
	for i in range(a):
		for j in range(b):
			if m[i][j] == 1:
				row[i] = 1
				col[j] = 1
	for i in range(a):
		for j in range(b):
			if row[i] == 1 or col[j] == 1:
				m[i][j] = 1
	return m
t = int(input())
for _ in range(t):
	(a, b) = map(int, input().split())
	mat = []
	row = [0 for i in range(a)]
	col = [0 for i in range(b)]
	for i in range(a):
		x = [int(i) for i in input().split()][:b]
		mat.append(x)
	mat = marchu(mat, a, b)
	s = 0
	r = set()
	c = set()
	r.add(-1)
	c.add(-1)
	for i in range(a):
		for j in range(b):
			if mat[i][j] == 0 and (i not in r and j not in c):
				r.add(i)
				c.add(j)
				s = s + 1
	if s % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
from bisect import *
from math import floor, sqrt, ceil, factorial as F, gcd, pi, log
from itertools import chain, combinations, permutations, accumulate
from collections import Counter, defaultdict, OrderedDict, deque
from array import array
INT_MAX = sys.maxsize
INT_MIN = -sys.maxsize - 1
mod = 1000000007
ch = 'abcdefghijklmnopqrstuvwxyz'
lcm = lambda a, b: a * b // gcd(a, b)
setbit = lambda x: bin(x)[2:].count('1')

def solve():
	T = int(sys.stdin.readline())
	for i in range(T):
		(n, m) = map(int, sys.stdin.readline().split())
		mat = []
		for i in range(n):
			a = list(map(int, sys.stdin.readline().split()))
			mat.append(a)
		c = 0
		for i in range(n):
			for j in range(m):
				ok = False
				for k in range(m):
					if mat[i][k] == 1:
						ok = True
				for k in range(n):
					if mat[k][j] == 1:
						ok = True
				if not ok:
					mat[i][j] = 1
					c += 1
		if c & 1:
			print('Ashish')
		else:
			print('Vivek')
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass
solve()


def main():
	(n, m) = list(map(int, input().split()))
	mass = []
	checker = [0] * m
	for item in range(n):
		buff = list(map(int, input().split()))
		for i in range(len(buff)):
			if buff[i] == 1:
				checker[i] = 1
		if 1 in buff:
			pass
		else:
			mass.append(buff)
	if min(m - sum(checker), len(mass)) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
for item in range(int(input())):
	main()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	colb = [False] * m
	rowb = [False] * n
	row = 0
	col = 0
	for i in range(n):
		l.append(tuple(map(int, input().split())))
		for j in range(m):
			if l[i][j] == 1:
				colb[j] = 1
				rowb[i] = 1
	for i in range(n):
		if rowb[i] == 0:
			row += 1
	for i in range(m):
		if colb[i] == 0:
			col += 1
	row = min(row, col)
	if row & 1:
		print('Ashish')
	else:
		print('Vivek')


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 build_grid(H, W, intv, _type, space=True, padding=False):
	if space:
		_input = lambda : input().split()
	else:
		_input = lambda : input()
	_list = lambda : list(map(_type, _input()))
	if padding:
		offset = 1
	else:
		offset = 0
	grid = list2d(H + offset * 2, W + offset * 2, intv)
	for i in range(offset, H + offset):
		row = _list()
		for j in range(offset, W + offset):
			grid[i][j] = row[j - offset]
	return grid
for _ in range(INT()):
	(H, W) = MAP()
	grid = build_grid(H, W, 0, int)
	row0 = 0
	for i in range(H):
		if not grid[i].count(1):
			row0 += 1
	grid = list(zip(*grid))
	col0 = 0
	for i in range(W):
		if not grid[i].count(1):
			col0 += 1
	if min(row0, col0) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
t = int(input())
for t1 in range(t):
	(n, m) = list(map(int, input().split(' ')))
	mat = []
	for i in range(n):
		l = list(map(int, input().split(' ')))
		mat.append(l)
	row = 0
	for i in range(n):
		c = 0
		for j in range(m):
			if mat[i][j] == 1:
				c = 1
		if c == 0:
			row += 1
	col = 0
	for i in range(m):
		c = 0
		for j in range(n):
			if mat[j][i] == 1:
				c = 1
		if c == 0:
			col += 1
	if row == 0 or col == 0:
		print('Vivek')
	else:
		z = min(row, col)
		if z % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')


def main():
	for t in range(int(input())):
		(n, m) = map(int, input().split())
		a = []
		for i in range(n):
			a.append(list(map(int, input().split())))
		rows_left = [1] * n
		columns_left = [1] * m
		for i in range(n):
			for j in range(m):
				if a[i][j] == 1:
					rows_left[i] = 0
					columns_left[j] = 0
		moves_left = min(sum(rows_left), sum(columns_left))
		print('Ashish' if moves_left % 2 == 1 else 'Vivek')
main()


import sys

def solve(m):
	return None

def main():
	q = []
	for line in sys.stdin.readlines():
		q.append(line)
	for i in range(len(q)):
		q[i] = q[i].rstrip().split(' ')
	i = 1
	while i < len(q):
		rows = int(q[i][0])
		cols = int(q[i][1])
		m = []
		m_cols = []
		for j in range(1, rows + 1):
			m.append(q[i + j])
		for k in range(cols):
			temp = [m[j][k] for j in range(len(m))]
			m_cols.append(temp)
		count = 0
		count2 = 0
		for k in m:
			if '1' in k:
				continue
			else:
				count += 1
		for k in m_cols:
			if '1' in k:
				continue
			else:
				count2 += 1
		count = min(count2, count)
		if count % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
		i += rows + 1
main()


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import ceil, floor
from copy import *
from collections import deque, defaultdict
from collections import Counter as counter
from itertools import combinations
from itertools import permutations as permutate
from bisect import bisect_left as bl
from operator import *
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192
from sys import stderr

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

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

def iterative(f, stack=[]):

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

class SortedList:

	def __init__(self, iterable=[], _load=200):
		values = sorted(iterable)
		self._len = _len = len(values)
		self._load = _load
		self._lists = _lists = [values[i:i + _load] for i in range(0, _len, _load)]
		self._list_lens = [len(_list) for _list in _lists]
		self._mins = [_list[0] for _list in _lists]
		self._fen_tree = []
		self._rebuild = True

	def _fen_build(self):
		self._fen_tree[:] = self._list_lens
		_fen_tree = self._fen_tree
		for i in range(len(_fen_tree)):
			if i | i + 1 < len(_fen_tree):
				_fen_tree[i | i + 1] += _fen_tree[i]
		self._rebuild = False

	def _fen_update(self, index, value):
		if not self._rebuild:
			_fen_tree = self._fen_tree
			while index < len(_fen_tree):
				_fen_tree[index] += value
				index |= index + 1

	def _fen_query(self, end):
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		x = 0
		while end:
			x += _fen_tree[end - 1]
			end &= end - 1
		return x

	def _fen_findkth(self, k):
		_list_lens = self._list_lens
		if k < _list_lens[0]:
			return (0, k)
		if k >= self._len - _list_lens[-1]:
			return (len(_list_lens) - 1, k + _list_lens[-1] - self._len)
		if self._rebuild:
			self._fen_build()
		_fen_tree = self._fen_tree
		idx = -1
		for d in reversed(range(len(_fen_tree).bit_length())):
			right_idx = idx + (1 << d)
			if right_idx < len(_fen_tree) and k >= _fen_tree[right_idx]:
				idx = right_idx
				k -= _fen_tree[idx]
		return (idx + 1, k)

	def _delete(self, pos, idx):
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len -= 1
		self._fen_update(pos, -1)
		del _lists[pos][idx]
		_list_lens[pos] -= 1
		if _list_lens[pos]:
			_mins[pos] = _lists[pos][0]
		else:
			del _lists[pos]
			del _list_lens[pos]
			del _mins[pos]
			self._rebuild = True

	def _loc_left(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(lo, pos) = (-1, len(_lists) - 1)
		while lo + 1 < pos:
			mi = lo + pos >> 1
			if value <= _mins[mi]:
				pos = mi
			else:
				lo = mi
		if pos and value <= _lists[pos - 1][-1]:
			pos -= 1
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value <= _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def _loc_right(self, value):
		if not self._len:
			return (0, 0)
		_lists = self._lists
		_mins = self._mins
		(pos, hi) = (0, len(_lists))
		while pos + 1 < hi:
			mi = pos + hi >> 1
			if value < _mins[mi]:
				hi = mi
			else:
				pos = mi
		_list = _lists[pos]
		(lo, idx) = (-1, len(_list))
		while lo + 1 < idx:
			mi = lo + idx >> 1
			if value < _list[mi]:
				idx = mi
			else:
				lo = mi
		return (pos, idx)

	def add(self, value):
		_load = self._load
		_lists = self._lists
		_mins = self._mins
		_list_lens = self._list_lens
		self._len += 1
		if _lists:
			(pos, idx) = self._loc_right(value)
			self._fen_update(pos, 1)
			_list = _lists[pos]
			_list.insert(idx, value)
			_list_lens[pos] += 1
			_mins[pos] = _list[0]
			if _load + _load < len(_list):
				_lists.insert(pos + 1, _list[_load:])
				_list_lens.insert(pos + 1, len(_list) - _load)
				_mins.insert(pos + 1, _list[_load])
				_list_lens[pos] = _load
				del _list[_load:]
				self._rebuild = True
		else:
			_lists.append([value])
			_mins.append(value)
			_list_lens.append(1)
			self._rebuild = True

	def discard(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_right(value)
			if idx and _lists[pos][idx - 1] == value:
				self._delete(pos, idx - 1)

	def remove(self, value):
		_len = self._len
		self.discard(value)
		if _len == self._len:
			raise ValueError('{0!r} not in list'.format(value))

	def pop(self, index=-1):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		value = self._lists[pos][idx]
		self._delete(pos, idx)
		return value

	def bisect_left(self, value):
		(pos, idx) = self._loc_left(value)
		return self._fen_query(pos) + idx

	def bisect_right(self, value):
		(pos, idx) = self._loc_right(value)
		return self._fen_query(pos) + idx

	def count(self, value):
		return self.bisect_right(value) - self.bisect_left(value)

	def __len__(self):
		return self._len

	def __getitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		return self._lists[pos][idx]

	def __delitem__(self, index):
		(pos, idx) = self._fen_findkth(self._len + index if index < 0 else index)
		self._delete(pos, idx)

	def __contains__(self, value):
		_lists = self._lists
		if _lists:
			(pos, idx) = self._loc_left(value)
			return idx < len(_lists[pos]) and _lists[pos][idx] == value
		return False

	def __iter__(self):
		return (value for _list in self._lists for value in _list)

	def __reversed__(self):
		return (value for _list in reversed(self._lists) for value in reversed(_list))

	def __repr__(self):
		return 'SortedList({0})'.format(list(self))
mod = 1000000007

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

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

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

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

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

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

def fsep():
	return map(float, inp().split())

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

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

def pow(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
from functools import reduce

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

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

def prefix_sum(ar):
	return list(accumulate(ar))

def suffix_sum(ar):
	return list(accumulate(ar[::-1]))[::-1]

def N():
	return int(inp())
dx = [0, 0, 1, -1]
dy = [1, -1, 0, 0]

def YES():
	print('YES')

def NO():
	print('NO')

def Yes():
	print('Yes')

def No():
	print('No')
from collections import defaultdict

def numberOfSetBits(i):
	i = i - (i >> 1 & 1431655765)
	i = (i & 858993459) + (i >> 2 & 858993459)
	return ((i + (i >> 4) & 252645135) * 16843009 & 4294967295) >> 24

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

def nc2(n):
	return n * (n - 1) // 2

def nc3(n):
	return n * (n - 1) * (n - 2) // 6

def solve():
	(n, m) = sep()
	cr = 0
	cc = 0
	ar = [lis() for _ in range(n)]
	for i in range(n):
		if ar[i].count(1) == 0:
			cr += 1
	for j in range(m):
		cc += 1
		for i in range(n):
			if ar[i][j] == 1:
				cc -= 1
				break
	t = min(cc, cr)
	if t % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
testcase(int(inp()))


def matgame(n, m, mat):
	v = 'Vivek'
	a = 'Ashish'
	row = []
	column = []
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				row.append(i)
				column.append(j)
	count = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 0:
				if i not in row and j not in column:
					count += 1
					row.append(i)
					column.append(j)
	if count % 2 == 0:
		return v
	else:
		return a
test = int(input())
for i in range(test):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		a = list(map(int, input().split()))
		mat.append(a)
	print(matgame(n, m, mat))


from sys import stdin

def inp():
	return stdin.readline().strip()
t = int(inp())
for _ in range(t):
	(n, m) = [int(x) for x in inp().split()]
	ar = []
	flag = False
	answer = n
	for i in range(n):
		ar.append(inp())
		ar[i] = ar[i].split()
	for i in range(n):
		for j in range(m):
			if ar[i][j] == '1':
				answer -= 1
				break
		else:
			for j in range(m):
				if ar[i][j] == '1':
					answer -= 1
					break
				if ar[i][j] == '0':
					for k in range(n):
						if ar[k][j] == '1':
							flag = True
							break
					else:
						ar[i][j] = '1'
						break
					if flag and j == m - 1:
						answer -= 1
						flag = False
						break
	if answer % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


a = input()
for x in range(int(a)):
	b = input().split(' ')
	list1 = []
	list2 = []
	for i in range(int(b[0])):
		c = input().split(' ')
		for j in range(len(c)):
			if c[j] == '1':
				list1.append(i)
				list2.append(j)
	list1 = list(set(list1))
	list2 = list(set(list2))
	ans = 0
	tag = 1
	while len(list1) != int(b[0]) and len(list2) != int(b[1]) and (tag == 1):
		tag = 0
		for i in range(int(b[0])):
			if i not in list1:
				for j in range(int(b[1])):
					if j not in list2:
						list1.append(i)
						list2.append(j)
						tag = 1
						ans += 1
						break
			if tag == 1:
				break
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


maxn = int(1000.0 + 7)
a = []

def get_h(n, m):
	ans = 0
	for i in range(n):
		j = 0
		while j < m:
			if a[i][j]:
				break
			j += 1
		if j >= m:
			ans += 1
	return ans

def get_l(n, m):
	ans = 0
	for j in range(m):
		i = 0
		while i < n:
			if a[i][j]:
				break
			i += 1
		if i >= n:
			ans += 1
	return ans
for cas in range(int(input())):
	(n, m) = map(int, input().split())
	a.clear()
	for i in range(n):
		b = list(map(int, input().split()))
		a.append(b)
	ans = get_l(n, m)
	ans = min(ans, get_h(n, m))
	if ans & 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(0, int(input())):
	(n, m) = map(int, input().strip().split())
	mat = []
	r = []
	c = []
	for i in range(0, n):
		t = list(map(int, input().strip().split()))
		for k in range(0, m):
			if t[k] == 1:
				r.append(i)
				c.append(k)
	l = min(n - len(set(r)), m - len(set(c)))
	if l % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	M = []
	for i in range(n):
		M.append(list(map(int, input().split())))
	ans = 0
	true_row = set(list(range(n)))
	true_col = set(list(range(m)))
	row = set()
	col = set()
	count = 0
	for i in M:
		count += 1
		for j in range(m):
			if i[j] == 1:
				col.add(j)
				row.add(count - 1)
	fin_row = list(true_row.difference(row))
	fin_col = list(true_col.difference(col))
	if fin_col == [] or fin_row == []:
		print('Vivek')
	else:
		while fin_row != [] and fin_col != []:
			ans += 1
			fin_row.pop(-1)
			fin_col.pop(-1)
		if ans % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	c = set()
	r = set()
	l = [list(map(int, input().split())) for i in range(n)]
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				c.add(i)
				r.add(j)
	x = n - len(c)
	y = m - len(r)
	print('Ashish' if min(x, y) % 2 else 'Vivek')


for i in range(int(input())):
	(n, m) = map(int, input().split())
	pole = [0 for j in range(m)]
	ans = n
	for j in range(n):
		b = [int(k) for k in input().split()]
		ans -= 1 if b.count(1) else 0
		pole = [pole[j] or b[j] for j in range(m)]
	ans = min(ans, pole.count(0))
	print('Ashish' if ans % 2 else 'Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	g = []
	for _ in range(n):
		g.append(list(map(int, input().split())))
	(ns, ms) = (set(), set())
	for i in range(n):
		for j in range(m):
			if g[i][j] == 1:
				ns.add(i)
				ms.add(j)
	x = min(n - len(ns), m - len(ms))
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for _ in range(n):
		a.append(list(map(int, input().split())))
	rcnt = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				rcnt += 1
				break
	ccnt = 0
	for j in range(m):
		for i in range(n):
			if a[i][j] == 1:
				ccnt += 1
				break
	ans = ['Vivek', 'Ashish']
	print(ans[min(n - rcnt, m - ccnt) % 2])


t = int(input())
for _ in range(t):
	(n, m) = [int(i) for i in input().split()]
	(v, h) = (0, 0)
	grid = []
	for _ in range(n):
		line = [int(i) for i in input().split()]
		if 1 not in line:
			h += 1
		grid.append(line)
	for i in range(m):
		if 1 not in [j[i] for j in grid]:
			v += 1
	M = min(h, v)
	if M & 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	row = n
	column = m
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	for i in range(n):
		if 1 in a[i]:
			row -= 1
	for j in range(m):
		test = [a[i][j] for i in range(n)]
		if 1 in test:
			column -= 1
	if min(row, column) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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):
	(n, m) = inar()
	arr = []
	for i in range(n):
		arr.append(inar())
	a = [[0 for i in range(m)] for i in range(n)]
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				for k in range(n):
					a[k][j] = 1
				for k in range(m):
					a[i][k] = 1
	cnt = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0:
				cnt += 1
				for k in range(n):
					a[k][j] = 1
				for k in range(m):
					a[i][k] = 1
	if cnt % 2:
		print('Ashish')
	else:
		print('Vivek')


for t in range(int(input())):
	(n, m) = list(map(int, input().split()))
	cols = 0
	rows = 0
	a = [list(map(int, input().split())) for i in range(n)]
	for i in range(n):
		if sum(a[i]) == 0:
			rows += 1
	for j in range(m):
		free = 1
		for i in range(n):
			if a[i][j]:
				free = 0
		cols += free
	if min(cols, rows) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
T = int(stdin.readline().strip())
for caso in range(T):
	(n, m) = list(map(int, stdin.readline().strip().split()))
	s = [list(map(int, stdin.readline().strip().split())) for i in range(n)]
	r = n
	for i in range(n):
		if 1 in s[i]:
			r -= 1
	c = m
	for i in range(m):
		for j in range(n):
			if s[j][i] == 1:
				c -= 1
				break
	x = min(c, r)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for i in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	row = 0
	col = 0
	for i in range(n):
		f = 0
		c = list(map(int, input().split()))
		for j in c:
			if j == 1:
				f = 1
				break
		if f == 0:
			row += 1
		matrix.append(c)
	for i in range(m):
		f = 0
		for j in range(n):
			if matrix[j][i] == 1:
				f = 1
				break
		if f == 0:
			col += 1
	if min(row, col) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = [int(_) for _ in input().split()]
	N = [1] * n
	M = [1] * m
	for j in range(n):
		list = [int(_) for _ in input().split()]
		for k in range(m):
			if list[k] == 1:
				N[j] = 0
				M[k] = 0
	squares = min(sum(N), sum(M))
	if squares % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = [int(x) for x in input().split()]
	grid = [[int(x) for x in input().split()] for _ in range(n)]
	row1 = sum((1 for x in grid if all((y == 0 for y in x))))
	col1 = sum((1 for j in range(m) if all((grid[i][j] == 0 for i in range(n)))))
	res = min(row1, col1)
	if res % 2:
		print('Ashish')
	else:
		print('Vivek')


for z in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	b = []
	c = 0
	d = 0
	for w in range(n):
		a.append(list(map(int, input().split())))
	for i in range(n):
		if a[i].count(1):
			c += 1
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				if j not in b:
					d += 1
				b.append(j)
	if n - c == 0 or m - d == 0:
		print('Vivek')
	else:
		c = n - c
		d = m - d
		e = 0
		if c >= d:
			f = d
			for i in range(d):
				if i % 2 == 0:
					e = 0
				else:
					e = 1
				c -= 1
				f -= 1
				if f == 0 or c == 0:
					break
		else:
			f = c
			for i in range(c):
				if i % 2 == 0:
					e = 0
				else:
					e = 1
				d -= 1
				f -= 1
				if f == 0 or d == 0:
					break
		if e == 0:
			print('Ashish')
		else:
			print('Vivek')


t = int(input())
while t:
	(n, m) = map(int, input().split())
	s = []
	for i in range(n):
		s.append(list(map(int, input().split())))
	r = []
	c = []
	for i in range(n):
		for j in range(m):
			if s[i][j] == 1:
				r.append(i)
				c.append(j)
	n = n - len(set(r))
	m = m - len(set(c))
	l = min(n, m)
	if l % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
	t -= 1


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	r = 0
	c = [0] * m
	for i in range(n):
		k = list(map(int, input().split()[:m]))
		if set(k) == {0}:
			r += 1
		ind = 0
		while ind < len(k):
			if k[ind] == 1:
				c[ind] = 1
			ind += 1
	num = min(r, c.count(0))
	if num % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	count = 0
	l = list()
	k = [0] * n
	p = [0] * m
	for i in range(n):
		l.append(list(map(int, input().split())))
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				k[i] += 1
				p[j] += 1
	for i in range(n):
		for j in range(m):
			if k[i] == 0 and p[j] == 0:
				count += 1
				k[i] += 1
				p[j] += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	r = 0
	c = 0
	for i in range(n):
		if a[i].count(1) == 0:
			r += 1
	for j in range(m):
		b = []
		for i in range(n):
			b.append(a[i][j])
		if b.count(1) == 0:
			c += 1
	ans = min(r, c)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split(' '))
	row = [0] * n
	col = [0] * m
	box = []
	x = 0
	for a in range(n):
		temp = list(map(int, input().split(' ')))
		if 1 in temp:
			row[a] = 1
			for b in range(len(temp)):
				if temp[b] == 1:
					col[b] = 1
		box.append(temp)
	temp2 = 0
	while temp2 != 1:
		temp2 = 1
		for i in range(n):
			for j in range(m):
				if box[i][j] == 0 and col[j] == 0 and (row[i] == 0):
					temp2 = 0
					x += 1
					box[i][j] = 1
					row[i] = 1
					col[j] = 1
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math as mt
t = int(input())
for g in range(t):
	(n, m) = map(int, input().split())
	a = 0
	b = 0
	B = []
	for i in range(n):
		A = list(map(int, input().split()))
		B.append(A)
	ans = 0
	for i in range(n):
		for j in range(m):
			if B[i][j] == 0:
				c = 0
				for l in range(0, n):
					if B[l][j] == 1:
						c = 1
						break
				if 1 in B[i]:
					c = 1
				if c == 0:
					B[i][j] = 1
					ans += 1
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	(n, m) = map(int, input().split(' '))
	a = []
	t = 1
	s = 1
	for i in range(n):
		a.append(input().split(' '))
	for i in range(n):
		s = 1
		for j in range(m):
			if a[i][j] == '1':
				s = -1
				break
		if s == 1:
			for k in range(m):
				s2 = 1
				for w in range(n):
					if a[w][k] == '1':
						s2 = -1
				if s2 == 1:
					a[i][k] = '1'
					t = -t
					break
	if t == 1:
		print('Vivek')
	else:
		print('Ashish')


import math
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		x = list(map(int, input().split()))
		l.append(x)
	res = 0
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				res += 1
				break
	ans = 0
	for i in range(m):
		for j in range(n):
			if l[j][i] == 1:
				ans += 1
				break
	ans = m - ans
	res = n - res
	r = min(ans, res)
	if r % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	t = t - 1
	(n, m) = map(int, input().split())
	a = list()
	for i in range(n):
		x = list(map(int, input().split()))
		a.append(x)
	row = [0 for i in range(n)]
	col = [0 for i in range(m)]
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row[i] = 1
				col[j] = 1
	r = min(row.count(0), col.count(0))
	if r % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def whoWin(arr, n, m):
	num_moves_left = 0
	for i in range(n):
		if sum(arr[i]) == 0:
			for j in range(m):
				if sum([arr[k][j] for k in range(n)]) == 0:
					arr[i][j] = 1
					num_moves_left += 1
					break
	if num_moves_left % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
t = int(input().strip())
for _ in range(t):
	(n, m) = list(map(int, input().strip().split()))
	arr = []
	for _ in range(n):
		arr.append(list(map(int, input().strip().split())))
	print(whoWin(arr, n, m))


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append([int(s) for s in input().split()])
	r = [1] * n
	c = [1] * m
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r[i] = 0
				c[j] = 0
	if min(sum(r), sum(c)) & 1:
		print('Ashish')
	else:
		print('Vivek')


from fractions import Fraction
from collections import defaultdict
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))

def input():
	return sys.stdin.readline().rstrip('\r\n')
t = int(input())
for _ in range(t):
	(n, m) = [int(x) for x in input().split()]
	l = []
	for i in range(n):
		tmp = list([int(x) for x in input().split()])
		l.append(tmp)
	c1 = 0
	for i in range(n):
		for j in range(m):
			f = 0
			if l[i][j] == 0:
				f = 0
				if 1 in l[i]:
					f = 1
				for k in range(n):
					if l[k][j] == 1:
						f = 1
				if f == 0:
					l[i][j] = 1
					c1 += 1
	if c1 % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	grid = []
	for _ in range(n):
		grid.append(input().split())
	zero_rows = 0
	zero_cols = 0
	for i in range(n):
		if grid[i] == ['0'] * m:
			zero_rows += 1
	for i in range(m):
		if [grid[j][i] for j in range(n)] == ['0'] * n:
			zero_cols += 1
	steps = min(zero_rows, zero_cols)
	if steps % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


x = int(input())
for _ in range(x):
	(n, m) = map(int, input().split())
	(rows, cols) = (set(), set())
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(m):
			if a[j] == 1:
				rows.add(i)
				cols.add(j)
	x = min(n - len(rows), m - len(cols))
	print('Ashish' if x % 2 == 1 else 'Vivek')


def is_valid(m, n, pos, board):
	(x, y) = pos
	for i in range(n):
		if board[x, i] == 1:
			return False
	for i in range(m):
		if board[i, y] == 1:
			return False
	return True

def game(m, n, board, availables):
	players = ['Vivek', 'Ashish']
	seen = set()
	while True:
		for p in players:
			played = False
			for v in availables:
				(i, j) = v
				if not played and v not in seen:
					if is_valid(m, n, (i, j), board):
						board[i, j] = 1
						seen.add((i, j))
						played = True
			if not played:
				return p

def receive_inputs():
	t = int(input())
	for i in range(t):
		(m, n) = [int(x) for x in input().split()]
		board = dict()
		availables = set()
		for i in range(m):
			line = [int(x) for x in input().split()]
			for j in range(n):
				board[i, j] = line[j]
				if line[j] == 0:
					availables.add((i, j))
		print(game(m, n, board, availables))
receive_inputs()


def soln(R, C, matrix):
	numUnset = 0
	unsetRows = 0
	for r in range(R):
		if all((matrix[r][c] == 0 for c in range(C))):
			unsetRows += 1
	unsetCols = 0
	for c in range(C):
		if all((matrix[r][c] == 0 for r in range(R))):
			unsetCols += 1
	numUnset = min(unsetCols, unsetRows)
	if numUnset % 2 == 0:
		return 'Vivek'
	return 'Ashish'

def brute(R, C, matrix):
	memo = {}

	def dp(rows, cols):
		hashVal = f'{rows}, {cols}'
		if hashVal in memo:
			return memo[hashVal]
		result = True
		if len(rows) == 0 or len(cols) == 0:
			result = False
		else:
			for (r, row) in enumerate(rows):
				for (c, col) in enumerate(cols):
					if dp(rows[:r] + rows[r + 1:], cols[:c] + cols[c + 1:]):
						result = False
						break
				if not result:
					break
		memo[hashVal] = result
		return result
	rows = []
	for r in range(R):
		if not any((matrix[r][c] == 1 for c in range(C))):
			rows.append(r)
	cols = []
	for c in range(C):
		if not any((matrix[r][c] == 1 for r in range(R))):
			cols.append(c)
	ashish = dp(rows, cols)
	if ashish:
		return 'Ashish'
	return 'Vivek'

def test():
	(R, C) = (6, 5)
	matrix = [[0, 0, 0, 1, 0], [0, 0, 1, 0, 0], [0, 0, 1, 0, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
	b = brute(R, C, matrix)
	f = soln(R, C, matrix)
	print(b, f)

def main():
	t = int(input())
	for _ in range(t):
		(R, C) = [int(x) for x in input().split()]
		matrix = []
		for _ in range(R):
			row = [int(x) for x in input().split()]
			matrix.append(row)
		result = soln(R, C, matrix)
		print(result)
main()


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

def solve(t):
	(n, m) = map(int, input().split())
	data = []
	for i in range(n):
		data.append(input().split())
	rows = [1] * n
	cols = [1] * m
	for i in range(n):
		for j in range(m):
			if data[i][j] == '1':
				rows[i] = 0
				cols[j] = 0
	no_of_cells = 0
	for i in range(n):
		for j in range(m):
			if rows[i] and cols[j]:
				no_of_cells += 1
				rows[i] = cols[j] = 0
	if no_of_cells % 2 == 1:
		return 'Ashish'
	else:
		return 'Vivek'

def main():
	tc = int(input().strip())
	for t in range(1, tc + 1):
		print(solve(t))
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

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


n = int(input())
for k in range(n):
	(row, col) = input().split()
	row = int(row)
	col = int(col)
	count1 = 0
	count2 = 0
	t = []
	for i in range(row):
		cnt1 = 0
		t.append(list(map(int, input().split())))
		for j in range(col):
			if t[i][j] == 0:
				cnt1 += 1
		if cnt1 == col:
			count1 += 1
	for i in range(0, col):
		cnt2 = 0
		for j in range(0, row):
			if t[j][i] == 0:
				cnt2 += 1
		if cnt2 == row:
			count2 += 1
	if count1 < count2:
		k = count1
	else:
		k = count2
	if k % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
from collections import *
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = [list(map(int, input().split())) for _ in range(n)]
	f1 = [True] * n
	f2 = [True] * m
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				f1[i] = False
	for i in range(m):
		for j in range(n):
			if a[j][i] == 1:
				f2[i] = False
	c = min(f1.count(True), f2.count(True))
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


n = int(input())
result = []
p = 0
while p < n:
	a = list(map(int, input().split()))
	x = a[0]
	y = a[1]
	row = [0] * x
	col = [0] * y
	p = p + 1
	for j in range(0, x):
		b = list(map(int, input().split()))
		k = 0
		while k < y:
			if b[k] == 1:
				col[k] = 1
				row[j] = 1
			k = k + 1
	i = 0
	rowcount = 0
	colcount = 0
	while i < x:
		if row[i] == 0:
			rowcount = rowcount + 1
		i = i + 1
	j = 0
	while j < y:
		if col[j] == 0:
			colcount = colcount + 1
		j = j + 1
	z = min(rowcount, colcount)
	if z % 2 == 0:
		result.append('Vivek')
	else:
		result.append('Ashish')
for i in range(0, n):
	print(result[i])


T = int(input())
for t in range(T):
	(n, m) = list(map(int, input().split()))
	a = [list(map(int, input().split())) for i in range(n)]
	rows = set()
	cols = set()
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				rows.add(i)
				cols.add(j)
	m = min(n - len(rows), m - len(cols))
	if m % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
input = stdin.readline

def poss_coord(mtr):
	idx = None
	for (i, row) in enumerate(mtr):
		if not sum(row):
			idx = i
			break
	if idx is None:
		return None
	jdx = None
	for j in range(len(mtr[0])):
		cnt = 0
		for i in range(len(mtr)):
			cnt += mtr[i][j]
		if not cnt:
			jdx = j
			break
	if jdx is not None:
		return (idx, jdx)
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mtrx = []
	for _ in range(n):
		mtrx.append(list(map(int, input().split())))
	mv = 0
	while poss_coord(mtrx):
		mv += 1
		(i, j) = poss_coord(mtrx)
		mtrx[i][j] = 1
	print('Ashish' if mv % 2 else 'Vivek')


def numFree(n, m, a):
	numsteps = 0
	for i in range(n):
		for j in range(m):
			if sum(a[i]) == 0 and sum(list(zip(*a))[j]) == 0:
				a[i][j] = 1
				numsteps += 1
	if numsteps % 2 == 0:
		Winner = 'Vivek'
	else:
		Winner = 'Ashish'
	return Winner
t = int(input())
for i in range(t):
	a = []
	(n, m) = map(int, input().split())
	for k in range(n):
		a.append(list(map(int, input().split())))
	print(numFree(n, m, a))


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	x = []
	for _ in range(n):
		x.append(list(map(int, input().split())))
	(nn, mm) = (0, 0)
	for i in range(n):
		if 1 not in x[i]:
			nn += 1
	for i in range(m):
		if 1 not in [l[i] for l in x]:
			mm += 1
	print('Vivek' if min(nn, mm) % 2 == 0 else 'Ashish')


from typing import List
PLAYERS = ['Vivek', 'Ashish']

def make_move(curr_matrix: List[List[int]], curr_winner: str, size: (int, int), start: (int, int)):
	if start[0] >= size[0] or start[1] >= size[1]:
		print(curr_winner)
		return (True, curr_matrix)
	move_down = 0
	move_right = 0
	for c in range(size[1]):
		if curr_matrix[start[0]][c] & 1 == 1:
			move_down = 1
	for r in range(size[0]):
		if curr_matrix[r][start[1]] & 1 == 1:
			move_right = 1
	if move_down or move_right:
		return make_move(curr_matrix, curr_winner, size, (start[0] + move_down, start[1] + move_right))
	curr_matrix[start[0]][start[1]] |= 1
	if curr_winner == PLAYERS[0]:
		curr_winner = PLAYERS[1]
	else:
		curr_winner = PLAYERS[0]
	return make_move(curr_matrix, curr_winner, size, (start[0] + move_down, start[1] + move_right))

def decide_winner(matrix: List[List[int]], r: int, c: int):
	ended = False
	make_move(matrix, PLAYERS[0], (r, c), (0, 0))
	return

def main():
	tc = int(input())
	for t_case in range(tc):
		(r, c) = [int(x) for x in input().split(' ')]
		start_matrix = []
		for row in range(r):
			start_matrix.append([int(x) for x in input().split(' ')])
		decide_winner(start_matrix, r, c)
	return
main()


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	table = []
	rows = set(range(n))
	cols = set(range(m))
	for i in range(n):
		row = map(int, input().split())
		for (j, v) in enumerate(row):
			if v == 1:
				if i in rows:
					rows.remove(i)
				if j in cols:
					cols.remove(j)
	print('Ashish' if min(len(rows), len(cols)) % 2 == 1 else 'Vivek')


def solve(n, m, grid):
	track_row = set()
	track_col = set()
	for i in range(n):
		for j in range(m):
			if grid[i][j] == '1':
				track_row.add(i)
				track_col.add(j)
	min_moves_possible = min(n - len(track_row), m - len(track_col))
	return 'Ashish' if min_moves_possible % 2 == 1 else 'Vivek'
t = int(input())
results = list()
for _ in range(t):
	(n, m) = map(int, input().split(' '))
	grid = list()
	for _ in range(n):
		row = input().split(' ')
		grid.append(row)
	results.append(solve(n, m, grid))
for result in results:
	print(result + ' ')


import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
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 t in range(int(input())):
	(n, m) = map(int, input().split())
	row = [0] * n
	column = [0] * m
	a = [[0 for i in range(m)] for j in range(n)]
	for i in range(n):
		curr = 0
		b = list(map(int, input().split()))
		for j in range(m):
			a[i][j] = b[j]
			if b[j] == 1:
				curr += 1
				column[j] += 1
		row[i] += curr
	tot = 0
	for i in row:
		if i != 0:
			continue
		for j in range(m):
			if column[j] == 0:
				column[j] = 1
				tot += 1
				break
	if tot % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	a = [list(map(int, input().split())) for i in range(n)]
	l = [[] for i in range(m)]
	(x, y) = (0, 0)
	for j in a:
		if 1 in j:
			n -= 1
	for j in a:
		for k in range(m):
			l[k].append(j[k])
	for j in l:
		if 1 in j:
			m -= 1
	print('Vivek' if min(n, m) % 2 == 0 else 'Ashish')


q = int(input())
for _ in range(q):
	(n, m) = list(map(int, input().split(' ')))
	A = []
	for i in range(n):
		A.append(list(map(int, input().split(' '))))
	row = [1 for i in range(n)]
	col = [1 for i in range(m)]
	count = 0
	for i in range(n):
		for j in range(m):
			if A[i][j] == 1:
				row[i] = 0
				col[j] = 0
	dic = {}
	for i in range(n):
		for j in range(m):
			if row[i] == 1 and col[j] == 1 and (j not in dic):
				dic[j] = 1
				count += 1
				break
	al = count
	if al % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	lst = []
	for i in range(n):
		temp = list(map(int, input().split()))
		lst.append(temp)
	(r, c) = (0, 0)
	for i in range(n):
		for j in range(m):
			if lst[i][j] == 1:
				r += 1
				break
	for i in range(m):
		for j in range(n):
			if lst[j][i] == 1:
				c += 1
				break
	r = n - r
	c = m - c
	a = min(r, c)
	if a % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = [0] * n
	Row = n
	Col = m
	for i in range(n):
		a[i] = [int(_) for _ in input().split()]
		if sum(a[i]) > 0:
			Row -= 1
	for i in range(m):
		for j in range(n):
			if a[j][i] != 0:
				Col -= 1
				break
	cnt = min(Row, Col)
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for lo in range(int(input())):
	(n, m) = map(int, input().split())
	ls = []
	for i in range(n):
		a = [int(x) for x in input().split()]
		ls.append(a)
	a = [0 for i in range(n)]
	b = [0 for i in range(m)]
	for i in range(n):
		for j in range(m):
			if ls[i][j] == 1:
				a[i] = 1
				b[j] = 1
	c = c1 = 0
	for i in range(n):
		if a[i] == 0:
			c += 1
	for j in range(m):
		if b[j] == 0:
			c1 += 1
	res = min(c, c1)
	if res % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


import sys
input = lambda : sys.stdin.readline()
int_arr = lambda : list(map(int, input().split()))
str_arr = lambda : list(map(str, input().split()))
get_str = lambda : map(str, input().split())
get_int = lambda : map(int, input().split())
get_flo = lambda : map(float, input().split())
mod = 1000000007
for _ in range(int(input())):
	(n, m) = get_int()
	(rd, cd) = ([False] * n, [False] * m)
	for i in range(n):
		arr = int_arr()
		for j in range(m):
			if arr[j] == 1:
				rd[i] = True
				cd[j] = True
	c = min(rd.count(False), cd.count(False))
	print(('Vivek', 'Ashish')[c % 2])


for i in range(int(input())):
	(n, m) = map(int, input().split())
	l = set()
	c = n
	d = m
	for i in range(n):
		l1 = list(map(int, input().split()))
		f = 0
		for j in range(d):
			if l1[j] == 1:
				if f == 0:
					n -= 1
				f = 1
				if j not in l:
					if m > 0:
						m -= 1
					l.add(j)
	mini = min(n, m)
	if mini % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	(n, m) = list(map(int, input().split()))
	arr = []
	r = [0] * n
	c = [0] * m
	for i in range(n):
		temp = list(map(int, input().split()))
		arr.append(temp)
		for j in range(m):
			if temp[j] == 1:
				c[j] = 'X'
		val = temp.count(1)
		if val >= 1:
			r[i] = 'X'
	rc = r.count(0)
	cc = c.count(0)
	res = min(rc, cc)
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


ans = []
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	d1 = [0] * n
	d2 = [0] * m
	for i in range(n):
		inp = list(map(int, input().split()))
		for j in range(m):
			if inp[j] == 1:
				d1[i] = 1
				d2[j] = 1
	n -= sum(d1)
	m -= sum(d2)
	x = min(n, m)
	if x % 2 == 1:
		ans.append('Ashish')
	else:
		ans.append('Vivek')
print('\n'.join(ans))


for t in range(int(input())):
	(n, m) = map(int, input().split())
	(w, l) = (set(), set())
	for r in range(n):
		for (y, x) in enumerate(map(int, input().split())):
			if x == 1:
				w.add(r)
				l.add(y)
	print(['Vivek', 'Ashish'][min(n - len(w), m - len(l)) % 2])


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	Mat = []
	for i in range(n):
		Mat.append(list(map(int, input().split())))
	Row = set()
	Col = set()
	for i in range(n):
		for j in range(m):
			if Mat[i][j] == 1:
				Row.add(i)
				Col.add(j)
	(r, c) = (n - len(Row), m - len(Col))
	if r == 0 or c == 0:
		print('Vivek')
	else:
		r = min(r, c)
		if r % 2 != 0:
			print('Ashish')
		else:
			print('Vivek')


tests = int(input())
for _ in range(tests):
	(n, m) = map(int, input().split())
	counts = n
	countv = m
	a = [0] * n
	for i in range(n):
		a[i] = list(map(int, input().split()))
		if 1 in a[i]:
			counts -= 1
	for i in range(m):
		for j in range(n):
			if a[j][i] == 1:
				countv -= 1
				break
	p = min(counts, countv)
	if p % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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 inputmatrixchar(rows):
	arr2d = [[j for j in input().strip()] for i in range(rows)]
	return arr2d

def inputmatrixint(rows):
	arr2d = []
	for _ in range(rows):
		arr2d.append([int(i) for i in input().split()])
	return arr2d
t = int(input())
for q in range(t):
	(n, m) = inputnums()
	a = inputmatrixint(n)
	cntr = 0
	cntc = 0
	for i in range(n):
		good = True
		for j in range(m):
			if a[i][j] == 1:
				good = False
		if good:
			cntr += 1
	for i in range(m):
		good = True
		for j in range(n):
			if a[j][i] == 1:
				good = False
		if good:
			cntc += 1
	mn = min(cntr, cntc)
	if mn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	matrix = [[int(i) for i in input().split()] for _ in range(n)]
	c = 0
	for row in range(n):
		for col in range(m):
			if [matrix[i][col] for i in range(n)].count(1) == 0 and matrix[row].count(1) == 0:
				matrix[row][col] = 1
				c += 1
	if c % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import sys, os, io
I = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
for tc in range(1, 1 + int(I())):
	(n, m) = map(int, I().split())
	g = [list(map(int, I().split())) for _ in range(n)]
	r = n
	c = m
	cy = [False for _ in range(m)]
	for row in g:
		yes = False
		for (ci, col) in enumerate(row):
			if col > 0:
				yes = True
				cy[ci] = True
		if yes:
			r -= 1
	for ci in cy:
		if ci:
			c -= 1
	r = min(r, c)
	print('Ashish' if r & 1 else 'Vivek')


t = int(input())
while t:
	t -= 1
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l1 = list(map(int, input().split()))
		l.append(l1)
	l2 = []
	for i in range(n):
		l3 = []
		for j in range(m):
			l3.append(l[i][j])
		l2.append(l3)
	for i in range(n):
		for j in range(m):
			if l2[i][j] == 1:
				for k in range(n):
					l[k][j] = 1
				for k in range(m):
					l[i][k] = 1
	f = 0
	c = 0
	while 1:
		f = 0
		for i in range(n):
			for j in range(m):
				if l[i][j] == 0:
					c += 1
					f = 1
					for k in range(n):
						l[k][j] = 1
					for k in range(m):
						l[i][k] = 1
					break
			if f == 1:
				break
		if f == 0:
			break
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


ncases = int(input())
for i in range(ncases):
	take = input().split(' ')
	rows = int(take[0])
	cols = int(take[1])
	r = 0
	c = 0
	matrix = []
	for j in range(rows):
		take2 = input().split(' ')
		if '1' not in take2:
			r += 1
		for t in take2:
			t = int(t)
			matrix.append(t)
	for k in range(cols):
		count = k
		count2 = 0
		while count < len(matrix):
			ele = matrix[count]
			if ele == 1:
				break
			else:
				count += cols
				count2 += 1
				if count2 == rows:
					c += 1
					break
	ash = 0
	vivek = 0
	turns = 0
	while min(r, c) > 0:
		r -= 1
		c -= 1
		if turns % 2 == 0:
			ash += 1
		else:
			vivek += 1
		turns += 1
	if ash == vivek:
		print('Vivek')
	elif ash > vivek:
		print('Ashish')


def matrix_game(m, n, mat):
	r = []
	c = []
	for i in range(m):
		if mat[i] != [0] * n:
			r.append(i)
			for j in range(n):
				if mat[i][j] == 1 and j not in c:
					c.append(j)
	dec = min(m - len(r), n - len(c))
	if dec % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
T = int(input())
for i in range(T):
	(m, n) = [int(i) for i in input().split()]
	mat = []
	for j in range(m):
		row = [int(i) for i in input().split()]
		mat.append(row)
	print(matrix_game(m, n, mat))


t = int(input())
while t > 0:
	(n, m) = map(int, input().split())
	(row, col) = (set(), set())
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(m):
			if a[j] == 1:
				row.add(i)
				col.add(j)
	d = min(n - len(row), m - len(col))
	if d % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	s = set()
	p = set()
	for i in range(n):
		l = list(map(int, input().split()))
		for j in range(m):
			if l[j] == 1:
				s.add(i)
				p.add(j)
	ans = min(n - len(s), m - len(p))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve(n, m, b):
	n_proj = [0 for _ in range(n)]
	m_proj = [0 for _ in range(m)]
	for i in range(n):
		for j in range(m):
			if b[i][j] == 1:
				n_proj[i] = 1
				m_proj[j] = 1
	q = min(n_proj.count(0), m_proj.count(0))
	return 'Vivek' if q % 2 == 0 else 'Ashish'
t = int(input())
for _ in range(t):
	(n, m) = (*map(int, input().split()),)
	b = []
	for _ in range(n):
		b.append(list(map(int, input().split())))
	print(solve(n, m, b))


test_cases = int(input())
for z in range(test_cases):
	(n, m) = list(map(int, input().split()))
	matrix = []
	for i in range(n):
		row = list(map(int, input().split()))
		matrix.append(row)
	column = 0
	row = 0
	count = 0
	for i in matrix:
		for j in i:
			if j == 1:
				break
			else:
				count += 1
			if count == m:
				row += 1
		count = 0
	count = 0
	for j in range(m):
		for i in range(n):
			if matrix[i][j] == 1:
				break
			else:
				count += 1
			if count == n:
				column += 1
		count = 0
	x = min(row, column)
	if x == 0:
		ans = 'Vivek'
	elif x % 2 != 0:
		ans = 'Ashish'
	else:
		ans = 'Vivek'
	print(ans)


def countSetBits(n):
	count = 0
	while n:
		count += n & 1
		n >>= 1
	return count
import math

def mycool(i, j, l):
	for oo in range(m):
		if l[i][oo] == 1:
			return 0
	for oo in range(n):
		if l[oo][j] == 1:
			return 0
	return 1
t = int(input())
while t:
	t -= 1
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		r = list(map(int, input().split()))
		l.append(r[:])
	cnt = 0
	for i in range(n):
		for j in range(m):
			if mycool(i, j, l):
				cnt += 1
				l[i][j] = 1
	if cnt % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for t in range(0, t):
	(r, c) = map(int, input().split())
	ll = []
	sr = set()
	sc = set()
	for i in range(r):
		l = list(map(int, input().split()))
		for j in range(len(l)):
			if l[j] == 1:
				sr.add(i)
				sc.add(j)
		ll.append(l)
	ts = []
	for i in range(r):
		for j in range(c):
			if ll[i][j] == 0 and i not in sr and (j not in sc):
				ll[i][j] = 1
				sr.add(i)
				sc.add(j)
				if not ts:
					ts.append('a')
				elif ts[-1] == 'a':
					ts.append('v')
				else:
					ts.append('a')
	if not ts:
		print('Vivek')
	elif ts[-1] == 'a':
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = [list(map(int, input().split())) for _ in range(n)]
	tmp = n
	for row in a:
		if 1 in row:
			n -= 1
	for i in range(m):
		for j in range(tmp):
			if a[j][i] == 1:
				m -= 1
				break
	if min(n, m) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	sp = 0
	r = []
	matrix = [[int(x) for x in input().split()] for j in range(n)]
	for i in range(n):
		if matrix[i].count(0) == m:
			r.append(i)
	tr = 1
	ar = []
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1 and j not in ar:
				ar.append(j)
	if len(ar) == m:
		print('Vivek')
	else:
		sp = min(len(r), m - len(ar))
		if sp % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')


t = int(input())
while t > 0:
	(n, m) = list(map(int, input().split()))
	arr = []
	r = []
	c = []
	for i in range(n):
		l = list(map(int, input().split()))
		if 1 not in l:
			r.append(i)
		arr.append(l)
	for j in range(m):
		flag = 1
		for i in range(n):
			if arr[i][j] == 1:
				flag = -1
				break
		if flag == 1:
			c.append(j)
	if min(len(set(r)), len(set(c))) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for _ in range(1, int(input()) + 1):
	lst = [int(i) for i in input().split()]
	(cols, rows) = (set(), set())
	for i in range(lst[0]):
		y = [int(z) for z in input().split()]
		for (j, val) in enumerate(y):
			if val == 1:
				cols.add(j)
				rows.add(i)
	b = min(lst[0] - len(rows), lst[1] - len(cols))
	print('Vivek' if b % 2 == 0 else 'Ashish')


for __ in range(int(input())):
	(n, m) = map(int, input().split())
	(R, C) = (set(), set())
	for i in range(n):
		s = [c for (c, x) in enumerate(map(int, input().split())) if x]
		if len(s):
			C.update(s)
			R.add(i)
	ops = min(n - len(R), m - len(C))
	print(['Vivek', 'Ashish'][ops % 2])


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

def read_ints():
	return list(map(int, input().split(' ')))
t = read_int()
for case_num in range(t):
	(n, m) = read_ints()
	a = []
	for i in range(n):
		a.append(list(read_ints()))
	row = set([i for i in range(n)])
	col = set([i for i in range(m)])
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				if i in row:
					row.remove(i)
				if j in col:
					col.remove(j)
	lo = min(len(row), len(col))
	print('Ashish' if lo % 2 == 1 else 'Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	count = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				pass
			else:
				x = 0
				for k in range(n):
					if mat[k][j] == 1:
						x = 1
				for k in range(m):
					if mat[i][k] == 1:
						x = 1
				if x == 0:
					mat[i][j] = 1
					count += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for i in range(int(input())):
	(n, m) = [int(i) for i in input().split()]
	a = []
	for i in range(n):
		a.append([int(i) for i in input().split()])
	available_columns = 0
	available_rows = 0
	for i in a:
		if sum(i) == 0:
			available_rows += 1
	for i in range(len(a[0])):
		taken = False
		for j in a:
			if j[i] == 1:
				taken = True
		if not taken:
			available_columns += 1
	if min(available_columns, available_rows) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


tc = int(input())
for _ in range(tc):
	(n, m) = list(map(int, input().split()))
	matrix = []
	for _ in range(n):
		row = list(map(int, input().split()))
		matrix.append(row)
	turns = 0
	(claimed_row, claimed_col) = ([], [])
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				claimed_row.append(i)
				claimed_col.append(j)
	for i in range(n):
		for j in range(m):
			if i in claimed_row or j in claimed_col:
				pass
			else:
				matrix[i][j] = 1
				claimed_row.append(i)
				claimed_col.append(j)
				turns += 1
	if turns % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def read():
	t = int(input())
	for i in range(t):
		(n, m) = list(map(int, input().strip().split()))
		rows = set()
		cols = set()
		for i in range(n):
			r = list(map(str, input().strip().split()))
			for j in range(m):
				if r[j] == '1':
					rows.add(i + 1)
					cols.add(j + 1)
		cnt_rows = 0
		for i in range(1, n + 1):
			if i not in rows:
				cnt_rows += 1
		cnt_cols = 0
		for j in range(1, m + 1):
			if j not in cols:
				cnt_cols += 1
		if min(cnt_rows, cnt_cols) % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
read()


from math import sqrt
t = int(input())
for q in range(t):
	(n, m) = [int(i) for i in input().split()]
	ver = [0] * n
	hor = [0] * m
	a = []
	for i in range(n):
		b = [int(i) for i in input().split()]
		a.append(b)
		for j in range(m):
			if b[j] == 1:
				ver[i] = 1
				hor[j] = 1
	v = 0
	h = 0
	for i in ver:
		if i == 0:
			v += 1
	for i in hor:
		if i == 0:
			h += 1
	mi = min(h, v)
	if mi % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	a = list(map(int, input().split()))
	(n, m) = (a[0], a[1])
	l = []
	row = []
	column = []
	for j in range(n):
		l.append(list(map(int, input().split())))
		for u in range(m):
			if l[j][u] == 1:
				if j not in row:
					row.append(j)
				if u not in column:
					column.append(u)
	x = n - len(row)
	y = m - len(column)
	q = min(x, y)
	if q % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(m, n) = [int(x) for x in input().split()]
	l = []
	for i in range(m):
		arr = list(map(int, input().split()))
		l.append(arr)
	r = 0
	col = 0
	for i in range(m):
		c = 0
		for j in range(n):
			if l[i][j] == 0:
				c += 1
		if c == n:
			r += 1
	for i in range(0, n):
		c = 0
		for j in range(0, m):
			if l[j][i] == 0:
				c += 1
		if c == m:
			col += 1
	mini = min(r, col)
	if mini % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	matrix = [list(map(int, input().split())) for i in range(n)]
	r = {}
	c = {}
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				r[i] = 1
				c[j] = 1
	left_place = min(n - len(r), m - len(c))
	if left_place % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def main():
	(n, m) = map(int, input().split())
	arr = []
	for _ in range(n):
		arr.append(list(map(int, input().split())))
	dpr = [0 for _ in range(n)]
	dpc = [0 for _ in range(m)]
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				dpr[i] = 1
				dpc[j] = 1
	ans = min(n - sum(dpr), m - sum(dpc))
	if ans % 2:
		print('Ashish')
	else:
		print('Vivek')
	return

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


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	r = set()
	c = set()
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r.add(i)
				c.add(j)
	i = 0
	f = 0
	while i < n:
		j = 0
		while j < m:
			if a[i][j] == 0 and (i not in r and j not in c):
				if f == 0:
					f = 1
				else:
					f = 0
				r.add(i)
				c.add(j)
			j += 1
		i += 1
	if f == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		s = [int(x) for x in input().split()]
		mat.append(s)
	onr = []
	oc = []
	zr = []
	zc = []
	a = 1
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				onr.append(i)
				oc.append(j)
			if mat[i][j] == 0:
				zr.append(i)
				zc.append(j)
	while 1:
		a = 1 - a
		flag = 0
		for i in range(len(zr)):
			if zr[i] not in onr and zc[i] not in oc:
				flag = 1
				x = zr[i]
				y = zc[i]
				onr.append(x)
				oc.append(y)
				break
		if flag == 0:
			break
	if a == 1:
		print('Ashish')
	else:
		print('Vivek')
	t = t - 1


t = int(input())
for test in range(t):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		temp = list(map(int, input().split()))
		arr.append(temp)
	ans = 0
	cnt1 = 0
	cnt2 = 0
	for i in range(n):
		x = 0
		for j in range(m):
			if arr[i][j] == 1:
				x += 1
		if x == 0:
			cnt1 += 1
	for j in range(m):
		x = 0
		for i in range(n):
			if arr[i][j] == 1:
				x += 1
		if x == 0:
			cnt2 += 1
	ans = min(cnt1, cnt2)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


n = int(input())
for i in range(n):
	(a, b) = map(int, input().split())
	c = []
	for j in range(a):
		c.append(list(map(int, input().split())))
	d = []
	e = []
	for j in range(a):
		for k in range(b):
			if c[j][k] == 1:
				d.append(j)
				e.append(k)
	f = 0
	for j in range(a):
		for k in range(b):
			if j not in d and k not in e:
				d.append(j)
				e.append(k)
				if f == 0:
					f = 1
				elif f == 1:
					f = 2
				elif f == 2:
					f = 1
	if f == 1:
		print('Ashish')
	elif f == 2:
		print('Vivek')
	elif f == 0:
		print('Vivek')


import os
import sys
from io import BytesIO, IOBase
import math
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')
arnab = int(input())
tt = 0
for _ in range(arnab):
	(n, m) = [int(x) for x in input().split()]
	l = []
	raj = 'krish'
	rrr = 1
	mio = 'krishrrr'
	hu = rrr ** 6
	for i in range(n):
		tmp = list([int(x) for x in input().split()])
		l.append(tmp)
	c1 = 0
	for i in range(n):
		for j in range(m):
			fal = 0
			if l[i][j] == 0:
				fal = 0
				if 1 in l[i]:
					fal = 1
				for k in range(n):
					if l[k][j] == 1:
						fal = 1
				if fal == 0:
					l[i][j] = 1
					c1 += 1
	if c1 % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
q = int(input())
for i in range(q):
	(n, m) = [int(j) for j in sys.stdin.readline().split()]
	c = [0] * m
	d = [0] * n
	for j in range(n):
		a = input().split()
		for k in range(len(a)):
			if a[k] == '1':
				c[k] = 1
				d[j] = 1
	t1 = c.count(0)
	t2 = d.count(0)
	ol = min(t1, t2)
	if ol % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	for q in range(n):
		temp = [int(x) for x in input().split()]
		matrix.append(temp)
	temp1 = 0
	temp2 = 0
	for q in range(n):
		t = matrix[q].count(1)
		if t == 0:
			temp1 += 1
	for q in range(m):
		flag = 1
		for w in range(n):
			if matrix[w][q] == 1:
				flag = 0
				break
		if flag:
			temp2 += 1
	ans = min(temp1, temp2)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
import os
import random
import re
import sys
t = int(input())
while t > 0:
	t -= 1
	(n, m) = map(int, input().split())
	nn = n
	pn = set()
	pm = set()
	while n > 0:
		n -= 1
		is_any_one = False
		marr = list(map(int, input().split()))
		for i in range(len(marr)):
			if marr[i] == 1:
				pm.add(i)
				is_any_one = True
		if is_any_one:
			pn.add(n)
	ppn = max(0, nn - len(pn))
	ppm = max(0, m - len(pm))
	if min(ppn, ppm) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	b = []
	for j in range(n):
		c = list(map(int, input().split()))
		b.append(c)
	p = 0
	q = 0
	for i in range(n):
		f = 0
		for j in range(m):
			if b[i][j] == 1:
				f = 1
				break
		if f == 0:
			p += 1
	for j in range(m):
		f = 0
		for i in range(n):
			if b[i][j] == 1:
				f = 1
				break
		if f == 0:
			q += 1
	p = min(p, q)
	if p % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	b = []
	cntr = n
	cntc = m
	for i in range(n):
		a = list(map(int, input().split()))
		cnt = a.count(1)
		if cnt > 0:
			cntr -= 1
		b.append(a)
	for i in range(m):
		c = 0
		for j in range(n):
			if b[j][i] == 1:
				c += 1
				break
		if c > 0:
			cntc -= 1
	d = min(cntr, cntc)
	if d % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	mat = [None for x in range(n)]
	for z in range(n):
		mat[z] = [int(x) for x in input().split()]
	rows = [int(x) for x in range(n)]
	rows = set(rows)
	coloum = [int(x) for x in range(m)]
	coloum = set(coloum)
	for i in range(m):
		for j in range(n):
			if mat[j][i] == 1:
				rows.discard(j)
				coloum.discard(i)
	if min(len(rows), len(coloum)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	row = [0] * n
	col = [0] * m
	for i in range(n):
		for j in range(m):
			if a[i][j]:
				row[i] = 1
				col[j] = 1
	rowc = row.count(0)
	colc = col.count(0)
	moves = min(rowc, colc)
	if moves & 1:
		print('Ashish')
	else:
		print('Vivek')


T = int(input())
for t in range(T):
	(n, m) = map(int, input().split())
	arr = [list(map(int, input().split())) for i in range(n)]
	occrows = set([])
	occols = set([])
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				occrows.add(i)
				occols.add(j)
	available = min(n - len(occrows), m - len(occols))
	if available % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
from sys import stdin
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = [int(j) for j in input().split()]
	mat = []
	for i in range(n):
		arr = [int(j) for j in input().split()]
		mat.append(arr)
	remcol = [0] * m
	remrow = [0] * n
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				remcol[j] = 1
				remrow[i] = 1
	col = remcol.count(1)
	row = remrow.count(1)
	ans = min(m - col, n - row)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	li = [[]] * n
	for i in range(n):
		li[i] = list(map(int, input().split()))
	for i in range(n):
		for j in range(m):
			if li[i][j] == 1:
				for k in range(n):
					if li[k][j] == 0:
						li[k][j] = -1
				for p in range(m):
					if li[i][p] == 0:
						li[i][p] = -1
	ans = 0
	while 1:
		f = 1
		for i in range(n):
			for j in range(m):
				if li[i][j] == 0:
					if ans:
						ans = 0
					else:
						ans = 1
					f = 0
					for k in range(n):
						li[k][j] = -1
					for p in range(m):
						li[i][p] = -1
		if f:
			break
	if ans:
		print('Ashish')
	else:
		print('Vivek')


for i in range(0, int(input())):
	(n, m) = list(map(int, input().split()))
	p = []
	q = []
	for j in range(0, n):
		q = list(map(int, input().split()))
		p.append(q)
	r = 0
	c = 0
	for i in range(0, n):
		z = 0
		for j in range(0, m):
			if p[i][j] == 0:
				z = z + 1
		if z == m:
			r = r + 1
	for i in range(0, m):
		z = 0
		for j in range(0, n):
			if p[j][i] == 0:
				z = z + 1
		if z == n:
			c = c + 1
	if r <= c:
		d = r
	else:
		d = c
	if d % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout

def check(x, y):
	for j in range(c):
		if a[x][j] == 1:
			return False
	for i in range(r):
		if a[i][y] == 1:
			return False
	return True
for _ in range(int(stdin.readline())):
	(r, c) = map(int, stdin.readline().split())
	a = [list(map(int, stdin.readline().split())) for _ in range(r)]
	c1 = p = q = 0
	while 1:
		f = 0
		for i in range(r):
			for j in range(c):
				if check(i, j):
					f = 1
					c1 += 1
					a[i][j] = 1
		if f == 0:
			break
	print('Ashish' if c1 & 1 else 'Vivek')


def solve(a, n, m):
	r = [False] * n
	c = [False] * m
	count = 0
	for i in range(n):
		f = 0
		for j in range(m):
			if a[i][j] == 1:
				r[i] = True
				c[j] = True
	x = min(r.count(False), c.count(False))
	return 'Vivek' if x % 2 == 0 else 'Ashish'
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	res = solve(a, n, m)
	print(res)


def main():
	t = int(input())
	for _ in range(t):
		(n, m) = map(int, input().split())
		N = [0] * n
		M = [0] * m
		for i in range(n):
			a = list(map(int, input().split()))
			for j in range(m):
				if a[j] == 1:
					M[j] = 1
					N[i] = 1
		x = y = 0
		for i in M:
			if i == 0:
				x += 1
		for i in N:
			if i == 0:
				y += 1
		ans = min(x, y)
		if ans % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	used1 = set()
	used2 = set()
	for i in range(n):
		for r in range(m):
			if a[i][r] == 1:
				used1.add(i)
				used2.add(r)
	ans = min(n - len(used1), m - len(used2))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from math import *
from copy import *
t = int(input())
for i in range(t):
	(n, m) = list(map(int, input().split()))
	l = []
	c = 0
	for j in range(n):
		tt = list(map(int, input().split()))
		if tt == [0] * len(tt):
			c += 1
		l.append(tt)
	result = []
	for j in range(m):
		result.append([0] * n)
	for i in range(len(l)):
		for j in range(len(l[0])):
			result[j][i] = l[i][j]
	d = 0
	for j in range(m):
		if result[j] == [0] * n:
			d += 1
	if min(c, d) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	(m, n) = map(int, input().split())
	x = []
	for j in range(m):
		x.append(list(map(int, input().split())))
	count = 0
	a = []
	count1 = 0
	for j in range(m):
		if sum(x[j]) == 0:
			count += 1
	for j in range(m):
		for k in range(n):
			if x[j][k] == 1:
				a.append(k)
	for j in range(n):
		if j not in a:
			count1 += 1
	if min(count, count1) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	a = []
	cols = 0
	rows = 0
	(n, m) = map(int, input().split())
	for q in range(n):
		a.append(list(map(int, input().split())))
	for row in range(n):
		hj = 0
		for r in a[row]:
			if r == 1:
				hj = 1
				break
		rows += hj
	for col in range(m):
		hj = 0
		for row in range(n):
			if a[row][col] == 1:
				hj = 1
				break
		cols += hj
	k = min(n - rows, m - cols)
	if k % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, k) = map(int, input().split(' '))
	(rws, clmns) = ([], [])
	for i in range(n):
		arr = list(map(int, input().split(' ')))
		if arr.count(0) == k:
			rws.append(i)
		else:
			for j in range(k):
				if arr[j] == 1 and j not in clmns:
					clmns.append(j)
	p = min(len(rws), k - len(clmns))
	if p % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for t in range(int(input())):
	(n, m) = map(int, input().split())
	s = st = 0
	b = []
	for i in range(n):
		a = list(input().split())
		if a.count('1') == 0:
			s += 1
		b.append(a)
	for j in range(m):
		c = [b[i][j] for i in range(n)]
		if c.count('1') == 0:
			st += 1
	k = min(s, st)
	if k % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	ash = 0
	vi = 0
	first = 0
	for k in range(n):
		matrix.append([int(j) for j in input().split()])
	for k in range(n):
		for j in range(m):
			if matrix[k][j] == 0:
				if 1 not in matrix[k]:
					for g in range(n):
						if matrix[g][j] == 0:
							if g == n - 1:
								if first == 0:
									ash = 1
									first = 1
									matrix[k][j] = 1
								elif ash == 1:
									ash = 0
									vi = 1
									matrix[k][j] = 1
								else:
									vi = 0
									ash = 1
									matrix[k][j] = 1
						else:
							break
	if first == 0:
		print('Vivek')
	elif ash == 1:
		print('Ashish')
	else:
		print('Vivek')


import functools

def A():
	t = int(input())
	for _ in range(t):
		(n, m) = map(int, input().split())
		a = [[]] * n
		for j in range(n):
			a[j] = list(map(int, input().split()))
		free_str_state = [1] * n
		free_col_state = [1] * m
		for i in range(n):
			for j in range(m):
				if a[i][j]:
					free_str_state[i] = 0
					free_col_state[j] = 0
		res = min(sum(free_str_state), sum(free_col_state))
		if res % 2 == 1:
			print('Ashish')
		else:
			print('Vivek')
A()


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 = ['\n4\n2 2\n0 0\n0 0\n2 2\n0 0\n0 1\n2 3\n1 0 1\n1 1 0\n3 3\n1 0 0\n0 0 0\n1 0 0\n\n', '\n3\n1 1\n0\n1 1\n1\n1 2\n1 0\n', '\n$$$\n', '\n$$$\n']
test_outputs = ['\nVivek\nAshish\nVivek\nAshish\n\n', '\n$$$\n', '\n$$$\n', '\n$$$\n']

def solve():
	for z in range(input(1)[0]):
		(n, m) = input(1)
		k = []
		for i in range(n):
			k.append(input(1))
		log(k)
		r = [0] * n
		c = [0] * m
		for (i, a) in enumerate(k):
			for (j, b) in enumerate(a):
				if b == 1:
					r[i] = 1
					c[j] = 1
		o = n
		u = m
		for i in r:
			if i == 1:
				o -= 1
		for i in c:
			if i == 1:
				u -= 1
		t = min(o, u)
		log(u, o)
		if t % 2 == 0:
			out('Vivek')
		else:
			out('Ashish')
	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)


from collections import Counter, defaultdict, deque
from math import *
import sys
input = sys.stdin.readline

def solve():
	(n, m) = [int(x) for x in input().split()]
	mat = []
	for i in range(n):
		r = [int(x) for x in input().split()]
		mat.append(r)
	(rows, cols) = (0, 0)
	for i in range(n):
		if not any(mat[i]):
			rows += 1
	for i in range(m):
		c = []
		for j in range(n):
			c.append(mat[j][i])
		if not any(c):
			cols += 1
	if min(rows, cols) % 2:
		print('Ashish')
	else:
		print('Vivek')
tt = int(input())
for test in range(tt):
	solve()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	non_move_x = []
	non_move_y = []
	for (x, i) in enumerate(mat):
		for (y, j) in enumerate(i):
			if j == 1:
				non_move_x.append(x)
				non_move_y.append(y)
	zero_count = 0
	for (x, i) in enumerate(mat):
		for (y, j) in enumerate(i):
			if x in non_move_x or y in non_move_y:
				continue
			else:
				zero_count += 1
				non_move_x.append(x)
				non_move_y.append(y)
	ans = ['Vivek', 'Ashish']
	print(ans[zero_count % 2])


for _ in range(int(input())):
	(row, col) = map(int, input().split())
	lst1 = []
	for _ in range(row):
		lst1.append([int(x) for x in input().split()])
	lst = []
	for _ in range(row):
		lx = []
		for _ in range(col):
			lx.append(0)
		lst.append(lx)
	for i in range(row):
		for j in range(col):
			if lst1[i][j] == 1:
				for x in range(0, col):
					lst[i][x] = 1
				for x in range(0, row):
					lst[x][j] = 1
	k = 0
	while True:
		tmp = False
		for i in range(row):
			cnt = False
			for j in range(col):
				flg = False
				if lst[i][j] == 0 and lst[i][j] != 1:
					(flg, cnt, tmp) = (True, True, True)
					for x in range(0, col):
						lst[i][x] = 1
					for y in range(0, row):
						lst[y][j] = 1
				if flg == True:
					break
			if cnt == True:
				break
		if tmp == True:
			k += 1
		else:
			break
	if k % 2 != 0:
		print('Ashish')
	if k % 2 == 0:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	(r, c) = (set(), set())
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(m):
			if a[j] == 1:
				r.add(i)
				c.add(j)
	if min(n - len(r), m - len(c)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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()
		arr = [[0 for _ in range(m)] for __ in range(n)]
		for i in range(n):
			arr[i] = input_array()
		mn = 0
		for i in range(n):
			for j in range(m):
				if arr[i][j] == 1:
					for k in range(n):
						if arr[k][j] == 0:
							arr[k][j] = 2
					for k in range(m):
						if arr[i][k] == 0:
							arr[i][k] = 2
		rr = 0
		for i in range(n):
			cnt = 0
			for j in range(m):
				if arr[i][j] == 0:
					cnt += 1
			rr = max(rr, cnt)
		cc = 0
		for j in range(m):
			cnt = 0
			for i in range(n):
				if arr[i][j] == 0:
					cnt += 1
			cc = max(cc, cnt)
		mn = min(rr, cc)
		if mn % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
	pass
READ('in.txt')
main()


from sys import stdin, stdout
import math, queue, heapq
fastinput = stdin.readline
fastout = stdout.write
t = int(input())
while t:
	t -= 1
	(n, m) = map(int, fastinput().split())
	count = 0
	rowset = set()
	colset = set()
	for j in range(n):
		k = 0
		for i in input().strip().split(' '):
			if i == '1':
				rowset.add(j)
				colset.add(k)
			k += 1
	rowset = set([i for i in range(n)]) - rowset
	colset = set([i for i in range(m)]) - colset
	count = min(len(rowset), len(colset))
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for w in range(t):
	(n, m) = list(map(int, input().split()))
	a = []
	delta_n = 0
	delta_m = 0
	for i in range(n):
		a.append(list(map(int, input().split())))
		if 1 in a[i]:
			delta_n += 1
	col = []
	for i in range(n):
		for j in range(m):
			if j in col:
				continue
			if a[i][j] == 1:
				col.append(j)
				delta_m += 1
	k = min(n - delta_n, m - delta_m)
	if k % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	d = [0] * m
	c = n
	for i in range(n):
		w = list(map(int, input().split()))
		if w.count(1):
			c -= 1
		d = [w[j] or d[j] for j in range(m)]
	x = min(c, d.count(0))
	print('Ashish' if x % 2 else 'Vivek')


import math
n = int(input())
while n:
	n = n - 1
	a = list(map(int, input().split()))
	mat = []
	for i in range(a[0]):
		mat.append(list(map(int, input().split())))
	r = 0
	for i in range(a[0]):
		if sum(mat[i]) == 0:
			r += 1
	c = 0
	for i in range(a[1]):
		su = 0
		for j in range(a[0]):
			su += mat[j][i]
		if su == 0:
			c += 1
	if min(c, r) % 2:
		print('Ashish')
	else:
		print('Vivek')


def solve(ar, n, m):
	track = [[True] * n for _ in range(m)]
	cnt = 0
	flag = 0
	for i in range(n):
		for j in range(m):
			if ar[i][j] == 1:
				break
			else:
				ptr_i = i
				ptr_j = 0
				while ptr_j != m:
					if ar[ptr_i][ptr_j] == 0:
						ptr_j += 1
					else:
						ar[i][j] = -1
						break
				ptr_i = 0
				ptr_j = j
				while ptr_i != n:
					if ar[ptr_i][ptr_j] == 0:
						ptr_i += 1
					else:
						ar[i][j] = -1
						break
				if ar[i][j] == -1:
					ar[i][j] = 0
					continue
				else:
					ar[i][j] = 1
					cnt += 1
					break
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	ar = []
	for _ in range(n):
		ar.append(list(map(int, input().split())))
	solve(ar, n, m)


import math

def Divisors(n):
	l = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				l.append(i)
			else:
				l.append(i)
				l.append(n // i)
		i = i + 1
	return l

def SieveOfEratosthenes(n):
	l = []
	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
	for p in range(2, n + 1):
		if prime[p]:
			l.append(p)
	return l

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

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

def maxSubArraySum(a):
	max_so_far = 0
	max_ending_here = 0
	size = len(a)
	for i in range(0, size):
		max_ending_here = max_ending_here + a[i]
		if max_so_far < max_ending_here:
			max_so_far = max_ending_here
		if max_ending_here < 0:
			max_ending_here = 0
	return max_so_far

def main():
	(n, m) = list(map(int, input().split()))
	l = []
	for j in range(0, n):
		l.append(list(map(int, input().split())))
	c = 0
	for j in range(0, n):
		f = 0
		for k in range(0, m):
			if l[j][k] == 0:
				f = 0
				for p in range(0, n):
					if l[p][k] == 1:
						f = 1
						break
				if f == 0:
					for p in range(0, m):
						if l[j][p] == 1:
							f = 1
							break
					if f == 0:
						c += 1
						l[j][k] = 1
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for i in range(0, t):
	main()


t = int(input())
while t > 0:
	t -= 1
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		x = list(map(int, input().split()))
		a.append(x)
	cnt = 0
	r = 0
	c = 0
	for i in range(n):
		k = 0
		for j in range(m):
			if a[i][j] == 1:
				k = 1
				break
		if k == 0:
			r += 1
	for i in range(m):
		k = 0
		for j in range(n):
			if a[j][i] == 1:
				k = 1
				break
		if k == 0:
			c += 1
	cnt = min(r, c)
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = [int(x) for x in input().split()]
	matrix = [-1 for z in range(n)]
	for i in range(n):
		row = [int(y) for y in input().split()]
		matrix[i] = row
	availRows = set(range(n))
	availCols = set(range(m))
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				if i in availRows:
					availRows.remove(i)
				if j in availCols:
					availCols.remove(j)
	nTurns = min(len(availRows), len(availCols))
	if nTurns % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	(r, c) = ([False] * n, [False] * m)
	for i in range(n):
		x = list(map(int, input().split()))
		if not all((k == 0 for k in x)):
			r[i] = True
		for j in range(m):
			if x[j] == 1:
				c[j] = True
	z = min(r.count(False), c.count(False))
	print(['Vivek', 'Ashish'][z % 2])


for t in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	f = False
	r = set()
	c = set()
	i = 0
	j = 0
	while i < n:
		j = 0
		while j < len(a[i]):
			if a[i][j] == 1:
				r.add(i)
				c.add(j)
			j += 1
		i += 1
	l = min(n - len(r), m - len(c))
	if l % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(a, b) = list(map(int, input().split()))
	row = [0 for i in range(a)]
	coloum = [0 for i in range(b)]
	matrix = []
	erow = 0
	for i in range(a):
		x = [int(j) for j in input().split()]
		if 1 in x:
			row[i] = 1
			for j in range(len(x)):
				if x[j] == 1:
					coloum[j] = 1
	winner = 1
	for i in range(len(row)):
		if row[i] == 0:
			for j in range(len(coloum)):
				if coloum[j] == 0:
					row[i] = 1
					coloum[j] = 1
					winner += 1
					break
	if winner % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


import sys
import math
import collections
from collections import deque
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

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

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))
T = 1
T = int(stdin.readline())
for _ in range(T):
	(n, m) = list(map(int, stdin.readline().split()))
	a = []
	for i in range(n):
		a.append(list(map(int, stdin.readline().split())))
	(row, col) = ({}, {})
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row[i] = True
				col[j] = True
	rR = n - len(row)
	cR = m - len(col)
	finalR = min(rR, cR)
	if finalR % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t > 0:
	t = t - 1
	(n, m) = map(int, input().split())
	p = n
	ls = []
	while p > 0:
		p = p - 1
		a = input()
		A = list(map(int, list(a.split())))
		ls.append(A)
	r = {}
	c = {}
	for i in range(n):
		for j in range(m):
			if ls[i][j] == 1:
				r[i] = 1
				c[j] = 1
	g = list(r.values())
	f = list(c.values())
	b = n - len(g)
	d = m - len(f)
	if min(b, d) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import copy
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		matrix.append([int(j) for j in input().split()])
	copy_matrix = copy.deepcopy(matrix)
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				for k in range(n):
					copy_matrix[k][j] = 1
				for k in range(m):
					copy_matrix[i][k] = 1
	count = 0
	for i in range(n):
		for j in range(m):
			if copy_matrix[i][j] == 0:
				for k in range(n):
					copy_matrix[k][j] = 1
				for k in range(m):
					copy_matrix[i][k] = 1
				count += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	arr = [[0 for i in range(m)] for j in range(n)]
	for i in range(n):
		inp = list(map(int, input().split()))
		for j in range(m):
			arr[i][j] = inp[j]
	ra = [i for i in range(n)]
	ca = [i for i in range(m)]
	r = set(ra)
	c = set(ca)
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				if i in r:
					r.remove(i)
				if j in c:
					c.remove(j)
	R = len(r)
	C = len(c)
	m = min(R, C)
	if m % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


l = lambda : map(int, input().split())
for _ in range(int(input())):
	(n, m) = l()
	(r, c) = ([0] * n, [0] * m)
	for i in range(n):
		s = list(l())
		for j in range(m):
			if s[j] == 1:
				r[i] = c[j] = 1
	print(['Vivek', 'Ashish'][min(r.count(0), c.count(0)) % 2])


from sys import stdin

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

def sinput():
	return input()

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

def linput():
	return list(map(int, stdin.readline().split()))
t = iinput()
while t:
	t -= 1
	(n, m) = minput()
	mat = []
	for _ in range(n):
		mat.append(linput())
	(r, c) = (0, 0)
	for i in range(n):
		if all((e == 0 for e in mat[i])):
			r += 1
	for j in range(m):
		if all((mat[i][j] == 0 for i in range(n))):
			c += 1
	print('Ashish' if min(r, c) & 1 else 'Vivek')


for T in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		temp = list(map(int, input().split()))
		mat.append(temp)
	(r, c) = (set(), set())
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				r.add(i)
				c.add(j)
	count = min(n - len(r), m - len(c))
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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, m) = I()
	donerows = set()
	donecols = set()
	matr = [[] for i in range(n)]
	for i in range(n):
		matr[i] = I()
		for j in range(m):
			if matr[i][j] == 1:
				donerows.add(i)
				donecols.add(j)
	todo = min(n - len(donerows), m - len(donecols))
	if todo % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	sums = []
	for i in range(m):
		sums.append(0)
	for i in range(n):
		row = [int(x) for x in input().split()]
		if sum(row) != 0:
			n -= 1
			for j in range(m):
				sums[j] += row[j]
	m = sums.count(0)
	i = 0
	while n > 0 and m > 0:
		n -= 1
		m -= 1
		i += 1
	if i % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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

def main():
	test = int(input())
	while test != 0:
		(n, m) = [int(x) for x in input().split()]
		dp = []
		for i in range(n):
			dp.append([int(x) for x in input().split()])
		a = set()
		b = set()
		for i in range(n):
			for j in range(m):
				if dp[i][j] == 1:
					a.add(i)
					b.add(j)
		val = min(n - len(a), m - len(b))
		if val % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
		test -= 1
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

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


def solve(arr, n, m):
	zero = 0
	c = 0
	for i in range(n):
		if arr[i].count(0) == m:
			zero += 1
	for i in range(m):
		tem = 0
		for j in range(n):
			if arr[j][i] == 0:
				tem += 1
		if tem == n:
			c += 1
	zero = min(c, zero)
	if zero % 2 == 0:
		return 0
	else:
		return 1
test = int(input())
for i in range(test):
	j = []
	(n, m) = list(map(int, input().split()))
	for i in range(n):
		j.append(list(map(int, input().split())))
	if solve(j, n, m) == 0:
		print('Vivek')
	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, m) = mi()
	a = []
	row = 0
	for _ in range(n):
		x = li()
		a.append(x)
		if not any(x):
			row += 1
	col = 0
	for i in range(m):
		f = 1
		for j in range(n):
			if a[j][i]:
				f = 0
				break
		col += f
	print(['Vivek', 'Ashish'][min(row, col) % 2])


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	row = [0] * n
	col = [0] * m
	for r in range(n):
		curr = list(map(int, input().split()))
		for c in range(m):
			if curr[c] == 1:
				row[r] = 1
				col[c] = 1
	count = 0
	going = True
	while going:
		if 0 in row and 0 in col:
			for i in range(n):
				if row[i] == 0:
					row[i] = 1
					break
			for i in range(m):
				if col[i] == 0:
					col[i] = 1
					break
			count += 1
		else:
			going = False
	if count % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for q in range(t):
	(n, m) = map(int, input().split())
	matr = []
	for i in range(n):
		matr.append(list(map(int, input().split())))
	x = 0
	for j in range(m):
		f = False
		for i in range(n):
			if matr[i][j]:
				f = True
		if f:
			x += 1
	y = 0
	for i in range(n):
		f = False
		for j in range(m):
			if matr[i][j]:
				f = True
		if f:
			y += 1
	if min(n - y, m - x) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	B = []
	x = 0
	for i in range(m):
		B.append(0)
	for i in range(n):
		A = list(map(int, input().split()))
		for j in range(len(A)):
			B[j] = max(A[j], B[j])
		x += max(A)
	z = sum(B)
	if min(m - z, n - x) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for t in range(int(input())):
	(n, m) = map(int, input().split())
	table = []
	row = set()
	col = set()
	for i in range(n):
		table.append([int(x) for x in input().split()])
		for j in range(m):
			if table[i][j] == 1:
				row.add(i)
				col.add(j)
	d = min(n - len(row), m - len(col))
	if d % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
while t > 0:
	t = t - 1
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	mat = []
	for i in range(n):
		l = input().split()
		mat.append(l)
	cr = []
	cc = []
	ans = 0
	for i in range(n):
		for j in range(m):
			mat[i][j] = int(mat[i][j])
			if mat[i][j] == 1:
				if i not in cr:
					cr.append(i)
				if j not in cc:
					cc.append(j)
	p = 0
	cd = 1
	while cd == 1:
		flag = 0
		for i in range(n):
			if flag == 1:
				break
			for j in range(m):
				if mat[i][j] == 0 and i not in cr and (j not in cc):
					flag = 1
					r = i
					c = j
					break
		if flag == 1:
			cr.append(r)
			cc.append(c)
			if p == 0:
				p = 1
			else:
				p = 0
		else:
			if p == 0:
				print('Vivek')
			else:
				print('Ashish')
			break


from sys import stdin
A = int(stdin.readline())
for k in range(0, A):
	B = list(map(int, stdin.readline().split()))
	C = list()
	for t in range(0, B[0]):
		D = list(map(int, stdin.readline().split()))
		C.append(D)
	countho = 0
	countver = 0
	for k in range(0, B[0]):
		sum = 0
		for t in C[k]:
			sum += t
		if sum == 0:
			countho += 1
	for u in range(0, B[1]):
		sum = 0
		for y in range(0, B[0]):
			sum += C[y][u]
		if sum == 0:
			countver += 1
	ans = min(countho, countver)
	if ans % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
while t:
	(n, m) = [int(x) for x in input().split()]
	c = 0
	l1 = []
	l2 = []
	for i in range(n):
		l = [x for x in input().split()]
		for j in range(m):
			if l[j] == '1':
				if i not in l1:
					l1.append(i)
				if j not in l2:
					l2.append(j)
	c1 = len(l1)
	c2 = len(l2)
	if c1 == n or c2 == m:
		c = 0
	else:
		c1 = abs(n - c1)
		c2 = abs(m - c2)
		c = min(c1, c2)
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


tcs = int(input())
for tc in range(tcs):
	(n, m) = map(int, input().split())
	arr = []
	for _ in range(n):
		arr.append(list(map(int, input().split())))
	row = [0] * n
	col = [0] * m
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				row[i] = 1
				col[j] = 1
	ans = min(row.count(0), col.count(0))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for g in range(t):
	n = [int(i) for i in input().split(' ')]
	arr = [[int(i) for i in input().split(' ')] for j in range(n[0])]
	(aRows, aCol) = (0, n[1])
	for i in arr:
		aRows += 1 if 1 not in i else 0
	for i in range(n[1]):
		for j in range(n[0]):
			if arr[j][i] == 1:
				aCol -= 1
				break
	a = min(aRows, aCol)
	print('Ashish' if a % 2 == 1 else 'Vivek')


for t in range(int(input())):
	(n, m) = list(map(int, input().split()))
	l = []
	r = 0
	c = set()
	for i in range(n):
		x = list(map(int, input().split()))
		if 1 in x:
			r += 1
			for j in range(m):
				if x[j] == 1:
					c.add(j)
	dr = n - r
	dc = m - len(c)
	d = min(dr, dc)
	if d > 0:
		if d % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
	else:
		print('Vivek')


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

def readn():
	return int(input())
N = readn()
for _ in range(N):
	(n, m) = readintlst()
	mat = []
	for _ in range(n):
		mat.append(readintlst())
	r = set(range(n))
	c = set(range(m))
	t = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				r.discard(i)
				c.discard(j)
	placed = False
	while r and c:
		for i in range(n):
			for j in range(m):
				if i in r and j in c:
					r.discard(i)
					c.discard(j)
					placed = True
					t += 1
					break
			if placed:
				placed = False
				break
	if t & 1 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	r = [0] * n
	c = [0] * m
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r[i] = 1
				c[j] = 1
	o = r.count(0)
	k = c.count(0)
	t = min(o, k)
	if t % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t > 0:
	inp = list(map(int, input().split()))
	n = inp[0]
	m = inp[1]
	arr = []
	rows = []
	columns = []
	for i in range(n):
		inp = list(map(int, input().split()))
		arr.append(inp)
		rows.append(0)
	for j in range(m):
		columns.append(0)
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				rows[i] = 1
				columns[j] = 1
	row_count = 0
	column_count = 0
	for i in range(n):
		if rows[i] == 1:
			row_count += 1
	for j in range(m):
		if columns[j] == 1:
			column_count += 1
	row_left = n - row_count
	column_left = m - column_count
	ans = min(row_left, column_left)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


t = int(input())
for _ in range(t):
	(row, col) = map(int, input().split())
	m = [[int(j) for j in input().split()] for i in range(row)]
	r = [0] * row
	c = [0] * col
	for i in range(row):
		for j in range(col):
			if m[i][j] == 1:
				r[i] = 1
				c[j] = 1
	task = min(r.count(0), c.count(0))
	if task % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		b = list(map(int, input().split()))
		a.append(b)
	row = []
	col = []
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row.append(i)
				col.append(j)
	count = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0:
				if i in row:
					continue
				elif j in col:
					continue
				else:
					row.append(i)
					col.append(j)
					count += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


T = int(input())
for _ in range(T):
	(n, m) = tuple(map(int, input().split()))
	matrix = []
	min_n = n
	row_count = 0
	column = [0] * m
	for i in range(n):
		row = list(map(int, input().split()))
		single_count = row.count(1)
		for j in range(m):
			if row[j] == 1 and column[j] != 1:
				column[j] = 1
		local_min = n - single_count
		if single_count > 0:
			row_count = row_count + 1
	min_n = min_n - row_count
	min_m = column.count(0)
	turns = min(min_n, min_m)
	if turns % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for tt in range(t):
	(n, m) = map(int, input().split())
	rr = [0] * n
	cc = [0] * m
	for i in range(n):
		s = list(map(int, input().split()))
		rr[i] = sum(s)
		for j in range(m):
			if s[j] == 1:
				cc[j] += 1
	nrow = 0
	for i in range(n):
		if rr[i] == 0:
			nrow += 1
	ncol = 0
	for i in range(m):
		if cc[i] == 0:
			ncol += 1
	sol = min(ncol, nrow)
	if sol % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	arr = [list(map(int, input().split())) for ch in range(n)]
	r = 0
	c = 0
	for i in range(n):
		if 1 in arr[i]:
			pass
		else:
			r += 1
	for i in range(m):
		check = False
		for j in range(n):
			if arr[j][i] == 1:
				check = True
				break
		if check == False:
			c += 1
	if min(r, c) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


T = int(input())
for i in range(T):
	(n, m) = map(int, input().split())
	a = []
	v1 = [False for i in range(n)]
	v2 = [False for j in range(m)]
	for j in range(n):
		a.append([int(e) for e in input().split()])
		for k in range(m):
			if a[j][k] == 1:
				v1[j] = True
				v2[k] = True
	ans = 0
	for i in range(n):
		for j in range(m):
			if not v1[i] and (not v2[j]):
				v1[i] = True
				v2[j] = True
				ans += 1
	print('Ashish' if ans % 2 else 'Vivek')


for _ in range(int(input())):
	(r, c) = list(map(int, input().split()))
	matrix = []
	x = 0
	for i in range(r):
		matrix.append(list(map(int, input().split())))
	flag = 0
	for i in range(r):
		for j in range(c):
			if matrix[i][j] == 1:
				break
			if matrix[i][j] == 0:
				if 1 not in matrix[i][:]:
					x = 0
					for k in range(r):
						if matrix[k][j] == 1:
							x = 1
							break
					if flag == 0 and x == 0:
						matrix[i][j] = 1
						flag = 1
					elif flag == 1 and x == 0:
						matrix[i][j] = 1
						flag = 0
	if flag == 0:
		print('Vivek')
	elif flag == 1:
		print('Ashish')


t = int(input())
for _ in range(t):
	moves_x = 0
	moves_y = 0
	(n, m) = list(map(int, input().split()))
	board = []
	for i in range(n):
		board.append(list(map(int, input().split())))
		if not any(board[i]):
			moves_y += 1
	for i in range(m):
		a = []
		for j in range(n):
			a.append(board[j][i])
		if not any(a):
			moves_x += 1
	moves = min(moves_y, moves_x)
	if moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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

def solve():
	(n, m) = inp()
	a = []
	strok = 0
	stol = 0
	for i in range(n):
		x = list(inp())
		if x.count(1) == 0:
			strok += 1
		a.append(x)
	for j in range(m):
		fl = True
		for i in range(n):
			if a[i][j] == 1:
				fl = False
				break
		if fl:
			stol += 1
	res = min(strok, stol)
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')

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


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split(' '))
	mat = []
	for ni in range(n):
		row = []
		for num in input().split(' '):
			row.append(int(num))
		mat.append(row)
	rfill = 0
	for r in mat:
		if sum(r) > 0:
			rfill += 1
	cfill = 0
	for c in range(m):
		if sum([mat[i][c] for i in range(len(mat))]) > 0:
			cfill += 1
	turns = min(n - rfill, m - cfill)
	if turns % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math, sys
from sys import stdin, stdout
from collections import Counter, defaultdict, deque
input = stdin.readline
I = lambda : int(input())
li = lambda : list(map(int, input().split()))

def solve():
	(n, m) = li()
	a = []
	f = 0
	for i in range(n):
		a.append(li())
	for i in range(n):
		for j in range(m):
			f1 = 1
			for k in range(m):
				if a[i][k] == 0:
					f1 *= 1
				else:
					f1 *= 0
			for k in range(n):
				if a[k][j] == 0:
					f1 *= 1
				else:
					f1 *= 0
			if f1 == 1:
				a[i][j] = 1
				f += 1
	if f % 2:
		print('Ashish')
	else:
		print('Vivek')
for _ in range(I()):
	solve()


def solve_test_case(t):
	(n, m) = parse_array(int)
	grid = []
	for i in range(n):
		grid.append(parse_array(int))
	n_rows_claimed = 0
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 1:
				n_rows_claimed += 1
				break
	n_cols_claimed = 0
	for j in range(m):
		for i in range(n):
			if grid[i][j] == 1:
				n_cols_claimed += 1
				break
	to_claim = min(n - n_rows_claimed, m - n_cols_claimed)
	if to_claim % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')

def parse_array(f):
	return list(map(f, input().split()))

def solve():
	T = int(input())
	for t in range(T):
		solve_test_case(t)
solve()


t = int(input())
while t != 0:
	(n, m) = map(int, input().split())
	t -= 1
	total = n
	ans = []
	while total != 0:
		nums = list(map(int, input().split()))
		ans.append(nums)
		total -= 1
	possible = [[True] * m for _ in range(n)]
	for i in range(n):
		for j in range(m):
			if ans[i][j] == 1:
				ans[i][j] = 0
				possible[i] = [False] * m
				for k in range(n):
					possible[k][j] = False
	turn = 0
	allFalse = False
	while not allFalse:
		allFalse = True
		for i in range(n):
			for j in range(m):
				if possible[i][j] == True:
					turn += 1
					allFalse = False
					ans[i][j] = 0
					possible[i] = [False] * m
					for k in range(n):
						possible[k][j] = False
	if turn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	rows = [0] * n
	cols = [0] * m
	for i in range(n):
		for j in range(m):
			rows[i] |= a[i][j]
			cols[j] |= a[i][j]
	r = [False] * n
	c = [False] * m
	for i in range(n):
		for j in range(m):
			if not (rows[i] or cols[j]):
				r[i] = True
				c[j] = True
	res = min(sum(r), sum(c))
	print('Ashish' if res % 2 else 'Vivek')


for _ in range(int(input())):
	(a, b) = map(int, input().split())
	A = a
	se = set()
	for i in range(a):
		s = map(int, input().split())
		s = list(s)
		if any(s):
			A -= 1
		for (j, x) in enumerate(s):
			if x == 1:
				se.add(j)
	b -= len(se)
	a = min(A, b)
	if a % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
for t in range(int(input())):
	(n, m) = [int(x) for x in input().split()]
	mat = []
	for i in range(n):
		l = [int(x) for x in input().split()]
		mat.append(l)
	s_r = []
	s_c = []
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				s_r.append(i + 1)
				s_c.append(j + 1)
	a_r = set(s_r)
	a_c = set(s_c)
	l_r = len(a_r)
	l_c = len(a_c)
	z = 0
	while l_r < n and l_c < m:
		l_r += 1
		l_c += 1
		z += 1
	if z % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for x in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	for row in range(n):
		matrix.append(list(map(int, input().split())))
	row = len(matrix) - sum([1 if sum(row) > 0 else 0 for row in matrix])
	col = len(matrix[0]) - sum([1 if sum([row[i] for row in matrix]) > 0 else 0 for i in range(len(matrix[0]))])
	min_v = min(row, col)
	if min_v & 1:
		print('Ashish')
	else:
		print('Vivek')


import sys
cont = sys.stdin.readlines()
cont = [i.strip('\n').split() for i in cont]
numTests = int(cont.pop(0)[0])
ind = 0
newCont = []
for i in range(numTests):
	n = int(cont[0][0])
	newCont.append(cont[:n + 1])
	cont = cont[n + 1:]
ans = []
for case in newCont:
	(n, m) = case.pop(0)
	(n, m) = (int(n), int(m))
	for i in range(n):
		for j in range(m):
			case[i][j] = int(case[i][j])
	(numRows, numCols) = (0, 0)
	for i in case:
		if 1 in i:
			numRows += 1
	for colInd in range(m):
		for i in range(n):
			if case[i][colInd] == 1:
				numCols += 1
				break
	numRows = n - numRows
	numCols = m - numCols
	ans.append(min(numRows, numCols))
for i in ans:
	if i % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout
for _ in range(int(stdin.readline())):
	(n, m) = map(int, stdin.readline().split())
	ar = []
	for i in range(n):
		ar.append(stdin.readline().split())
	r = []
	c = []
	for i in range(n):
		if '1' not in ar[i]:
			r.append(i)
	for i in range(m):
		f = True
		for j in range(n):
			if ar[j][i] != '0':
				f = False
				break
		if f:
			c.append(j)
	ans = min(len(r), len(c))
	if ans % 2 == 1:
		stdout.write('Ashish\n')
	else:
		stdout.write('Vivek\n')


l = []
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l2 = []
	l3 = []
	l4 = []
	for i in range(n):
		l1 = list(map(int, input().split()))
		l2.append(l1)
	for i in range(m):
		l3 = []
		for j in range(n):
			l3.append(l2[j][i])
		l4.append(l3)
	ssum = 0
	c = 0
	for i in range(n):
		if l2[i].count(1) == 0:
			for j in range(m):
				if l4[j].count(1) == 0:
					c += 1
					l4[j][i] = 1
					break
	if c % 2 == 0:
		l.append('Vivek')
	else:
		l.append('Ashish')
for i in l:
	print(i)


for test_i in range(int(input())):
	(n, m) = map(int, input().split())
	rows = n
	free_cols = [True for i in range(m)]
	for i in range(n):
		row = list(map(int, input().split()))
		if 1 in row:
			rows -= 1
		for i in range(m):
			if row[i]:
				free_cols[i] = False
	cols = sum(free_cols)
	print('Ashish' if min(rows, cols) % 2 else 'Vivek')


t = int(input().strip())
while t > 0:
	(n, m) = map(int, input().strip().split())
	rows = [0 for i in range(0, n)]
	columns = [0 for j in range(0, m)]
	for i in range(0, n):
		y = [int(x) for x in input().split()]
		for j in range(0, m):
			if y[j]:
				rows[i] = 1
				columns[j] = 1
	cnt = min(n - sum(rows), m - sum(columns))
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	ra = []
	ca = []
	for z in range(n):
		a = []
		for y in input().split():
			a.append(int(y))
			if a[-1] == 1:
				if not len(a) in ca:
					ca.append(len(a))
		if not 1 in a:
			ra.append(z + 1)
	c = 0
	vm = m - len(ca)
	while len(ra) * vm != 0:
		ra.pop()
		vm -= 1
		c += 1
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	(r, c) = ([0] * n, [0] * m)
	for i in range(n):
		a = [int(x) for x in input().split()]
		for j in range(len(a)):
			if a[j] == 1:
				c[j] = 1
				r[i] = 1
	ans = 0
	rn = n - sum(r)
	cn = m - sum(c)
	while rn and cn:
		ans += 1
		rn -= 1
		cn -= 1
	print('Vivek' if ans % 2 == 0 else '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, m) = nm()
	a = [nl() for _ in range(n)]
	f = sum((sum(x) == 0 for x in a))
	g = sum((sum([a[i][j] for i in range(n)]) == 0 for j in range(m)))
	f = min(f, g)
	print('Ashish' if f & 1 else 'Vivek')
	return
T = int(input())
for _ in range(T):
	solve()


def main():
	(n, m) = map(int, input().split())
	rows = [1] * n
	cols = [1] * m
	for i in range(n):
		row = input().split()
		for c in range(m):
			if row[c] == '1':
				rows[i] = 0
				cols[c] = 0
	s = min(sum(rows), sum(cols))
	if s % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
for _ in range(int(input())):
	main()


def solve(a):
	row = len(a) - sum([1 if sum(row) > 0 else 0 for row in a])
	col = len(a[0]) - sum([1 if sum([row[i] for row in a]) > 0 else 0 for i in range(len(a[0]))])
	minrc = min(row, col)
	if minrc % 2:
		return 'Ashish'
	return 'Vivek'
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for _ in range(n):
		a.append(list(map(int, input().split())))
	ans = solve(a)
	print(ans)


def get_info():
	(n, m) = list(map(int, input().split()))
	M = []
	for i in range(n):
		M.append(list(map(int, input().split())))
	return (M, n, m)

def check_winner(M, n, m):
	col = list(range(m))
	raw = list(range(n))
	for i in range(n):
		for j in range(m):
			if M[i][j] == 1:
				if i in raw:
					raw.remove(i)
				if j in col:
					col.remove(j)
	coups_restants = min(len(col), len(raw))
	if coups_restants % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for _ in range(t):
	(M, n, m) = get_info()
	check_winner(M, n, m)


import sys, collections, math

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

def col_safe(matrix, j, m):
	for i in range(0, m):
		if matrix[i][j] == 1:
			return False
	return True
for _ in range(int(input())):
	(m, n) = map(int, input().split())
	matrix = []
	move = 0
	for i in range(m):
		arr = list(map(int, input().split()))
		matrix.append(arr)
	for i in range(m):
		for j in range(n):
			if 1 in matrix[i]:
				continue
			elif col_safe(matrix, j, m):
				matrix[i][j] = 1
				move = 0 if move == 1 else 1
	if move == 1:
		print('Ashish')
	else:
		print('Vivek')


def check(I, J, l):
	for j in range(a):
		if 1 in l[j] and (not j in I):
			I.append(j)
		for k in range(b):
			if l[j][k] == 1 and (not k in J):
				J.append(k)
for i in range(int(input())):
	(a, b) = map(int, input().split())
	l = []
	for j in range(a):
		l.append(list(map(int, input().split())))
	I = []
	J = []
	c = 0
	check(I, J, l)
	while len(I) < a and len(J) < b:
		check(I, J, l)
		x = 0
		y = 0
		for x in range(a):
			if not x in I:
				break
		for y in range(b):
			if not y in J:
				break
		l[x][y] = 1
		c += 1
	if c == 0:
		print('Vivek')
	elif c % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	grid = []
	rowsEmpty = 0
	collumsEmpty = 0
	for i in range(n):
		row = list(map(int, input().split()))
		if 1 not in row:
			rowsEmpty += 1
		grid.append(row)
	for i in range(m):
		empty = True
		for j in range(n):
			if grid[j][i] == 1:
				empty = False
				break
		if empty == True:
			collumsEmpty += 1
	if min(rowsEmpty, collumsEmpty) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	count = 0
	s_col = set()
	s_col1 = []
	s_row = 0
	count = 0
	for r in range(n):
		row = list(map(int, input().split()))
		l = len(s_col1)
		for i in range(m):
			if row[i] == 1:
				s_col1.append(i)
		if l == len(s_col1):
			s_row += 1
	s_col = set(s_col1)
	for i in range(s_row):
		for k in range(m):
			if k not in s_col:
				count += 1
				s_col.add(k)
				break
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	mat = []
	(a, b) = (set(), set())
	for _ in range(n):
		mat.append(list(map(int, input().split())))
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				a.add(i)
				b.add(j)
	chk = min(n - len(a), m - len(b))
	if chk % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	rows = [0] * n
	columns = [0] * m
	for x in range(n):
		t = [int(i) for i in input().split()]
		for y in range(m):
			if t[y] == 1:
				columns[y] = 1
				rows[x] = 1
	ans = min(columns.count(0), rows.count(0))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(r, c) = map(int, input().strip().split(' '))
	l = []
	for j in range(0, c):
		l.append(j)
	lst = 0
	for j in range(r):
		lst1 = list(map(int, input().strip().split(' ')))
		if 1 in lst1:
			lst1 = [index for (index, value) in enumerate(lst1) if value == 1]
			l = [i for i in l if i not in lst1]
		else:
			lst += 1
	m = min(len(l), lst)
	if m % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	columns_0 = set()
	columns_1 = set()
	rows_0 = set()
	for i in range(n):
		a = list(map(int, input().split()))
		fl = 0
		for (j, el) in enumerate(a):
			if el == 0:
				columns_0.add(j)
			else:
				columns_1.add(j)
				fl = 1
		if fl == 0:
			rows_0.add(i)
	l = min(len(list(columns_0.difference(columns_1))), len(list(rows_0)))
	if l % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	a = [[0] * m for i in range(n)]
	for i in range(n):
		a[i] = list(map(int, input().split()))
	row = [0] * n
	col = [0] * m
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row[i] += 1
				col[j] += 1
	x = 0
	y = 0
	for i in range(n):
		if row[i] == 0:
			x = x + 1
	for j in range(m):
		if col[j] == 0:
			y = y + 1
	if min(x, y) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


def solve(n, m, a):
	rn = 0
	cols = [True] * m
	for i in range(n):
		tr = True
		for j in range(m):
			if a[i][j]:
				cols[j] = False
				tr = False
		if tr:
			rn += 1
	cn = len(list(filter(bool, cols)))
	return min(rn, cn) % 2 != 0
t = int(input())
for i_t in range(t):
	[n, m] = list(map(int, input().split(' ')))
	a = [None] * n
	for i in range(n):
		a[i] = list(map(int, input().split(' ')))
	print('Ashish' if solve(n, m, a) else 'Vivek')


T = int(input())
A = []
for i in range(0, T):
	(m, n) = [int(x) for x in input().split(' ')]
	R = []
	rows = []
	columns = []
	for j in range(0, m):
		S = [int(x) for x in input().split(' ')]
		R.append(S)
		if R[j].count(1) > 0:
			rows.append(j)
		for k in range(0, n):
			if R[j][k] == 1 and k not in columns:
				columns.append(k)
	s = min(m - len(rows), n - len(columns))
	if s % 2 == 1:
		A.append('Ashish')
	else:
		A.append('Vivek')
for i in A:
	print(i)


t = int(input())
for we in range(t):
	(n, m) = map(int, input().split())
	l = []
	row = set()
	col = set()
	for i in range(n):
		k = list(map(int, input().split()))
		for j in range(m):
			if k[j] == 1:
				row.add(i)
				col.add(j)
	row = n - len(row)
	col = m - len(col)
	f = min(row, col)
	if f % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


import sys
import string
import math
import bisect as bi
from collections import defaultdict as dd
input = sys.stdin.readline

def cin():
	return map(int, sin().split())

def ain():
	return list(map(int, sin().split()))

def sin():
	return input()

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

def pref(a, n):
	pre = [0] * n
	pre[0] = a[0]
	for i in range(1, n):
		pre[i] = a[i] + pre[i - 1]
	return pre
for i in range(inin()):
	(n, m) = cin()
	l = []
	row = []
	col = []
	tran = [[0] * n for i in range(m)]
	for i in range(n):
		l.append(ain())
		if l[i].count(1) == 0:
			row += [i]
	for i in range(n):
		for j in range(m):
			tran[j][i] = l[i][j]
	if row == []:
		print('Vivek')
	else:
		for j in range(m):
			if tran[j].count(1) == 0:
				col += [j]
		if col == []:
			print('Vivek')
		else:
			mi = min(len(row), len(col))
			if mi % 2 == 0:
				print('Vivek')
			else:
				print('Ashish')


def task_A():
	t = int(input())
	for _ in range(t):
		(n, m) = map(int, input().split())
		grid = []
		for i in range(n):
			grid.append(list(map(int, input().split())))
		free_rows = 0
		free_cols = 0
		for i in range(n):
			if sum(grid[i]) == 0:
				free_cols += 1
		for i in range(m):
			curr_sum = 0
			for j in range(n):
				curr_sum += grid[j][i]
			if curr_sum == 0:
				free_rows += 1
		moves = min(free_rows, free_cols)
		if moves % 2:
			print('Ashish')
		else:
			print('Vivek')

def main():
	task_A()
main()


def check(n, k, p):
	c = 0
	for i in range(len(arr)):
		if arr[i] <= n or p % 2:
			c += 1
			p += 1
		if c == k:
			return True
	return False
for _ in range(int(input())):
	(ro, cfv) = map(int, input().split())
	k = []
	for _ in range(ro):
		k.append(list(map(int, input().split())))
	n = ro
	r = [0] * n
	c = [0] * cfv
	l = k
	cnt = 0
	for i in range(ro):
		for k in range(cfv):
			if l[i][k]:
				r[i] = 1
				c[k] = 1
	for i in range(ro):
		for k in range(cfv):
			if r[i] != 1 and c[k] != 1:
				cnt += 1
				r[i] = 1
				c[k] = 1
	if cnt & 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	b = []
	s1 = 0
	for i in range(n):
		b.append(list(map(int, input().split())))
	for j in b:
		if sum(j) == 0:
			s1 += 1
	s2 = 0
	for k in range(m):
		h = 0
		for l in range(n):
			h += b[l][k]
		if h == 0:
			s2 += 1
	if min(s1, s2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	y = 0
	x = 0
	(n, m) = [int(i) for i in input().split()]
	sp_x = []
	for i in range(n):
		f_x = True
		row = input()
		for j in range(0, len(row), 2):
			el = int(row[j])
			if el == 1:
				if f_x:
					x += 1
					f_x = False
				if j not in sp_x:
					y += 1
					sp_x.append(j)
	if min((n - x, m - y)) % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


import sys
Ri = lambda : [int(x) for x in sys.stdin.readline().split()]
ri = lambda : sys.stdin.readline().strip()
for _ in range(int(ri())):
	(n, m) = Ri()
	arr = []
	for i in range(n):
		temp = Ri()
		arr.append(temp)
	row = set([i for i in range(n)])
	col = set([i for i in range(m)])
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				if i in row:
					row.remove(i)
				if j in col:
					col.remove(j)
	ans = min(len(row), len(col))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t > 0:
	(n, m) = map(int, input().split())
	_list = []
	for i in range(n):
		_list.append(list(map(int, input().split())))
	empty_rows = 0
	for i in range(n):
		counter = 0
		for j in range(m):
			counter += _list[i][j]
		if counter == 0:
			empty_rows += 1
	empty_cols = 0
	for i in range(m):
		counter = 0
		for j in range(n):
			counter += _list[j][i]
		if counter == 0:
			empty_cols += 1
	steps = min(empty_cols, empty_rows)
	if steps % 2:
		print('Ashish')
	else:
		print('Vivek')
	t -= 1


for _ in range(int(input())):
	mat = []
	(n, m) = map(int, input().split())
	for i in range(n):
		arr = list(map(int, input().split()))
		mat.append(arr)
	row = [0 for i in range(n + 1)]
	col = [0 for i in range(m + 1)]
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				row[i + 1] = 1
				col[j + 1] = 1
	cnt = 0
	for i in range(1, n + 1):
		if row[i] == 0:
			cnt += 1
	cnt1 = 0
	for i in range(1, m + 1):
		if col[i] == 0:
			cnt1 += 1
	cnt = min(cnt, cnt1)
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append([int(i) for i in input().split()])
	b = set(range(n))
	c = set(range(m))
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				if i in b:
					b.remove(i)
				if j in c:
					c.remove(j)
	if min(len(b), len(c)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = [int(x) for x in input().split()]
	isclaimed_cols = [0] * m
	isclaimed_rows = [0] * n
	for j in range(n):
		mat_n = [int(x) for x in input().split()]
		loc = [i for (i, x) in enumerate(mat_n) if x == 1]
		if len(loc) > 0:
			isclaimed_rows[j] = 1
			for k in range(len(loc)):
				isclaimed_cols[loc[k]] = 1
	tmp1 = n - sum(isclaimed_rows)
	tmp2 = m - sum(isclaimed_cols)
	if min(tmp1, tmp2) % 2 < 1:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	rows = []
	for i in range(n):
		row = list(map(int, input().split()))
		rows.append(row)
	empty_rows = 0
	for row in rows:
		if not any(row):
			empty_rows += 1
	empty_cols = 0
	for i in range(m):
		if not any(list(map(lambda x: x[i], rows))):
			empty_cols += 1
	valid_moves = min(empty_cols, empty_rows)
	if valid_moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	A = [[int(i) for i in input().split()] for _ in range(n)]
	(r, c) = ([1 for _ in range(n)], [1 for _ in range(m)])
	for i in range(n):
		for j in range(m):
			if A[i][j] == 1:
				r[i] = 0
				c[j] = 0
	res = min(sum(r), sum(c))
	if res % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().strip().split()))
	list1 = []
	for _ in range(n):
		temp = list(map(int, input().strip().split()))
		list1.append(temp)
	bad_row = set()
	bad_col = set()
	for i in range(n):
		for j in range(m):
			if list1[i][j] == 1:
				bad_row.add(i)
				bad_col.add(j)
	good_row = n - len(bad_row)
	good_col = m - len(bad_col)
	num = min(good_row, good_col)
	if num % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def main():
	t = int(input())
	for _ in range(t):
		(n, m) = map(int, input().split())
		(a, b) = ([0] * n, [0] * m)
		for i in range(n):
			s = list(map(int, input().split()))
			a[i] = sum(s)
			for j in range(m):
				b[j] += s[j]
		cnt = 0
		if 0 in a and 0 in b:
			cnt = min([a.count(0), b.count(0)])
		print('Vivek' if cnt % 2 == 0 else 'Ashish')
main()


import sys
import math
from collections import defaultdict, deque
import heapq
t = int(sys.stdin.readline())
for _ in range(t):
	(n, m) = map(int, sys.stdin.readline().split())
	grid = []
	for i in range(n):
		l = list(map(int, sys.stdin.readline().split()))
		grid.append(l)
	row = defaultdict(int)
	col = defaultdict(int)
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 1:
				row[i] += 1
				col[j] += 1
	cnt = 0
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 0 and row[i] == 0 and (col[j] == 0):
				cnt += 1
				row[i] += 1
				col[j] += 1
				break
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	cnt = 0
	flag = 0
	st_col = set()
	st_row = set()
	win = False
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				st_col.add(j)
				st_row.add(i)
	for i in range(n):
		for j in range(m):
			if i not in st_row and j not in st_col:
				win = not win
				st_row.add(i)
				st_col.add(j)
				break
	if win == False:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(row, col) = [int(x) for x in input().split()]
	matrix = []
	for i in range(row):
		matrix.append([int(x) for x in input().split()])
	occupied_row = 0
	for r in range(row):
		for c in range(col):
			if matrix[r][c] == 1:
				occupied_row += 1
				break
	occupied_col = 0
	for c in range(col):
		for r in range(row):
			if matrix[r][c] == 1:
				occupied_col += 1
				break
	free_col = col - occupied_col
	free_row = row - occupied_row
	turn = min(free_col, free_row)
	if turn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t > 0:
	(n, m) = map(int, input().split())
	moves = n * m
	matrix = []
	for i in range(n):
		a = list(map(int, input().split()))
		matrix.append(a)
	row = list([0] * n)
	col = list([0] * m)
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				row[i] = 1
				col[j] = 1
	count = 0
	for i in range(n):
		for j in range(m):
			if row[i] == 0 and col[j] == 0:
				count += 1
				row[i] = 1
				col[j] = 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


import sys
from collections import defaultdict as dd
from collections import deque
from functools import *
from fractions import Fraction as f
from copy import *
from bisect import *
from heapq import *
from math import *
from itertools import permutations, product

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

def inc(d, c):
	d[c] = d[c] + 1 if c in d else 1

def bo(i):
	return ord(i) - ord('A')

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

def fli():
	return [float(x) for x in input().split()]

def comp(a, b):
	if a > b:
		return 2
	return 2 if a == b else 0

def gi():
	return [xx for xx in input().split()]

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

def pro(a):
	return reduce(lambda a, b: a * b, a)

def swap(a, i, j):
	(a[i], a[j]) = (a[j], a[i])

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

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

def gh():
	sys.stdout.flush()

def isvalid(i, j):
	return 0 <= i < n and 0 <= j < n

def bo(i):
	return ord(i) - ord('a')

def graph(n, m):
	for i in range(m):
		(x, y) = mi()
		a[x].append(y)
		a[y].append(x)
t = fi()
while t > 0:
	t -= 1
	(n, m) = mi()
	a = []
	for i in range(n):
		a.append(li())
	r = [0] * n
	c = [0] * m
	for i in range(n):
		for j in range(m):
			r[i] |= a[i][j]
			c[j] |= a[i][j]
	print('Ashish' if min(r.count(0), c.count(0)) % 2 else 'Vivek')


import sys
input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	mat = [list(map(int, input().split())) for _ in range(n)]
	r = []
	c = []
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				if j not in r:
					r.append(j)
				if i not in c:
					c.append(i)
	claims = min(n - len(c), m - len(r))
	print('Ashish' if claims % 2 == 1 else 'Vivek')


CASES = int(input())
for _ in range(CASES):
	(m, n) = map(int, input().split())
	available = min(m, n)
	num_rows = 0
	cols = set()
	for i in range(m):
		s = list(map(int, input().split()))
		temp = 0
		for j in range(len(s)):
			if s[j] == 1:
				cols.add(j)
				temp = 1
		num_rows += temp
	num_cols = len(cols)
	covered = max(num_rows, num_cols)
	available = min(m - num_rows, n - num_cols)
	if available % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	r = {}
	c = {}
	for i in range(n):
		a = list(map(int, input().split()))
		l.append(a)
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				if i not in r:
					r[i] = 1
				if j not in c:
					c[j] = 1
	mn = min(n - len(r), m - len(c))
	if mn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for l in range(t):
	B = []
	C = []
	(n, m) = list(map(int, input().split()))
	a = n
	b = m
	A = list()
	for i in range(n):
		A.append(list(map(int, input().split())))
	for i in range(a):
		for j in range(b):
			if A[i][j] == 1:
				if i not in B:
					B.append(i)
					n -= 1
				if j not in C:
					C.append(j)
					m -= 1
	ans = min(n, m)
	if ans % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


def matrix_game(matrix):
	possible_moves = 0
	for (n, row) in enumerate(matrix):
		for (m, cell) in enumerate(row):
			valid = True
			if cell == '1':
				valid = False
				break
			for i in row:
				if i == '1':
					valid = False
					break
			for r in matrix:
				if r[m] == '1':
					valid = False
					break
			if valid:
				possible_moves += 1
				matrix[n][m] = '1'
				break
	if possible_moves % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
t = int(input())
for test in range(t):
	dim = input()
	dim = dim.split()
	n = int(dim[0])
	matrix = []
	for i in range(n):
		l = input()
		l = l.split()
		matrix.append(l)
	ans = matrix_game(matrix)
	print(ans)


q = int(input())
for _ in range(q):
	(n, m) = map(int, input().split())
	a = 0
	live = [True] * m
	for _ in range(n):
		dat = list(map(int, input().split()))
		for i in range(m):
			if dat[i] == 1:
				live[i] = False
		a += 1 if dat.count(1) == 0 else 0
	b = live.count(True)
	a = min(a, b)
	print('Vivek' if a % 2 == 0 else 'Ashish')


t = int(input())
for x in range(t):
	a_v = 0
	(n, m) = input().split()
	n_list = []
	m_list = []
	for z in range(int(n)):
		n_list.append(z)
	for z in range(int(m)):
		m_list.append(z)
	for y in range(int(n)):
		i = input().split()
		j = 0
		for w in i:
			if w == '1':
				if y in n_list:
					n_list.remove(y)
				if j in m_list:
					m_list.remove(j)
			j += 1
	while n_list != [] and m_list != []:
		a_v += 1
		n_list.pop()
		m_list.pop()
	if a_v % 2 == 0 or a_v == 0:
		print('Vivek')
	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
sys.setrecursionlimit(10 ** 2)

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 ri():
	return int(f.readline().strip())

def ria():
	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 rs():
	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(a, n, m):
	cols = set(range(m))
	rows = set(range(n))
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				if j in cols:
					cols.remove(j)
				if i in rows:
					rows.remove(i)
	if min(len(cols), len(rows)) % 2:
		return 'Ashish'
	return 'Vivek'

def main():
	T = ri()
	for i in range(T):
		(n, m) = ria()
		a = []
		for j in range(n):
			a.append(ria())
		x = solution(a, n, m)
		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 i in range(t):
	s = input()
	l = s.split(' ')
	n = int(l[0])
	m = int(l[1])
	matrix = []
	for j in range(n):
		line = input()
		row = line.split(' ')
		row_final = []
		for k in range(m):
			row_final.append(int(row[k]))
		matrix.append(row_final)
	empty_rows = []
	empty_cols = []
	for j in range(n):
		if not 1 in matrix[j]:
			empty_rows.append(j)
	for j in range(m):
		col = []
		for k in range(n):
			col.append(matrix[k][j])
		if not 1 in col:
			empty_cols.append(j)
	res = min(len(empty_cols), len(empty_rows))
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout
import math
n = int(stdin.readline())
for i in range(n):
	size = [int(x) for x in stdin.readline().split()]
	data = []
	for i in range(size[0]):
		data.append([int(x) for x in stdin.readline().split()])
	least = 0
	if size[0] > size[1]:
		least = 1
	col = [0] * size[1]
	row = [0] * size[0]
	for i in range(size[0]):
		for j in range(size[1]):
			if data[i][j]:
				col[j] = 1
				row[i] = 1
	rem_col = size[1] - sum(col)
	rem_row = size[0] - sum(row)
	if min(rem_col, rem_row) % 2:
		stdout.write('Ashish \n')
	else:
		stdout.write('Vivek \n')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	rows = []
	cols = []
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				rows.append(i)
				cols.append(j)
	if min(n - len(set(rows)), m - len(set(cols))) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
while t:
	(n, m) = [int(i) for i in input().split()]
	mat = []
	for i in range(n):
		mat.append([int(i) for i in input().split()])
	rows = set([i for i in range(n)])
	columns = set([i for i in range(m)])
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				if i in rows:
					rows.remove(i)
				if j in columns:
					columns.remove(j)
	l = min(len(rows), len(columns))
	winner = ['Ashish', 'Vivek']
	print(winner[l % 2 - 1])
	t -= 1


t = int(input())
c = []
for i in range(t):
	(n, m) = input().split()
	(n, m) = (int(n), int(m))
	a = []
	x = 0
	for j in range(n):
		p = [int(i) for i in input().split()]
		a.append(p)
		if 1 not in p:
			x += 1
	y = 0
	for i in range(m):
		o = 0
		for j in range(n):
			if a[j][i] == 1:
				o = 1
				break
		if o == 0:
			y += 1
	v = min(x, y)
	if v % 2 == 0:
		c.append('Vivek')
	else:
		c.append('Ashish')
for k in c:
	print(k)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	lst1 = []
	(cnt1, cnt2) = (0, 0)
	for i in range(n):
		lst = list(map(int, input().split()))
		if 1 not in lst:
			cnt1 += 1
		lst1.append(lst)
	for i in range(m):
		for j in range(n):
			if lst1[j][i] == 1:
				cnt2 += 1
				break
	if min(cnt1, m - cnt2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from operator import add
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	(j, x) = ([0] * m, 0)
	for k in range(n):
		s = list(map(int, input().split()))
		if 1 in s:
			j = [a + b for (a, b) in zip(j, s)]
		else:
			x += 1
	x = min(x, j.count(0))
	print('Ashish' if x % 2 == 1 else 'Vivek')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	row = [0 for i in range(n)]
	col = [0 for i in range(m)]
	for j in range(n):
		l = list(map(int, input().split()))
		for k in range(m):
			if l[k] == 1:
				row[j] = 1
				col[k] = 1
	a = col.count(0)
	b = row.count(0)
	c = min(a, b)
	if c % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


q = int(input())
while q:
	q -= 1
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	g = 0
	v = 0
	for i in range(n):
		f = 1
		for j in range(m):
			if a[i][j] == 1:
				f = 0
		g += f
	for i in range(m):
		f = 1
		for j in range(n):
			if a[j][i] == 1:
				f = 0
		v += f
	if g > v:
		g = v
	if g % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


tc = int(input())
for _ in range(tc):
	(n, m) = map(int, input().split())
	arr = [list(map(int, input().split())) for _ in range(n)]
	cnt = [0, 0]
	for i in range(n):
		if 1 in arr[i]:
			continue
		else:
			cnt[0] += 1
	for i in range(m):
		flag = 1
		for j in range(n):
			if arr[j][i]:
				flag = 0
				break
		if flag:
			cnt[1] += 1
	if min(cnt) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from math import *
t = int(input())
for y in range(t):
	(n, m) = list(map(int, input().split()))
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	(r, c) = (0, 0)
	for i in range(n):
		ct = 0
		for j in range(m):
			if a[i][j] == 0:
				ct += 1
		if ct == m:
			r += 1
	for i in range(m):
		ct = 0
		for j in range(n):
			if a[j][i] == 0:
				ct += 1
		if ct == n:
			c += 1
	x = min(r, c)
	if x & 1:
		print('Ashish')
	else:
		print('Vivek')


def check(mat, row, col, n, m):
	for i in range(n):
		if mat[i][col] == 1:
			return False
	for i in range(m):
		if mat[row][i] == 1:
			return False
	return True

def update(vis, row, col, n, m):
	for i in range(n):
		vis[i][col] = False
	for i in range(m):
		vis[row][i] = False
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	vis = [[False] * m for t in range(n)]
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 0:
				if check(mat, i, j, n, m):
					vis[i][j] = True
	count = 1
	for i in range(n):
		for j in range(m):
			if vis[i][j] == True:
				count += 1
				update(vis, i, j, n, m)
	if count % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


T = int(input())
for i in range(T):
	(n, m) = map(int, input().split())
	row1 = []
	col1 = []
	count = 0
	X = []
	for _ in range(n):
		A = list(map(int, input().split()))
		X.append(A)
	for j in range(n):
		for k in range(m):
			if X[j][k] == 1:
				row1.append(j)
				col1.append(k)
	for j in range(len(X)):
		for k in range(len(X[0])):
			if X[j][k] == 0:
				if j not in row1 and k not in col1:
					count += 1
					row1.append(j)
					col1.append(k)
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	aij = [list(map(int, input().split())) for i in range(n)]
	an = [1 - max(aij[i]) for i in range(n)]
	aji = [[aij[j][i] for j in range(n)] for i in range(m)]
	am = [1 - max(aji[i]) for i in range(m)]
	if min(sum(an), sum(am)) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
s = []
for i in range(t):
	k = 0
	x = list(map(int, input().split()))
	n = x[0]
	m = x[1]
	indices1 = []
	mylist = []
	for j in range(n):
		y = list(map(str, input().split()))
		indices = [o for (o, z) in enumerate(y) if z == '1']
		indices1.append(indices)
		str1 = ' '
		str1 = str1.join(y)
		f = str1.find('1')
		if f == -1:
			k = k + 1
	for o in indices1:
		mylist.extend(o)
	unique = list(dict.fromkeys(mylist))
	l = len(unique)
	l1 = m - l
	l2 = min(l1, k)
	if l2 % 2 == 0:
		s.append('Vivek')
	else:
		s.append('Ashish')
for i in range(len(s)):
	print(s[i])


def solve(n, m, mat):
	ocr = [0] * n
	occ = [0] * m
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				occ[j] = 1
				ocr[i] = 1
	sumr = sum(ocr)
	sumc = sum(occ)
	if sumr == n or sumc == m:
		return 'Vivek'
	remr = n - sumr
	remc = m - sumc
	minn = min(remr, remc)
	if minn % 2 == 0:
		return 'Vivek'
	return 'Ashish'
t = int(input())
for _ in range(t):
	inp = input().split()
	(n, m) = (int(inp[0]), int(inp[1]))
	mat = []
	for _ in range(n):
		mat.append([int(x) for x in input().split()])
	print(solve(n, m, mat))


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	A = [0] * n
	for i in range(n):
		A[i] = list(map(int, input().split()))
	(cnt, acnt) = (0, 0)
	for i in range(n):
		for j in range(m):
			if A[i][j] == 1:
				cnt += 1
				break
	for i in range(m):
		for j in range(n):
			if A[j][i] == 1:
				acnt += 1
				break
	ans = min(n - cnt, m - acnt)
	if ans % 2:
		print('Ashish')
	else:
		print('Vivek')


import math
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	for j in range(n):
		matrix.append(input().split())
	fail_row = set()
	fail_col = set()
	for row in range(n):
		for col in range(m):
			if matrix[row][col] == '1':
				fail_row.add(row)
				fail_col.add(col)
	less = n - len(fail_row)
	if less > m - len(fail_col):
		less = m - len(fail_col)
	if less % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout
from math import gcd, sqrt
from collections import deque
input = stdin.readline
R = lambda : map(int, input().split())
I = lambda : int(input())
S = lambda : input().rstrip('\n')
P = lambda x: stdout.write(x)
hg = lambda x, y: (y + x - 1) // x * x
N = 10 ** 9 + 7
for _ in range(I()):
	(r, c) = R()
	cnt = 0
	a = [[0] * (c + 2)]
	for i in range(r):
		a.append([0] + list(R()) + [0])
	a.append([0] * (c + 2))
	for i in range(1, r + 1):
		for j in range(1, c + 1):
			if a[i].count(1) == 0:
				cn = 0
				for x in range(1, r + 1):
					if a[x][j] == 1:
						cn += 1
				if cn == 0:
					cnt += 1
					a[i][j] = 1
	if cnt % 2:
		print('Ashish')
	else:
		print('Vivek')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	A = [list(map(int, input().split())) for _ in range(n)]
	cols = set(range(m))
	rows = set(range(n))
	for (y, l) in enumerate(A):
		for (x, c) in enumerate(l):
			if c == 1:
				cols.discard(x)
				rows.discard(y)
	r = min(len(cols), len(rows))
	print('Ashish' if r % 2 == 1 else 'Vivek')


T = int(input())
for t in range(T):
	(n, m) = [int(i) for i in input().split()]
	A = [[int(j) for j in input().split()] for i in range(n)]
	row_set = set([int(i) for i in range(n)])
	col_set = set([int(i) for i in range(m)])
	remove_row = set()
	remove_col = set()
	for i in range(n):
		for j in range(m):
			if A[i][j] == 1:
				remove_row.add(i)
				remove_col.add(j)
	row_set = row_set.difference(remove_row)
	col_set = col_set.difference(remove_col)
	key = min(len(row_set), len(col_set))
	if key % 2:
		print('Ashish')
	else:
		print('Vivek')


import math
for w in range(int(input())):
	n = list(map(int, input().split()))
	cont = 0
	lit = list(map(int, input().split()))
	if 1 not in lit:
		cont += 1
	for x in range(n[0] - 1):
		aux = input().split()
		if '1' not in aux:
			cont += 1
		for i in range(len(aux)):
			lit[i] += int(aux[i])
	aux = 0
	if cont <= lit.count(0):
		aux = cont
	else:
		aux = lit.count(0)
	if aux % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	size = [int(x) for x in input().split()]
	n = size[0]
	m = size[1]
	array = [[int(x) for x in input().split()] for x in range(n)]
	row_index = []
	col_index = []
	for x in range(n):
		for y in range(m):
			if array[x][y] == 1:
				if x not in row_index:
					row_index.append(x)
				if y not in col_index:
					col_index.append(y)
	option = min(n - len(row_index), m - len(col_index))
	if option % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	row = col = 0
	for i in range(n):
		li = list(map(int, input().split()))
		mat.append(li)
		aa = li.count(0)
		if aa == m:
			row += 1
	c = 0
	for i in range(m):
		c = 0
		for j in range(n):
			if mat[j][i] != 0:
				c = 0
				break
			c += 1
		if c == n:
			col += 1
	if min(row, col) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = [list(map(int, input().split())) for i in range(n)]
	ans = res = 0
	for i in range(n):
		flag = False
		for j in range(m):
			if a[i][j] == 1:
				flag = True
				break
		if flag == False:
			ans += 1
	for i in range(m):
		flag = True
		for j in range(n):
			if a[j][i] == 1:
				flag = False
				break
		if flag:
			res += 1
	lol = min(ans, res)
	if lol & 1 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	l1 = set()
	l2 = set()
	for i in range(n):
		a = map(int, input().split())
		for (j, aa) in enumerate(a):
			if aa:
				l1.add(i)
				l2.add(j)
	l1 = n - len(l1)
	l2 = m - len(l2)
	print('Vivek' if min(l1, l2) % 2 == 0 else 'Ashish')


def solve(mat, n, m):
	turn = 0
	(row, col, moot) = (set(), set(), set())
	for i in range(n):
		if sum(mat[i]) > 0:
			moot.add(i)
			continue
		row.add(i)
	for j in range(m):
		col.add(j)
	for r in moot:
		for c in range(m):
			if mat[r][c] == 1 and c in col:
				col.remove(c)
	while len(row) > 0 and len(col) > 0:
		row.pop()
		col.pop()
		turn = 1 if turn == 0 else 0
	return 'Vivek' if turn == 0 else 'Ashish'
cases = int(input())
for _ in range(cases):
	(n, m) = map(int, input().split())
	mat = [[0 for _ in range(m)] for _ in range(n)]
	for i in range(n):
		row = list(map(int, input().split()))
		for j in range(m):
			mat[i][j] = row[j]
	print(solve(mat, n, m))


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	col = [True] * m
	row = [True] * n
	for j in range(n):
		temp = list(map(int, input().split()))
		for k in range(m):
			if temp[k]:
				col[k] = False
				row[j] = False
	t = min(col.count(True), row.count(True))
	if t % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline

def print(*args, end='\n', sep=' '):
	sys.stdout.write(sep.join(map(str, args)) + end)

def solve():
	(n, m) = map(int, input().split())
	mat = []
	rows = 0
	for i in range(n):
		mat.append(list(map(int, input().split())))
		if 1 not in mat[-1]:
			rows += 1
	cols = 0
	for col in zip(*mat):
		if 1 not in col:
			cols += 1
	available = min(rows, cols)
	print(['Vivek', 'Ashish'][available % 2])

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


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		temp = list(map(int, input().split()))
		l.append(temp)
	a = [0] * n
	b = [0] * m
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				a[i] = 1
				b[j] = 1
	x1 = len(a) - sum(a)
	x2 = len(b) - sum(b)
	if x1 < x2:
		c = 0
		for i in range(n):
			if a[i] == 0:
				j = 0
				while b[j] != 0:
					j += 1
					break
				b[j] = 1
				a[i] = 1
				c += 1
		if c % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
	else:
		c = 0
		for i in range(m):
			if b[i] == 0:
				j = 0
				while a[j] != 0:
					j += 1
					break
				a[j] = 1
				b[i] = 1
				c += 1
		if c % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	an = [1] * n
	am = [1] * m
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				an[i] = 0
				am[j] = 0
	m = sum(am)
	n = sum(an)
	if min(n, m) == 0:
		print('Vivek')
	elif min(n, m) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


from sys import stdin, stdout
q = int(input())
for k in range(q):
	(n, m) = list(map(int, stdin.readline().split()))
	claim = [[0 for i in range(m)] for i in range(n)]
	for i in range(n):
		claim[i] = list(map(int, stdin.readline().split()))
	cnt = 0
	l = min(n, m)
	row = [0 for i in range(n)]
	col = [0 for i in range(m)]
	for i in range(n):
		for j in range(m):
			if claim[i][j] == 1:
				row[i] = 1
				col[j] = 1
	rowvis = [0 for i in range(n)]
	colvis = [0 for i in range(m)]
	for i in range(n):
		for j in range(m):
			if row[i] == 0 and col[j] == 0:
				row[i] = 1
				col[j] = 1
				cnt += 1
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve(n, m, a):
	rows = [True] * n
	cols = [True] * m
	for r in range(n):
		for c in range(m):
			if a[r][c] == 1:
				rows[r] = False
				cols[c] = False
	turns = min(sum(rows), sum(cols))
	return turns % 2 == 0
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for _ in range(n):
		a.append(list(map(int, input().split())))
	print('Vivek' if solve(n, m, a) else 'Ashish')


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	matrix = []
	for i in range(n):
		row = list(map(int, input().split()))
		matrix.append(row)
	rows = [0] * n
	cols = [0] * m
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				rows[i] = 1
				cols[j] = 1
	iRow = 0
	iCol = 0
	plyr = 0
	while True:
		while iRow < n:
			if rows[iRow] == 0:
				break
			iRow += 1
		if iRow == n:
			break
		while iCol < m:
			if cols[iCol] == 0:
				break
			iCol += 1
		if iCol == m:
			break
		rows[iRow] = 1
		cols[iCol] = 1
		plyr ^= 1
	if plyr == 0:
		print('Vivek')
	if plyr == 1:
		print('Ashish')


t = int(input())
for test in range(t):
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	arr = []
	for i in range(n):
		l = list(map(int, input().split()))
		arr.append(l)
	rows = 0
	for i in range(n):
		flag = True
		for j in range(m):
			if arr[i][j] == 1:
				flag = False
				break
		if flag:
			rows += 1
	cols = 0
	for j in range(m):
		flag = True
		for i in range(n):
			if arr[i][j] == 1:
				flag = False
				break
		if flag:
			cols += 1
	if min(rows, cols) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
from math import log2, floor
TEST = 0
if TEST == 1:
	input_file = open('inputA.txt', 'r')
	input_from_file = input_file.readlines()

def read_int():
	if TEST:
		return int(input_from_file.pop(0))
	else:
		return int(sys.stdin.readline())

def read_ints():
	if TEST:
		return list(map(int, input_from_file.pop(0).rstrip().split()))
	else:
		return list(map(int, sys.stdin.readline().split()))
t = read_int()
for test in range(t):
	(n, m) = read_ints()
	open_col = [j for j in range(m)]
	open_row = []
	for j in range(n):
		current_row = read_ints()
		closed_in_row = [ind for (ind, el) in enumerate(current_row) if el == 1]
		if len(closed_in_row) == 0:
			open_row.append(j)
		for ind in closed_in_row:
			if ind in open_col:
				open_col.remove(ind)
	hodov = min(len(open_col), len(open_row))
	if hodov & 1:
		ans = 'Ashish'
	else:
		ans = 'Vivek'
	print(ans)


from sys import stdin, stdout
import collections
import heapq
import itertools
import functools
import math
import operator
import string
ALPHABET = string.ascii_lowercase
DIGITS = string.digits

def read_line():
	return stdin.readline().strip()

def read_int():
	return int(read_line())

def read_arr():
	return read_line().split(' ')

def read_int_arr():
	return [int(x) for x in read_arr()]

def query_interactive(s):
	print(s)
	stdout.flush()

def solve():
	(n, m) = read_int_arr()
	mat = []
	for _ in range(n):
		mat.append(read_int_arr())
	cols = [False] * m
	rows = [False] * n
	for r in range(n):
		for c in range(m):
			if mat[r][c] == 1:
				cols[c] = True
				rows[r] = True
	avail = min(cols.count(False), rows.count(False))
	if avail % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')

def main():
	T = 1
	T = read_int()
	for _ in range(T):
		solve()
main()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	x = 0
	y = 0
	l = []
	for i in range(n):
		s = input().split()
		if '1' not in s:
			x += 1
		l.append(s)
	for i in range(m):
		for j in range(n):
			if l[j][i] == '1':
				break
		else:
			y += 1
	if min(x, y) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from math import *
from sys import *
input = stdin.readline
for u in range(int(input())):
	(n, m) = map(int, input().split())
	c = 0
	l = []
	for i in range(n):
		d = list(map(int, input().split()))
		l.append(d)
		if 1 not in d:
			c = c + 1
	k = list(zip(*l))
	s = 0
	for i in range(m):
		if 1 not in k[i]:
			s += 1
	x = min(s, c)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
ans = []
for kek in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	strok = 0
	stolb = 0
	for i in range(n):
		s = 0
		for j in range(m):
			s += a[i][j]
		if s == 0:
			strok += 1
	for j in range(m):
		s = 0
		for i in range(n):
			s += a[i][j]
		if s == 0:
			stolb += 1
	s = min(stolb, strok)
	if s % 2 == 1:
		ans.append('Ashish')
	else:
		ans.append('Vivek')
print(*ans, sep='\n')


t = int(input())
for test in range(t):
	(n, m) = [int(x) for x in input().split()]
	matrix = []
	for i in range(n):
		row = [int(x) for x in input().split()]
		matrix.append(row)
	countr = 0
	countc = 0
	for i in range(n):
		delta = 0
		for j in range(m):
			if matrix[i][j] == 1:
				delta = 1
		countr += delta
	for j in range(m):
		delta = 0
		for i in range(n):
			if matrix[i][j] == 1:
				delta = 1
		countc += delta
	t1 = n - countr
	t2 = m - countc
	minn = min(t1, t2)
	if minn % 2:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	row = [0] * n
	column = [0] * m
	for i in range(n):
		array = list(map(int, input().split()))
		if array.count(1) > 0:
			row[i] = 1
			for (j, k) in enumerate(array):
				if k == 1:
					column[j] = 1
	winner = False
	for i in range(m):
		if column[i] == 0:
			for j in range(n):
				if row[j] == 0:
					row[j] = column[i] = 1
					winner ^= True
					break
	print('Ashish' if winner else 'Vivek')


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, m) = MP()
		r = [0] * n
		c = [0] * m
		ct = 0
		for i in range(n):
			arr = LS()
			cnt = arr.count(1)
			ct += cnt
			if cnt > 0:
				r[i] = 1
			for j in range(m):
				if arr[j] == 1:
					c[j] = 1
		ans = 0
		for i in range(n):
			for j in range(m):
				if r[i] == c[j] and r[i] == 0:
					ans += 1
					r[i] = 1
					c[j] = 1
		if ans & 1:
			print('Ashish')
		else:
			print('Vivek')
solve()


def solve():
	(n, m) = map(int, input().split())
	mat = []
	row = [0] * n
	col = [0] * m
	for i in range(n):
		l = list(map(int, input().split()))
		mat.append(l)
	for i in range(n):
		for j in range(m):
			if mat[i][j]:
				row[i] = 1
				col[j] = 1
	row1 = row.count(0)
	col1 = col.count(0)
	ans = min(row1, col1)
	if ans % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
t = input()
for loop in range(int(t)):
	print(solve())


import sys
input = sys.stdin.readline

def sear():
	for i in range(n):
		for j in range(m):
			if l[i][j] == 0:
				f = 0
				for a in range(m):
					if l[i][a] == 1:
						f = 1
						break
				if f:
					continue
				for a in range(n):
					if l[a][j] == 1:
						f = 1
						break
				if f:
					continue
				return (i, j)
	return (-1, -1)
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	c = 0
	while True:
		(x, y) = sear()
		if x == -1:
			if c % 2 == 0:
				print('Vivek')
			else:
				print('Ashish')
			break
		else:
			l[x][y] = 1
			c += 1


T = int(input())
for t_itr in range(T):
	(N, M) = map(int, input().split())
	A = []
	for _ in range(N):
		A.append(list(map(int, input().split())))
	X = [0 for _ in range(N)]
	Y = [0 for _ in range(M)]
	for i in range(N):
		for j in range(M):
			X[i] = X[i] | A[i][j]
			Y[j] = Y[j] | A[i][j]
	result = 0
	for i in range(N):
		if X[i] == 0:
			for j in range(M):
				if Y[j] == 0:
					Y[j] = 1
					X[i] = 1
					result += 1
					break
	if result % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	A = [list(map(int, input().split())) for i in range(n)]
	r = 0
	for i in range(n):
		for j in range(m):
			if A[i][j] == 1:
				r += 1
				break
	c = 0
	for j in range(m):
		for i in range(n):
			if A[i][j] == 1:
				c += 1
				break
	min_ = min(n - r, m - c)
	if min_ % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	rows = [0] * n
	cols = [0] * m
	pos = []
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				rows[i] = 1
				cols[j] = 1
			else:
				pos.append([i, j])
	c = 0
	for i in pos:
		if rows[i[0]] == 0 and cols[i[1]] == 0:
			c += 1
			rows[i[0]] = 1
			cols[i[1]] = 1
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def inp():
	ls = list(map(int, input().split()))
	return ls
n = int(input())
for ii in range(n):
	(n, m) = map(int, input().split())
	flag1 = [0] * n
	flag2 = [0] * m
	a = []
	k = 0
	for i in range(n):
		s = inp()
		a.append(s)
		for it in range(m):
			if s[it] == 1:
				flag2[it] = 1
				flag1[k] = 1
		k += 1
	turns = 0
	for i in range(n):
		if flag1[i] == 0:
			for j in range(m):
				if flag2[j] == 0:
					a[i][j] = 1
					flag2[j] = 1
					flag1[i] = 1
					turns += 1
					break
	if turns % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	ls = []
	row = [True for i in range(n)]
	coloumb = [True for i in range(m)]
	for i in range(n):
		ls.append(list(map(int, input().split())))
		if 1 in ls[i]:
			row[i] = False
		while True:
			if 1 in ls[i]:
				t = ls[i].index(1)
				coloumb[t] = False
				ls[i][t] = 0
			else:
				break
	ans = 0
	for i in range(n):
		for j in range(m):
			if row[i] and coloumb[j]:
				ans += 1
				row[i] = False
				coloumb[j] = False
	print('Vivek' if ans % 2 == 0 else 'Ashish')


from collections import defaultdict as dd
from collections import deque
import bisect
import heapq

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

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

def solve():
	(n, m) = rl()
	(N, M) = (n, m)
	rows = set()
	cols = set()
	for i in range(n):
		for (j, val) in enumerate(rl()):
			if val == 1:
				if i not in rows:
					N -= 1
					rows.add(i)
				if j not in cols:
					M -= 1
					cols.add(j)
	if min(N, M) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
mode = 'T'
if mode == 'T':
	t = ri()
	for i in range(t):
		solve()
else:
	solve()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	row = []
	col = []
	for i in range(n):
		if 1 not in a[i]:
			row.append(i)
	for i in range(m):
		for j in range(n):
			if a[j][i] == 1:
				break
		else:
			col.append(i)
	mi = min(len(row), len(col))
	if mi % 2:
		print('Ashish')
	else:
		print('Vivek')


for i in range(int(input())):
	c_col = 0
	c_row = 0
	(n, m) = map(int, input().split())
	matrix = []
	for j in range(n):
		temp = [x for x in map(int, input().split())]
		matrix.append(temp)
	for l in range(n):
		if 1 not in matrix[l]:
			c_row += 1
	for q in range(m):
		for t in range(n):
			if matrix[t][q] == 1:
				break
		else:
			c_col += 1
	c = min(c_row, c_col)
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for T in range(t):
	(rows, columns) = [int(i) for i in input().split()]
	freeRows = 0
	freeColumns = 0
	matrix = []
	for i in range(rows):
		matrix.append([int(i) for i in input().split()])
		if 1 not in matrix[-1]:
			freeRows += 1
	for column in range(columns):
		if 1 not in [matrix[i][column] for i in range(rows)]:
			freeColumns += 1
	winner = min(freeRows, freeColumns) % 2
	if winner == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for ti in range(t):
	(n, m) = map(int, input().split())
	si = set()
	sj = set()
	for i in range(n):
		inp = input().split()
		for j in range(m):
			if int(inp[j]):
				si.add(i)
				sj.add(j)
	if min(n - len(si), m - len(sj)) % 2:
		print('Ashish')
	else:
		print('Vivek')


for i1 in range(int(input())):
	(n, m) = map(int, input().split())
	rows = []
	columns = []
	arr = []
	for i in range(n):
		l = list(map(int, input().split()))
		arr.append(l)
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				rows.append(i)
				columns.append(j)
	rows = list(set(rows))
	columns = list(set(columns))
	r = n - len(rows)
	c = m - len(columns)
	ans = min(r, c)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	board = []
	illegalRows = []
	illegalColumns = []
	count = 0
	(n, m) = input().split()
	for i in range(int(n)):
		board += [input().split()]
	for i in range(int(n)):
		for j in range(int(m)):
			if board[i][j] == '1':
				illegalRows.append(i)
				illegalColumns.append(j)
	for i in range(int(n)):
		for j in range(int(m)):
			if i not in illegalRows and j not in illegalColumns:
				illegalRows.append(i)
				illegalColumns.append(j)
				board[i][j] = '1'
				count += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


test = int(input())
for t in range(test):
	(n, m) = map(int, input().split())
	arr = []
	for row in range(n):
		list1 = list(map(int, input().split()))
		arr.append(list1)
	rowOk = [True] * n
	colOk = [True] * m
	for row in range(n):
		for col in range(m):
			if arr[row][col] == 1:
				rowOk[row] = False
				colOk[col] = False
	count = 0
	for row in range(n):
		for col in range(m):
			if arr[row][col] == 0:
				if rowOk[row] == True and colOk[col] == True:
					count += 1
					rowOk[row] = False
					colOk[col] = False
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from collections import defaultdict
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	A = []
	for i in range(n):
		A.append(list(map(int, input().split())))
	row = n
	col = m
	row_set = defaultdict(int)
	col_set = defaultdict(int)
	for i in range(n):
		for j in range(m):
			if A[i][j]:
				if row_set[i] == 0:
					row -= 1
					row_set[i] = 1
				if col_set[j] == 0:
					col -= 1
					col_set[j] = 1
	ans = min(row, col)
	if ans & 1:
		print('Ashish')
	else:
		print('Vivek')


rri = lambda : int(input())
rrm = lambda : list(map(int, input().split()))
t = rri()

def solve(N, M, grid):
	xpossible = set([i for i in range(M)])
	ypossible = set([i for i in range(N)])
	for i in range(N):
		for j in range(M):
			if grid[i][j] == 1:
				if i in ypossible:
					ypossible.remove(i)
				if j in xpossible:
					xpossible.remove(j)
	leng = min(len(xpossible), len(ypossible))
	if leng & 1:
		return 'Ashish'
	else:
		return 'Vivek'
for _ in range(t):
	(n, m) = rrm()
	arr = []
	for _ in range(n):
		arr.append(rrm())
	print(solve(n, m, arr))


def good(grid, x, y, n, m):
	if grid[x][y] == 1:
		return False
	for col in range(m):
		if grid[x][col] != 0:
			return False
	for row in range(n):
		if grid[row][y] != 0:
			return False
	return True

def possible(grid, n, m):
	for i in range(n):
		for j in range(m):
			if good(grid, i, j, n, m):
				return (i, j)
	return (-1, -1)

def solve(grid, n, m, ans):
	moves = 0
	while True:
		(x, y) = possible(grid, n, m)
		if x == -1:
			break
		grid[x][y] = 1
		moves += 1
	if moves % 2 == 0:
		ans.append('Vivek')
	else:
		ans.append('Ashish')

def main():
	t = int(input())
	ans = []
	for i in range(t):
		(n, m) = map(int, input().split())
		grid = []
		for j in range(n):
			grid.append(list(map(int, input().split())))
		solve(grid, n, m, ans)
	for i in ans:
		print(i)
main()


t = int(input())
for _ in range(t):
	(n, m) = [int(c) for c in input().split()]
	arr = []
	rowcount = 0
	colc = [0 for i in range(m)]
	for i in range(n):
		a = [int(c) for c in input().split()]
		arr.append(a)
		if sum(a) > 0:
			rowcount += 1
	for i in arr:
		for j in range(len(i)):
			colc[j] += i[j]
	colcount = 0
	for i in colc:
		if i > 0:
			colcount += 1
	k = min(m - colcount, n - rowcount)
	if k % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


T = int(input())
for _ in range(T):
	(n, m) = list(map(int, input().split()))
	M = []
	for i in range(n):
		temp = list(map(int, input().split()))
		M.append(temp)
	R = []
	C = []
	for i in range(n):
		for j in range(m):
			if M[i][j] == 1:
				R.append(i)
				C.append(j)
	win = 0
	for i in range(n):
		for j in range(m):
			if i not in R and j not in C:
				if M[i][j] == 0:
					M[i][j] = 1
					R.append(i)
					C.append(j)
					if win == 0:
						win = 1
					else:
						win = 0
	if win == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	lista = []
	for j in range(n):
		lista1 = input().split()
		lista += [lista1]
	dg = n
	ds = m
	dstiles = []
	for k in range(n):
		if '1' in lista[k]:
			dg -= 1
		for l in range(m):
			if lista[k][l] == '1' and l not in dstiles:
				dstiles += [l]
				ds -= 1
	turns = min(dg, ds)
	if turns % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(m, n) = map(int, input().strip().split())
	mat = []
	row = 0
	col = 0
	for i in range(m):
		a = list(map(int, input().strip().split()))
		mat.append(a)
		if sum(a) == 0:
			row += 1
	B = [[0 for x in range(m)] for y in range(n)]
	for i in range(n):
		for j in range(m):
			B[i][j] = mat[j][i]
	for i in range(len(B)):
		if sum(B[i]) == 0:
			col += 1
	if min(row, col) % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


num = int(input())
for i in range(num):
	(x, y) = map(int, input().split())
	arr = []
	for j in range(x):
		arr.append(input().split())
	player = 0
	c = 0
	for i in range(len(arr)):
		h = arr[i].count('1')
		if arr[i].count('1') == 0:
			for j in range(len(arr[i])):
				c = 0
				if arr[i][j] == '0':
					for k in range(len(arr)):
						if arr[k][j] == '1':
							c += 1
					if c == 0:
						c = 0
						player += 1
						arr[i][j] = '1'
						break
	if player % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys, random
input = sys.stdin.readline
T = int(input())
for _ in range(T):
	(n, m) = map(int, input().split())
	A = []
	for i in range(n):
		A.append(list(map(int, input().split())))
	(rc, cc) = (n, m)
	for i in range(n):
		for j in range(m):
			if A[i][j] == 1:
				rc = rc - 1
				break
	for j in range(m):
		for i in range(n):
			if A[i][j] == 1:
				cc = cc - 1
				break
	v = min(rc, cc)
	if v % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	arr = [list(map(int, input().split())) for _ in range(n)]
	rows = 0
	for i in range(n):
		if 1 in arr[i]:
			rows += 1
	rows = n - rows
	cols = 0
	for j in range(m):
		for i in range(n):
			if arr[i][j] == 1:
				cols += 1
				break
	cols = m - cols
	if min(cols, rows) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout
lis = lambda : list(map(int, input().split()))
Ma = lambda : map(int, input().split())
inte = lambda : int(input())
st = lambda : input()
import math
from collections import Counter
for i in range(inte()):
	(n, m) = Ma()
	a = []
	c = []
	ans = 0
	for i in range(n):
		l = lis()
		a.append(l)
		if l.count(0) == m:
			c.append(i)
	for i in range(n):
		if i in c:
			for j in range(m):
				f = 1
				for k in range(n):
					if a[k][j] == 1:
						f = 0
				if f == 1:
					ans += 1
					a[i][j] = 1
					break
	if ans % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for test in range(t):
	(n, m) = map(int, input().rstrip().split())
	row_claimed = set()
	col_claimed = set()
	for row in range(n):
		new_row = list(map(int, input().rstrip().split()))
		for i in range(m):
			if new_row[i] == 1:
				row_claimed.add(row)
				col_claimed.add(i)
	remaining = min(n - len(row_claimed), m - len(col_claimed))
	if remaining % 2:
		print('Ashish')
	else:
		print('Vivek')


(z, zz) = (input, lambda : list(map(int, z().split())))
mod = 10 ** 9 + 7
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0:
			return 0
	return 1
n = int(z())
for _ in range(n):
	(n, m) = zz()
	ans = []
	t = 0
	for i in range(n):
		l = zz()
		ans.append(l)
		if l.count(1) <= 0:
			t += 1
	if t == 0:
		print('Vivek')
		continue
	p1 = 0
	for i in range(m):
		t1 = 0
		for j in range(n):
			if ans[j][i] == 1:
				t1 += 1
				break
		if t1 == 0:
			p1 += 1
	t = min(t, p1)
	if t % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
t = int(input())
for t in range(t):
	s = input().split(' ')
	n = int(s[0])
	m = int(s[1])
	l = []
	for i in range(n):
		ss = input().split(' ')
		ll = []
		for j in range(m):
			ll.append(int(ss[j]))
		l.append(ll)
	steps = 0
	for i in range(n):
		one = False
		for j in range(m):
			if l[i][j] == 1:
				one = True
				break
		if not one:
			for j in range(m):
				oneone = False
				for u in range(n):
					if l[u][j] == 1:
						oneone = True
						break
				if not oneone:
					l[i][j] = 1
					steps += 1
					break
	if steps % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


ashish = 'Ashish'
vivek = 'Vivek'
for test_case in range(int(input())):
	(n, m) = map(int, input().split())
	game_board = [list(map(int, input().split())) for inputs in range(n)]
	columns = set(range(m))
	rows = set(range(n))
	for (y_axis, each) in enumerate(game_board):
		for (x_axis, value) in enumerate(each):
			if value == 1:
				columns.discard(x_axis)
				rows.discard(y_axis)
	available_turns = min(len(columns), len(rows))
	if available_turns % 2 != 0:
		print(ashish)
	else:
		print(vivek)


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nsmallest
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, 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 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, m) = sp()
	(row, col) = (set(), set())
	mat = []
	for i in range(n):
		mat.append(l())
		for j in range(m):
			if mat[i][j]:
				row.add(i)
				col.add(j)
	par = 1
	while True:
		(temp1, temp2) = (-1, -1)
		for i in range(n):
			if i not in row:
				temp1 = i
				break
		for i in range(m):
			if i not in col:
				temp2 = i
				break
		if temp1 == -1 or temp2 == -1:
			if par & 1:
				out('Vivek')
			else:
				out('Ashish')
			break
		row.add(temp1)
		col.add(temp2)
		par = 1 - par


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	row = set()
	col = set()
	for i in range(n):
		arr = list(map(int, input().split()))
		for j in range(m):
			if arr[j] == 1:
				col.add(j)
		if 1 in arr:
			row.add(i)
	x = min(n - len(row), m - len(col))
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
t = int(sys.stdin.readline())
while t:
	(n, m) = map(int, sys.stdin.readline().split())
	arr = []
	for i in range(n):
		arr.append(list(map(int, sys.stdin.readline().split())))
	rowcount = 0
	colcount = 0
	for i in range(n):
		if sum(arr[i]) == 0:
			rowcount += 1
	for i in range(m):
		summ = 0
		for j in range(n):
			summ += arr[j][i]
			if arr[j][i] == 1:
				break
		if summ == 0:
			colcount += 1
	z = min(rowcount, colcount)
	if z % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


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, ma) = MAP()
	m = []
	for i in range(n):
		arr = LIST()
		m.append(arr)
	row = n
	col = ma
	cr = set()
	cc = set()
	for i in range(n):
		for j in range(ma):
			if m[i][j] == 1:
				if i not in cr:
					row -= 1
				if j not in cc:
					col -= 1
				cr.add(i)
				cc.add(j)
	x = min(row, col)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t > 0:
	(n, m) = [int(x) for x in input().split(' ')]
	curr_n = n
	i = n
	L = []
	while i > 0:
		X = [int(x) for x in input().split(' ')]
		if sum(X) > 0:
			curr_n -= 1
		L.append(X)
		i = i - 1
	Q = [[str(i) for i in x] for x in L]
	R = [''.join(x) for x in Q]
	C = [int(x, 2) for x in R]
	F = 0
	j = 0
	while j < n:
		F = F | C[j]
		j = j + 1
	D = bin(F).count('1')
	if min(curr_n, m - D) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
	t = t - 1


import math as m
t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	c = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0:
				if 1 not in a[i]:
					e = 0
					for k in range(n):
						if a[k][j] == 1:
							e = 1
							break
					if e == 0:
						a[i][j] = 1
						c += 1
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def main():
	import sys
	input = sys.stdin.readline
	sys.setrecursionlimit(10 ** 6)
	t = int(input())
	for _ in range(t):
		(N, M) = [int(x) for x in input().strip().split()]
		g = [0] * N
		zero_columns = [0] * M
		zero_rows = 0
		for n in range(N):
			g[n] = [int(x) for x in input().strip().split()]
			if sum(g[n]) == 0:
				zero_rows += 1
			for m in range(M):
				if g[n][m] == 1:
					zero_columns[m] = 1
		if min(zero_rows, M - sum(zero_columns)) % 2 == 1:
			print('Ashish')
		else:
			print('Vivek')
main()


t = int(input())
for ii in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		l = list(map(int, input().split()))
		mat.append(l)
	row_c = 0
	col_c = 0
	for j in range(n):
		f = True
		for k in range(m):
			if mat[j][k] == 1:
				f = False
				break
		if f:
			row_c += 1
	for j in range(m):
		f = True
		for k in range(n):
			if mat[k][j] == 1:
				f = False
				break
		if f:
			col_c += 1
	val = min(col_c, row_c)
	if val % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	Matrix = []
	for i in range(n):
		temp = [int(x) for x in input().split()]
		Matrix.append(temp)
	Rows = []
	Cols = []
	for i in range(n):
		Rows.append(sum(Matrix[i]))
	for j in range(m):
		Cols.append(sum([i[j] for i in Matrix]))
	r = Rows.count(0)
	c = Cols.count(0)
	Min = min(r, c)
	if not Min & 1:
		print('Vivek')
	else:
		print('Ashish')


def row_sum(arr, a, b):
	sum = 0
	x1 = [0 for i in range(a)]
	for i in range(a):
		for j in range(b):
			sum += arr[i][j]
		x1[i] = sum
		sum = 0
	return x1

def column_sum(arr, a, b):
	sum = 0
	x2 = []
	for i in range(b):
		for j in range(a):
			sum += arr[j][i]
		x2.append(sum)
		sum = 0
	return x2
for _ in range(int(input())):
	(a, b) = map(int, input().split())
	l = [[0 for i in range(b)] for j in range(a)]
	for i in range(a):
		x = list(map(int, input().split()))
		for j in range(b):
			l[i][j] = x[j]
	a1 = row_sum(l, a, b)
	a2 = column_sum(l, a, b)
	a3 = 0
	a4 = 0
	for i1 in range(len(a1)):
		if a1[i1] == 0:
			a3 += 1
	for i2 in range(len(a2)):
		if a2[i2] == 0:
			a4 += 1
	c = min(a3, a4)
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


n = int(input())
ans = []
for i in range(n):
	l = []
	(a, b) = map(int, input().split())
	for j in range(a):
		m = list(map(int, input().split()))
		l.append(m)
	count = 0
	for j in range(a):
		for x in range(b):
			if sum(l[j]) == 0 and sum((l[k][x] for k in range(a))) == 0:
				if count == 1:
					count = 0
				else:
					count = 1
				l[j][x] = 1
	if count == 0:
		ans.append('Vivek')
	else:
		ans.append('Ashish')
print('\n'.join(ans))


import enum
t = int(input())
for i in range(t):
	(row, column) = list(map(int, input().split(' ')))
	row_sum = [0] * row
	column_sum = [0] * column
	for r in range(row):
		arr = list(map(int, input().split(' ')))
		temp_sum = sum(arr)
		if temp_sum > 0:
			row_sum[r] = 1
			for (idx, c) in enumerate(arr):
				if c > 0:
					column_sum[idx] = 1
	poss_row = [idx for (idx, value) in enumerate(row_sum) if value == 0]
	poss_colum = [idx for (idx, value) in enumerate(column_sum) if value == 0]
	poss = min(len(poss_colum), len(poss_row))
	if poss % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		b = list(map(int, input().split()))
		a.append(b)
	b = []
	for i in range(m):
		c = []
		for j in range(n):
			c.append(0)
		b.append(c)
	for i in range(n):
		for j in range(m):
			b[j][i] = a[i][j]
	p1 = 'Ashish'
	p2 = 'Vivek'
	p = 'Vivek'
	for i in range(n):
		for j in range(m):
			if 1 not in a[i] and 1 not in b[j]:
				a[i][j] = 1
				b[j][i] = 1
				if p == p1:
					p = p2
				else:
					p = p1
	print(p)


for t in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	c = 0
	for i in range(n):
		l.append(list(map(int, input().split())))
	for j in range(m):
		(u, v) = (-1, -1)
		flag = 0
		for i in range(n):
			if u == -1:
				if l[i][j] == 0 and sum(l[i]) == 0:
					u = i
					v = j
					continue
			if l[i][j] == 1:
				flag = 1
				break
			else:
				continue
		if u != -1 and flag == 0:
			l[u][v] = 1
			c = c + 1
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
ans = []
for k in range(t):
	(n, m) = map(int, input().split())
	a = [[0] * m for _ in range(n)]
	for i in range(n):
		a[i] = [int(j) for j in input().split()]
	r = []
	c = []
	(x, y) = ([i for i in range(n)], [j for j in range(m)])
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r.append(i)
				c.append(j)
	(r, c) = (set(r), set(c))
	for i in r:
		x.remove(i)
	for j in c:
		y.remove(j)
	c = 0
	while len(x) != 0 and len(y) != 0:
		x.pop(0)
		y.pop(0)
		c += 1
	if c % 2 == 0:
		ans.append('Vivek')
	else:
		ans.append('Ashish')
for b in ans:
	print(b)


for _ in range(int(input())):
	(r, c) = map(int, input().split())
	arr = []
	x = 0
	y = 0
	for i in range(r):
		x = list(map(int, input().split()))
		arr.append(x)
	x = 0
	for i in range(r):
		f = 1
		for j in range(c):
			if arr[i][j] == 1:
				f = 0
				break
		if f == 1:
			x += 1
	for i in range(c):
		f = 1
		for j in range(r):
			if arr[j][i] == 1:
				f = 0
				break
		if f == 1:
			y += 1
	c = min(x, y)
	if c % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for o in range(t):
	(n, m) = map(int, input().split())
	r = set()
	c = set()
	for i in range(n):
		l = list(map(int, input().split()))
		for j in range(m):
			if l[j] == 1:
				r.add(i)
				c.add(j)
		mn = min(n - len(r), m - len(c))
	if mn % 2:
		print('Ashish')
	else:
		print('Vivek')


n = int(input())
for _ in range(n):
	(n, m) = list(map(int, input().split()))
	grid = [[int(x) for x in input().split()] for _ in range(n)]
	n_rows = sum([1 for x in grid if sum(x) == 0])
	n_cols = sum([1 for x in zip(*grid) if sum(x) == 0])
	move = min(n_cols, n_rows)
	if move % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def main():
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		(v, h) = ([1] * n, [1] * m)
		for y in range(n):
			for (x, c) in enumerate(input()[::2]):
				if c == '1':
					v[y] = h[x] = 0
		print(('Vivek', 'Ashish')[min(sum(v), sum(h)) & 1])
main()


def safe(mat, i, j, m, n):
	for r in range(n):
		if mat[r][j] != 0:
			return False
	for c in range(m):
		if mat[i][c] != 0:
			return False
	return True
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for _ in range(n):
		l = list(map(int, input().split()))
		mat.append(l)
	score = 0
	for i in range(n):
		for j in range(m):
			if safe(mat, i, j, m, n):
				mat[i][j] = 1
				score += 1
	if score % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
while t > 0:
	t -= 1
	(n, m) = list(map(int, input().split()))
	mat = []
	filled_rows = [0 for _ in range(n)]
	filled_cols = [0 for _ in range(m)]
	for i in range(n):
		col = list(map(int, input().split()))
		mat.append(col)
	for i in range(0, n):
		for j in range(0, m):
			if mat[i][j]:
				filled_cols[j] = 1
				filled_rows[i] = 1
	tot_f_rows = sum(filled_rows)
	tot_f_cols = sum(filled_cols)
	cnt = min(abs(n - tot_f_rows), abs(m - tot_f_cols))
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	row = {}
	col = {}
	ct = 0
	(n, m) = map(int, input().split())
	matrix = [[] for i in range(n)]
	for i in range(n):
		matrix[i] = list(map(int, input().split()))
		for j in range(m):
			if matrix[i][j] == 1:
				row[i] = 1
				col[j] = 1
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 0:
				if i not in row and j not in col:
					ct += 1
					row[i] = 1
					col[j] = 1
	if ct & 1 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
import heapq

def main():
	t = int(input())
	for _ in range(t):
		(n, m) = map(int, input().split())
		table = []
		for __ in range(n):
			table.append(list(map(int, sys.stdin.readline().split())))
		rowCnt = n
		colCnt = m
		for i in range(n):
			if 1 in table[i]:
				rowCnt -= 1
		for i in range(m):
			for j in range(n):
				if table[j][i] == 1:
					colCnt -= 1
					break
		ans = min(rowCnt, colCnt)
		if ans % 2:
			print('Ashish')
		else:
			print('Vivek')
	return
main()


import sys, math
input = lambda : sys.stdin.readline().rstrip()
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mas = []
	for __ in range(n):
		mas.append(list(map(int, input().split())))
	for i in range(n):
		for j in range(m):
			if mas[i][j] == 1:
				for jk in range(m):
					if jk != j:
						if mas[i][jk] != 1:
							mas[i][jk] = -1
				for jk in range(n):
					if jk != i:
						if mas[jk][j] != 1:
							mas[jk][j] = -1
	ans = 0
	while True:
		for i in range(n):
			for j in range(m):
				if mas[i][j] == 0:
					ans += 1
					mas[i][j] = 1
					for jk in range(m):
						if jk != j:
							if mas[i][jk] != 1:
								mas[i][jk] = -1
					for jk in range(n):
						if jk != i:
							if mas[jk][j] != 1:
								mas[jk][j] = -1
					continue
		break
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys, re, math
from collections import deque, defaultdict, Counter, OrderedDict
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from queue import Queue
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]))[::-1]
	toret = {}
	for tup in temp:
		toret[tup[0]] = tup[1]
	return toret

def sortDictWithKey(passedDic):
	return dict(OrderedDict(sorted(passedDic.items())))
INF = float('inf')
mod = 10 ** 9 + 7
t = INT()
while t != 0:
	(n, m) = MAP()
	grid = []
	for _ in range(n):
		a = list(map(str, input().split()))
		grid.append(a)
	(row, col) = (0, 0)
	for i in range(n):
		if '1' not in grid[i]:
			row += 1
	for j in range(m):
		flag = 0
		for i in range(n):
			if grid[i][j] == '1':
				flag = 1
				break
		if flag == 0:
			col += 1
	winner = 1
	if row < 1 or col < 1:
		print('Vivek')
	else:
		temp = min(row, col)
		if (temp - 1) % 2 == 0:
			print('Ashish')
		else:
			print('Vivek')
	t -= 1


import math
from collections import defaultdict

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

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

def rl():
	return list(map(int, input().split()))
for _ in range(r()):
	(a, b) = rm()
	c = [i for i in range(a)]
	d = [i for i in range(b)]
	for i in range(a):
		f = rl()
		for j in range(b):
			if f[j] == 1:
				if i in c:
					c.remove(i)
				if j in d:
					d.remove(j)
	e = len(c)
	f = len(d)
	g = min(e, f)
	if g & 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	l = []
	for r in range(n):
		a = list(map(int, input().split()))
		l.append(a)
	rcount = 0
	ccount = 0
	for r in range(n):
		if l[r] == [0] * m:
			rcount += 1
	for c in range(m):
		flag = 0
		for r in range(n):
			if l[r][c] == 0:
				flag += 1
		if flag == n:
			ccount += 1
	count = min(rcount, ccount)
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def getWinner(matrix):
	(n, m) = (len(matrix), len(matrix[0]))
	(row, col) = (set(), set())
	for i in range(n):
		for j in range(m):
			if matrix[i][j]:
				row.add(i)
				col.add(j)
	(rowCount, colCount) = (n - len(row), m - len(col))
	x = min(rowCount, colCount)
	return 'Ashish' if x % 2 == 1 else 'Vivek'
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	for __ in range(n):
		matrix.append(list(map(int, input().split())))
	print(getWinner(matrix))


t = int(input())
for _ in range(t):
	(n, m) = [int(i) for i in input().split(' ')]
	rows = set([])
	cols = set([])
	for i in range(n):
		row = [int(k) for k in input().split(' ')]
		count = 0
		for j in range(m):
			if row[j] == 1:
				count += 1
				cols.add(j)
		if count:
			rows.add(i)
	player = min(n - len(rows), m - len(cols))
	if player % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for ii in range(t):
	(n, m) = list(map(int, input().split()))
	full_rows = [0] * n
	full_columns = [0] * m
	for i in range(n):
		row = list(map(int, input().split()))
		for j in range(m):
			if row[j] == 1:
				full_rows[i] = 1
				full_columns[j] = 1
	empty_rows = 0
	for row in full_rows:
		if row == 0:
			empty_rows += 1
	empty_cols = 0
	for column in full_columns:
		if column == 0:
			empty_cols += 1
	if min(empty_rows, empty_cols) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	r = [False] * n
	c = [False] * m
	for i in range(n):
		for j in range(m):
			if l[i][j]:
				r[i] = True
				c[j] = True
	c1 = 0
	for i in range(n):
		for j in range(m):
			if r[i] == False and c[j] == False:
				c1 += 1
				r[i] = True
				c[j] = True
	if c1 % 2:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	(r, c) = (0, 0)
	for i in l:
		if i.count(0) == m:
			r += 1
	for i in range(m):
		co = 0
		for j in range(n):
			if l[j][i] == 0:
				co += 1
		if co == n:
			c += 1
	n = min(r, c)
	if n & 1:
		print('Ashish')
	else:
		print('Vivek')


def has1(l):
	for i in l:
		if i == '1':
			return 1
	return 0
t = int(input())
for you in range(t):
	l = input().split()
	n = int(l[0])
	m = int(l[1])
	x = min(m, n)
	l = []
	for i in range(n):
		s = input().split()
		l.append(s)
	lt = [[0 for i in range(n)] for i in range(m)]
	for i in range(n):
		for j in range(m):
			lt[j][i] = l[i][j]
	for i in l:
		if has1(i):
			n -= 1
	for i in lt:
		if has1(i):
			m -= 1
	z = min(m, n)
	if z % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	r = 0
	c = 0
	for i in range(n):
		f = 1
		for j in range(m):
			if l[i][j] == 1:
				f = 0
				break
		if f:
			r = r + 1
	for j in range(m):
		f = 1
		for i in range(n):
			if l[i][j] == 1:
				f = 0
				break
		if f:
			c = c + 1
	if min(r, c) % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	inp = input()
	(n, m) = list(map(int, inp.split()))
	count = 0
	matrix = []
	for i in range(n):
		inp = input()
		matrix.append(list(map(int, inp.split())))
	for i in range(n):
		for j in range(m):
			if sum((el[j] for el in matrix)) == 0 and sum(matrix[i]) == 0:
				matrix[i][j] = 1
				count += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for t1 in range(t):
	(r, c) = map(int, input().split())
	data = []
	r1 = 0
	c1 = 0
	for rz in range(r):
		d1 = list(map(int, input().split()))
		if 1 not in d1:
			r1 += 1
		data.append(d1)
	for rz in range(c):
		flag = True
		for cz in range(r):
			if data[cz][rz] == 1:
				flag = False
		if flag:
			c1 += 1
	ans = min(r1, c1)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(1, int(input()) + 1):
	(n, m) = map(int, input().split())
	board = []
	for i in range(n):
		row = list(map(int, input().split()))
		board.append(row)
	(a, b) = (0, 0)
	(i, j) = (0, 0)
	while i < n:
		j = 0
		while j < m:
			if board[i][j] == 1:
				break
			j += 1
		if j == m:
			a += 1
		i += 1
	(i, j) = (0, 0)
	while j < m:
		i = 0
		while i < n:
			if board[i][j] == 1:
				break
			i += 1
		if i == n:
			b += 1
		j += 1
	poss = min(a, b)
	if poss % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = [0] * m
	mm = m
	for i in range(n):
		row = list(map(int, input().split()))
		if 1 in row:
			n -= 1
		for j in range(m):
			if row[j] == 1 and l[j] == 0:
				l[j] = 1
				mm -= 1
	if min(n, mm) % 2:
		print('Ashish')
	else:
		print('Vivek')


def row_s(a, n, m):
	ans = 0
	for j in range(m):
		for i in range(n):
			if a[i][j] == 1:
				ans += 1
				break
	return ans
for _ in range(int(input())):
	ones = 0
	(n, m) = [int(s) for s in input().split()]
	a = [[int(s) for s in input().split()] for j in range(n)]
	row_ones = row_s(a, n, m)
	line_ones = 0
	for i in range(n):
		if sum(a[i]) > 0:
			line_ones += 1
	ones = min(m - row_ones, n - line_ones)
	if ones % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for h in range(0, t):
	(n, m) = map(int, input().split())
	a = [0 for i in range(0, m)]
	b = [0 for i in range(0, n)]
	for i in range(0, n):
		cur = list(map(int, input().split()))
		for j in range(0, m):
			if cur[j] == 1:
				a[j] = 1
				b[i] = 1
	x = 0
	y = 0
	for i in range(0, n):
		if b[i] == 0:
			x += 1
	for j in range(0, m):
		if a[j] == 0:
			y += 1
	x = min(x, y)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


a = int(input())
for i in range(a):
	i = i + 1
	x = [0] * 55
	y = [0] * 55
	(n, m) = map(int, input().split(' '))
	tmp = 0
	for j in range(n):
		b = input().split()
		for c in range(m):
			if int(b[c]) != 0:
				x[j] = 1
				y[c] = 1
	for j in range(n):
		for c in range(m):
			if x[j] != 0:
				break
			if y[c] == 0:
				tmp += 1
				x[j] = 1
				y[c] = 1
	if tmp & 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
ans = []
for i in range(t):
	nm = list(map(int, input().rstrip().split()))
	n = nm[0]
	m = nm[1]
	mat = []
	for j in range(n):
		ar = list(map(int, input().rstrip().split()))
		mat.append(ar)
	turn = 0
	flg = 1
	while flg != 0:
		row = -1
		col = -1
		for k in range(n):
			f = 1
			for l in range(m):
				if mat[k][l] != 0:
					f = 0
					break
			if f == 1:
				row = k
				break
		if row != -1:
			for o in range(m):
				f = 1
				for p in range(n):
					if mat[p][o] != 0:
						f = 0
						break
				if f == 1:
					col = o
					break
			if col != -1:
				mat[row][col] = 1
				turn += 1
			else:
				flg = 0
				break
		else:
			flg = 0
			break
	if turn % 2 == 0:
		ans.append('Vivek')
	else:
		ans.append('Ashish')
for i in range(t):
	print(ans[i])


import bisect
import sys
import math
input = sys.stdin.readline
import functools
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())

@functools.lru_cache(maxsize=None)
def canWin(rows, cols):
	if rows == 0 or cols == 0:
		return False
	if rows > 0 and cols > 0 and (not canWin(rows - 1, cols - 1)):
		return True
	return False

def solve(case):
	[n, m] = inlt()
	aa = [inlt() for i in range(n)]
	rows = set(range(n))
	cols = set(range(m))
	for i in range(n):
		for j in range(m):
			if aa[i][j]:
				rows.discard(i)
				cols.discard(j)
	if canWin(len(rows), len(cols)):
		return 'Ashish'
	else:
		return 'Vivek'
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))


from bisect import bisect_left, bisect_right

class Result:

	def __init__(self, index, value):
		self.index = index
		self.value = value

class BinarySearch:

	def __init__(self):
		pass

	@staticmethod
	def greater_than(num: int, func, size: int=1):
		if isinstance(func, list):
			index = bisect_right(func, num)
			if index == len(func):
				return Result(None, None)
			else:
				return Result(index, func[index])
		else:
			(alpha, omega) = (0, size - 1)
			if func(omega) <= num:
				return Result(None, None)
			while alpha < omega:
				if func(alpha) > num:
					return Result(alpha, func(alpha))
				if omega == alpha + 1:
					return Result(omega, func(omega))
				mid = (alpha + omega) // 2
				if func(mid) > num:
					omega = mid
				else:
					alpha = mid

	@staticmethod
	def less_than(num: int, func, size: int=1):
		if isinstance(func, list):
			index = bisect_left(func, num) - 1
			if index == -1:
				return Result(None, None)
			else:
				return Result(index, func[index])
		else:
			(alpha, omega) = (0, size - 1)
			if func(alpha) >= num:
				return Result(None, None)
			while alpha < omega:
				if func(omega) < num:
					return Result(omega, func(omega))
				if omega == alpha + 1:
					return Result(alpha, func(alpha))
				mid = (alpha + omega) // 2
				if func(mid) < num:
					alpha = mid
				else:
					omega = mid
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, m) = map(int, input().split())
	a = []
	for _ in range(n):
		a += [list(map(int, input().split()))]
	ans = 0
	for i in range(n):
		for j in range(m):
			(c1, c2) = (0, 0)
			for k in range(n):
				if a[k][j] == 0:
					c1 += 1
			for k in range(m):
				if a[i][k] == 0:
					c2 += 1
			if c1 == n and c2 == m:
				ans += 1
				a[i][j] = 1
	print('Ashish' if ans % 2 else 'Vivek')


def main():
	control = int(input())
	first = []
	second = []
	for i in range(55):
		first.append(False)
		second.append(False)
	while control != 0:
		for i in range(55):
			first[i] = False
			second[i] = False
		str = list(input().split(' '))
		n = int(str[0])
		m = int(str[1])
		temp = 0
		for i in range(0, n):
			x = input().split(' ')
			count = 0
			for j in x:
				if int(j) != 0:
					first[i] = True
					second[count] = True
				count += 1
		for i in range(0, n):
			j = 0
			while first[i] == False and j < m:
				if second[j] == False:
					temp += 1
					first[i] = True
					second[j] = True
				j += 1
		if temp & 1 != 0:
			print('Ashish')
		else:
			print('Vivek')
		control -= 1
main()


def check(l, x, y, n, m):
	for x1 in range(n):
		if l[x1][y] == 1:
			return False
	for y1 in range(m):
		if l[x][y1] == 1:
			return False
	return True
for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	l = []
	for _ in range(n):
		l.append(list(map(int, input().split())))
	c = 0
	for x in range(n):
		for y in range(m):
			if l[x][y] == 0:
				if check(l, x, y, n, m):
					c += 1
					l[x][y] = 1
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	si = set()
	sj = set()
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				si.add(i)
				sj.add(j)
	max_1 = 0
	for i in range(n):
		for j in range(m):
			if l[i][j] == 0:
				if i not in si and j not in sj:
					si.add(i)
					sj.add(j)
					max_1 += 1
	if max_1 % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l1 = list(map(int, input().split()))
		l.append(l1)
	(lr, lc) = ([], [])
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				lr.append(i)
				lc.append(j)
	lr = list(set(lr))
	lc = list(set(lc))
	cnt = 0
	for i in range(n):
		if i not in lr:
			for j in range(m):
				if j not in lc:
					cnt += 1
					lr.append(i)
					lc.append(j)
					break
	if cnt % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


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

def main():
	ntc = next(ints)
	for tc in range(1, ntc + 1):
		(R, C) = (next(ints) for i in range(2))
		m = [[next(ints) for c in range(C)] for r in range(R)]
		x = sum((sum((m[r][c] for c in range(C))) == 0 for r in range(R)))
		y = sum((sum((m[r][c] for r in range(R))) == 0 for c in range(C)))
		ans = min(x, y) % 2
		print('Ashish' if ans else 'Vivek')
	return
main()


from pprint import pprint
from sys import stdin, stdout
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		arr.append(list(map(int, input().split())))
	s_r = set()
	s_c = set()
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				s_r.add(i)
				s_c.add(j)
	res = min(n - len(s_r), m - len(s_c))
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for q in range(t):
	(n, m) = [int(i) for i in input().split()]
	a = [[int(j) for j in input().split()] for i in range(n)]
	row = [False for i in range(n)]
	col = [False for i in range(m)]
	(nr, nc) = (0, 0)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				if not row[i]:
					row[i] = True
					nr += 1
				if not col[j]:
					col[j] = True
					nc += 1
	t = min(n - nr, m - nc)
	res = 'Vivek' if t % 2 == 0 else 'Ashish'
	print(res)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = [list(map(int, input().split())) for _ in range(n)]
	rowsLeft = n
	columnsLeft = m
	for i in range(n):
		rowsLeft -= 1 in a[i]
	for j in range(m):
		found = False
		for i in range(n):
			if a[i][j] == 1:
				found = True
				break
		if found:
			columnsLeft -= 1
	if min(rowsLeft, columnsLeft) % 2 == 1 and 0 not in [rowsLeft, columnsLeft]:
		print('Ashish')
	else:
		print('Vivek')


import io
import os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def get_str():
	return input().decode().strip()

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

def oint():
	return int(input())
t = oint()
for _ in range(t):
	(n, m) = rint()
	a = [list(rint()) for i in range(n)]
	index = min([sum(a[i]) for i in range(n)].count(0), [sum((a[i][j] for i in range(n))) for j in range(m)].count(0)) % 2
	print(['Vivek', 'Ashish'][index])


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	ls = []
	row = 0
	col = 0
	for i in range(n):
		ls.append(list(map(int, input().split())))
		if ls[-1].count(1) == 0:
			row += 1
	l2 = list(map(list, zip(*ls)))
	for i in l2:
		if i.count(1) == 0:
			col += 1
	mi = min(row, col)
	if mi % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


list_ans = []
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	dict1 = {}
	dict2 = {}
	for i in range(n):
		dict1[i] = 0
	for i in range(m):
		dict2[i] = 0
	for i in range(n):
		list1 = list(map(int, input().split()))
		for x in range(m):
			if list1[x] == 1:
				dict1[i] = 1
				dict2[x] = 1
	a = n - sum(dict1.values())
	b = m - sum(dict2.values())
	s = min(a, b)
	if s % 2 == 0:
		list_ans.append('Vivek')
	else:
		list_ans.append('Ashish')
for item in list_ans:
	print(item)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	lst = []
	for i in range(n):
		lst.append(list(map(int, input().split())))
	r = set()
	c = set()
	for i in range(n):
		for j in range(m):
			if lst[i][j] == 1:
				r.add(i)
				c.add(j)
	mn = min(n - len(r), m - len(c))
	if mn % 2:
		print('Ashish')
	else:
		print('Vivek')


from sys import stdin, stdout
cin = stdin.readline
cout = stdout.write
mp = lambda : list(map(int, cin().split()))

def getSum(j):
	for x in range(n):
		if a[x][j] == 1:
			return 1
	return 0
l = ['Vivek', 'Ashish']
(t,) = mp()
for _ in range(t):
	(n, m) = mp()
	a = [[] * m for _ in range(n)]
	for i in range(n):
		a[i] = mp()
	x = y = 0
	for i in range(n):
		if not sum(a[i]):
			x += 1
	for i in range(m):
		if not getSum(i):
			y += 1
	win = min(x, y) % 2
	cout(l[win] + '\n')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	x = []
	for i in range(n):
		l = list(map(int, input().split()))
		x.append(l)
	n1 = [1] * n
	m1 = [1] * m
	for i in range(n):
		for y in range(m):
			if x[i][y] == 1:
				n1[i] = 0
				m1[y] = 0
	nc = n1.count(1)
	mc = m1.count(1)
	mn = min(nc, mc)
	if mn % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	l = []
	for j in range(n):
		a = list(map(int, input().split()))
		l.append(a)
	r = [i for i in range(n)]
	c = [i for i in range(m)]
	k = 0
	for j in range(len(l)):
		for k in range(len(l[j])):
			if l[j][k] == 1:
				if j in r:
					r.remove(j)
				if k in c:
					c.remove(k)
	q = min(len(r), len(c))
	if q % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
max_int = 1000000001
min_int = -max_int
t = int(input())
for _t in range(t):
	(n, m) = map(int, sys.stdin.readline().split())
	a = []
	for _n in range(n):
		a.append(list(sys.stdin.readline().split()))
	rows = cols = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == '1':
				break
		else:
			rows += 1
	for j in range(m):
		for i in range(n):
			if a[i][j] == '1':
				break
		else:
			cols += 1
	print('Ashish' if min(rows, cols) % 2 else 'Vivek')


def f(i, j, n, m):
	for k in range(0, n):
		if l[k][j] == 1:
			return 0
	for k in range(0, m):
		if l[i][k] == 1:
			return 0
	return 1
for tt in range(int(input())):
	(r, c) = map(int, input().split())
	l = []
	for i in range(r):
		temp = list(map(int, input().split()))
		l.append(temp)
	count = 0
	for i in range(r):
		for j in range(c):
			if l[i][j] == 0 and f(i, j, r, c):
				count += 1
				l[i][j] = 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for tt in range(int(input())):
	(r, c) = map(int, input().split())
	m = []
	counr = 0
	counc = 0
	for i in range(r):
		temp = list(map(int, input().split()))
		counr += min(1, temp.count(1))
		m.append(temp)
	for j in range(c):
		for i in range(r):
			if m[i][j] == 1:
				counc += 1
				break
	ans = min(c - counc, r - counr)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	(n, m) = map(int, input().split())
	r_emp = 0
	c_emp = 0
	mat = []
	for i in range(n):
		l = list(map(int, input().split()))
		if l.count(1) == 0:
			r_emp += 1
		mat.append(l)
	for i in range(m):
		count = 0
		for j in range(n):
			if mat[j][i] == 0:
				count += 1
			else:
				break
		if count == n:
			c_emp += 1
	if r_emp == 0 or c_emp == 0:
		print('Vivek')
	else:
		m = min(r_emp, c_emp)
		if m % 2 != 0:
			print('Ashish')
		else:
			print('Vivek')
	t = t - 1


def matgame(mat, n, m):
	row = [1 for _ in range(n)]
	col = [1 for _ in range(m)]
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				row[i] = 0
				col[j] = 0
	res = min(sum(row), sum(col))
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for i in range(t):
	(n, m) = list(map(int, input().rstrip().split()))
	mat = []
	for _ in range(n):
		mat.append(list(map(int, input().rstrip().split())))
	matgame(mat, n, m)


a = int(input())
for _ in range(a):
	(n, m) = [int(x) for x in input().split()]
	k = list()
	for _ in range(n):
		l = list(map(int, input().strip().split()))
		k.append(l)
	row = 0
	for x in range(n):
		if sum(k[x]) == 0:
			row += 1
	col = 0
	for x in range(m):
		e = 0
		for y in range(n):
			if k[y][x] == 0:
				e = e + 1
		if e == n:
			col = col + 1
	if min(row, col) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def matrixGame(n, m, matrix):
	blankX = []
	blankY = []
	for x in range(n):
		flag = 0
		for y in range(m):
			if matrix[x][y] == 1:
				flag = 1
				break
		if flag == 0:
			blankX.append(x)
	for y in range(m):
		flag = 0
		for x in range(n):
			if matrix[x][y] == 1:
				flag = 1
				break
		if flag == 0:
			blankY.append(y)
	p = min(len(blankY), len(blankX))
	if p % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	for x in range(n):
		matrix.append(list(map(int, input().split())))
	print(matrixGame(n, m, matrix))


import sys
input = sys.stdin.readline
t = int(input())
for ti in range(1, t + 1):
	(n, m) = map(int, input().split())
	a = [[] for _ in range(n)]
	r = c = 0
	for i in range(n):
		a[i] = list(map(int, input().split()))
		if sum(a[i]) == 0:
			r += 1
	for j in range(m):
		sm_col = sum((a[i][j] for i in range(n)))
		if sm_col == 0:
			c += 1
	if min(r, c) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	total = min([n, m])
	rows = [0] * n
	cols = [0] * m
	for j in range(n):
		b = input().split()
		yes = 0
		for (ind, i) in enumerate(b):
			if int(i) == 1:
				yes = 1
				cols[ind] = 1
		if yes == 1:
			rows[j] = 1
	row_0 = rows.count(0)
	col_0 = cols.count(0)
	new = min([row_0, col_0])
	if new % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	b1 = 0
	for i in range(n):
		flag = 0
		for j in range(m):
			if a[i][j] == 1:
				flag = 1
				break
		if flag == 0:
			b1 += 1
	b2 = 0
	for j in range(m):
		flag = 0
		for i in range(n):
			if a[i][j] == 1:
				flag = 1
				break
		if flag == 0:
			b2 += 1
	if min(b1, b2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve():
	(n, m) = [int(i) for i in input().split()]
	list = []
	for i in range(n):
		seznam = [int(i) for i in input().split()]
		list.append(seznam)
	o_radky = 0
	for i in range(n):
		if list[i].count(1) > 0:
			o_radky += 1
	o_sloupce = 0
	for i in range(m):
		for j in range(n):
			if list[j][i] == 1:
				o_sloupce += 1
				break
	x = min(n - o_radky, m - o_sloupce)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for i in range(t):
	solve()


t = int(input())
while t:
	t = t - 1
	a = []
	(n, m) = input().split()
	(n, m) = (int(n), int(m))
	for i in range(n):
		x = input().split()
		a.append(x)
	(r, c) = (n, m)
	for i in range(n):
		for j in range(m):
			if a[i][j] == '1':
				r = r - 1
				break
	for j in range(m):
		for i in range(n):
			if a[i][j] == '1':
				c = c - 1
				break
	mi = min(r, c)
	if mi % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	l = []
	(n, m) = map(int, input().split())
	for i in range(n):
		l.append(list(map(int, input().split())))
	l1 = [0] * n
	l2 = [0] * m
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				l1[i] = 1
				l2[j] = 1
	c = 0
	for i in range(n):
		for j in range(m):
			if l1[i] == 0 and l2[j] == 0:
				c += 1
				l1[i] = 1
				l2[j] = 1
	if c % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import math
from sys import stdin
from collections import Counter, defaultdict, deque
input = stdin.readline
mod = pow(10, 9) + 7

def solve():
	(n, m) = map(int, input().split())
	l1 = []
	r = 0
	c = 0
	for i in range(n):
		l1.append(list(map(int, input().split())))
	for i in range(n):
		a = sum(l1[i])
		if a == 0:
			r += 1
	for i in range(m):
		sum1 = 0
		for j in range(n):
			sum1 += l1[j][i]
		if sum1 == 0:
			c += 1
	x = min(r, c)
	if x % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
for _ in range(int(input())):
	solve()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = [0]
	for i in range(n):
		l.append([0] + list(map(int, input().split())))
	(rn, cn) = ([1] * (n + 1), [1] * (m + 1))
	for i in range(1, n + 1):
		for j in range(1, m + 1):
			if l[i][j] == 1:
				rn[i] = 0
				cn[j] = 0
	sr = sum(rn) - 1
	sc = sum(cn) - 1
	if min(sr, sc) % 2:
		print('Ashish')
	else:
		print('Vivek')


from sys import stdin
inp = lambda : stdin.readline().strip()
t = int(inp())
for _ in range(t):
	(n, m) = [int(x) for x in inp().split()]
	arr = []
	for i in range(n):
		arr.append([int(x) for x in inp().split()])
	rows = 0
	columns = 0
	for i in arr:
		if max(i) == 0:
			rows += 1
	arr = list(map(list, zip(*arr)))
	for i in arr:
		if max(i) == 0:
			columns += 1
	if min(columns, rows) % 2:
		print('Ashish')
	else:
		print('Vivek')


def eval(matrix):
	visitedR = [False] * len(matrix)
	visitedC = [False] * len(matrix[0])
	K = 0
	for r in range(len(matrix)):
		for c in range(len(matrix[0])):
			if matrix[r][c] == 1:
				visitedR[r] = True
				visitedC[c] = True
	for r in range(len(visitedR)):
		for c in range(len(visitedC)):
			if not visitedR[r] and (not visitedC[c]):
				K += 1
				visitedR[r] = True
				visitedC[c] = True
	if K == 0:
		print('Vivek')
	elif K % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
for _ in range(int(input())):
	(r, j) = list(map(int, input().split()))
	matrix = [list(map(int, input().split())) for _ in range(r)]
	eval(matrix)


t = int(input())
while t:
	(n, m) = map(int, input().split())
	ele = []
	n_ctr = 0
	a = []
	for i in range(n):
		ele.append(list(map(int, input().split())))
	for i in range(n):
		flag = False
		for j in range(m):
			if ele[i][j] == 1:
				flag = True
				a.append(j)
		if flag == False:
			n_ctr = n_ctr + 1
	if min(n_ctr, m - len(set(a))) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t = t - 1


for _ in range(int(input())):
	(m, n) = map(int, input().split())
	arr = [list(map(int, input().split())) for i in range(m)]
	a = 0
	b = 0
	for i in arr:
		if sum(i) == 0:
			a += 1
	for j in range(n):
		s = 0
		for i in range(m):
			s += arr[i][j]
		if s == 0:
			b += 1
	print('Ashish' if min(a, b) % 2 != 0 else 'Vivek')


t = int(input())
for _ in range(t):
	a = [int(x) for x in input().split(' ')]
	n = a[0]
	m = a[1]
	a = []
	for _ in range(n):
		a.append([int(x) for x in input().split(' ')])
	avRow = n
	avCol = m
	for r in a:
		if 1 in r:
			avRow -= 1
	for i in range(m):
		for r in a:
			if r[i] == 1:
				avCol -= 1
				break
	if min(avCol, avRow) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def checkmat(mat, m, n):
	for i in range(len(mat)):
		if mat[i][n] == 1:
			return False
	for j in range(len(mat[0])):
		if mat[m][j] == 1:
			return False
	return True

def game(mat, turn):
	for i in range(len(mat)):
		for j in range(len(mat[0])):
			if checkmat(mat, i, j):
				turn = not turn
				mat[i][j] = 1
	return turn
n = int(input())
while n:
	(j, k) = map(int, input().split())
	arr = []
	for i in range(j):
		arr.append(list(map(int, input().split())))
	if game(arr, 0):
		print('Ashish')
	else:
		print('Vivek')
	n = n - 1


for _ in range(int(input())):
	(n, m) = [int(x) for x in input().split()]
	a = []
	for i in range(n):
		b = [int(x) for x in input().split()]
		a.append(b)
	b = [0] * n
	c = [0] * m
	for i in range(n):
		for j in range(m):
			if a[i][j]:
				b[i] += 1
				c[j] += 1
	ss = min(b.count(0), c.count(0))
	if ss % 2:
		print('Ashish')
	else:
		print('Vivek')


test_cases = int(input())
for case in range(0, test_cases):
	z = []
	p = []
	dimensions = input()
	dimensions = dimensions.split()
	no_of_rows = int(dimensions[0])
	no_of_cols = int(dimensions[1])
	elements = [[None] * no_of_cols] * no_of_rows
	for row in range(0, no_of_rows):
		inp = input()
		elements[row] = inp.split()
		x = '1' in elements[row][:]
		if x == False:
			z.append(row)
	elements = list(map(list, zip(*elements)))
	for col in range(0, no_of_cols):
		x = '1' in elements[col]
		if x == False:
			p.append(col)
	possible_spaces = min(len(z), len(p))
	if possible_spaces % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def help():
	(n, m) = map(int, input().split(' '))
	row = set()
	col = set()
	for i in range(n):
		am = list(map(int, input().split(' ')))
		for j in range(m):
			if am[j] == 1:
				row.add(i)
				col.add(j)
	left = min(n - len(row), m - len(col))
	if left % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
for _ in range(int(input())):
	help()


import os
import sys
import io
import math
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
for t in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		row = list(map(int, input().split()))
		matrix.append(row)
	rowcount = 0
	for i in matrix:
		if 1 not in i:
			rowcount += 1
	colcount = 0
	rez = [[matrix[j][i] for j in range(len(matrix))] for i in range(len(matrix[0]))]
	for i in rez:
		if 1 not in i:
			colcount += 1
	if min(rowcount, colcount) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


T = int(input())
for _ in range(T):
	(n, m) = map(int, input().split())
	a = []
	(r, c) = (0, 0)
	for i in range(n):
		ar = list(map(int, input().split()))
		a.append(ar)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				break
		else:
			r += 1
	for k in range(m):
		for l in range(n):
			if a[l][k] == 1:
				break
		else:
			c += 1
	if min(r, c) % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = [[] for _ in range(n)]
	for i in range(n):
		a[i] = list(map(int, input().split()))
	rows_empty = 0
	for i in range(n):
		if sum(a[i]) == 0:
			rows_empty += 1
	col_empty = 0
	for j in range(m):
		sum_col = 0
		for i in range(n):
			sum_col += a[i][j]
		if sum_col == 0:
			col_empty += 1
	if min(rows_empty, col_empty) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
m_ = []
n_ = []
nums = []
for i in range(t):
	(m, n) = map(int, input().split())
	m_.append(m)
	n_.append(n)
	p = []
	for i in range(m):
		u = list(map(int, input().split()))
		p.append(u)
	nums.append(p)

def minx(m, n, nums_ith):
	col = 0
	row = 0
	for i in range(m):
		f = 1
		for j in range(n):
			if nums_ith[i][j] == 1:
				f = 0
				break
		if f:
			col += 1
	for i in range(n):
		f = 1
		for j in range(m):
			if nums_ith[j][i] == 1:
				f = 0
				break
		if f:
			row += 1
	return min(row, col)
for i in range(t):
	l = minx(m_[i], n_[i], nums[i])
	if l % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	(n, m) = map(int, input().split())
	l = [list(map(int, input().split())) for i in range(n)]
	r = [0] * n
	c = [0] * m
	(dd, ss) = (0, 0)
	for i in range(n):
		for j in range(m):
			if l[i][j]:
				r[i] += 1
				c[j] += 1
	for i in range(n):
		if not r[i]:
			dd += 1
	for i in range(m):
		if not c[i]:
			ss += 1
	if min(dd, ss) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


def main():
	t = int(input())
	for _ in range(t):
		(n, m) = map(int, input().split())
		row_set = set()
		col_set = set()
		first_row = input().split()
		bad_first_row = False
		for (c, el) in enumerate(first_row):
			if el == '0':
				col_set.add(c)
			else:
				bad_first_row = True
		if not bad_first_row:
			row_set.add(0)
		for r in range(n - 1):
			bad_row = False
			row = input().split()
			for (c, el) in enumerate(row):
				if el == '1':
					if c in col_set:
						col_set.remove(c)
					bad_row = True
			if not bad_row:
				row_set.add(r + 1)
		available = min(len(row_set), len(col_set))
		if available % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


t = int(input())
while t > 0:
	t -= 1
	(n, m) = map(int, input().split())
	mat = [list(map(int, input().split())) for i in range(n)]
	vis_row = [0] * n
	vis_col = [0] * m
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				vis_row[i] = 1
				vis_col[j] = 1
	cnt = 0
	for i in range(n):
		if vis_row[i] == 0:
			for j in range(m):
				if vis_col[j] == 0:
					cnt += 1
					vis_row[i] = 1
					vis_col[j] = 1
					break
	if cnt % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split(' ')))
	A = []
	for __ in range(n):
		A.append(list(map(int, input().split(' '))))
	numFreeRows = 0
	for i in range(n):
		if not any(A[i]):
			numFreeRows += 1
	numFreeCols = 0
	for i in range(m):
		add = 1
		for j in range(n):
			if A[j][i] == 1:
				add = 0
		numFreeCols += add
	print('Ashish' if min(numFreeCols, numFreeRows) % 2 == 1 else 'Vivek')


def getWinner(arr):
	n = len(arr)
	m = len(arr[0])
	numEmptyRows = 0
	numEmptyCols = 0
	for row in arr:
		is1Present = False
		for val in row:
			if val == 1:
				is1Present = True
		if is1Present == False:
			numEmptyRows += 1
	for j in range(m):
		is1Present = False
		for i in range(n):
			if arr[i][j] == 1:
				is1Present = True
		if is1Present == False:
			numEmptyCols += 1
	minimum = min(numEmptyRows, numEmptyCols)
	if minimum % 2 != 0:
		return 'Ashish'
	else:
		return 'Vivek'
numTestCases = int(input(''))
for t in range(numTestCases):
	temp = input('').strip().split()
	n = int(temp[0])
	m = int(temp[1])
	arr = list()
	for i in range(n):
		row = list()
		temp = input('').strip().split()
		for j in range(m):
			row.append(int(temp[j]))
		arr.append(row)
	print(getWinner(arr))


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	li = []
	r = 0
	c = 0
	for i in range(n):
		a = list(map(int, input().split()))
		if 1 not in a:
			r += 1
		li.append(a)
	for i in range(m):
		f = 0
		for j in range(n):
			if li[j][i] == 1:
				f = 1
				break
		if f == 0:
			c += 1
	x = min(r, c)
	if x % 2:
		print('Ashish')
	else:
		print('Vivek')


from collections import defaultdict
for _ in range(int(input())):
	(n, m) = [int(x) for x in input().split()]
	count = 0
	a = []
	row = defaultdict(lambda : False)
	column = defaultdict(lambda : False)
	for i in range(n):
		el = [int(x) for x in input().split()]
		a.append(el)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row[i] = True
				column[j] = True
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0 and (row[i] == False and column[j] == False):
				a[i][j] = 1
				count += 1
				row[i] = True
				column[j] = True
	if count % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(r, c) = map(int, input().split())
	row = set()
	column = set()
	for i in range(r):
		row.add(i)
	for i in range(c):
		column.add(i)
	for i in range(r):
		l = list(map(int, input().split()))
		for j in range(c):
			if l[j] == 1:
				if i in row:
					row.remove(i)
				if j in column:
					column.remove(j)
	q = min(len(row), len(column))
	if q % 2 == 0:
		print('Vivek')
	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')
testcases = int(input())
for j in range(testcases):
	(n, m) = map(int, input().split())
	usedr = set([])
	usedc = set([])
	nl = n
	ml = m
	for s in range(n):
		vals = list(map(int, input().split()))
		for k in range(m):
			if vals[k] == 1 and (not k in usedc or not s in usedr):
				usedc.add(k)
				usedr.add(s)
	unclaimed = min(nl - len(usedr), ml - len(usedc))
	if unclaimed % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from operator import add
tc = int(input())
while tc > 0:
	(n, m) = map(int, input().split())
	rh = [0 for _ in range(n)]
	ch = [0 for _ in range(m)]
	for i in range(n):
		row = list(map(int, input().split()))
		ch = list(map(add, row, ch))
		rh[i] = sum(row)
	rc = sum((1 if x == 0 else 0 for x in rh))
	cc = sum((1 if x == 0 else 0 for x in ch))
	print('Ashish' if min(rc, cc) % 2 == 1 else 'Vivek')
	tc -= 1


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	for_n = [int(i) for i in range(0, n)]
	for_m = [int(i) for i in range(0, m)]
	for j in range(n):
		mas = list(map(int, input().split()))
		for g in range(m):
			if mas[g] == 1:
				if g in for_m:
					for_m.pop(for_m.index(g))
				if j in for_n:
					for_n.pop(for_n.index(j))
	l = 1
	while len(for_n) > 0 and len(for_m) > 0:
		for_n.pop()
		for_m.pop()
		if l == 1:
			l = 2
		else:
			l = 1
	if l == 1:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	L = [[int(l) for l in input().split()] for _ in range(n)]
	N = 0
	M = 0
	for i in range(n):
		if 1 not in L[i]:
			N += 1
	for j in range(m):
		f = True
		for i in range(n):
			if L[i][j] == 1:
				f = False
		if f:
			M += 1
	if min(N, M) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(a, b) = map(int, input().split())
	(w, r) = (0, set())
	for _ in range(a):
		z = list(map(int, input().split()))
		s = set(z)
		if len(s) == 1:
			if 0 in s:
				w += 1
			else:
				for i in range(b):
					r.add(i)
		else:
			for i in range(b):
				if z[i] == 1:
					r.add(i)
	t = min(w, b - len(r))
	if t % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for z in range(t):
	(n, m) = map(int, input().split())
	(ii, jj) = ([], [])
	for i in range(n):
		l = list(map(int, input().split()))
		if 1 in l:
			ii.append(i)
			j = 0
			while j < m:
				if j not in jj:
					if l[j] == 1:
						jj.append(j)
				j += 1
	a = n - len(ii)
	b = m - len(jj)
	c = min(a, b)
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def is_row(arr, i):
	m = len(arr[0])
	for j in range(m):
		if arr[i][j] == 1:
			return False
	return True

def is_col(arr, j):
	n = len(arr)
	for i in range(n):
		if arr[i][j] == 1:
			return False
	return True
t = int(input())
for test in range(t):
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	arr = []
	for i in range(n):
		l = list(map(int, input().split()))
		arr.append(l)
	flag = True
	chance = 0
	i_pos = 0
	j_pos = 0
	while flag:
		for i in range(i_pos, n):
			for j in range(j_pos, m):
				if is_row(arr, i) and is_col(arr, j):
					arr[i][j] = 1
					flag = True
					i_pos = i
					j_pos = j
					break
				else:
					flag = False
			if flag:
				break
		if flag:
			chance = (chance + 1) % 2
	if chance == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve(M, n, m):
	cols_destroyed = []
	rows_destroyed = []
	for i in range(n):
		for j in range(m):
			if M[i][j] == 1:
				if i not in rows_destroyed:
					rows_destroyed.append(i)
				if j not in cols_destroyed:
					cols_destroyed.append(j)
	_n = n - len(rows_destroyed)
	_m = m - len(cols_destroyed)
	x = min(_n, _m)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
T = int(input())
while T > 0:
	a = input().split(' ')
	n = int(a[0])
	m = int(a[1])
	N = n
	M = []
	while N > 0:
		x = input().split(' ')
		for i in range(m):
			x[i] = int(x[i])
		M.append(x)
		N -= 1
	solve(M, n, m)
	T -= 1


from sys import stdin
for _ in range(int(stdin.readline())):
	(n, m) = list(map(int, stdin.readline().split()))
	row = [True] * n
	column = [True] * m
	for i in range(n):
		a = list(map(int, stdin.readline().split()))
		for (index, value) in enumerate(a):
			if value == 1:
				column[index] = False
				row[i] = False
	r = row.count(True)
	c = column.count(True)
	t = min(r, c)
	if t % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.buffer.readline
t = int(input())
while t:
	t -= 1
	(n, m) = map(int, input().split())
	count = min(m, n)
	z = []
	c1 = 0
	ans = []
	for i in range(n):
		arr = list(map(int, input().split()))
		ans.append(arr)
		if 1 in arr:
			c1 += 1
	c1 = n - c1
	c2 = 0
	for i in range(m):
		for j in range(n):
			if ans[j][i] == 1:
				c2 += 1
				break
	c2 = m - c2
	count = min(c1, c2)
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())

def cal(i, j, lis):
	for k in range(m):
		if lis[k][j] == 1:
			return 1
	for k in range(n):
		if lis[i][k] == 1:
			return 1
	return 0
for ii in range(t):
	(m, n) = map(int, input().split())
	lis = []
	for i in range(m):
		r = list(map(int, input().split()))
		lis.append(r[:])
	c = 0
	for i in range(m):
		for j in range(n):
			if not cal(i, j, lis):
				c += 1
				lis[i][j] = 1
	if c % 2:
		print('Ashish')
	else:
		print('Vivek')


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

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

def si():
	return input()

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

def msi():
	return map(str, input().strip().split(' '))

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

def dmain():
	sys.setrecursionlimit(100000000)
	threading.stack_size(40960000)
	thread = threading.Thread(target=main)
	thread.start()
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
inf = float('inf')
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[1]

def sort2(l):
	return sorted(l, key=getKey, reverse=True)

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

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

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

def ntl(n):
	return [int(i) for i in str(n)]

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

def binary_search(arr, low, high, x):
	if high >= low:
		mid = (high + low) // 2
		if arr[mid] == x:
			return mid
		elif arr[mid] > x:
			return binary_search(arr, low, mid - 1, x)
		else:
			return binary_search(arr, mid + 1, high, x)
	else:
		return -1

def ceil(x, y):
	if x % y == 0:
		return x // y
	else:
		return x // y + 1

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

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

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 read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def padded_bin_with_complement(x):
	if x < 0:
		return bin(2 ** 16 - abs(x))[2:].zfill(16)
	else:
		return bin(x)[2:].zfill(16)

def binaryToDecimal(binary):
	binary1 = binary
	(decimal, i, n) = (0, 0, 0)
	while binary != 0:
		dec = binary % 10
		decimal = decimal + dec * pow(2, i)
		binary = binary // 10
		i += 1
	print(decimal)

def CountFrequency(arr):
	return collections.Counter(arr)

def pos(a):
	b = [0] * len(a)
	c = sorted(a)
	for i in range(len(a)):
		for j in range(len(a)):
			if c[j] == a[i]:
				b[i] = j
				break
	return b

def smallestDivisor(n):
	if n % 2 == 0:
		return 2
	i = 3
	while i * i <= n:
		if n % i == 0:
			return i
		i += 2
	return n

def commonn(a, b, n):
	c = []
	for i in range(n):
		if a[i] == b[i]:
			c.append('-1')
		else:
			c.append(b[i])
	return c

def main():
	for _ in range(ii()):
		(n, m) = mi()
		a = []
		cou = 0
		for i in range(n):
			j = li()
			a.append(j)
		r = [0] * n
		c = [0] * m
		for i in range(n):
			for j in range(m):
				if a[i][j] == 1:
					r[i] = 1
					c[j] = 1
		for i in range(n):
			for j in range(m):
				if r[i] == 0 and c[j] == 0:
					cou += 1
					r[i] = 1
					c[j] = 1
		if cou % 2:
			print('Ashish')
		else:
			print('Vivek')
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

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


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	matrix = [[int(x) for x in input().split()] for j in range(n)]
	freeRows = freeCols = 0
	for i in range(n):
		if 1 not in matrix[i]:
			freeRows += 1
	j = 0
	for i in range(m):
		for j in range(n):
			if matrix[j][i] != 0:
				freeCols += 1
				break
	freeCols = m - freeCols
	if min(freeRows, freeCols) & 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	s = []
	pl1 = 0
	pl2 = 0
	for i in range(n):
		l = list(map(int, input().split()))
		ch = 0
		for j in l:
			if j == 1:
				ch += 1
		if ch == 0:
			pl1 += 1
		s.append(l)
	for j in range(m):
		ch = 0
		for i in range(n):
			if s[i][j] == 1:
				ch += 1
		if ch == 0:
			pl2 += 1
	ans = min(pl2, pl1)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
input = stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = [input().split() for i in range(n)]
	(x, y) = (0, 0)
	b = [['0' for j in range(m)] for i in range(n)]
	for i in range(n):
		if a[i].count('1'):
			for j in range(m):
				b[i][j] = '1'
	for i in range(m):
		if [a[k][i] for k in range(n)].count('1'):
			for j in range(n):
				b[j][i] = '1'
	for i in range(n):
		if b[i].count('0'):
			x += 1
	for i in range(m):
		if [b[k][i] for k in range(n)].count('0'):
			y += 1
	print(['Vivek', 'Ashish'][min(x, y) & 1])


from sys import stdin, stdout

def main():
	t = int(stdin.readline())
	for _ in range(t):
		(n, m) = list(map(int, stdin.readline().split()))
		ta = []
		for _ in range(n):
			arr = list(map(int, stdin.readline().split()))
			ta.append(arr)
		taken_i = [False] * n
		taken_j = [False] * m
		for i in range(n):
			for j in range(m):
				if ta[i][j] == 1:
					taken_i[i] = True
					taken_j[j] = True
		cnt = 0
		for i in range(n):
			for j in range(m):
				if taken_i[i] == False and taken_j[j] == False:
					taken_i[i] = True
					taken_j[j] = True
					cnt += 1
		if cnt % 2 == 0:
			stdout.write('Vivek\n')
		else:
			stdout.write('Ashish\n')
main()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	arr = [list(map(int, input().split())) for i in range(n)]
	(c, r) = ([], [])
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				if i not in r:
					r.append(i)
				if j not in c:
					c.append(j)
	l = min(n - len(r), m - len(c))
	if l % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
sys.setrecursionlimit(10 ** 8)
try:
	FILE_POINTER = open('input.inpt')
	input = FILE_POINTER.readline
except:
	FILE_POINTER = None
	input = sys.stdin.readline
t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().strip().split()))
	turn = 0
	row = [0] * n
	col = [0] * m
	for i in range(n):
		inp = input().strip().split()
		for j in range(m):
			if inp[j] == '1':
				row[i] = 1
				col[j] = 1
	for i in range(n):
		for j in range(m):
			if row[i] == 0 and col[j] == 0:
				row[i] = 1
				col[j] = 1
				if turn:
					turn = 0
				else:
					turn = 1
				break
	if turn == 0:
		print('Vivek')
	else:
		print('Ashish')
if FILE_POINTER:
	FILE_POINTER.close()


import sys
input = lambda : sys.stdin.readline().strip()
li = lambda : list(map(int, input().split()))
I = lambda : int(input())
for _ in range(I()):
	(n, m) = li()
	ans = 0
	mat = []
	for i in range(n):
		mat.append(li())
	for i in range(n):
		for j in range(m):
			(f1, f2) = (0, 0)
			if mat[i][j] == 0:
				for p in range(m):
					if mat[i][p] == 1:
						break
				else:
					f1 = 1
				for p in range(n):
					if mat[p][j] == 1:
						break
				else:
					f2 = 1
				if f1 and f2:
					mat[i][j] = 1
					ans += 1
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def checker(matrix):
	for col in range(len(matrix)):
		for row in range(len(matrix[col])):
			if matrix[col][row] == 1:
				if col not in col_taken or row not in row_taken:
					col_taken.append(col)
					row_taken.append(row)
for _ in range(int(input())):
	(x, y) = map(int, input().split())
	matrix = []
	count = 0
	col_taken = []
	row_taken = []
	for _ in range(x):
		matrix.append(list(map(int, input().split())))
	checker(matrix)
	for i in range(x):
		for j in range(y):
			if i not in col_taken and j not in row_taken:
				matrix[i][j] = 1
				count += 1
				checker(matrix)
	if count % 2 == 1:
		winner = 'Ashish'
	else:
		winner = 'Vivek'
	print(winner)


t = int(input())

def isBad(arr):
	if 1 in arr:
		return True
	return False
while t > 0:
	l = [int(x) for x in input().split()]
	grid = []
	for i in range(l[0]):
		grid.append([int(x) for x in input().split()])
	column = []
	for i in range(l[1]):
		currCol = []
		for j in range(l[0]):
			currCol.append(grid[j][i])
		column.append(isBad(currCol))
	total = 0
	for i in range(l[0]):
		if not isBad(grid[i]):
			for j in range(l[1]):
				if not column[j]:
					column[j] = True
					total += 1
					break
	if total % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


import sys
input = sys.stdin.readline
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, m) = ip()
	x = []
	(r, c) = (set(), set())
	for i in range(n):
		t = ip()
		x.append(t)
		if 1 not in t:
			r.add(i)
	for j in range(m):
		t = [x[i][j] for i in range(n)]
		if 1 not in t:
			c.add(j)
	l = min(len(r), len(c))
	if l % 2:
		print('Ashish')
	else:
		print('Vivek')


def check(i, j, a, I, J):
	if i < 0 or i >= len(a) or j < 0 or (j >= len(a[0])):
		return True
	if a[i][j] == 1:
		return False
	if i == I and j == J:
		return check(i - 1, j, a, I, J) and check(i + 1, j, a, I, J) and check(i, j - 1, a, I, J) and check(i, j + 1, a, I, J)
	if i < I:
		return check(i - 1, j, a, I, J)
	if j < J:
		return check(i, j - 1, a, I, J)
	if i > I:
		return check(i + 1, j, a, I, J)
	if j > J:
		return check(i, j + 1, a, I, J)

def whoIsThat(n, m, a) -> str:
	who = 'Ashish'
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0:
				if check(i, j, a, i, j):
					a[i][j] = 1
					if who == 'Ashish':
						who = 'Vivek'
					else:
						who = 'Ashish'
	if who == 'Ashish':
		return 'Vivek'
	return 'Ashish'
t = int(input().strip())
while t > 0:
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		arr = list(map(int, input().split()))
		mat.append(arr)
	print(whoIsThat(n, m, mat))
	t -= 1


def num():
	return int(input())

def line():
	return map(int, input().split())
from itertools import repeat
t = num()
for _ in repeat(None, t):
	(n, m) = line()
	board = [list(line()) for _ in repeat(None, n)]
	alines = sum((not any(board[i]) for i in range(n)))
	acols = sum((not any((board[j][i] for j in range(n))) for i in range(m)))
	a = min(alines, acols)
	print('Ashish' if a % 2 else 'Vivek')


test = int(input())
for _ in range(test):
	(n, m) = map(int, input().split())
	row = set()
	col = set()
	for i in range(n):
		row.add(i)
	for i in range(m):
		col.add(i)
	for i in range(n):
		c = list(map(int, input().split()))
		for j in range(m):
			if c[j] == 1:
				if i in row:
					row.remove(i)
				if j in col:
					col.remove(j)
	l = min(len(row), len(col))
	if l % 2:
		print('Ashish')
	else:
		print('Vivek')


import os
import sys
from io import BytesIO, IOBase

def main():
	pass
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
t = int(input())
while t:
	(n, m) = map(int, input().split())
	td = []
	for i in range(n):
		td.append(list(map(int, input().split())))
	count = 0
	for i in range(n):
		for j in range(m):
			if td[i][j] == 0:
				flag = 0
				for k in range(n):
					if td[k][j] == 1:
						flag = 1
						break
				for f in range(m):
					if td[i][f] == 1:
						flag = 1
						break
				if flag == 0:
					td[i][j] = 1
					count += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


def matrixGame(n, m, a):
	t = 1
	flag = 0
	for i in range(n):
		if 1 in a[i]:
			continue
		while 0 in a[i]:
			x = a[i].index(0)
			for j in range(n):
				if a[j][x] == 1:
					flag = 1
					break
			if flag == 0 and 1 not in a[i]:
				a[i][x] = 1
				t = abs(t - 1)
			else:
				flag = 0
				a[i][x] = -1
	if t == 1:
		return 'Vivek'
	return 'Ashish'
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		l = list(map(int, input().split()))
		a.append(l)
	print(matrixGame(n, m, a))


T = int(input())
for _ in range(T):
	(n, m) = list(map(int, input().split()))
	s = []
	count1 = 0
	for i in range(n):
		a = list(map(int, input().split()))
		if a.count(1) == 0:
			count1 += 1
		s.append(a)
	count = 0
	for i in range(m):
		d = [g[i] for g in s]
		if d.count(1) == 0:
			count += 1
	count = min(count1, count)
	if count % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


def ans(arr, n, m):
	x = 0
	y = 0
	count = 0
	for i in range(n):
		z = True
		for j in range(m):
			if arr[i][j] == '1':
				z = False
				break
		if z == True:
			count += 1
	x = count
	count = 0
	for i in range(m):
		z = True
		for j in range(n):
			if arr[j][i] == '1':
				z = False
				break
		if z == True:
			count += 1
	y = count
	q = min(x, y)
	if q % 2 == 0:
		return 'Vivek'
	return 'Ashish'
m = int(input())
for j in range(m):
	A = input().split()
	a = int(A[0])
	b = int(A[1])
	arr = []
	for i in range(a):
		B = input().split()
		arr.append(B)
	print(ans(arr, a, b))


for _ in range(int(input())):
	(m, n) = map(int, input().split())
	l = [list(map(int, input().split())) for _ in range(m)]
	r = [0] * m
	c = [0] * n
	for i in range(m):
		for j in range(n):
			if l[i][j] == 1:
				r[i] = 1
				c[j] = 1
	s = 0
	for i in range(m):
		if r[i] == 1:
			continue
		for j in range(n):
			if c[j] == 1:
				continue
			if r[i] == 0 and c[j] == 0:
				r[i] = 1
				c[j] = 1
				s += 1
				break
	if s % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat += [[int(j) for j in input().split()]]
	row = set([i for i in range(n)])
	col = set([i for i in range(m)])
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				if i in row:
					row.remove(i)
				if j in col:
					col.remove(j)
	mi = min(len(row), len(col))
	if mi % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


tc = int(input())
for ctr in range(tc):
	(r, c) = map(int, input().split())
	(a, b) = (0, 0)
	m = []
	for i in range(r):
		k = list(map(int, input().split()))
		m.append(k)
		if 1 not in k:
			a += 1
	for i in zip(*m):
		if 1 not in i:
			b += 1
	if min(a, b) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(x, y) = map(int, input().split())
	arr = [[0 for i in range(y)] for j in range(x)]
	for i in range(0, x):
		arr[i] = list(map(int, input().split()))
	ans = 0
	flag = 2
	for i in range(x):
		for j in range(y):
			if 1 not in arr[i]:
				if 1 not in [row[j] for row in arr]:
					arr[i][j] = 1
					ans += 1
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys, os
from io import BytesIO, IOBase
import collections, itertools, bisect, heapq, math, string
from decimal import *
BUFSIZE = 8192
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():
	t = int(input())
	for i in range(t):
		nm = list(map(int, input().split()))
		(n, m) = (nm[0], nm[1])
		matrix = []
		(s, t) = (set(), set())
		for j in range(n):
			temp = list(map(int, input().split()))
			matrix.append(temp)
		for x in range(len(matrix)):
			for y in range(len(matrix[x])):
				if matrix[x][y] == 1:
					s.add(x)
					t.add(y)
		mn = min(n - len(s), m - len(t))
		if mn % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


t = int(input())
for _ in range(t):
	[n, m] = [int(x) for x in input().split()]
	a = []
	for i in range(n):
		a.append([int(x) for x in input().split()])
	rows = n * [False]
	colls = m * [False]
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				rows[i] = True
				colls[j] = True
	free_rows = 0
	free_colls = 0
	for i in range(n):
		if not rows[i]:
			free_rows += 1
	for j in range(m):
		if not colls[j]:
			free_colls += 1
	free = min(free_rows, free_colls)
	if free % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
from math import *

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

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

def finput():
	return float(input())

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

def linput():
	return list(input())

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

def fiinput():
	return map(float, tinput())

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

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

def main():
	(n, m) = rinput()
	(q, w) = ([0] * (n + 1), [0] * (m + 1))
	for i in range(n):
		o = 0
		for j in rlinput():
			if j == 1:
				q[i] = w[o] = 1
			o += 1
	res = min(n - q.count(1), m - w.count(1))
	if res & 1:
		print('Ashish')
	else:
		print('Vivek')
for inytd in range(iinput()):
	main()


t = int(input())

def sum_row(mat, r):
	cols = len(mat[0])
	sumr = 0
	for co in range(cols):
		sumr = sumr + mat[r][co]
	return sumr

def sum_col(mat, c):
	rows = len(mat)
	sumc = 0
	for ro in range(rows):
		sumc = sumc + mat[ro][c]
	return sumc
for test in range(t):
	row = []
	mat = []
	(n, m) = [int(item) for item in input().split()]
	for r in range(n):
		row = list(map(int, input().strip().split()))[:m]
		mat.append(row)
	sumflag = 0
	res = 1
	while sumflag == 0:
		sumflag = 1
		br = 0
		for r in range(n):
			sr = sum_row(mat, r)
			if sr == 0:
				for c in range(m):
					sc = sum_col(mat, c)
					if sc == 0:
						mat[r][c] = 1
						res = res + 1
						sumflag = 0
						br = 1
						break
			if br == 1:
				break
	if res % 2 != 0:
		print('Vivek')
	else:
		print('Ashish')


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 dfs(self, x, func=lambda pr, prv, nx, dist: prv + dist, root_v=0):
		q = deque([x])
		v = [None] * self.size
		v[x] = root_v
		while q:
			c = q.pop()
			for (nb, d) in self.edges[c]:
				if v[nb] == None:
					q.append(nb)
					v[nb] = func(c, v[c], nb, d)
		return v

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

	def parent(self, x):
		return self.dfs(0, func=lambda pr, prv, nx, dist: pr, root_v=-1)

	def topological_sort(self, x):
		tps = []
		q = deque([x])
		v = [None] * self.size
		v[x] = 0
		while q:
			c = q.popleft()
			tps.append(c)
			for (nb, d) in self.edges[c]:
				if v[nb] == None:
					q.append(nb)
					v[nb] = 0
		return tps

	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]

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

	def show(self):
		if all([all([d == 1 for (nd, d) in edge]) for edge in self.edges]):
			print([[nd for (nd, d) in edge] for edge in self.edges])
		else:
			print(self)

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)
show_flg = False
show_flg = True
ans = 0
for _ in range(I()):
	ans = ['Ashish', 'Vivek']
	k = 0
	(n, m) = LI()
	N = [1] * n
	M = [1] * m
	for i in range(n):
		a = LI()
		for j in range(m):
			if a[j] == 1:
				M[j] = 0
				N[i] = 0
	n = sum(N)
	m = sum(M)
	k = min(n, m) % 2
	print(ans[1 - k])


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
for _ in range(int(ri())):
	(n, m) = Ri()
	arr = []
	for i in range(n):
		temp = Ri()
		arr.append(temp)
	row = set([i for i in range(n)])
	col = set([i for i in range(m)])
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				if i in row:
					row.remove(i)
				if j in col:
					col.remove(j)
	ans = min(len(row), len(col))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math as mt
import sys, string
input = sys.stdin.readline
import collections
from heapq import heappush, heapify, heappop
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
t = I()
for _ in range(t):
	(n, m) = M()
	k = min(n, m)
	l = []
	for i in range(n):
		l.append(L())
	s = set([])
	c = set([])
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				s.add(i)
				c.add(j)
	r = max(0, min(n - len(s), m - len(c)))
	if r % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	(r, c) = ([0] * n, [0] * m)
	for i in range(n):
		a = [int(x) for x in input().split()]
		for j in range(len(a)):
			if a[j] == 1:
				c[j] = 1
				r[i] = 1
	ans = min(n - sum(r), m - sum(c))
	print('Vivek' if ans % 2 == 0 else 'Ashish')


def solve():
	T = int(input())
	for _ in range(T):
		(n, m) = [int(s) for s in input().split(' ')]
		grid = [[0 for _ in range(m)] for _ in range(n)]
		for i in range(n):
			lst = [int(s) for s in input().split(' ')]
			for j in range(len(lst)):
				grid[i][j] = lst[j]
		row = 0
		cols = [True for _ in range(len(grid[0]))]
		for i in range(len(grid)):
			b = True
			for j in range(len(grid[0])):
				if grid[i][j] == 1:
					b = False
					cols[j] = False
			if b:
				row += 1
		col = 0
		for bo in cols:
			if bo:
				col += 1
		winner = 'Vivek' if min(row, col) % 2 == 0 else 'Ashish'
		print(winner)
solve()


from collections import deque
from sys import stdin, stdout
import math
input = stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	arr = [list(map(int, input().split())) for i in range(n)]
	lcnt = 0
	for i in range(n):
		if 1 not in arr[i]:
			lcnt += 1
	rcnt = 0
	for g in range(m):
		was = False
		for i in range(n):
			if arr[i][g] == 1:
				was = True
		if not was:
			rcnt += 1
	print('Vivek' if not min(lcnt, rcnt) % 2 else 'Ashish')


from sys import stdin, stdout
import sys
from math import *
input = stdin.buffer.readline
for __ in range(int(input())):
	(n, m) = map(int, input().split())
	ar = []
	for i in range(n):
		ar.append(list(map(int, input().split())))
	x = 0
	count = 0
	while x < n:
		for i in range(m):
			p = 0
			if ar[x][i] == 0:
				if sum(ar[x]) > 0:
					p = 1
					break
				else:
					for j in range(n):
						if ar[j][i] == 1:
							p = 1
							break
				if p == 0:
					ar[x][i] = 1
					count += 1
					break
		x += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split(' '))
	matrix = []
	c = []
	r = []
	k = 0
	for i in range(n):
		y = list(map(int, input().split()))
		matrix.append(y)
		if y.count(0) == m:
			r.append(i)
	for i in range(m):
		flag = 0
		for j in range(n):
			if matrix[j][i] == 1:
				flag = 1
				break
		if flag == 0:
			c.append(i)
	if len(c) == 0 or len(r) == 0:
		print('Vivek')
	else:
		x = min(len(r), len(c))
		if x % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')


iterations = int(input())

def optimal(x, y):
	check = 0
	for i in range(ncol):
		if matrix[x][i] == 1:
			check += 1
	for z in range(nrow):
		if matrix[z][y] == 1:
			check += 1
	if check >= 1:
		return False
	else:
		matrix[x][y] = 1
		return True
for _ in range(iterations):
	matrix = []
	(nrow, ncol) = map(int, input().split())
	counter = 0
	for row in range(nrow):
		matrix.append(list(map(int, input().split())))
	for row in range(nrow):
		for col in range(ncol):
			if optimal(row, col) is True:
				counter += 1
	if counter % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	mat = [[int(x) for x in input().split()] for _ in range(n)]
	for r in mat:
		if 1 in r:
			n -= 1
	for c in zip(*mat):
		if 1 in c:
			m -= 1
	if min(n, m) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math as mt
import sys, string
input = sys.stdin.readline
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
from collections import defaultdict
t = I()
for _ in range(t):
	(n, m) = M()
	c = []
	r = []
	l = []
	for i in range(n):
		l.append(L())
		for j in range(m):
			if l[i][j] == 1:
				if i not in r:
					r.append(i)
				if j not in c:
					c.append(j)
	x = min(n - len(r), m - len(c))
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	(n, m) = map(int, input().split())
	countr = 0
	s = set()
	for i in range(0, n):
		l2 = list(map(int, input().split()))
		check = 0
		for j in range(0, m):
			if l2[j] == 1:
				s.add(j)
				check = 1
		if check == 1:
			countr += 1
	ans = min(n - countr, m - len(s))
	if ans % 2:
		print('Ashish')
	else:
		print('Vivek')
	t = t - 1


from sys import stdin, stdout
t = int(input())
for _ in range(t):
	(n, m) = map(int, stdin.readline().strip().split())
	tot = 0
	usedcols = set()
	for row in range(n):
		r = input()
		if '1' in r:
			tot += 1
		rnums = list(map(int, r.split()))
		for i in range(m):
			if rnums[i] == 1:
				usedcols.add(i)
	if n - tot <= 0:
		print('Vivek')
	elif len(usedcols) == m:
		print('Vivek')
	else:
		left = n - tot
		left2 = m - len(usedcols)
		left = min(left, left2)
		if left % 2 == 1:
			print('Ashish')
		else:
			print('Vivek')


import sys
input = sys.stdin.readline

def solve(n, m, matrix):
	rows_closed = [0] * n
	cols_closed = [0] * m
	moves = []
	for r in range(n):
		for c in range(m):
			if matrix[r][c] == 1:
				rows_closed[r] = 1
				cols_closed[c] = 1
	for r in range(n):
		for c in range(m):
			if rows_closed[r] == 0 and cols_closed[c] == 0:
				moves.append((r, c))
	p = 0
	while moves:
		(r, c) = moves.pop()
		if rows_closed[r] == 1 or cols_closed[c] == 1:
			continue
		else:
			rows_closed[r] = 1
			cols_closed[c] = 1
			p = (p + 1) % 2
	return 'Ashish' if p == 1 else 'Vivek'
t = int(input())
res = []
for _ in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	for _ in range(n):
		matrix.append([int(s) for s in input().strip().split()])
	res.append(solve(n, m, matrix))
for r in res:
	print(r)


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	(arr, col) = ([], [])
	for i in range(n):
		arr.append(list(map(int, input().split())))
	for i in range(m):
		lis = []
		for j in range(n):
			lis.append(arr[j][i])
		col.append(lis)
	(r, c) = ({}, {})
	for i in range(n):
		if arr[i].count(1) == 0:
			r[i] = 1
	for j in range(m):
		if col[j].count(1) == 0:
			c[j] = 1
	count = 0
	for i in r.keys():
		for j in c.keys():
			if arr[i][j] == 0:
				count += 1
				del c[j]
				break
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	arr = [list(map(int, input().split())) for __ in range(n)]
	row = 0
	col = [0 for i in range(m)]
	flag = 1
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				col[j] = 1
				flag = 0
		if flag:
			row += 1
		flag = 1
	col1 = col.count(0)
	if min(row, col1) & 1 == 1:
		print('Ashish')
	else:
		print('Vivek')


for t in range(int(input())):
	(n, m) = map(int, input().split(' '))
	mat = []
	for i in range(n):
		mat.append([*map(int, input().split())])
	unclaimedR = 0
	unclaimedC = 0
	temp = [0] * m
	for i in range(n):
		if sum(mat[i]) == 0:
			unclaimedR += 1
		for j in range(m):
			temp[j] += mat[i][j]
	unclaimedC = temp.count(0)
	x = min(unclaimedC, unclaimedR)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	l = []
	d = 0
	for j in range(n):
		l1 = list(map(int, input().split()))
		l.append(l1)
	for j in range(n):
		if sum(l[j]) == 0:
			for k in range(m):
				if l[j][k] == 0:
					a = 0
					for p in range(n):
						a += l[p][k]
					if a == 0:
						l[j][k] = 1
						d += 1
						break
	if d % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().strip().split()))
	matrix = []
	for k in range(n):
		arr = list(map(int, input().split()))
		matrix.append(arr)
	s = set()
	for i in range(len(matrix)):
		for j in range(len(matrix[0])):
			if matrix[i][j]:
				s.add(j)
	t = set()
	for i in range(len(matrix)):
		for j in range(len(matrix[0])):
			if matrix[i][j]:
				t.add(i)
	if min(m - len(s), n - len(t)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = [int(x) for x in input().split()]
	row = {}
	column = {}
	for i in range(n):
		s = list(map(int, input().split()))
		for j in range(m):
			if s[j] == 1:
				row[i] = 1
				column[j] = 1
	(a, b) = (0, 0)
	for i in range(n):
		if row.get(i) is None:
			a += 1
	for i in range(m):
		if column.get(i) is None:
			b += 1
	if min(a, b) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
input = stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	g = []
	for _ in range(n):
		g.append(list(map(int, input().split())))
	un_col = 0
	for i in range(m):
		curr = 0
		for j in range(n):
			if g[j][i]:
				curr = 1
			if curr:
				break
		else:
			un_col += 1
	un_row = 0
	for i in range(n):
		curr = 0
		for j in range(m):
			if g[i][j]:
				curr = 1
			if curr:
				break
		else:
			un_row += 1
	if min(un_row, un_col) % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	rowmat = []
	for i in range(n):
		rowmat.append(list(map(int, input().split())))
	clmat = []
	for i in range(m):
		l = []
		for j in range(n):
			l.append(rowmat[j][i])
		clmat.append(l)
	places = 0
	for i in range(n):
		if sum(rowmat[i]) == 0:
			for j in range(m):
				if sum(clmat[j]) == 0:
					rowmat[i][j] = 1
					clmat[j][i] = 1
					places += 1
					break
	if places % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	arr = [[int(x) for x in input().split()] for _ in range(n)]
	(r_set, c_set) = (set(), set())
	(r, c) = (0, 0)
	for i in range(n):
		for j in range(m):
			if arr[i][j]:
				r_set.add(i)
				c_set.add(j)
	if min(n - len(r_set), m - len(c_set)) % 2:
		print('Ashish')
	else:
		print('Vivek')


for case in range(int(input())):
	(n, m) = [int(x) for x in input().split()]
	mat = []
	for i in range(n):
		mat.append([int(x) for x in input().split()])
	r = 0
	c = 0
	for i in range(n):
		if mat[i].count(1) == 0:
			r += 1
	for i in range(m):
		flag = True
		for j in range(n):
			if mat[j][i] == 1:
				flag = False
				break
		if flag:
			c += 1
	k = min(r, c)
	if k % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for i in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		s = list(map(int, input().split()))
		matrix.append(s)
	rows = 0
	columns = 0
	for i in range(n):
		if sum(matrix[i]) == 0:
			rows += 1
	for i in range(m):
		temp = 0
		for j in range(n):
			temp += matrix[j][i]
		if temp == 0:
			columns += 1
	if min(rows, columns) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(1, int(input()) + 1):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l1 = [int(j) for j in input().split()]
		l.append(l1)
	r = [0] * n
	c = [0] * m
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				r[i] = 1
				c[j] = 1
	(er, ec) = (0, 0)
	for i in range(n):
		if r[i] == 0:
			er += 1
	for j in range(m):
		if c[j] == 0:
			ec += 1
	t = min(er, ec)
	if t & 1:
		print('Ashish')
	else:
		print('Vivek')


for test in range(int(input())):
	(n, m) = map(int, input().split())
	a = [[]] * n
	for i in range(n):
		a[i] = list(map(int, input().split()))
	x = 0
	y = 0
	for i in range(n):
		if a[i] == [0] * m:
			x += 1
	for i in range(m):
		b = True
		for j in range(n):
			if a[j][i] != 0:
				b = False
				break
		if b:
			y += 1
	if min(x, y) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
ans = ''
for _ in range(t):
	nm = input().split()
	n = int(nm[0])
	m = int(nm[1])
	x = [0 for i in range(n)]
	y = [0 for i in range(m)]
	x1 = n
	y1 = m
	for i in range(n):
		a = [int(j) for j in input().split()]
		for j in range(m):
			if a[j] == 1:
				x[i] = 1
				y[j] = 1
	for i in range(n):
		if x[i] == 1:
			x1 -= 1
	for j in range(m):
		if y[j] == 1:
			y1 -= 1
	if min(x1, y1) % 2 == 0:
		ans += 'Vivek \n'
	else:
		ans += 'Ashish \n'
print(ans)


for test in range(int(input())):
	(n, m) = map(int, input().split())
	matriz = []
	col = m
	lin = n
	listalinha = [False for i in range(n)]
	listacoluna = [False for j in range(m)]
	for k in range(n):
		linha = list(map(int, input().split()))
		for i in range(m):
			if linha[i] == 1:
				if not listalinha[k]:
					listalinha[k] = True
					lin -= 1
				if not listacoluna[i]:
					listacoluna[i] = True
					col -= 1
	final = min(lin, col)
	if final % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	countr = 0
	for i in range(len(mat)):
		if mat[i].count(1) == 0:
			countr += 1
	countcol = 0
	for i in range(len(mat[0])):
		col = []
		for j in range(len(mat)):
			col.append(mat[j][i])
		if col.count(1) == 0:
			countcol += 1
	x = min(countr, countcol)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = [int(i) for i in input().split()]
	matrix = []
	r = c = 0
	for i in range(n):
		temp = [int(i) for i in input().split()]
		s1 = sum(temp)
		if s1 == 0:
			r += 1
		matrix.append(temp)
	for i in range(m):
		s = 0
		for j in range(n):
			s += matrix[j][i]
		if s == 0:
			c += 1
	avail = min(r, c)
	if avail % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for tt in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		x = [int(item) for item in input().split()]
		mat.append(x)
	rowCount = 0
	colCount = 0
	for i in range(n):
		z = True
		for j in range(m):
			if mat[i][j] == 1:
				z = False
				break
		if z:
			rowCount += 1
	for i in range(m):
		z = True
		for j in range(n):
			if mat[j][i] == 1:
				z = False
				break
		if z:
			colCount += 1
	mi = min(rowCount, colCount)
	print('Vivek' if mi % 2 == 0 else 'Ashish')


def check(x, y, m, n, mat):
	if 1 in mat[x]:
		return False
	t = []
	for z in range(n):
		t.append(mat[z][y])
	if 1 in t:
		return False
	else:
		return True
t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split(' ')))
	mat = []
	win = 0
	for x in range(n):
		l = list(map(int, input().split(' ')))
		mat.append(l)
	while True:
		count = 0
		for x in range(n):
			chk = 0
			for y in range(m):
				if check(x, y, m, n, mat):
					count = count + 1
					mat[x][y] = 1
					if win == 0:
						win = 1
					else:
						win = 0
					chk = 1
					break
			if chk == 1:
				break
		if count == 0:
			break
	if win == 1:
		print('Ashish')
	else:
		print('Vivek')


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

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

class Node:

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

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 pr_list(a):
	print(*a, sep=' ')

def main():
	tests = inp()
	mod = 1000000007
	limit = 10 ** 18
	for test in range(tests):
		[n, m] = inlt()
		c = {}
		r = {}
		grid = []
		for i in range(n):
			grid.append(inlt())
		for i in range(n):
			for j in range(m):
				if grid[i][j] == 1:
					r[i] = 1
					c[j] = 1
		k = 0
		while True:
			flag = 0
			for i in range(n):
				for j in range(m):
					if i not in r and j not in c:
						r[i] = 1
						c[j] = 1
						flag = 1
						break
				if flag == 1:
					break
			if flag == 0:
				break
			k = k + 1
		if k % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


for _ in range(int(input())):
	(m, n) = map(int, input().split())
	mat = []
	s = []
	vivek = 1
	ashish = 0
	t = 0
	for i in range(m):
		s = []
		s = list(map(int, input().split()))
		mat.append(s)
	for i in range(m):
		if 1 not in set(mat[i]):
			f = 1
			try:
				for k in range(n):
					f = 1
					for j in range(m):
						if mat[j][k] == 1:
							f = 0
							break
					if f == 1:
						mat[i][k] = 1
						t = ashish
						ashish = vivek
						vivek = t
						break
			except:
				pass
	if vivek:
		print('Vivek')
	else:
		print('Ashish')


def solve(n, m, grid):
	n_free_cols = sum((all((grid[i][j] == 0 for i in range(n))) for j in range(m)))
	n_free_lines = sum((all((grid[i][j] == 0 for j in range(m))) for i in range(n)))
	N = min(n_free_lines, n_free_cols)
	return N % 2 == 1

def main():
	T = int(input())
	for _ in range(T):
		(n, m) = map(int, input().split())
		grid = [list(map(int, input().split())) for _ in range(n)]
		print('Ashish' if solve(n, m, grid) else 'Vivek')
main()


import math

def safe(arr, n, m, x, y):
	t = x
	while t > -1:
		if arr[t][y]:
			return False
		t -= 1
	t = x
	while t < n:
		if arr[t][y]:
			return False
		t += 1
	t = y
	while t > -1:
		if arr[x][t]:
			return False
		t -= 1
	t = y
	while t < m:
		if arr[x][t]:
			return False
		t += 1
	return True

def default():
	t = int(input())
	while t:
		t -= 1
		a = input()
		a = a.split()
		n = int(a[0])
		m = int(a[1])
		arr = []
		for i in range(0, n):
			aa = input()
			aa = aa.split()
			for j in range(0, m):
				aa[j] = int(aa[j])
			ab = aa[:]
			arr.append(ab)
		player = 1
		play = 1
		while play:
			x = -1
			y = -1
			for i in range(0, n):
				for j in range(0, m):
					if safe(arr, n, m, i, j):
						x = i
						y = j
						break
				if x != -1:
					break
			if x == -1:
				play = 0
				break
			else:
				arr[x][y] = 1
				if player == 1:
					player = 0
				else:
					player = 1
		if not player:
			print('Ashish')
		else:
			print('Vivek')
default()


import sys
input = lambda : sys.stdin.readline().strip()
t = int(input())
while t:
	t -= 1
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	o_r = 0
	o_c = 0
	for i in range(n):
		if mat[i].count(1) > 0:
			o_r += 1
	for j in range(m):
		val = 0
		for i in range(n):
			if mat[i][j] == 1:
				val += 1
		if val:
			o_c += 1
	pre = min(n - o_r, m - o_c)
	if pre % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = [int(i) for i in input().split()]
	mat = []
	for _ in range(n):
		row = [int(i) for i in input().split()]
		mat.append(row)
	uRows = 0
	uCols = 0
	for row in range(n):
		found = False
		for col in range(m):
			if mat[row][col] == 1:
				found = True
				break
		if not found:
			uRows += 1
	for col in range(m):
		found = False
		for row in range(n):
			if mat[row][col] == 1:
				found = True
				break
		if not found:
			uCols += 1
	if min(uRows, uCols) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from collections import Counter
from sys import stdin
t = int(input())
res = ''

def read_matrix():
	(n, m) = [int(i) for i in stdin.readline().split()]
	matrix = []
	for x in range(n):
		matrix.append([int(i) for i in stdin.readline().split()])
	return matrix
for _ in range(t):
	matrix = read_matrix()
	row_claimed = [False for _ in range(len(matrix[0]))]
	col_claimed = [False for _ in range(len(matrix))]
	for row in range(len(matrix)):
		for col in range(len(matrix[0])):
			if matrix[row][col] == 1:
				row_claimed[col] = True
				col_claimed[row] = True
	minimum = min(Counter(row_claimed)[False], Counter(col_claimed)[False])
	if minimum % 2 == 0:
		res += 'Vivek' + '\n'
	else:
		res += 'Ashish' + '\n'
print(res[:-1])


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

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, m) = int_array()
	mat = []
	for __ in range(n):
		mat.append(int_array())
	rows = set()
	cols = set()
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				rows.add(i)
				cols.add(j)
	rows = {i for i in range(n)}.difference(rows)
	cols = {i for i in range(m)}.difference(cols)
	x = min(len(rows), len(cols))
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	M = []
	p = 0
	for i in range(n):
		a = list(map(int, input().split()))
		M.append(a)
		if 1 in a:
			continue
		else:
			p += 1
	k = m
	for i in range(m):
		for j in range(n):
			if M[j][i] == 0:
				continue
			else:
				k -= 1
				break
	ans = min(p, k)
	if ans % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().rstrip().split()))
	a = []
	r = {}
	c = {}
	for i in range(n):
		ip = list(map(int, input().rstrip().split()))
		a.append(ip)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r[i] = 's'
				c[j] = 's'
	r0 = n - len(r)
	c0 = m - len(c)
	if min(r0, c0) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	ans = 0
	a = []
	r = {i for i in range(n)}
	c = {i for i in range(m)}
	for i in range(n):
		flag = 0
		l = list(map(int, input().split()))
		for j in range(m):
			if l[j] == 1:
				flag = 1
				if j in c:
					c.remove(j)
		if flag == 1:
			r.remove(i)
	ans = min(len(r), len(c))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for i in range(int(input())):
	(n, m) = [int(k) for k in input().split()]
	mat = []
	jlist = []
	klist = []
	ans = 0
	for j in range(n):
		mat.append(list(map(int, input().split())))
		for k in range(m):
			if mat[j][k] == 1:
				jlist.append(j)
				klist.append(k)
	jset = list(set(jlist))
	kset = list(set(klist))
	ans = min(n - len(jset), m - len(kset))
	if ans % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for q in range(t):
	(n, m) = map(int, input().split())
	st = [0 for _ in range(m)]
	row = 0
	bol = False
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(m):
			if a[j] == 1:
				st[j] = 1
				bol = True
		if bol:
			row += 1
			bol = False
	ans = min(n - row, m - sum(st))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	matrix = []
	row = set()
	col = set()
	for i in range(n):
		l = [int(x) for x in input().split()]
		matrix.append(l)
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				row.add(i)
				col.add(j)
	mn = min(n - len(row), m - len(col))
	if mn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	li = []
	(rowui, colums) = (0, 0)
	for i in range(n):
		li.append(list(map(int, input().split())))
		if 1 in li[-1]:
			rowui += 1
	for i in range(m):
		for j in li:
			if j[i] == 1:
				colums += 1
				break
	z = min(n - rowui, m - colums)
	if z % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout, setrecursionlimit

def f(a):
	for i in range(n):
		for j in range(m):
			cur = []
			for k in range(n):
				cur.append(a[k][j])
			if 1 not in a[i] and 1 not in cur:
				a[i][j] = 1
				return True
	return False
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append([int(i) for i in input().split()])
	ans = 1
	while f(a):
		ans = 1 - ans
	if ans == 0:
		print('Ashish')
	else:
		print('Vivek')


wer = int(input())
for ewr in range(wer):
	(n, m) = list(map(int, input().split(' ')))
	li = []
	for i in range(n):
		temp = list(map(int, input().split(' ')))
		li.append(temp)
	row = 0
	for i in range(n):
		flag = 0
		for j in range(m):
			if li[i][j] == 1:
				flag = 1
				break
		if flag == 0:
			row += 1
	col = 0
	for i in range(m):
		flag = 0
		for j in range(n):
			if li[j][i] == 1:
				flag = 1
				break
		if flag == 0:
			col += 1
	mi = min(row, col)
	if mi % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
t = int(input())

def get_column(matrix, i):
	return [row[i] for row in matrix]
for i in range(t):
	(n, m) = list(map(int, input().split()))
	matrix = []
	for i in range(n):
		matrix.append(list(map(int, input().split())))
	new_matrix = matrix
	a = n
	b = m
	for i in range(n):
		if 1 in matrix[i]:
			a -= 1
	for j in range(m):
		if 1 in get_column(matrix, j):
			b -= 1
	if min(a, b) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	matrix = []
	for _ in range(n):
		matrix.append(input().split())
	rnew = set()
	cnew = set()
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == '1':
				rnew.add(i)
				cnew.add(j)
	if min(n - len(rnew), m - len(cnew)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for k in range(t):
	(n, k) = map(int, input().split())
	mat = []
	for j in range(n):
		li = list(map(int, input().split()))
		mat.append(li)
	r = set()
	c = set()
	for i in range(n):
		for j in range(k):
			if mat[i][j] == 1:
				r.add(i)
				c.add(j)
	mn = min(n - len(r), k - len(c))
	if mn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def read_many_bool():
	return list(map(lambda x: x == '1', input().split()))

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

def read_int():
	return int(input())
for test_case in range(read_int()):
	(n, m) = read_many()
	board = []
	for i in range(n):
		board.append(read_many_bool())
	rows = set(range(n))
	cols = set(range(m))
	for i in range(n):
		for j in range(m):
			if board[i][j]:
				try:
					rows.remove(i)
				except KeyError:
					pass
				try:
					cols.remove(j)
				except KeyError:
					pass
	maxi_moves = min(len(rows), len(cols))
	first_wins = maxi_moves % 2
	print(f"{('Ashish' if first_wins else 'Vivek')}")


def cal(mat):
	c = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 0 and i not in R and (j not in C):
				c += 1
				mat[i][j] = 1
				R[i] = 1
				C[j] = 1
	return c
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	R = {}
	C = {}
	a = [[int(i) for i in input().split()] for j in range(n)]
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				R[i] = 1
				C[j] = 1
	count = cal(a)
	ans = 'Vivek' if count % 2 == 0 else 'Ashish'
	print(ans)


tc = int(input())
for _ in range(tc):
	(n, m) = list(map(int, input().split()))
	count = 0
	a = set()
	b = set()
	for i in range(n):
		row = list(map(int, input().split()))
		for j in range(m):
			if row[j] == 1:
				a.add(i)
				b.add(j)
	moves = min(n - len(a), m - len(b))
	if moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	grid = []
	for i in range(n):
		grid.append(list(map(int, input().split())))
	hor = 0
	ver = 0
	for i in range(n):
		if 1 not in grid[i]:
			hor += 1
	for j in range(m):
		flag = True
		for i in range(n):
			if grid[i][j] == 1:
				flag = False
				break
		if flag:
			ver += 1
	poss = min(hor, ver)
	if poss % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for q in range(0, t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(0, n):
		a.append([int(i) for i in input().split()])
	rows = [0] * n
	cols = [0] * m
	for i in range(0, n):
		for j in range(0, m):
			if a[i][j] == 1:
				rows[i] = 1
				cols[j] = 1
	count = 0
	for i in range(0, n):
		for j in range(0, m):
			if rows[i] == 0 and cols[j] == 0:
				count += 1
				rows[i] += 1
				cols[j] += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout

def main():
	for t in range(int(stdin.readline())):
		(n, m) = map(int, stdin.readline().strip().split())
		a = []
		for i in range(n):
			a.append(list(map(int, stdin.readline().strip().split())))
		count = 0
		for i in range(n):
			for j in range(m):
				if a[i][j] == 0:
					flag = 0
					for k in range(m):
						if a[i][k] == 1:
							flag = 1
							break
					for k in range(n):
						if a[k][j] == 1:
							flag = 1
							break
					if flag == 0:
						count += 1
						a[i][j] = 1
		if count % 2 == 0:
			stdout.write('Vivek\n')
		else:
			stdout.write('Ashish\n')
main()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = [[0] * m] * n
	countrow = 0
	countcol = 0
	for i in range(0, n):
		a[i] = list(map(int, input().split()))
		if a[i].count(1) > 0:
			countrow += 1
	for i in range(0, m):
		for j in range(0, n):
			if a[j][i] == 1:
				countcol += 1
				break
	rem = min(n - countrow, m - countcol)
	if rem % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	(n, m) = list(map(int, input().split()))
	board = []
	winner = 0
	pos = 0
	for i in range(n):
		board.append(list(map(int, input().split())))
	for i in board:
		if i.count(1) != 0:
			pos += 1
			continue
		else:
			for j in range(m):
				aux = 0
				for cell in board:
					if cell[j] != 0:
						aux = 1
						break
				if aux == 0:
					board[pos][j] = 1
					winner += 1
					break
	if winner % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for test_case in range(int(input())):
	(n, m) = map(int, input().split())
	game_board = [list(map(int, input().split())) for values in range(n)]
	cols = set(range(m))
	rows = set(range(n))
	for (y, l) in enumerate(game_board):
		for (x, c) in enumerate(l):
			if c == 1:
				cols.discard(x)
				rows.discard(y)
	r = min(len(cols), len(rows))
	print('Ashish' if r % 2 == 1 else 'Vivek')


from functools import reduce
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase
input = lambda : sys.stdin.readline().rstrip('\r\n')

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

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

def sarr():
	return [int(i) for i in input()]

def inn():
	return int(input())
mo = 1000000007
t = inn()
while t:
	t -= 1
	(n, m) = value()
	a = [arr() for i in range(n)]
	ox = defaultdict(int)
	oy = defaultdict(int)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				ox[i] += 1
				oy[j] += 1
	ans = 'Ashish'
	c = 0
	for i in range(n):
		for j in range(m):
			if ox[i] == 0 and oy[j] == 0:
				c += 1
				ox[i] += 1
				oy[j] += 1
	if c % 2 == 1:
		print(ans)
	else:
		print('Vivek')


def solve():
	(n, m) = map(int, input().split())
	a = [list(map(int, input().split())) for _ in range(n)]
	(r, c) = ([False] * n, [False] * m)
	for i in range(n):
		for j in range(m):
			if a[i][j]:
				r[i] = True
				c[j] = True
	w = min(r.count(False), c.count(False))
	print('Ashish' if w % 2 == 1 else 'Vivek')
t = int(input())
for _ in range(t):
	solve()


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	ls = []
	for j in range(n):
		ls.append([int(a) for a in input().split()])
	(un, um) = (0, 0)
	for j in range(n):
		if 1 not in ls[j]:
			un += 1
	for j in range(m):
		bp = False
		for k in range(n):
			if ls[k][j] == 1:
				bp = True
				break
		if bp == False:
			um += 1
	if min(un, um) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


I = input
t = int(I())
for tt in range(t):
	(n, m) = [int(x) for x in I().strip().split()]
	arr = []
	for i in range(n):
		cols = list((int(x) for x in I().strip().split()))
		arr.append(cols)
	a = 0
	b = 0
	for row in arr:
		if row.count(1) == 0:
			a += 1
	for j in range(m):
		fg = 1
		for i in range(n):
			if arr[i][j] == 1:
				fg = 0
				break
		if fg == 1:
			b += 1
	cnt = min(a, b)
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from random import random
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	field = []
	for i in range(n):
		field.append(list(map(int, input().split())))
	afield = []
	for i in range(n):
		if sum(field[i]) != 0:
			afield.append([1] * m)
		else:
			afield.append([0] * m)
	for i in range(m):
		if sum((field[j][i] for j in range(n))) != 0:
			for j in range(n):
				afield[j][i] = 1
	s = 0
	s1 = 0
	for i in range(n):
		s += min(1, m - sum(afield[i]))
	for i in range(m):
		s1 += min(1, n - sum((afield[j][i] for j in range(n))))
	(s, s1) = (min(s, s1), max(s, s1))
	if s % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	A = [list(map(int, input().split())) for _ in range(n)]
	pl = False
	for i in range(n):
		for j in range(m):
			fl = True
			for k in range(n):
				fl &= not A[k][j]
			for k in range(m):
				fl &= not A[i][k]
			if fl:
				A[i][j] = 1
				pl ^= True
	print('Ashish') if pl else print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	r = [0] * n
	for i in range(n):
		a = list(map(int, input().split()))
		if 1 in a:
			r[i] = 1
		mat.append(a)
	c = [0] * m
	for i in range(m):
		for j in range(n):
			if mat[j][i] == 1:
				c[i] = 1
				break
	count = 0
	rd = 0
	cd = 0
	for i in r:
		if i == 1:
			rd += 1
	for i in c:
		if i == 1:
			cd += 1
	rd = n - rd
	cd = m - cd
	ma = min(rd, cd)
	if ma % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	l = []
	for j in range(n):
		a = list(map(int, input().split()))
		l.append(a)
	b = []
	c1 = 0
	c2 = 0
	for j in l:
		if 1 in j:
			c1 = c1 + 1
	for i in range(m):
		for j in range(n):
			if l[j][i] == 1:
				c2 = c2 + 1
				break
	x = min(n - c1, m - c2)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t != 0:
	t -= 1
	(n, m) = [int(x) for x in input().split()]
	l = []
	for i in range(n):
		arr = list(map(int, input().split()))
		l.append(arr)
	c = [-1] * m
	r = [-1] * n
	for x in range(len(l)):
		for j in range(len(l[x])):
			if l[x][j] == 1:
				c[j] = 1
				r[x] = 1
	if c.count(1) == m or r.count(1) == n:
		print('Vivek')
		continue
	else:
		k = min(c.count(-1), r.count(-1))
		if k % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')


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, m) = map(int, input().split())
	r = []
	for i in range(n):
		a = list(map(int, input().split()))
		r.append(a)
	affr = [0 for i in range(n)]
	affc = [0 for i in range(m)]
	for i in range(n):
		for j in range(m):
			if r[i][j] == 1:
				affr[i] = 1
				affc[j] = 1
	tu = 0
	for i in range(n):
		for j in range(m):
			if affr[i] == affc[j] == 0:
				tu += 1
				affr[i] = 1
				affc[j] = 1
	if tu % 2:
		print('Ashish')
	else:
		print('Vivek')


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

def read_ints():
	return map(int, input().split())
t = read_int()
for _ in range(t):
	(n, m) = read_ints()
	mat = []
	for i in range(n):
		mat.append(list(read_ints()))
	even = 0
	odd = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				break
		else:
			even += 1
	for i in range(m):
		for j in range(n):
			if mat[j][i] == 1:
				break
		else:
			odd += 1
	res = min(even, odd)
	if res % 2:
		print('Ashish')
	else:
		print('Vivek')


from collections import deque
from collections import OrderedDict
import math
import sys
import os
from io import BytesIO
import threading
import bisect
import heapq
input = lambda : sys.stdin.readline().rstrip('\r\n')
for t in range(int(input())):
	(n, m) = map(int, input().split())
	arr = [[0] * m for i in range(n)]
	for i in range(n):
		arr[i] = list(map(int, input().split()))
	coR = 0
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				break
		else:
			coR += 1
	coC = 0
	for j in range(m):
		for i in range(n):
			if arr[i][j] == 1:
				break
		else:
			coC += 1
	answer = min(coC, coR)
	if answer % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	grid = [list(map(int, input().split())) for _ in range(n)]
	(r, c) = (set(), set())
	for y in range(n):
		for x in range(m):
			if grid[y][x] == 1:
				r.add(y)
				c.add(x)
	print(['Vivek', 'Ashish'][min(n - len(r), m - len(c)) % 2])


t = int(input())
for i in range(t):
	(n, m) = tuple(map(int, input().split()))
	d = min(n, m)
	taken_rows = set()
	taken_cols = set()
	for r in range(n):
		row = list(map(int, input().split()))
		for c in range(m):
			if row[c] == 1:
				taken_rows.add(r)
				taken_cols.add(c)
	remaining_rows = n - len(taken_rows)
	remaining_cols = m - len(taken_cols)
	possible_moves = min(remaining_rows, remaining_cols)
	print('Ashish' if possible_moves & 1 else 'Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	b = []
	for i in range(n):
		b.append([int(i) for i in input().split()])
	cc = [True for i in range(m)]
	cr = [True for i in range(n)]
	t = 0
	for row in range(n):
		for col in range(m):
			if b[row][col] == 1:
				cc[col] = False
				cr[row] = False
	for i in range(n):
		for j in range(m):
			if cc[j] and cr[i]:
				t += 1
				cc[j] = False
				cr[i] = False
	if t % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	r = 0
	p = set()
	q = set()
	for _ in range(n):
		k = list(map(int, input().split()))
		c = 0
		for i in k:
			if i == 1:
				p.add(r)
				q.add(c)
			c += 1
		r += 1
	count = 0
	for i in range(n):
		for j in range(m):
			if i in p or j in q:
				continue
			elif i not in p and j not in q:
				p.add(i)
				q.add(j)
				count += 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math

def main():
	t = int(input())
	for _ in range(t):
		rc = input().split()
		r = int(rc[0])
		c = int(rc[1])
		matrix = []
		for q in range(r):
			w = list(map(int, input().split()))
			matrix.append(w)
		name = False
		for i in range(r):
			for j in range(c):
				if matrix[i][j] == 0 and 1 not in matrix[i] and (1 not in [p[j] for p in matrix]):
					matrix[i][j] = 1
					name = not name
		if name:
			print('Ashish')
		else:
			print('Vivek')
main()


try:
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		arr = []
		cnt = 0
		for __ in range(n):
			arr1 = list(map(int, input().split()))
			arr.append(arr1)
		row = [0] * n
		col = [0] * m
		for i in range(n):
			for j in range(m):
				if arr[i][j]:
					row[i] = 1
					col[j] = 1
		while True:
			i = j = 0
			while i < n:
				if row[i] == 0:
					break
				i += 1
			while j < m:
				if col[j] == 0:
					break
				j += 1
			if i < n and j < m:
				cnt += 1
				row[i] = 1
				col[j] = 1
			else:
				break
		if cnt % 2 != 0:
			print('Ashish')
		else:
			print('Vivek')
except EOFError:
	pass


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	li = []
	cnt = 0
	row = [True] * n
	col = [True] * m
	for i in range(n):
		a = list(map(int, input().split()))
		li.append(a)
	for i in range(n):
		for j in range(m):
			if li[i][j] == 1:
				row[i] = False
				col[j] = False
	for i in range(n):
		for j in range(m):
			if row[i] == True and col[j] == True:
				li[i][j] = 1
				row[i] = False
				col[j] = False
				cnt += 1
	if cnt & 1:
		print('Ashish')
	else:
		print('Vivek')


import sys

def input():
	return sys.stdin.readline().rstrip()
t = int(input())
answers = []
for _ in range(t):
	(n, m) = [int(i) for i in input().split()]
	grid = []
	for _ in range(n):
		grid.append([int(i) for i in input().split()])
	used_row = [False for i in range(n)]
	used_col = [False for i in range(m)]
	for i in range(n):
		for j in range(m):
			used_col[j] = used_col[j] or grid[i][j] == 1
			used_row[i] = used_row[i] or grid[i][j] == 1
	available_rows = sum([0 if i else 1 for i in used_row])
	available_cols = sum([0 if i else 1 for i in used_col])
	pending = min(available_cols, available_rows)
	if pending % 2 == 1:
		ans = 'Ashish'
	else:
		ans = 'Vivek'
	answers.append(ans)
print(*answers, sep='\n')


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())
entries = inp()
for i in range(entries):
	l = inlt()
	n = l[0]
	m = l[1]
	free_col = list(range(m))
	free_row = list(range(n))
	for j in range(n):
		l = inlt()
		for k in range(m):
			if l[k] == 1:
				if j in free_row:
					free_row.remove(j)
				if k in free_col:
					free_col.remove(k)
	z = min(len(free_col), len(free_row))
	if z % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for ghjkl in range(t):
	(n, m) = map(int, input().split())
	a = [[0 for i in range(m)] for j in range(n)]
	for i in range(n):
		a[i] = list(map(int, input().split()))
	A = [0] * n
	B = [0] * m
	for i in range(n):
		s = 0
		for j in range(m):
			s += a[i][j]
		A[i] = s
	for j in range(m):
		s = 0
		for i in range(n):
			s += a[i][j]
		B[j] = s
	step = 0
	hod = True
	while hod:
		hod = False
		for i in range(n):
			for j in range(m):
				if A[i] == 0 and B[j] == 0:
					a[i][j] = 1
					A[i] = 1
					B[j] = 1
					step += 1
					hod = True
	if (step + 1) % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	list1 = []
	for _ in range(n):
		t = []
		t = list(map(int, input().split()))
		list1.append(t)
	row = []
	col = []
	for i in range(n):
		for j in range(m):
			if list1[i][j] == 1:
				row.append(i)
				col.append(j)
	row = list(dict.fromkeys(row))
	col = list(dict.fromkeys(col))
	count = 0
	for i in range(n):
		if i not in row:
			for j in range(m):
				if j not in col:
					count += 1
					row.append(i)
					col.append(j)
					break
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	l = []
	for j in range(n):
		l.append(list(map(int, input().split())))
	x1 = []
	x2 = []
	x3 = 0
	x4 = 0
	for w in range(n):
		c = 0
		for w2 in range(m):
			c += l[w][w2]
		x1.append(c)
	for w3 in range(m):
		p = 0
		for w4 in range(n):
			p += l[w4][w3]
		x2.append(p)
	x3 = x1.count(0)
	x4 = x2.count(0)
	x5 = min(x3, x4)
	if x5 % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for i in range(int(input())):
	(n, m) = map(int, input().split())
	r = [0] * n
	c = [0] * m
	for j in range(n):
		a = input().split()
		for k in range(m):
			if a[k] == '1':
				r[j] = 1
				c[k] = 1
	sumr = 0
	sumc = 0
	for j in range(n):
		if r[j] == 1:
			sumr += 1
	for k in range(m):
		if c[k] == 1:
			sumc += 1
	res = min(n - sumr, m - sumc)
	print('Ashish' if res & 1 else 'Vivek')


t = int(input())
for test in range(t):
	(n, m) = [int(x) for x in input().split()]
	row = [0] * n
	col = [0] * m
	for i in range(n):
		temp = [int(x) for x in input().split()]
		for j in range(m):
			if temp[j] == 1:
				row[i] = 1
				col[j] = 1
	last = 1
	for i in range(n):
		if row[i] == 0:
			for j in range(m):
				if col[j] == 0:
					row[i] = 1
					col[j] = 1
					last += 1
					break
	if last % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	c = 0
	l = []
	for i in range(n):
		a = list(map(int, input().split()))
		l.append(a)
	for i in range(n):
		for j in range(m):
			if l[i][j] == 0:
				f = 0
				s = 0
				for k in range(m):
					if l[i][k] != 0:
						f = 1
						break
				for x in range(n):
					if l[x][j] != 0:
						s = 1
						break
				if f == 0 and s == 0:
					c = c + 1
					l[i][j] = 1
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(a, b) = map(int, input().split())
	l = []
	for i in range(a):
		l.append(list(map(int, input().split())))
	(p, q) = (0, 0)
	for i in l:
		if len(set(i)) == 1 and i[0] == 0:
			p += 1
	for i in range(b):
		h = 0
		for j in range(a):
			if l[j][i] == 0:
				h += 1
			else:
				break
		if h == a:
			q += 1
	z = min(p, q)
	if z % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def column(matrix, i):
	return [row[i] for row in matrix]
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	c1 = 0
	for i in range(n):
		if a[i].count(0) == m:
			c1 += 1
	c2 = 0
	for i in range(m):
		if list(column(a, i)).count(0) == n:
			c2 += 1
	c = min(c1, c2)
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve(n, m, field):
	for y in range(0, n):
		for x in range(0, m):
			if field[y][x] == 1:
				field[y][x] = 'X'
				for x1 in range(0, m):
					if field[y][x1] != 1:
						field[y][x1] = 'X'
				for y1 in range(0, n):
					if field[y1][x] != 1:
						field[y1][x] = 'X'
	filled_x = []
	turns = 0
	for y in range(0, n):
		for x in range(0, m):
			if field[y][x] == 0:
				if x not in filled_x:
					turns += 1
					filled_x.append(x)
					break
	if turns % 2 == 0:
		name = 'Vivek'
	else:
		name = 'Ashish'
	return name
t = int(input())
answers = []
for i in range(t):
	(n, m) = [int(j) for j in input().split()]
	field = [[int(j) for j in input().split()] for k in range(n)]
	ans = solve(n, m, field)
	answers.append(ans)
for i in answers:
	print(i)


t = int(input())
while t:
	t -= 1
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		temp = list(map(int, input().split()))
		a.append(temp)
	rows = 0
	cols = 0
	for i in range(n):
		claimed = False
		for j in range(m):
			if a[i][j] == 1:
				claimed = True
				break
		if not claimed:
			rows += 1
	for i in range(m):
		claimed = False
		for j in range(n):
			if a[j][i] == 1:
				claimed = True
				break
		if not claimed:
			cols += 1
	ans = min(rows, cols)
	if ans % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		a = [int(i) for i in input().split()]
		arr.append(a)
	Arr = []
	for i in range(m):
		z = []
		for j in range(n):
			z.append(arr[j][i])
		Arr.append(z)
	cnt = 0
	for i in range(n):
		if 1 not in arr[i]:
			cnt += 1
	ans = 0
	for i in range(m):
		if 1 not in Arr[i]:
			ans += 1
		x = min(cnt, ans)
	if x % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


for i in range(int(input())):
	(n, m) = map(int, input().split())
	vert = set()
	gor = set()
	matrix = list((list() for j in range(n)))
	for j in range(n):
		arr = list(map(int, input().split()))
		matrix[j] = arr
	for j in range(n):
		for h in range(m):
			if matrix[j][h] == 1:
				vert.add(h)
				gor.add(j)
	ans = min(m - len(vert), n - len(gor))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


List = []
n = eval(input())
for i in range(n):
	(a, b) = input().split()
	a = int(a)
	b = int(b)
	for j in range(a):
		mtline = input().split()
		List.append(mtline)
	getl = 0
	for j in range(a):
		if '1' not in List[j]:
			getl += 1
	getc = 0
	for j in range(b):
		for i in range(a):
			if List[i][j] == '1':
				break
		else:
			getc += 1
	x = min(getc, getl)
	if x % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
	List.clear()


for i in range(int(input())):
	(n, m) = map(int, input().split())
	arr = [list(map(int, input().split())) for i in range(n)]
	temp = []
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				temp.append((i, j))
	for k in temp:
		(x, y) = k
		for i in range(n):
			arr[i][y] = 1
		arr[x] = [1] * m
	rows = set([])
	cols = set([])
	cnt = 0
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 0:
				if i not in rows and j not in cols:
					cnt += 1
					rows.add(i)
					cols.add(j)
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	inp = []
	for i in range(n):
		inp.append(list(map(int, input().split())))
	p = 0
	c = 0
	while p < n:
		d = 0
		while d < m:
			if inp[p][d] == 1:
				for j in range(m):
					if inp[p][j] == 0:
						inp[p][j] = -1
				for j in range(n):
					if inp[j][d] == 0:
						inp[j][d] = -1
				inp[p][d] = -1
			d += 1
		p += 1
	p = 0
	while p < n:
		d = 0
		while d < m:
			if inp[p][d] == 0:
				c += 1
				for j in range(m):
					if inp[p][j] == 0:
						inp[p][j] = -1
				for j in range(n):
					if inp[j][d] == 0:
						inp[j][d] = -1
				inp[p][d] = -1
			d += 1
		p += 1
	if c == 0:
		print('Vivek')
	elif c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
t = int(input())
for i in range(t):
	mat = []
	(n, m) = map(int, input().split())
	for j in range(n):
		r = [int(i) for i in input().split() if i != '\n']
		mat.append(r)
	row = [0] * n
	col = [0] * m
	for j in range(len(mat)):
		for k in range(m):
			if mat[j][k] == 1:
				row[j - 1] = 1
				col[k - 1] = 1
	pq = min(n - sum(row), m - sum(col))
	if pq % 2:
		sys.stdout.write('Ashish' + '\n')
	else:
		sys.stdout.write('Vivek' + '\n')


import sys
from collections import defaultdict as dd
from queue import Queue
import math
import itertools
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
input = lambda : sys.stdin.buffer.readline().rstrip()
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	k = 0
	e = 0
	r = 0
	for i in range(n):
		if a[i].count(1) == 0:
			k += 1
	for j in range(m):
		for i in range(n):
			if a[i][j] != 0:
				r = 1
		if r == 0:
			e += 1
		else:
			r = 0
	if min(e, k) % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


import sys

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

def idata():
	return [int(x) for x in ii().split()]

def solve_of_problem():
	(n, m) = idata()
	y = 0
	data = [0] * m
	for j in range(n):
		a = idata()
		for i in range(m):
			data[i] += a[i]
		if sum(a) == 0:
			y += 1
	x = data.count(0)
	s = min(x, y)
	if s % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	return
for ______ in range(int(ii())):
	solve_of_problem()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	c = set()
	r = 0
	for _ in range(n):
		d = 1
		for (i, v) in enumerate(map(int, input().split())):
			if v:
				c.add(i)
				d = 0
		r += d
	k = min(r, m - len(c))
	print('Ashish' if k & 1 else 'Vivek')


num_cases = int(input())
for n in range(num_cases):
	input_list = input().split()
	input_list = [int(n) for n in input_list]
	num_rows = input_list[0]
	num_cols = input_list[1]
	rows = set()
	cols = set()
	for i in range(num_rows):
		row = input().split()
		for j in range(num_cols):
			if row[j] == '1':
				rows.add(i)
				cols.add(j)
	rows_left = num_rows - len(rows)
	cols_left = num_cols - len(cols)
	if min(rows_left, cols_left) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


tests = int(input())
for _ in range(tests):
	(n, m) = map(int, input().split())
	d = []
	d1 = []
	for _ in range(n):
		d.append(list(map(int, input().split())))
	for i in range(m):
		s = []
		for j in range(n):
			s.append(d[j][i])
		d1.append(s)
	t = 0
	for i in range(n):
		if d[i] == [0] * m:
			f = -1
			for j in range(m):
				if d1[j] == [0] * n:
					d[i][j] = 1
					d1[j][i] = 1
					t += 1
					f = 0
					break
			if f == -1:
				break
	if t % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for i in range(int(input())):
	a = list(map(int, input().strip().split()))[:2]
	b = []
	n = []
	m = []
	for j in range(a[0]):
		c = list(map(int, input().strip().split()))[:a[1]]
		b.append(c)
	for k in range(len(b)):
		for g in range(a[1]):
			if b[k][g] == 1:
				if n.count(k) == 0:
					n.append(k)
				if m.count(g) == 0:
					m.append(g)
	r = len(n)
	w = len(m)
	r = a[0] - r
	w = a[1] - w
	d = 0
	while r != 0 and w != 0:
		d += 1
		r -= 1
		w -= 1
	if d % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from math import *

def r1(t):
	return t(input())

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

def r3(t):
	return [t(i) for i in input()]
for _ in range(r1(int)):
	(n, m) = r2(int)
	a = []
	for i in range(n):
		a.append(r2(int))
	c = 0
	for i in range(n):
		if sum(a[i]) > 0:
			c += 1
	c2 = 0
	for j in range(m):
		for i in range(n):
			if a[i][j] > 0:
				c2 += 1
				break
	if min(n - c, m - c2) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input().strip())
for i in range(t):
	(n, m) = input().strip().split(' ')
	n = int(n)
	m = int(m)
	rCount = 0
	cArr = [1 for i in range(m)]
	arr = [[0 for i in range(m)] for j in range(n)]
	for i in range(n):
		arr[i] = list(map(int, input().strip().split(' ')))
		for j in range(m):
			if arr[i][j] != 0:
				cArr[j] = 0
		if sum(arr[i]) == 0:
			rCount += 1
	cCount = sum(cArr)
	result = min(rCount, cCount)
	if result % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	(m, n) = map(int, input().split())
	arr = []
	for i in range(m):
		a = list(map(int, input().split()))
		arr.append(a)
	row = list(map(lambda x: sum(x), arr))
	n_row = 0
	for i in row:
		if i == 0:
			n_row += 1
	arr_ = []
	for j in range(n):
		a = []
		for i in range(m):
			a.append(arr[i][j])
		arr_.append(a)
	col = list(map(lambda x: sum(x), arr_))
	n_col = 0
	for i in col:
		if i == 0:
			n_col += 1
	x = min(n_row, n_col)
	if x % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


tc = int(input())
while tc:
	tc -= 1
	(r, c) = list(map(int, input().split(' ')))
	(r1, c1) = (set([]), set([]))
	arr = []
	for i in range(r):
		t = list(map(int, input().split(' ')))
		arr.append(t)
	for i in range(r):
		for j in range(c):
			if arr[i][j] == 1:
				r1.add(i)
				c1.add(j)
	t = min(r - len(r1), c - len(c1))
	if t % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
	(n, m) = map(int, input().split())
	A = [list(map(int, input().split())) for i in range(n)]
	C = [0] * n
	R = [0] * m
	for i in range(n):
		for j in range(m):
			if A[i][j] == 1:
				C[i] = 1
				R[j] = 1
	k = 0
	for i in range(n):
		if C[i] == 0:
			k += 1
	l = 0
	for i in range(m):
		if R[i] == 0:
			l += 1
	if min(k, l) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


tests = int(input())
for test in range(tests):
	r = 0
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		b = list(map(int, input().split()))
		if 1 not in b:
			r += 1
		a.append(b)
	c = 0
	for i in range(m):
		ok = 1
		for j in range(n):
			if a[j][i] == 1:
				ok = 0
		c += ok
	res = min(r, c)
	print(['Vivek', 'Ashish'][res % 2 != 0])


t = int(input())
while t:
	t += -1
	(n, m) = map(int, input().split())
	l = []
	row = [0] * n
	col = [0] * m
	for i in range(n):
		tmp = list(map(int, input().split()))
		l.append(tmp)
		for j in range(m):
			if tmp[j] == 1:
				col[j] = 1
				row[i] = 1
	cntro = 0
	for i in row:
		if i == 0:
			cntro -= -1
	cntcol = 0
	for i in col:
		if i == 0:
			cntcol -= -1
	mn = min(cntro, cntcol)
	if mn % 2:
		print('Ashish')
	else:
		print('Vivek')


cases = int(input())
answers = [] * 0
for problems in range(cases):
	(n, m) = [int(x) for x in input().split()]
	matrix = [[int(x) for x in input().split()] for lines in range(n)]
	numOpenCols = 0
	numOpenRows = 0
	for i in range(n):
		bOpen = True
		for j in range(m):
			if matrix[i][j] == 1:
				bOpen = False
		if bOpen:
			numOpenCols += 1
	for j in range(m):
		bOpen = True
		for i in range(n):
			if matrix[i][j] == 1:
				bOpen = False
		if bOpen:
			numOpenRows += 1
	answers.append('Ashish') if min(numOpenCols, numOpenRows) % 2 else answers.append('Vivek')
for answer in answers:
	print(answer)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	x = set()
	y = set()
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				x.add(i)
				y.add(j)
	cnt = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 0:
				if i not in x and j not in y:
					cnt += 1
					x.add(i)
					y.add(j)
	if cnt & 1:
		print('Ashish')
	else:
		print('Vivek')


def win(n, m, a):
	rows = {}
	cols = {}
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				rows[i] = 1
				cols[j] = 1
	return min(n - len(rows), m - len(cols)) % 2 == 1
cases = int(input().strip())
for _ in range(cases):
	(n, m) = list(map(int, input().strip().split()))
	a = []
	for _ in range(n):
		a.append(list(map(int, input().strip().split())))
	print('Ashish' if win(n, m, a) else 'Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		ll = list(map(int, input().split()))
		l.append(ll)
	c = 0
	r = 0
	for i in range(n):
		if l[i] == [0] * m:
			c += 1
	for j in range(m):
		p = [l[x][j] for x in range(n)]
		if p == [0] * n:
			r += 1
	if min(r, c) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


n_games = int(input())
for _ in range(n_games):
	[n, m] = list(map(int, input().split(' ')))
	a = [[0 for j in range(m)] for i in range(n)]
	for i in range(n):
		a[i] = list(map(int, input().split(' ')))
	rows_used = [False for _ in range(n)]
	cols_used = [False for _ in range(m)]
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				rows_used[i] = True
				cols_used[j] = True
	is_ashis = True
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0 and (not rows_used[i]) and (not cols_used[j]):
				rows_used[i] = True
				cols_used[j] = True
				is_ashis = not is_ashis
	if is_ashis:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout

def main():
	t = int(stdin.readline())
	ans = [None for i in range(t)]
	for q in range(t):
		(n, m) = map(int, stdin.readline().split())
		tabl = []
		for i in range(n):
			row = [int(x) for x in stdin.readline().split()]
			tabl.append(row)
		rows = 0
		columns = 0
		for i in range(n):
			empty = True
			for j in range(m):
				if tabl[i][j] == 1:
					empty = False
			if empty:
				rows += 1
		for j in range(m):
			empty = True
			for i in range(n):
				if tabl[i][j] == 1:
					empty = False
			if empty:
				columns += 1
		if min(rows, columns) % 2:
			ans[q] = 'Ashish'
		else:
			ans[q] = 'Vivek'
	for i in range(t):
		print(ans[i])
main()


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	items = []
	rows = 0
	columns = 0
	for i in range(n):
		item = list(map(int, input().split()))
		if 1 in item:
			rows += 1
		items.append(item)
	for i in range(m):
		sth = [x[i] for x in items]
		if 1 in sth:
			columns += 1
	res = min([m - columns, n - rows])
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout

def get_int():
	return int(stdin.readline().strip())

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

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

def get_string():
	return stdin.readline().strip()

def op(c):
	return stdout.write(c)
from collections import defaultdict
for _ in range(int(stdin.readline())):
	(n, m) = get_ints()
	ar = []
	for i in range(n):
		ar.append(get_array())
	row = [0] * n
	col = [0] * m
	for i in range(n):
		for j in range(m):
			if ar[i][j] == 1:
				row[i] += 1
				col[j] += 1
	a = 1
	for i in range(n):
		for j in range(m):
			if row[i] == 0:
				if col[j] == 0:
					row[i] += 1
					col[j] += 1
					a += 1
				else:
					continue
	if a % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


def populate(arr, n, m, i, j):
	for p in range(n):
		if arr[p][j] != 1:
			arr[p][j] = 2
	for q in range(m):
		if arr[i][q] != 1:
			arr[i][q] = 2
t = int(input())
while t:
	if t == 0:
		break
	t -= 1
	x = input()
	x = x.split()
	n = int(x[0])
	m = int(x[1])
	arr = [[0 for i in range(m)] for i in range(n)]
	for i in range(n):
		x = input()
		x = x.split()
		x = [int(y) for y in x]
		for j in range(len(x)):
			arr[i][j] = x[j]
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				populate(arr, n, m, i, j)
	win = 1
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 0:
				win *= -1
				populate(arr, n, m, i, j)
				arr[i][j] = 1
	if win == 1:
		print('Vivek')
	else:
		print('Ashish')


def result(mat, x, y, n, m, count):
	r = False
	f = False
	for a in range(m):
		if mat[x][a] == 1:
			r = True
			break
	for a in range(n):
		if mat[a][y] == 1:
			f = True
			break
	if r == False and f == False:
		count[0] = count[0] + 1
		return True
	return False
t = int(input())
i = 0
while i < t:
	(n, m) = map(int, input().split())
	mat = []
	for x in range(n):
		a = list(map(int, input().split()))
		mat.append(a)
	count = [0]
	for x in range(n):
		for y in range(m):
			if mat[x][y] == 0:
				a = result(mat, x, y, n, m, count)
				if a == True:
					mat[x][y] = 1
	if count[0] % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	i = i + 1


from collections import defaultdict
test = int(input())
for i in range(test):
	(n, m) = [int(x) for x in input().split(' ')]
	a = []
	fre = defaultdict(int)
	fre1 = defaultdict(int)
	row = 0
	col = 0
	for i in range(n):
		temp = [int(x) for x in input().split(' ')]
		a.append(temp)
	for i in range(n):
		a1 = 0
		for j in range(m):
			a1 = a1 | a[i][j]
		if a1 == 0:
			if i not in fre:
				fre[i] = 1
				row += 1
	for i in range(m):
		a1 = 0
		for j in range(n):
			a1 = a1 | a[j][i]
		if a1 == 0:
			if i not in fre1:
				fre1[i] = 1
				col += 1
	if min(row, col) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l1 = [int(j) for j in input().split()]
		l.append(l1)
	rows = [0] * n
	column = [0] * m
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				rows[i] = 1
				column[j] = 1
	(r, c) = (0, 0)
	for i in range(n):
		if rows[i] == 0:
			r += 1
	for j in range(m):
		if column[j] == 0:
			c += 1
	result = min(r, c)
	if result & 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
l1 = []
for i in range(t):
	l = []
	n = list(map(int, input().split()))
	for j in range(n[0]):
		s = list(map(int, input().split()))
		l.append(s)
	l1.append(l)
for m in l1:
	lr = [i for i in range(len(m))]
	lc = [i for i in range(len(m[0]))]
	win = 1
	a = len(lr)
	b = len(lc)
	for i in range(a):
		for j in range(b):
			if m[i][j] == 1:
				if i in lr:
					lr.remove(i)
				if j in lc:
					lc.remove(j)
	while len(lr) > 0 and len(lc) > 0:
		win = -win
		m[lr[0]][lc[0]] = 1
		lr.remove(lr[0])
		lc.remove(lc[0])
	if win == -1:
		print('Ashish')
	else:
		print('Vivek')


for i in range(int(input())):
	(a, b) = map(int, input().split())
	cells = [input().split() for i in range(a)]
	count = min(sum([1 for i in range(a) if '1' not in [cells[i][d] for d in range(b)]]), sum([1 for i in range(b) if '1' not in [cells[d][i] for d in range(a)]]))
	if count % 2:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	c = 0
	for i in range(n):
		b = list(map(int, input().split()))
		a += [b]
	for i in range(n):
		for j in range(m):
			flag = 1
			if a[i][j] == 0:
				if a[i].count(1) == 0:
					for k in range(n):
						if a[k][j] == 1:
							flag = 0
							break
					if flag:
						a[i][j] = 1
						c += 1
	if c % 2:
		print('Ashish')
	else:
		print('Vivek')


def time(arr):
	r = 0
	for i in arr:
		if 1 not in i:
			r = r + 1
	col = []
	for i in range(len(arr)):
		for j in range(len(arr[0])):
			if arr[i][j] == 1:
				col.append(j)
	c = len(arr[0]) - len(set(col))
	res = min(r, c)
	if res % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
t = int(input())
ans = []
for i in range(t):
	arr = list(map(int, input().rstrip().split()))
	ar = []
	for j in range(arr[0]):
		oo = list(map(int, input().rstrip().split()))
		ar.append(oo)
	ee = time(ar)
	ans.append(ee)
for i in ans:
	print(i)


t = int(input())
for tt in range(0, t):
	(n, m) = map(int, input().split())
	a = []
	s = []
	for i in range(0, n):
		b = list(map(int, input().split()))
		if 1 not in b:
			s.append(i)
		a.append(b)
	ss = []
	for i in range(0, m):
		f = 0
		for j in range(0, n):
			if a[j][i] == 1:
				f = 1
				break
		if f == 0:
			ss.append(i)
	l = len(ss)
	m = len(s)
	l = min(l, m)
	if l % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
i = 0
while i < t:
	(n, m) = list(map(int, input().split()))
	j = 0
	rows = set([ie for ie in range(n)])
	cols = set([ie for ie in range(m)])
	while j < n:
		a = list(map(int, input().split()))
		k = 0
		while k < m:
			if a[k] == 1:
				rows -= set([j])
				cols -= set([k])
			k += 1
		j += 1
	s = min(len(rows), len(cols))
	if s % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	i += 1


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

def gift():
	for _ in range(t):
		(n, m) = list(map(int, input().split()))
		zcount = 0
		kappre = [0] * m
		kappri = [0] * n
		didi = []
		for i in range(n):
			kap = list(map(int, input().split()))
			didi.append(kap)
			for j in range(m):
				if kap[j] == 1:
					kappre[j] = 1
					kappri[i] = 1
		for i in range(n):
			for j in range(m):
				if didi[i][j] == 0 and kappre[j] == 0 and (kappri[i] == 0):
					zcount += 1
					kappre[j] = 1
					kappri[i] = 1
		if zcount % 2:
			yield 'Ashish'
		else:
			yield 'Vivek'
t = int(input())
ans = gift()
print(*ans, sep='\n')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for j in range(n):
		l = list(map(int, input().split()))
		mat.append(l)
	(row, col) = (0, 0)
	for j in range(n):
		if mat[j].count(1) == 0:
			row += 1
	mat = list(zip(*mat))
	for j in range(m):
		if mat[j].count(1) == 0:
			col += 1
	x = min(row, col)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


I = input
for _ in [0] * int(I()):
	(n, m) = map(int, I().split())
	k = l = 0
	for _ in [0] * n:
		x = int(I().replace(' ', ''), 2)
		k += x < 1
		l |= x
	print('VAisvheiks h'[min(k, m - f'{l:b}'.count('1')) % 2::2])


from sys import stdin
input = stdin.readline
t = int(input())
for _ in range(t):
	(n, m) = [int(x) for x in input().split()]
	a = [[int(x) for x in input().split()] for _ in range(n)]
	r = set()
	c = set()
	for i in range(n):
		if not any(a[i]):
			r.add(i)
	for i in range(m):
		if not any([a[j][i] for j in range(n)]):
			c.add(i)
	if min(len(c), len(r)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	v = []
	for i in range(n):
		a = list(map(int, input().split()))
		v.append(a)
	r = [0 for i in range(n)]
	c = [0 for i in range(m)]
	for i in range(n):
		for j in range(m):
			if v[i][j] == 1:
				r[i] = 1
				c[j] = 1
	parity = 0
	while 1:
		flag = 0
		for i in range(n):
			for j in range(m):
				if r[i] == 0 and c[j] == 0:
					flag = 1
					r[i] = 1
					c[j] = 1
					parity ^= 1
					break
			if flag == 1:
				break
		if flag == 0:
			if parity == 0:
				print('Vivek')
			else:
				print('Ashish')
			break


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	for j in range(n):
		matrix.append(list(map(int, input().split())))
	count_row = 0
	for j in range(n):
		if 1 in matrix[j]:
			count_row = count_row + 1
		else:
			continue
	count_col = 0
	for j in range(m):
		for k in range(n):
			if matrix[k][j] == 1:
				count_col = count_col + 1
				break
	r = min(n - count_row, m - count_col)
	if r % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
read = sys.stdin.buffer.readline
mi = lambda : map(int, read().split())
cin = lambda : int(read())
li = lambda : list(mi())
for _ in range(cin()):
	(n, m) = mi()
	a = []
	(r, c) = (0, 0)
	rr = [0 for i in range(m)]
	for i in range(n):
		a.append(li())
		if a[-1] == rr:
			r += 1
	for j in range(m):
		flag = False
		for i in range(n):
			if a[i][j] == 1:
				flag = True
				break
		if flag:
			continue
		c += 1
	if min(r, c) % 2 == 0:
		print('Vivek')
	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, M, A):
	rc = 0
	for i in range(N):
		for j in range(M):
			if A[i][j] == 1:
				break
		else:
			rc += 1
	cc = 0
	for j in range(M):
		for i in range(N):
			if A[i][j] == 1:
				break
		else:
			cc += 1
	c = min(rc, cc)
	if c % 2 == 0:
		return 'Vivek'
	return 'Ashish'

def main():
	T = read_int()
	for _ in range(T):
		(N, M) = read_int_n()
		A = [read_int_n() for _ in range(N)]
		print(slv(N, M, A))
main()


for i in range(int(input())):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		t = []
		x = [int(i) for i in input().split()]
		arr.append(x)
	(c, d) = (0, 0)
	for i in range(n):
		f = 0
		for j in range(m):
			if arr[i][j] == 1:
				f = 1
		if f == 0:
			c += 1
	for i in range(m):
		s = 0
		for j in range(n):
			if arr[j][i] == 1:
				s = 1
		if s == 0:
			d += 1
	if min(c, d) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	grid = []
	bad = [0 for i in range(m)]
	ans = 0
	for i in range(n):
		row = list(map(int, input().split()))
		for j in range(m):
			if row[j] == 1:
				bad[j] = 1
		grid.append(row)
	for i in range(n):
		row = grid[i]
		if 1 not in row:
			for j in range(m):
				if bad[j]:
					continue
				else:
					ans += 1
					bad[j] = 1
					break
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
alist = [[0 for i in range(1100)] for j in range(1100)]
t = int(input())
while t > 0:
	t -= 1
	blist = list(map(int, input().split()))
	m = blist[0]
	n = blist[1]
	row = 0
	col = 0
	for i in range(m):
		line = list(map(int, input().split()))
		for j in range(len(line)):
			alist[i][j] = line[j]
	for i in range(m):
		for j in range(n):
			if alist[i][j] != 0:
				break
		else:
			row += 1
	for j in range(n):
		for i in range(m):
			if alist[i][j] != 0:
				break
		else:
			col += 1
	asw = min(row, col)
	if asw % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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

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

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

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

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

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

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
for _ in range(Int()):
	(r, c) = value()
	a = []
	row = set()
	col = set()
	for i in range(r):
		a.append(array())
	for i in range(r):
		for j in range(c):
			if a[i][j] == 1:
				row.add(i + 1)
				col.add(j + 1)
	(rl, cl) = (0, 0)
	rl = r - len(row)
	cl = c - len(col)
	ans = min(rl, cl)
	if ans % 2:
		print('Ashish')
	else:
		print('Vivek')


n = int(input())
gridFlag = False
doneFlag = False
doneCount = 0
while doneFlag == False:
	line = input()
	line = line.split()
	if gridFlag == False:
		numrow = int(line[0])
		numcol = int(line[1])
		rowList = []
		colList = list(range(numcol))
		rowcount = 0
		gridFlag = True
	else:
		rowcount += 1
		colcount = 0
		rowFlag = True
		for b in range(len(line)):
			col = int(line[b])
			colcount += 1
			if col == 1:
				colList[colcount - 1] = -1
				rowFlag = False
		if rowFlag == True:
			rowList.append(rowcount)
		if rowcount == numrow:
			gridFlag = False
			doneCount += 1
			if doneCount == n:
				doneFlag = True
			columnList = list(filter(lambda a: a != -1, colList))
			count = 0
			length = len(columnList)
			COUNTER = 0
			for row in rowList:
				if length > count:
					COUNTER += 1
				count += 1
			if COUNTER % 2 == 0:
				print('Vivek')
			else:
				print('Ashish')


T = int(input())
for _ in range(T):
	(N, M) = map(int, input().strip().split())
	mat = []
	for i in range(N):
		col = list(map(int, input().strip().split()))
		mat.append(col)
	rows = [i for i in range(N)]
	cols = [i for i in range(M)]
	for r in range(N):
		for c in range(M):
			if mat[r][c] == 1:
				if r in rows:
					rows.remove(r)
				if c in cols:
					cols.remove(c)
	possible = min(len(rows), len(cols))
	if possible % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
arr = []
for _ in range(t):
	(n, m) = map(int, input().split())
	l = []
	(n1, m1) = (0, 0)
	for _ in range(n):
		l.append(input().split())
	for i in range(n):
		n1 += int(l[i].count('1') == 0)
	for j in range(m):
		c = 0
		for i in range(n):
			c += int(l[i][j])
		if c == 0:
			m1 += 1
	res = min(n1, m1)
	arr.append('Ashish' if res % 2 else 'Vivek')
for i in arr:
	print(i)


def putOne(F, r, c, n, m):
	for i in range(n):
		F[i][c] = 1
	for i in range(m):
		F[r][i] = 1
test = int(input())
ans = []
for t in range(test):
	L = []
	F = []
	row_ori = []
	row_fake = []
	X = list(map(int, input().split()))
	n = X[0]
	m = X[1]
	for i in range(n):
		row_ori = list(map(int, input().split()))
		row_fake = [0 for i in range(m)]
		L.append(row_ori)
		F.append(row_fake)
	for x in range(n):
		for y in range(m):
			if L[x][y] == 1:
				putOne(F, x, y, n, m)
	z = 0
	for x in range(n):
		for y in range(m):
			if F[x][y] == 0:
				putOne(F, x, y, n, m)
				if z == 0:
					z = 1
				else:
					z = 0
	if z == 0:
		ans.append('Vivek')
	else:
		ans.append('Ashish')
for an in ans:
	print(an)


N = int(input())
for i in range(N):
	(n, m) = [int(x) for x in input().split()]
	t = []
	(n1, m1) = (n, m)
	for i in range(n):
		line = [int(x) for x in input().split()]
		if 1 in line:
			n1 -= 1
		t.append(line)
	for j in range(m):
		s = []
		for xs in t:
			s.append(xs[j])
		if 1 in s:
			m1 -= 1
	z = min(m1, n1)
	if z % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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

def solve():
	(h, w) = map(int, input().split())
	mat = [list(map(int, input().split())) for _ in range(h)]
	cntr = 0
	cntc = 0
	for i in range(h):
		fail = 0
		for j in range(w):
			if mat[i][j] == 1:
				fail = 1
		if not fail:
			cntr += 1
	for j in range(w):
		fail = 0
		for i in range(h):
			if mat[i][j] == 1:
				fail = 1
		if not fail:
			cntc += 1
	cntr = min(cntr, cntc)
	if cntr % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
for _ in range(t):
	solve()


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import bisect as bi
import string as st
import heapq

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

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

	def In():
		return map(int, input().split())
else:

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

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

def main():
	try:
		(n, m) = In()
		(col, row) = (set(), set())
		for i in range(n):
			temp = list(In())
			for j in range(m):
				if temp[j] == 1:
					col.add(j)
					row.add(i)
		n1 = n - len(row)
		m1 = m - len(col)
		t = min(n1, m1)
		if t & 1 == 1:
			print('Ashish')
		else:
			print('Vivek')
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(I()):
	main()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	c1 = 0
	for i in range(n):
		lt = list(map(int, input().split()))
		if lt.count(1) == 0:
			c1 += 1
		l.append(lt)
	c2 = 0
	for i in range(m):
		f = 0
		for j in range(n):
			if l[j][i] == 1:
				f = 1
		if f == 0:
			c2 += 1
	if min(c1, c2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve(matrix):
	rows = set()
	cols = set()
	for i in range(len(matrix)):
		for j in range(len(matrix[0])):
			if matrix[i][j]:
				rows.add(i)
				cols.add(j)
	r = len(matrix) - len(rows)
	c = len(matrix[0]) - len(cols)
	return min(r, c) % 2 == 0
t = int(input())
for _ in range(t):
	(m, n) = list(map(int, input().split()))
	matrix = []
	for _ in range(m):
		matrix.append(list(map(int, input().split())))
	if solve(matrix):
		print('Vivek')
	else:
		print('Ashish')


def matrix(dict):
	x = y = 0
	for i in range(n):
		if 1 not in dict[i]:
			x += 1
	for i in range(m):
		arr = []
		for j in range(n):
			arr.append(dict[j][i])
		if 1 not in arr:
			y += 1
	z = min(x, y)
	if z % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for a in range(t):
	(n, m) = map(int, input().split())
	l = []
	dict = {}
	for i in range(n):
		l = list(map(int, input().split()))
		dict[i] = l
		l = []
	matrix(dict)


for i in range(int(input())):
	(n, m) = map(int, input().split())
	x = set(range(0, n))
	y = set(range(0, m))
	lis = []
	for i in range(n):
		lis1 = list(map(int, input().split()))
		lis.append(lis1)
		for j in range(m):
			if lis1[j] == 1:
				x.discard(i)
				y.discard(j)
	a = 0
	v = 0
	while True:
		if a == v:
			a += 1
			if len(x) == 0 or len(y) == 0:
				print('Vivek')
				break
			else:
				q = x.pop()
				w = y.pop()
		elif a > v:
			v += 1
			if len(x) == 0 or len(y) == 0:
				print('Ashish')
				break
			else:
				q = x.pop()
				w = y.pop()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		t = list(map(int, input().split()))
		l.append(t)
	v = 0
	h = 0
	for i in range(n):
		if l[i] == [0] * m:
			v += 1
	for j in range(m):
		f = 1
		for i in range(n):
			if l[i][j] != 0:
				f = 0
		h += f
	if min(h, v) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	table = []
	for i in range(n):
		arr = list(map(int, input().split()))
		table.append(arr)
	columns = [0] * m
	for j in range(m):
		flag = True
		for i in range(n):
			if table[i][j] == 1:
				flag = False
				break
		if flag == False:
			columns[j] = 1
	cnt = 0
	for i in range(n):
		flag = True
		for j in range(m):
			if table[i][j] == 1:
				flag = False
				break
		if flag:
			for j in range(m):
				if table[i][j] == 0 and columns[j] == 0:
					cnt += 1
					columns[j] = 1
					break
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		matrix.append(list(map(int, input().split())))
	c = 0
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 0:
				found = 0
				for k in range(n):
					if matrix[k][j] == 1:
						found = 1
						break
				if found == 0:
					for l in range(m):
						if matrix[i][l] == 1:
							found = 1
							break
				if found == 0:
					matrix[i][j] = 1
					c += 1
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from time import time
from random import randint

def importMatrix():
	(rows, _) = list(map(int, input().split()))
	matrix = []
	for _ in range(rows):
		matrix.append(list(map(int, input().split())))
	return matrix

def freeRows(matrix):
	free = 0
	for e in matrix:
		free += sum(e) == 0
	return free

def freeColumns(matrix):
	free = 0
	columns = len(matrix[0])
	counter = [0] * columns
	for e in matrix:
		for i in range(columns):
			counter[i] += e[i]
	for e in counter:
		free += e == 0
	return free

def submit():
	for case in range(int(input())):
		matrix = importMatrix()
		printWinner(matrix)

def printWinner(matrix):
	free_rows = freeRows(matrix)
	free_columns = freeColumns(matrix)
	winner = ('Vivek', 'Ashish')[min(free_rows, free_columns) % 2]
	print(winner)
submit()


import os
import math
from math import sqrt
import sys
from functools import reduce
from itertools import accumulate

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

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

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

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

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

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)))
mod = int(1000000000.0) + 7

def toggle(f):
	if f == 'Vivek':
		return 'Ashish'
	return 'Vivek'
for _ in range(iinput()):
	(n, m) = get_ints()
	rows = {i: 0 for i in range(n)}
	columns = {i: 0 for i in range(m)}
	winner = 'Vivek'
	for row in range(n):
		a = get_list()
		for (i, x) in enumerate(a):
			if x == 1:
				columns[i] = 1
		if 1 in a:
			rows[row] = 1
	for i in range(n):
		for j in range(m):
			if rows[i] == columns[j] == 0:
				winner = toggle(winner)
				rows[i] = 1
				columns[j] = 1
	print(winner)


T = int(input().strip())
for t in range(T):
	a = []
	(n, m) = list(map(int, input().strip().split()))
	rows = n
	cols = [0] * m
	for _ in range(n):
		x = list(map(int, input().strip().split()))
		if sum(x):
			rows -= 1
		for (i, j) in enumerate(x):
			cols[i] += j
	for i in cols:
		if i:
			m -= 1
	rr = min(rows, m)
	if rr % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
import sys
from itertools import permutations
input = sys.stdin.readline
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		arr.append(list(map(int, input().split())))
	row = 0
	col = 0
	for i in range(n):
		cur = 0
		for j in range(m):
			if arr[i][j] == 1:
				cur += 1
		if cur == 0:
			row += 1
	for j in range(m):
		cur = 0
		for i in range(n):
			if arr[i][j] == 1:
				cur += 1
		if cur == 0:
			col += 1
	minn = min(row, col)
	if minn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for s in range(t):
	(r, c) = map(int, input().split())
	rama = []
	for i in range(r):
		array = list(map(int, input().split()))
		rama.append(array)
	hori = 0
	verti = 0
	for i in range(r):
		add = 0
		for j in range(c):
			if rama[i][j] == 1:
				add += 1
		if add == 0:
			hori += 1
	for i in range(c):
		add = 0
		for j in range(r):
			if rama[j][i] == 1:
				add += 1
		if add == 0:
			verti += 1
	d = min(hori, verti)
	if d % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


testcases = int(input())
for i in range(testcases):
	(n, m) = map(int, input().strip().split(' '))
	array = []
	for i in range(n):
		array.append(list(map(int, input().strip().split(' '))))
	cDicti = dict({})
	rdicti = dict({})
	for i in range(n):
		for j in range(m):
			if array[i][j] == 1:
				rdicti[i] = True
				cDicti[j] = True
	k = 0
	for i in range(n):
		for j in range(m):
			if j in cDicti.keys() or i in rdicti.keys():
				pass
			else:
				cDicti[j] = True
				rdicti[i] = True
				k += 1
	if k % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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

def ispowerof2(num):
	if num & num - 1 == 0:
		return 1
	return 0
import math
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	r = []
	c = []
	for i in range(n):
		s = list(map(int, input().split()))
		f = 0
		for j in range(m):
			if s[j] == 1:
				c.append(j + 1)
				f = 1
		if f == 1:
			r.append(i + 1)
	r = list(set(r))
	c = list(set(c))
	v1 = n - len(r)
	v2 = m - len(c)
	v2 = min(v2, v1)
	if v2 % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(N, M) = map(int, input().split())
	a = [list(map(int, input().split())) for _ in range(N)]
	r = set()
	c = set()
	for i in range(N):
		for j in range(M):
			if a[i][j]:
				r.add(i)
				c.add(j)
	if min(N - len(r), M - len(c)) % 2:
		print('Ashish')
	else:
		print('Vivek')


a = int(input())
for _ in range(a):
	(b, c) = map(int, input().split())
	t = []
	sum = 0
	y = c
	for _ in range(b):
		k = list(map(int, input().split()))
		if list(set(k)) == [0]:
			sum += 1
		t.append(k)
	for i in range(c):
		for j in range(b):
			if t[j][i] == 1:
				y -= 1
				break
	zz = min(sum, y)
	if zz % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	r = 0
	c = []
	for i in range(n):
		t = list(map(int, input().split()))
		if t.count(1) == 0:
			r += 1
		for i in range(m):
			if t[i] == 1:
				if i not in c:
					c += [i]
	c = m - len(c)
	t2 = 0
	while r > 0 and c > 0:
		r -= 1
		c -= 1
		t2 += 1
	if t2 % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


T = int(input())

def solve():
	[N, M] = list(map(int, input().split()))
	count_0 = 0
	board = []
	for _ in range(N):
		row = input()
		board.append(row.split())
	board_post = [['0' for _ in range(M)] for _ in range(N)]
	for i in range(N):
		for j in range(M):
			if board[i][j] == '1':
				for x in range(N):
					board_post[x][j] = '1'
				for x in range(M):
					board_post[i][x] = '1'
	free_row = set()
	free_col = set()
	for i in range(N):
		for j in range(M):
			if board_post[i][j] == '0':
				free_row.add(i)
				free_col.add(j)
	if min(len(free_row), len(free_col)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
for _ in range(T):
	solve()


t = int(input())
for k in range(t):
	(n, m) = map(int, input().split())
	an = [0] * n
	am = [0] * m
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(len(a)):
			if a[j] == 1:
				an[i] = 1
				am[j] = 1
	countn = 0
	countm = 0
	for i in range(n):
		if an[i] == 0:
			countn += 1
	for j in range(m):
		if am[j] == 0:
			countm += 1
	if min(countn, countm) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve():
	for _ in range(int(input())):
		(n, m) = map(int, input().strip().split())
		c = []
		for i in range(n):
			l = list(map(int, input().strip().split()))
			c.append(l)
		ct = [[row[i] for row in c] for i in range(len(c[0]))]
		a = 0
		for i in range(n):
			for j in range(m):
				if c[i][j] == 0 and c[i].count(1) == 0 and (ct[j].count(1) == 0):
					a += 1
					c[i][j] = 1
					ct[j][i] = 1
				else:
					continue
		if a % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
solve()


def chk(i, j, l):
	for ii in range(m):
		if l[i][ii] == 1:
			return 0
	for ii in range(n):
		if l[ii][j] == 1:
			return 0
	return 1
T = int(input())
while T:
	T -= 1
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		r = list(map(int, input().split()))
		l.append(r[:])
	cnt = 0
	for i in range(n):
		for j in range(m):
			if chk(i, j, l):
				cnt += 1
				l[i][j] = 1
	if cnt % 2:
		print('Ashish')
	else:
		print('Vivek')


from math import radians
from heapq import heapify, heappush, heappop
import bisect
from math import pi
from collections import deque
from math import factorial
from math import log, ceil
from collections import defaultdict
from math import *
from sys import stdin, stdout
import itertools
import os
import sys
import threading
from collections import deque, Counter, OrderedDict, defaultdict
from heapq import *
from fractions import Fraction
mod = int(pow(10, 9) + 7)

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

def si():
	return str(input())

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

def li1():
	return list(mi())

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

def fsi():
	return str(stdin.readline())

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

def fli():
	return list(fmi())
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

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

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

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

def ntl(n):
	return [int(i) for i in str(n)]

def powerMod(x, y, p):
	res = 1
	x %= p
	while y > 0:
		if y & 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d:
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d:
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = defaultdict(list)
	for i in range(n):
		(x, y) = mi()
		d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans

def primeFactors(n):
	s = set()
	while n % 2 == 0:
		s.add(2)
		n = n // 2
	for i in range(3, int(sqrt(n)) + 1, 2):
		while n % i == 0:
			s.add(i)
			n = n // i
	if n > 2:
		s.add(n)
	return s

def find_all(a_str, sub):
	start = 0
	while True:
		start = a_str.find(sub, start)
		if start == -1:
			return
		yield start
		start += len(sub)

def SieveOfEratosthenes(n, isPrime):
	isPrime[0] = isPrime[1] = False
	for i in range(2, n):
		isPrime[i] = True
	p = 2
	while p * p <= n:
		if isPrime[p] == True:
			i = p * p
			while i <= n:
				isPrime[i] = False
				i += p
		p += 1
	return isPrime

def dijkstra(edges, f, t):
	g = defaultdict(list)
	for (l, r, c) in edges:
		g[l].append((c, r))
	(q, seen, mins) = ([(0, f, ())], set(), {f: 0})
	while q:
		(cost, v1, path) = heappop(q)
		if v1 not in seen:
			seen.add(v1)
			path = (v1, path)
			if v1 == t:
				return (cost, path)
			for (c, v2) in g.get(v1, ()):
				if v2 in seen:
					continue
				prev = mins.get(v2, None)
				next = cost + c
				if prev is None or next < prev:
					mins[v2] = next
					heappush(q, (next, v2, path))
	return float('inf')

def binsearch(a, l, r, x):
	while l <= r:
		mid = l + (r - 1) // 2
		if a[mid]:
			return mid
		elif a[mid] > x:
			l = mid - 1
		else:
			r = mid + 1
	return -1

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 treeOrderByDepth(n, adj, root=0):
	parent = [-2] + [-1] * (n - 1)
	ordered = []
	q = deque()
	q.append(root)
	depth = [0] * n
	while q:
		c = q.popleft()
		ordered.append(c)
		for a in adj[c]:
			if parent[a] == -1:
				parent[a] = c
				depth[a] = depth[c] + 1
				q.append(a)
	return (ordered, parent, depth)

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

def nextPowerOf2(n):
	count = 0
	if n and (not n & n - 1):
		return n
	while n != 0:
		n >>= 1
		count += 1
	return 1 << count

def isChangeable(notes, n):
	fiveCount = 0
	tenCount = 0
	for i in range(n):
		if notes[i] == 5:
			fiveCount += 1
		elif notes[i] == 10:
			if fiveCount > 0:
				fiveCount -= 1
				tenCount += 1
			else:
				return 0
		elif fiveCount > 0 and tenCount > 0:
			fiveCount -= 1
			tenCount -= 1
		elif fiveCount >= 2:
			fiveCount -= 2
		else:
			return 0
	return 1
for _ in range(ii()):
	(n, m) = mi()
	l = []
	for i in range(n):
		x = li1()
		l.append(x)
	a = 'Ashish'
	v = 'Vivek'
	ans = v
	for i in range(n):
		for j in range(m):
			if l[i][j] == 0:
				f = 0
				for k in range(m):
					if l[i][k] == 1:
						f = 1
						break
				for k in range(n):
					if l[k][j] == 1:
						f = 1
						break
				if f == 0:
					l[i][j] = 1
					if ans == a:
						ans = v
					else:
						ans = a
	print(ans)


import sys
from collections import defaultdict
I = sys.stdin.readline
ans = ''
for _ in range(int(I())):
	(n, m) = map(int, I().split())
	mat = []
	for i in range(n):
		a = list(map(int, I().split()))
		mat.append(a)
	row = set()
	col = set()
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				row.add(i)
				col.add(j)
	row_left = n - len(row)
	col_left = m - len(col)
	pos = min(row_left, col_left)
	if pos % 2 != 0:
		ans += 'Ashish\n'
	else:
		ans += 'Vivek\n'
print(ans)


t = int(input())
for _ in range(t):
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	arr = []
	for _ in range(n):
		lis = list(map(int, input().split()))
		arr.append(lis)
	column = [False for _ in range(m)]
	row = [False for _ in range(n)]
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				if not column[j]:
					column[j] = True
				if not row[i]:
					row[i] = True
	winner = 'Vivek'
	for r in row:
		if not r:
			for c in range(m):
				if not column[c]:
					column[c] = True
					if winner == 'Vivek':
						winner = 'Ashish'
					else:
						winner = 'Vivek'
					break
	print(winner)


def f():
	(n, m) = [int(s) for s in input().split()]
	M = []
	for _ in range(n):
		M.append([int(s) for s in input().split()])

	def checkEmptyRow(r):
		if any(M[r]):
			return False
		return True

	def checkEmptyCol(c):
		for i in range(n):
			if M[i][c]:
				return False
		return True
	a = 0
	for i in range(n):
		if checkEmptyRow(i):
			a += 1
	b = 0
	for j in range(m):
		if checkEmptyCol(j):
			b += 1
	c = min(a, b)
	if c % 2:
		print('Ashish')
	else:
		print('Vivek')
for t in range(int(input())):
	f()


def solve():
	(n, m) = map(int, input().split(' '))
	matrix = []
	for _ in range(n):
		matrix.append(list(map(int, input().split(' '))))
	M = m
	N = n
	row = [True] * n
	col = [True] * m
	for i in range(n):
		for j in range(m):
			if matrix[i][j]:
				if row[i]:
					N -= 1
				if col[j]:
					M -= 1
				row[i] = False
				col[j] = False
	ans = ['Vivek', 'Ashish']
	return ans[max(0, min(M, N)) % 2]
T = int(input())
for _ in range(T):
	print(solve())


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	arr = []
	for _ in range(n):
		arr.append(list(map(int, input().split())))
	row = [1] * n
	col = [1] * m
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				row[i] = 0
				col[j] = 0
	(x, y) = (0, 0)
	for i in range(n):
		x += row[i]
	for i in range(m):
		y += col[i]
	print(('Vivek', 'Ashish')[min(x, y) & 1])


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	unclaimed_row_set = set([i for i in range(1, n + 1)])
	unclaimed_col_set = set([i for i in range(1, m + 1)])
	for row in range(1, n + 1):
		row_vector = list(map(int, input().split()))
		for col in range(1, m + 1):
			a = row_vector[col - 1]
			if a == 1:
				if row in unclaimed_row_set:
					unclaimed_row_set.remove(row)
				if col in unclaimed_col_set:
					unclaimed_col_set.remove(col)
	(unclaimed_row_count, unclaimed_col_count) = (len(unclaimed_row_set), len(unclaimed_col_set))
	min_count = min(unclaimed_row_count, unclaimed_col_count)
	if min_count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def gray_code_for_2(n):
	list = ['0', '1']
	for i in range(1, n):
		left = ['0' + i for i in list]
		right = ['1' + i for i in list[::-1]]
		list = left + right
	return list

def fun():
	(n, m) = map(int, input().split(' '))
	matrix = []
	for mdb in range(n):
		ren = list(map(int, input().split(' ')))
		matrix.append(ren)
	countr = 0
	for mdb in range(n):
		count = 1
		for er in range(m):
			if matrix[mdb][er] == 1:
				count = 0
		countr = countr + count
	jishu = 0
	for er in range(m):
		count = 1
		for mdb in range(n):
			if matrix[mdb][er] == 1:
				count = 0
		jishu += count
	if min(countr, jishu) % 2 != 1:
		print('Vivek')
	else:
		print('Ashish')
n = int(input())
for _ in range(n):
	fun()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	r = [0] * n
	c = [0] * m
	s = 0
	for i in range(n):
		a.append(list(map(int, input().split())))
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r[i] = 1
				c[j] = 1
	for i in range(n):
		for j in range(m):
			if r[i] == 0 and c[j] == 0:
				s += 1
				r[i] = 1
				c[j] = 1
	if s % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(r, c) = map(int, input().split())
	(cl_rows, cl_cols) = (set(), set())
	for i in range(r):
		row = input().split()
		for j in range(len(row)):
			if row[j] == '1':
				cl_rows.add(i)
				cl_cols.add(j)
	un_rows = r - len(cl_rows)
	un_cols = c - len(cl_cols)
	un = min(un_rows, un_cols)
	if un & 1:
		print('Ashish')
	else:
		print('Vivek')


T = int(input())
for _ in range(0, T):
	(n, m) = map(int, input().split())
	L = []
	for i in range(0, n):
		s = [int(x) for x in input().split()]
		L.append(s)
	c1 = 0
	for i in range(n):
		temp = 0
		for j in range(m):
			if L[i][j] == 1:
				temp = 1
				break
		if temp == 0:
			c1 += 1
	c2 = 0
	for i in range(m):
		temp = 0
		for j in range(n):
			if L[j][i] == 1:
				temp = 1
				break
		if temp == 0:
			c2 += 1
	c = min(c1, c2)
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin

def inp():
	return stdin.buffer.readline().rstrip().decode('utf8')

def itg():
	return int(stdin.buffer.readline())

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

def main():
	(n, m) = mpint()
	arr = [list(mpint()) for i in range(n)]
	new_arr = arr.copy()
	for i in range(n):
		if any(arr[i]):
			new_arr[i] = [1] * m
	for i in range(m):
		for j in range(n):
			if arr[j][i]:
				break
		else:
			continue
		for j in range(n):
			new_arr[j][i] = 1
	arr = new_arr.copy()
	r = False
	for _ in range(50):
		for i in range(n):
			for j in range(m):
				if arr[i][j] == 0:
					arr[i] = [1] * m
					for k in range(n):
						arr[k][j] = 1
					r = not r
					break
			else:
				continue
			break
		else:
			break
	return r
for case in range(itg()):
	print('Ashish' if main() else 'Vivek')


(z, zz) = (input, lambda : list(map(int, z().split())))
(szz, graph, mod) = (lambda : sorted(zz()), {}, 10 ** 9 + 7)
zzz = lambda : [int(i) for i in stdin.readline().split()]
from string import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
num = int(z())
for _ in range(num):
	(n, m) = zz()
	li = []
	(row, col) = (0, 0)
	for _ in range(n):
		l = zz()
		one = l.count(1)
		if one == 0:
			row += 1
		li.append(l)
	for i in range(m):
		t = 0
		for j in range(n):
			if li[j][i] == 1:
				t += 1
				break
		if t == 0:
			col += 1
	mi = min(row, col)
	if mi % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for q in range(t):
	(n, m) = list(map(int, input().split(' ')))
	linha = [0] * n
	coluna = [0] * m
	for k in range(n):
		ent = list(map(int, input().split(' ')))
		for j in range(m):
			if ent[j] == 1:
				linha[k] = 1
				coluna[j] = 1
	turn = 1
	vencedor = 'Vivek'
	for i in range(n):
		if linha[i] != 1:
			for j in range(m):
				if coluna[j] != 1:
					if turn == 1:
						turn = 0
						vencedor = 'Ashish'
					else:
						turn = 1
						vencedor = 'Vivek'
					linha[i] = 1
					coluna[j] = 1
					break
	print(vencedor)


import sys
input = sys.stdin.readline
I = lambda : list(map(int, input().split()))
(t,) = I()
for _ in range(t):
	(n, m) = I()
	l = []
	r = [0] * n
	c = [0] * m
	for i in range(n):
		k = I()
		l.append(k)
		for j in range(m):
			if k[j]:
				r[i] = 1
				c[j] = 1
	ct = 0
	for i in range(n):
		for j in range(m):
			if r[i] == 0 and c[j] == 0:
				ct += 1
				r[i] = c[j] = 1
	if ct % 2:
		print('Ashish')
	else:
		print('Vivek')


def f(arr):
	(n, m) = (len(arr), len(arr[0]))
	T = 0
	found = True
	while found:
		found = False
		for i in range(n):
			if sum(arr[i]) == 0 and (not found):
				for j in range(m):
					if sum((arr[l][j] for l in range(n))) == 0 and (not found):
						arr[i][j] = 1 if not found else arr[i][j]
						found = True
		if not found:
			break
		T += 1
	if T == 0:
		print('Vivek')
		return
	if T % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')
t = int(input())
for _ in range(t):
	(n, m) = input().split(' ')
	(n, m) = (int(n), int(m))
	arr = []
	for _ in range(n):
		arr.append([int(a) for a in input().split(' ')])
	f(arr)


def func(arr, row, col):
	rowcount = 0
	for i in arr:
		if 1 not in i:
			rowcount += 1
	count = 0
	for i in range(col):
		flag = True
		for j in range(row):
			if arr[j][i] == 1:
				flag = False
		if flag == True:
			count += 1
	small = 0
	if rowcount >= count:
		small = count
	else:
		small = rowcount
	if small % 2 == 0:
		print('Vivek')
		return
	else:
		print('Ashish')
		return
t = int(input())
for _ in range(t):
	(row, col) = map(int, input().split())
	arr = []
	for i in range(row):
		temp = list(map(int, input().split()))
		arr.append(temp[:])
	func(arr, row, col)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	aa = []
	for _ in range(n):
		aa.append(list(map(int, input().split())))
	a = v = 0
	b = [0] * m
	for i in range(n):
		for j in range(m):
			if aa[i][j] == 1:
				b[j] += 1
	for i in range(n):
		if aa[i].count(1) > 0:
			continue
		else:
			for j in range(m):
				if b[j] == 0:
					b[j] = 1
					if a == v:
						a += 1
					else:
						v += 1
					break
	print(['Ashish', 'Vivek'][a == v])


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

def nc2(x):
	if x == 1:
		return 0
	else:
		return x * (x - 1) // 2
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	flag = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 0:
				fl = 0
				for l in range(m):
					fl |= mat[i][l]
				for l in range(n):
					fl |= mat[l][j]
				if fl == 0:
					mat[i][j] = 1
					flag ^= 1
	if flag == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	row = col = 0
	av = 1
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				row += 1
				break
	for i in range(m):
		for j in range(n):
			if mat[j][i] == 1:
				col += 1
				break
	frow = n - row
	frcol = m - col
	while frcol > 0 and frow > 0:
		frcol -= 1
		frow -= 1
		av = 1 - av
	if av == 1:
		print('Vivek')
	else:
		print('Ashish')


def column(array, n):
	col = [sub[n] for sub in array]
	return col
t = int(input())
for p in range(t):
	(n, m) = [int(y) for y in input().split()]
	arr = [[0 for l in range(m)] for k in range(n)]
	for o in range(n):
		arr[o] = [int(h) for h in input().split()]
	winner = 'Vivek'
	for i in range(n):
		for j in range(m):
			row = arr[i]
			col = column(arr, j)
			su = sum(row) + sum(col)
			if su == 0:
				arr[i][j] = 1
				if winner == 'Vivek':
					winner = 'Ashish'
				elif winner == 'Ashish':
					winner = 'Vivek'
			else:
				pass
	print(winner)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	row = [False] * n
	col = [False] * m
	for i in range(n):
		l = list(map(int, input().split()))
		for j in range(m):
			if l[j] == 1:
				row[i] = True
				col[j] = True
	if min(row.count(False), col.count(False)) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


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 main():
	t = I()
	rr = []
	for _ in range(t):
		(n, m) = LI()
		aa = [LI() for _ in range(n)]
		a = set()
		b = set()
		for i in range(n):
			for j in range(m):
				if aa[i][j] == 1:
					a.add(i)
					b.add(j)
		n -= len(a)
		m -= len(b)
		mi = min(n, m)
		if mi % 2 == 1:
			rr.append('Ashish')
		else:
			rr.append('Vivek')
	return JA(rr, '\n')
print(main())


t = int(input())
for q in range(t):
	[m, n] = [int(x) for x in input().split()]
	arr = []
	for i in range(m):
		row = [int(x) for x in input().split()]
		arr.append(row)
	count = 0
	for i in range(m):
		if 1 not in arr[i]:
			for j in range(n):
				flag = 1
				for i1 in range(m):
					if arr[i1][j] == 1:
						flag = 0
				if flag == 1:
					arr[i][j] = 1
					count += 1
					break
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
import math

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

def get_list():
	return list(get_ints())

def printspx(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')

def printchk(*args):
	return print(*args, end=' \\ ')
MODPRIME = int(1000000000.0 + 7)
BABYMODPR = 998244353
for _testcases_ in range(int(input())):
	(n, m) = get_ints()
	matr = []
	for i in range(n):
		li = get_list()
		matr.append(li)
	(unclaimed_rows, unclaimed_cols) = (set([i for i in range(n)]), set([x for x in range(m)]))
	for i in range(n):
		for j in range(m):
			if matr[i][j] == 1:
				try:
					unclaimed_cols.remove(j)
				except:
					pass
				try:
					unclaimed_rows.remove(i)
				except:
					pass
	ans = min(len(unclaimed_cols), len(unclaimed_rows))
	if ans & 1:
		print('Ashish')
	else:
		print('Vivek')


def main():
	T = int(input())
	for _ in range(T):
		(N, M) = map(int, input().split())
		A = []
		for _ in range(N):
			A.append(list(map(int, input().split())))
		chance = 'Ashish'
		for i in range(N):
			for j in range(M):
				if A[i][j] == 0:
					flag = True
					for x in range(M):
						if x != j:
							if A[i][x] == 1:
								flag = False
								break
					if flag:
						for y in range(N):
							if y != i:
								if A[y][j] == 1:
									flag = False
									break
					if flag:
						A[i][j] = 1
						if chance == 'Ashish':
							chance = 'Vivek'
						else:
							chance = 'Ashish'
		if chance == 'Ashish':
			print('Vivek')
		else:
			print('Ashish')
main()


from sys import stdin, exit, setrecursionlimit
from math import *
from collections import deque
setrecursionlimit(10000000)
input = stdin.readline
lmi = lambda : list(map(int, input().split()))
mi = lambda : map(int, input().split())
si = lambda : input().strip('\n')
ssi = lambda : input().strip('\n').split()
for _ in range(int(input())):
	(n, m) = mi()
	grid = [lmi() for i in range(n)]
	a = [False for i in range(n)]
	b = [False for i in range(m)]
	cnt = n
	cnt2 = m
	for i in range(n):
		if 1 in grid[i]:
			a[i] = True
			cnt -= 1
	for j in range(m):
		if any((1 == grid[i][j] for i in range(n))):
			b[j] = True
			cnt2 -= 1
	print('Vivek' if min(cnt, cnt2) % 2 == 0 else 'Ashish')


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

def readInt():
	return int(input())

def solve():
	(n, m) = readInts()
	a = [readInts() for _ in range(n)]
	numRows = n
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				numRows -= 1
				break
	numCols = m
	for j in range(m):
		for i in range(n):
			if a[i][j] == 1:
				numCols -= 1
				break
	if min(numRows, numCols) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')

def main():
	t = 1
	t = readInt()
	for _ in range(t):
		solve()
main()


import sys
input = sys.stdin.readline
from sys import stdin, stdout

def main():
	for _ in range(int(input())):
		(n, m) = [int(s) for s in input().split()]
		l = [[int(s) for s in input().split()] for i in range(n)]
		av = 0
		row = [0] * m
		col = [0] * n
		for i in range(n):
			for j in range(m):
				if l[i][j] == 1:
					row[j] = 1
					col[i] = 1
		(r, c) = (0, 0)
		for i in range(n):
			if col[i] == 0:
				c += 1
		for i in range(m):
			if row[i] == 0:
				r += 1
		w = min(r, c)
		if w % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


def winner(n, m, L):
	R = []
	C = []
	for i in range(n):
		l = L[i]
		if 1 not in l:
			R.append(i)
	for i in range(m):
		temp = []
		for j in range(n):
			temp.append(L[j][i])
		if 1 not in temp:
			C.append(i)
	x = min(len(R), len(C))
	if x % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	L = []
	for j in range(n):
		L.append(list(map(int, input().split())))
	print(winner(n, m, L))


T = int(input())
for t in range(T):
	(n, m) = map(int, input().split())
	rows = [0] * n
	cols = [0] * m
	for r in range(n):
		row = input().split()
		for (c, a) in enumerate(row):
			if a == '1':
				rows[r] = 1
				cols[c] = 1
	turns = min(rows.count(0), cols.count(0))
	if turns % 2:
		print('Ashish')
	else:
		print('Vivek')


from sys import stdin
input = iter(stdin.readlines()).__next__
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = [list(map(int, input().split())) for _ in range(n)]
	rows = [0] * n
	cols = [0] * m
	for (r, ar) in enumerate(a):
		for (c, arc) in enumerate(ar):
			if arc == 1:
				rows[r] = 1
				cols[c] = 1
	free = min(n - sum(rows), m - sum(cols))
	if free % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for caseNr in range(1, t + 1):
	x = list(map(int, input().split()))
	cols = set()
	rows = set()
	for i in range(x[0]):
		y = list(map(int, input().split()))
		for (j, val) in enumerate(y):
			if val == 1:
				cols.add(j)
				rows.add(i)
	b = min(x[0] - len(rows), x[1] - len(cols))
	if b % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = lambda : sys.stdin.readline().rstrip()
inp = sys.stdin.buffer.readline

def I():
	return list(map(int, inp().split()))
for _ in range(int(input())):
	(n, m) = [int(i) for i in input().split()]
	a = []
	for i in range(n):
		a.append([int(i) for i in input().split()])
	row = set()
	col = set()
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row.add(i)
				col.add(j)
	ans = 0
	for i in range(n):
		for j in range(m):
			if i not in row and j not in col:
				row.add(i)
				col.add(j)
				ans += 1
	print(['Vivek', 'Ashish'][ans & 1])


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	row = [0 for i in range(n)]
	column = [0 for i in range(m)]
	for i in range(n):
		a = list(map(int, input().split()))
		if a.count(1) > 0:
			row[i] = 1
		for j in range(m):
			if a[j] == 1:
				column[j] = 1
	rower = row.count(0)
	columner = column.count(0)
	if min(rower, columner) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	(n, m) = [int(i) for i in sys.stdin.readline().split()]
	freeRows = 0
	freeCols = [0] * m
	for _ in range(n):
		row = [int(i) for i in sys.stdin.readline().split()]
		if 1 not in row:
			freeRows += 1
		for (i, v) in enumerate(row):
			if v == 1:
				freeCols[i] = 1
	freeCols = m - sum(freeCols)
	if min(freeCols, freeRows) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for t in range(int(input())):
	(n, m) = (int(i) for i in input().split())
	a = [0] * n
	r = n
	c = m
	for i in range(n):
		a[i] = [int(i) for i in input().split()]
		if a[i].count(1) > 0:
			r -= 1
	for j in range(m):
		g = True
		for i in range(n):
			if a[i][j] == 1:
				g = False
		if not g:
			c -= 1
	print(['Vivek', 'Ashish'][min(c, r) % 2])


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	(r, c) = (n, [0 for i in range(m)])
	for i in range(n):
		inp = list(map(int, input().split()))
		for j in range(m):
			if inp[j] == 1 and c[j] == 0:
				c[j] = 1
		if 1 in inp:
			r -= 1
	x = min(r, c.count(0))
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


nb_cases = int(input())
for case in range(nb_cases):
	(n, m) = [int(x) for x in input().split()]
	lines_ok = [1] * n
	columns_ok = [1] * m
	for i in range(n):
		line = [int(x) for x in input().split()]
		for j in range(m):
			if line[j] == 1:
				lines_ok[i] = 0
				columns_ok[j] = 0
	nb_lines = sum(lines_ok)
	nb_columns = sum(columns_ok)
	if min(nb_lines, nb_columns) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input(''))
while t > 0:
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		matrix.append(list(map(int, input().split())))
	winner = 0
	flag = 1
	possible_rows = []
	possible_squares = []
	possible_columns = []
	for row in range(n):
		if matrix[row] == [0] * m:
			possible_rows.append(row)
	for column in range(m):
		for row in range(n):
			if matrix[row][column] != 0:
				break
		else:
			possible_columns.append(column)
	for i in possible_rows:
		for j in possible_columns:
			possible_squares.append((i, j))
	while True and flag != -1:
		if possible_squares == []:
			flag = -1
			break
		else:
			(ans1, ans2) = possible_squares[0]
			limt = len(possible_squares)
			x = 0
			while x < limt:
				(a, b) = possible_squares[x]
				if a == ans1 or b == ans2:
					possible_squares.pop(x)
					limt -= 1
					x -= 1
				x += 1
			winner += 1
	if winner % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	s1 = set()
	s2 = set()
	counter = 0
	for k in range(n):
		now = list(map(int, input().split()))
		for j in range(m):
			if now[j] == 1:
				s1.add(j)
				s2.add(k)
				counter += 1
	s1 = m - len(s1)
	s2 = n - len(s2)
	if min(s1, s2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for v in range(t):
	(n, m) = map(int, input().split(' '))
	r_c = []
	occ_r = set()
	occ_c = set()
	for i in range(n):
		li = list(map(int, input().split(' ')))
		r_c.append(li)
	for i in range(n):
		for j in range(m):
			if r_c[i][j] == 1:
				occ_r.add(i)
				occ_c.add(j)
	left_r = n - len(occ_r)
	left_c = m - len(occ_c)
	num_of_moves = min(left_r, left_c)
	if num_of_moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for gfha in range(t):
	(n, m) = list(map(int, input().split()))
	res = []
	c = 0
	u = [0] * n
	v = [0] * m
	deff = 0
	for i in range(n):
		a = list(map(int, input().split()))
		for j in range(m):
			if a[j] == 1:
				deff = 1
		res.append(a)
		u[i] = int(deff)
		deff = 0
	for i in range(m):
		for j in range(n):
			if res[j][i] == 1:
				deff = 1
		v[i] = int(deff)
		deff = 0
	if min(u.count(0), v.count(0)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	arr = []
	ct = 0
	for i in range(n):
		ch = list(map(int, input().split()))
		arr.append(ch)
	ch = [[False] * m for i in range(n)]
	xor = 0
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				pass
			elif arr[i][j] == 0:
				flag = True
				for r in range(n):
					if arr[r][j] == 1:
						flag = False
						break
				for r in range(m):
					if arr[i][r] == 1:
						flag = False
						break
				if flag:
					arr[i][j] = 1
					xor ^= 1
	if xor == 0:
		print('Vivek')
	else:
		print('Ashish')


ct = input()
for _ in range(int(ct)):
	full = []
	rCount = 0
	cCount = 0
	line = [int(i) for i in input().split()]
	for i in range(line[0]):
		full.append([int(i) for i in input().split()])
	for i in full:
		if sum(i) == 0:
			rCount += 1
	for i in range(len(full[0])):
		if sum([item[i] for item in full]) == 0:
			cCount += 1
	if min(rCount, cCount) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	a = input().split(' ')
	n = int(a[0])
	m = int(a[1])
	rows = []
	columns = []
	for i in range(n):
		rows.append(i)
	for i in range(m):
		columns.append(i)
	for i in range(n):
		a = input().split(' ')
		for j in range(m):
			a[j] = int(a[j])
			if a[j] == 1:
				if i in rows:
					rows.remove(i)
				if j in columns:
					columns.remove(j)
	val = min(len(rows), len(columns))
	if val % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


T = int(input())
for t in range(T):
	(N, M) = [int(_) for _ in input().split()]
	matrix = []
	for i in range(N):
		row = [int(_) for _ in input().split()]
		matrix.append(row)
	available_rows = 0
	for row in matrix:
		if 1 not in row:
			available_rows += 1
	available_cols = 0
	for i in range(len(matrix[0])):
		for j in range(len(matrix)):
			if matrix[j][i] == 1:
				break
		else:
			available_cols += 1
	a = min(available_cols, available_rows)
	if a & 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	m = []
	pr = 0
	for i in range(n):
		p = list(map(int, input().split()))
		m.append(p)
		if 1 not in p:
			pr += 1
	rez = [[m[j][i] for j in range(len(m))] for i in range(len(m[0]))]
	pv = 0
	for i in range(len(rez)):
		if 1 not in rez[i]:
			pv += 1
	t = min(pv, pr)
	if t % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		mt = list(map(int, input().split()))
		matrix.append(mt)
	(spots, who) = (0, 1)
	for i in range(n):
		for j in range(m):
			can = True
			for k in range(m):
				if matrix[i][k] == 1:
					can = False
					break
			if can:
				for q in range(n):
					if matrix[q][j] == 1:
						can = False
						break
				if can:
					matrix[i][j] = 1
					who = 2 if who == 1 else 1
					spots += 1
	if spots == 0 or who == 1:
		print('Vivek')
	else:
		print('Ashish')


import os
import sys
from io import BytesIO, IOBase
profile = 0
pypy = 1

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

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

def main():
	T = iin()
	ans = ['Vivek', 'Ashish']
	while T:
		T -= 1
		(n, m) = lin()
		a = [lin() for i in range(n)]
		x = min(n, m)
		(n1, m1) = (set(), set())
		for i in range(n):
			for j in range(m):
				if a[i][j]:
					n1.add(i)
					m1.add(j)
		x = min(n - len(n1), m - len(m1))
		print(ans[x % 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')
if pypy:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
	input = lambda : sys.stdin.readline().rstrip('\r\n')
if profile:
	import cProfile
	cProfile.run('main()')
else:
	main()


t = int(input())

def choose(m):
	for i in range(len(m)):
		if any(m[i]):
			continue
		for j in range(len(m[0])):
			ll = []
			for k in range(len(m)):
				ll.append(m[k][j])
			if any(ll):
				continue
			else:
				return (True, (i, j))
	return (False, (-1, -1))
while t:
	(r, c) = map(int, input().split())
	m = []
	for i in range(r):
		cc = list(map(int, input().split()))
		m.append(cc)
	p = 1
	while True:
		(f, pos) = choose(m)
		if f == False:
			break
		m[pos[0]][pos[1]] = 1
		if p == 1:
			p = 0
		else:
			p = 1
	if p == 0:
		print('Ashish')
	else:
		print('Vivek')
	t = t - 1


import math
from collections import defaultdict, Counter, deque
INF = float('inf')

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def primeFactor(n):
	if n % 2 == 0:
		return 2
	i = 3
	while i ** 2 <= n:
		if n % i == 0:
			return i
		i += 1
	return n

def main():
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		col = list(map(int, input().split()))
		mat.append(col)
	c = []
	r = []
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				c.append(j)
				r.append(i)
	turn = 0
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 0 and i not in r and (j not in c):
				turn ^= 1
				r.append(i)
				c.append(j)
	if turn == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for _ in range(t):
	main()


numberOfTestCases = int(input())
for case in range(numberOfTestCases):
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		matrix.append(list(map(int, input().split())))
	claimedRow = []
	claimedColumn = []
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 0:
				continue
			if not i in claimedRow:
				claimedRow.append(i)
			if not j in claimedColumn:
				claimedColumn.append(j)
	numberOfTurns = min(n - len(claimedRow), m - len(claimedColumn))
	if numberOfTurns % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mj = list(map(int, input().split()))
		mat.append(mj)
	rows = set()
	cols = set()
	for i in range(len(mat)):
		for j in range(len(mat[i])):
			if mat[i][j] == 1:
				rows.add(i)
				cols.add(j)
	x = min(n - len(rows), m - len(cols))
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import math
t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	lst = [[int(i) for i in input().split()] for j in range(n)]
	a = 'Ashish'
	v = 'Vivek'
	r = set()
	c = set()
	for i in range(n):
		for j in range(m):
			if lst[i][j]:
				r.add(i)
				c.add(j)
	moves = min(n - len(r), m - len(c))
	if moves % 2 == 0:
		print(v)
	else:
		print(a)


T = int(input())
for t in range(T):
	(n, m) = map(int, input().split())
	rows = [False] * n
	cols = [False] * m
	for i in range(n):
		(*c,) = map(int, input().split())
		for j in range(m):
			if c[j] == 1:
				rows[i] = True
				cols[j] = True
	(r, c) = (0, 0)
	for i in range(n):
		if not rows[i]:
			r += 1
	for i in range(m):
		if not cols[i]:
			c += 1
	a = min(r, c)
	if a % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve(a, m):
	empty = '0' * m
	return len(tuple((ai for ai in a if ai == empty)))

def main():
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		a = tuple((input().replace(' ', '') for _ in range(n)))
		if min(solve(a, m), solve(map(''.join, zip(*a)), n)) % 2:
			print('Ashish')
		else:
			print('Vivek')
main()


import sys
t = int(input())
for _ in range(t):
	(n, m) = [int(c) for c in input().split()]
	matrix = [[int(c) for c in input().split()] for y in range(n)]
	rows = 0
	columns = 0
	for i in range(n):
		if all((matrix[i][j] == 0 for j in range(m))):
			rows += 1
	for j in range(m):
		if all((matrix[i][j] == 0 for i in range(n))):
			columns += 1
	print('Ashish' if min(rows, columns) % 2 == 1 else 'Vivek')


__multitest = True

def solve():
	(n, m) = map(int, input().split())
	state = []
	for i in range(n):
		arr = list(map(int, input().split()))
		state.append(arr)
	empty_row = empty_col = 0
	for i in range(n):
		if state[i].count(0) == m:
			empty_row += 1
	for i in range(m):
		counter = 0
		for j in range(n):
			counter += 1 if state[j][i] == 0 else 0
		if counter == n:
			empty_col += 1
	answer = ['Vivek', 'Ashish']
	print(answer[min(empty_col, empty_row) % 2])
t = int(input()) if __multitest else 1
for tt in range(t):
	solve()


T = int(input())
for _ in range(T):
	(n, m) = map(int, input().split())
	l = []
	l1 = [0] * m
	c = 0
	for __ in range(n):
		l.append(list(map(int, input().split())))
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				l1[j] += 1
	for i in range(n):
		if 1 in l[i]:
			continue
		else:
			for j in range(m):
				if l1[j] == 0:
					c += 1
					l1[j] += 1
					break
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	r = [0] * n
	c = [0] * m
	a = []
	for i in range(n):
		b = list(map(int, input().split()))
		a.append(b)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r[i] = 1
				c[j] = 1
	row = col = 0
	for i in range(n):
		if r[i] == 0:
			row += 1
	for i in range(m):
		if c[i] == 0:
			col += 1
	d = min(row, col)
	if d % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t:
	(m, n) = list(map(int, input().split()))
	a = []
	for i in range(m):
		x = list(map(int, input().split()))
		a.append(x)
	for i in range(m):
		for j in range(n):
			if a[i][j] == 1:
				a[i][j] = 0
			else:
				a[i][j] = 1
	(ashish, vivek) = (True, True)
	c = 0
	while ashish and vivek:
		if c % 2 == 0:
			flag = 0
			for i in range(m):
				if all(a[i]):
					for k in range(n):
						for j in range(m):
							if a[j][k] == 0:
								break
						else:
							a[i][k] = 0
							flag = 1
							break
						if flag == 1:
							break
			if flag == 0:
				ashish = False
		else:
			flag = 0
			for i in range(m):
				if all(a[i]):
					for k in range(n):
						for j in range(m):
							if a[j][k] == 0:
								break
						else:
							a[i][k] = 0
							flag = 1
							break
						if flag == 1:
							break
			if flag == 0:
				vivek = False
		c += 1
	if vivek == False:
		print('Ashish')
	else:
		print('Vivek')
	t -= 1


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		a = list(map(int, input().split()))
		l.append(a)
	r = []
	c = []
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				r.append(i)
				c.append(j)
	rset = len(set(r))
	cset = len(set(c))
	h = min(n - rset, m - cset)
	if h % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	mat = []
	dicto_r = {}
	dicto_c = {}
	for i in range(n):
		arr = [int(i) for i in input().split()][:m]
		mat.append(arr)
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				dicto_r[i] = 1
				dicto_c[j] = 1
	p_c = m - len(dicto_c)
	p_r = n - len(dicto_r)
	winner = 0
	while p_c != 0 and p_r != 0:
		p_c -= 1
		p_r -= 1
		winner += 1
	if winner % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	rows = set()
	cols = set()
	for i in range(n):
		row = list(map(int, input().split()))
		for (idx, val) in enumerate(row):
			if val == 1:
				rows.add(i)
				cols.add(idx)
	left_row = n - len(rows)
	left_cols = m - len(cols)
	left = min(left_row, left_cols)
	if left % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for test in range(t):
	(n, m) = list(map(int, input().split()))
	arr = []
	for i in range(n):
		arr.append(list(map(int, input().split())))
	cols = set()
	rows = set()
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				cols.add(j)
				rows.add(i)
	count = min(n - len(rows), m - len(cols))
	if count % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import sys
reader = (s.rstrip() for s in sys.stdin)
input = reader.__next__
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	arr = [[int(x) for x in input().split()] for y in range(n)]
	rows = set([x for x in range(n)])
	cols = set([x for x in range(m)])
	for x in range(n):
		for y in range(m):
			if arr[x][y]:
				if x in rows:
					rows.remove(x)
				if y in cols:
					cols.remove(y)
	mn = min(len(rows), len(cols))
	if mn & 1:
		print('Ashish')
	else:
		print('Vivek')


for i in int(input()) * [0]:
	(n, m) = map(int, input().split())
	cm = []
	cn = 0
	for x in range(n):
		row = input().split()
		if '1' in row:
			for x in range(m):
				if row[x] == '1' and x not in cm:
					cm.append(x)
		else:
			cn += 1
	print(['Vivek', 'Ashish'][min(m - len(cm), cn) % 2])


t = int(input())
for _ in range(t):
	(r, c) = map(int, input().split())
	matrix = []
	lisr = [0] * r
	lisc = [0] * c
	kr = 0
	kc = 0
	for i in range(r):
		row = list(map(int, input().split()))
		matrix.append(row)
	for i in range(r):
		for j in range(c):
			if matrix[i][j] == 1:
				lisr[kr] = 1
				kr += 1
				break
	for i in range(c):
		for j in range(r):
			if matrix[j][i] == 1:
				lisc[kc] = 1
				kc += 1
				break
	countr = lisr.count(0)
	countc = lisc.count(0)
	if countc == countr:
		if countr % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
	elif min(countc, countr) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import queue
import math
t = int(input())
while t:
	line = input().split()
	(n, m) = (int(line[0]), int(line[1]))
	a = []
	for i in range(n):
		a.append(input().split())
	for i in range(n):
		for j in range(m):
			if a[i][j] == '1':
				for k in range(n):
					if a[k][j] != '1':
						a[k][j] = '-1'
				for k in range(m):
					if a[i][k] != '1':
						a[i][k] = '-1'
	(N, M) = (0, 0)
	for i in range(n):
		mm = 0
		for j in range(m):
			if a[i][j] == '0':
				mm += 1
		M = max(M, mm)
		if mm > 0:
			N += 1
	if min(N, M) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


n = int(input())
for i in range(0, n):
	size = input().split()
	arr = [[0 for x in range(int(size[1]))] for y in range(int(size[0]))]
	x = [0 for y in range(int(size[0]))]
	y = [0 for y in range(int(size[1]))]
	for j in range(0, int(size[0])):
		inp = input().split()
		for k in range(0, len(inp)):
			temp = int(inp[k])
			arr[j][k] = temp
			if arr[j][k] == 1:
				x[j] += 1
				y[k] += 1
	Result = 0
	for xi in range(0, int(size[0])):
		for yi in range(0, int(size[1])):
			if x[xi] == 0 and y[yi] == 0:
				Result += 1
				x[xi] += 1
				y[yi] += 1
	if Result % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = [list(map(int, input().split())) for i in range(n)]
	x = 0
	y = 0
	for i in range(n):
		if matrix[i].count(1) >= 1:
			x += 1
	for j in range(m):
		for i in range(n):
			if matrix[i][j] >= 1:
				y += 1
				break
	if min(n - x, m - y) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = [int(num) for num in input().split()]
	matrix = []
	for i in range(n):
		matrix.append([int(x) for x in input().split()])
	transposed = []
	for i in range(m):
		new = []
		for row in matrix:
			new.append(row[i])
		transposed.append(new)
	k1 = 0
	k2 = 0
	for i in matrix:
		if sum(i) == 0:
			k1 += 1
	for i in transposed:
		if sum(i) == 0:
			k2 += 1
	if min(k1, k2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def check(a, k):
	for i in range(n):
		for j in range(m):
			if j == k:
				if a[i][j] == 1:
					return False
	return True
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	f = 0
	for i in range(n):
		for j in range(m):
			if 1 not in a[i] and check(a, j):
				if f == 1:
					f = 0
				else:
					f = 1
				a[i][j] = 1
	if f == 0:
		c = 'Vivek'
	else:
		c = 'Ashish'
	print(c)


import math, sys, bisect
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])
for _ in range(int(input())):
	(n, m) = ilele()
	A = []
	for i in range(n):
		B = alele()
		A.append(B.copy())
	a = 0
	b = 0
	for i in range(n):
		f = 0
		for j in range(m):
			if A[i][j] == 1:
				f = 1
				break
		if f == 0:
			a += 1
	for i in range(m):
		f = 0
		for j in range(n):
			if A[j][i] == 1:
				f = 1
				break
		if f == 0:
			b += 1
	z = min(a, b)
	if z % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


test = int(input())
while test > 0:
	(m, n) = list(map(int, input().split()))
	rows = set()
	cols = set()
	d1 = 0
	d2 = 0
	for i in range(m):
		a = list(map(int, input().split()))
		for j in range(n):
			if a[j] == 1:
				rows.add(i)
				cols.add(j)
	for i in range(m):
		if i not in rows:
			d1 += 1
	for j in range(n):
		if j not in cols:
			d2 += 1
	if min(d1, d2) % 2 == 1:
		print('Ashish\n')
	else:
		print('Vivek\n')
	test -= 1


amount = int(input())
for i in range(amount):
	info = input().split(' ')
	rows = int(info[0])
	columns = int(info[1])
	table_rows = []
	table_columns = []
	for row in range(rows):
		get = input().split(' ')
		get = [int(x) for x in get]
		table_rows = table_rows + [get]
	for column in range(columns):
		table_columns = table_columns + [[]]
	for row in range(rows):
		for column in range(columns):
			table_columns[column] = table_columns[column] + [table_rows[row][column]]
	winner = 'Vivek'
	for row in range(rows):
		if 1 not in table_rows[row]:
			for column in range(columns):
				if 1 not in table_rows[row]:
					if 1 not in table_columns[column]:
						table_rows[row][column] = 1
						table_columns[column][row] = 1
						if winner == 'Vivek':
							winner = 'Ashish'
						else:
							winner = 'Vivek'
	print(winner)


t = int(input())
for i in range(t):
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	lst_2d = [[0] * m for i in range(n)]
	for i in range(len(lst_2d)):
		x = list(input().split())
		x = [int(x[j]) for j in range(len(x))]
		for p in range(len(lst_2d[i])):
			lst_2d[i][p] = x[p]
	x = 0
	y = 0
	for i in range(n):
		flag = 0
		for j in range(m):
			if lst_2d[i][j]:
				flag = 1
				break
		if flag == 0:
			x += 1
	for i in range(m):
		flag = 0
		for j in range(n):
			if lst_2d[j][i]:
				flag = 1
				break
		if flag == 0:
			y += 1
	mins = x if x <= y else y
	if mins % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def check(mat, i, j):
	b = False
	for k in range(len(mat)):
		if mat[k][j] == 1:
			b = True
			break
	if b == True or 1 in mat[i]:
		return True
	else:
		return False
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		l = list(map(int, input().split()))
		mat.append(l)
	turn = 'A'
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 0:
				if check(mat, i, j) == False:
					mat[i][j] = 1
					if turn == 'A':
						turn = 'V'
					else:
						turn = 'A'
	if turn != 'A':
		print('Ashish')
	else:
		print('Vivek')


import math

def DenTofieM():
	for _ in range(int(input())):
		(x, y) = map(int, input().split())
		ar = []
		for i in range(x):
			ar.append(list(map(int, input().split())))
		ans = 0
		for i in range(x):
			for j in range(y):
				if ar[i][j] == 1:
					continue
				flag = True
				for k in range(y):
					if ar[i][k] == 1:
						flag = False
				for k in range(x):
					if ar[k][j] == 1:
						flag = False
				if flag:
					ans += 1
					ar[i][j] = 1
		if ans & 1:
			print('Ashish')
		else:
			print('Vivek')
DenTofieM()


first = 'Ashish'
second = 'Vivek'
t = int(input().strip())
for _ in range(t):
	(n, m) = map(int, input().strip().split(' '))
	M = []
	for _ in range(n):
		M.append(list(map(int, input().strip().split(' '))))
	(a, b) = (n, m)
	for i in range(n):
		for j in range(m):
			if M[i][j] == 1:
				a -= 1
				break
	for i in range(m):
		for j in range(n):
			if M[j][i] == 1:
				b -= 1
				break
	ans = (first, second)[min(a, b) % 2 == 0]
	print(ans)


import sys
input = sys.stdin.readline

def solve(grid):
	(m, n) = (len(grid), len(grid[0]))
	(free_rows, free_cols) = (0, 0)
	for i in range(m):
		free_rows += 1
		for j in range(n):
			if grid[i][j]:
				free_rows -= 1
				break
	for j in range(n):
		free_cols += 1
		for i in range(m):
			if grid[i][j]:
				free_cols -= 1
				break
	r = min(free_rows, free_cols)
	if r % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
N = int(input())
for ii in range(N):
	(m, n) = map(int, input().split())
	grid = []
	for i in range(m):
		grid.append(list(map(int, input().split())))
	print(solve(grid))


from collections import defaultdict
t = int(input())
while t:
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		k = list(map(int, input().split()))
		a.append(k)
	rr = defaultdict(int)
	cc = defaultdict(int)
	r = n
	c = m
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				if cc[j] == 0:
					c -= 1
					cc[j] = 1
				if rr[i] == 0:
					r -= 1
					rr[i] = 1
	res = min(c, r)
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t -= 1


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	o_row = 0
	o_col = set()
	for i in range(n):
		row = list(map(int, input().split()))
		if 1 in row:
			o_row += 1
			for j in range(m):
				if row[j] == 1:
					o_col.add(j)
	diff_col = m - len(o_col)
	diff_row = n - o_row
	diff = min(diff_col, diff_row)
	if diff > 0:
		if diff % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	row = []
	col = []
	for i in range(len(mat)):
		for j in range(len(mat[i])):
			if mat[i][j] == 1:
				row.append(i + 1)
				col.append(j + 1)
	count = 0
	for i in range(n):
		for j in range(m):
			if i + 1 not in row and j + 1 not in col:
				count += 1
	vr = n + m - 1
	i = 0
	r = len(list(set(row)))
	c = len(list(set(col)))
	while count > 0:
		count = count - vr + r + c
		i += 1
		r += 1
		c += 1
	if i % 2 == 0:
		print('Vivek')
	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

def calc(A, r, c):
	sumr = LIST_1D_ARRAY(r)
	sumc = LIST_1D_ARRAY(c)
	for i in range(r):
		sum = 0
		for j in range(c):
			sum += A[i][j]
		sumr[i] = sum
	for i in range(c):
		sum = 0
		for j in range(r):
			sum += A[j][i]
		sumc[i] = sum
	ans = 0
	for i in range(r):
		for j in range(c):
			if sumr[i] == 0 and sumc[j] == 0:
				ans += 1
				sumr[i] = 1
				sumc[j] = 1
	if ans & 1:
		return 'Ashish'
	return 'Vivek'
for i in range(int(input())):
	(r, c) = INPUT()
	A = []
	for j in range(r):
		x = INPUT()
		A.append(x)
	print(calc(A, r, c))


def solve():
	(x, y) = [int(x) for x in input().split()]
	rows = [0] * x
	cols = [0] * y
	for j in range(x):
		z = input().split()
		for i in range(y):
			if z[i] == '1':
				rows[j] += 1
				cols[i] += 1
	p1 = len([x for x in rows if x == 0])
	p2 = len([x for x in cols if x == 0])
	return ['Vivek', 'Ashish'][min(p1, p2) % 2]
test = int(input())
for i in range(test):
	print(solve())


t = int(input())
for i in range(t):
	arr = []
	(n, m) = map(int, input().split())
	for i in range(n):
		l = list(map(int, input().split()))
		arr.append(l)
	rsum = []
	csum = []
	count = 0
	for i in range(n):
		c = 0
		for j in range(m):
			c += arr[i][j]
		rsum.append(c)
	for i in range(m):
		c = 0
		for j in range(n):
			c += arr[j][i]
		csum.append(c)
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 0 and rsum[i] == 0 and (csum[j] == 0):
				arr[i][j] = 1
				count += 1
				rsum[i] = 1
				csum[j] = 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


x = int(input())
inputs = []
for i in range(x):
	(n, m) = map(int, input().split())
	put = []
	for i in range(n):
		a = list(map(int, input().split()))
		put.append(a)
	inputs.append(put)

def column(matrix, i):
	return [row[i] for row in matrix]

def findMoves(board):
	moves = 0
	n = len(board)
	m = len(board[0])
	for x in range(0, n):
		for y in range(0, m):
			if board[x][y] == 1:
				continue
			if 1 in board[x]:
				continue
			if 1 in column(board, y):
				continue
			else:
				board[x][y] = 1
				moves += 1
	return moves
for board in inputs:
	moves = findMoves(board)
	if moves == 0:
		print('Vivek')
		continue
	if moves % 2 == 0:
		print('Vivek')
		continue
	else:
		print('Ashish')
		continue


a = int(input())
for _ in range(a):
	(x, y) = map(int, input().split())
	li = [0] * x
	(count1, count2) = (0, 0)
	for i in range(x):
		li[i] = list(map(int, input().split()))
	for i in range(x):
		if sum(li[i]) == 0:
			count1 += 1
	for i in range(y):
		for j in range(x):
			if li[j][i] != 0:
				break
		else:
			count2 += 1
	if min(count1, count2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for j in range(t):
	(n, m) = map(int, input().split())
	usedUp = []
	rows = n
	columns = m
	for i in range(n):
		a = list(map(int, input().split()))
		if 1 in a:
			rows -= 1
			i = 0
			while i < m:
				if a[i] == 1 and i not in usedUp:
					columns -= 1
					usedUp.append(i)
				i += 1
	if min(rows, columns) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import sys
from sys import setrecursionlimit
setrecursionlimit(10 ** 5)
readline = sys.stdin.readline

def util():
	(n, m) = list(map(int, readline().split()))
	grid = [list(map(int, readline().split())) for _ in range(n)]
	visited_r = set()
	visited_c = set()
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 1:
				visited_r.add(i)
				visited_c.add(j)
	mn = min(n - len(visited_r), m - len(visited_c))
	if mn % 2:
		print('Ashish')
	else:
		print('Vivek')
for _ in range(int(readline())):
	util()


def check_one(arr):
	for val in arr:
		if val != 0:
			return False
	return True

def check_two(matrix, rows, col):
	for row in range(rows):
		if matrix[row][col] != 0:
			return False
	return True

def solve():
	matrix = []
	[rows, cols] = [int(x) for x in input().split()]
	count = 0
	for i in range(rows):
		temp = [int(x) for x in input().split()]
		matrix.append(temp)
	for row in range(rows):
		for col in range(cols):
			if check_one(matrix[row]) and check_two(matrix, rows, col):
				matrix[row][col] = 1
				count += 1
	if count % 2 == 0:
		return 'Vivek'
	return 'Ashish'
t = int(input())
while t > 0:
	ans = solve()
	print(ans)
	t -= 1


for ii in range(int(input())):
	(r, c) = map(int, input().split())
	ans = 0
	col = []
	for i in range(r):
		f = False
		l = list(map(int, input().split()))
		for (j, k) in enumerate(l):
			if k == 1:
				col.append(j)
				f = True
		if f:
			r -= 1
	lc = len(set(col))
	c -= lc
	while r and c:
		r -= 1
		c -= 1
		ans += 1
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for z in range(t):
	(n, m) = [int(i) for i in input().split()]
	l = []
	for i in range(n):
		x = [int(j) for j in input().split()]
		l.append(x)
	c1 = c2 = 0
	f = False
	for i in range(n):
		f = False
		for j in range(m):
			if l[i][j] == 1:
				f = True
				break
		if not f:
			c1 += 1
	for i in range(m):
		f = False
		for j in range(n):
			if l[j][i] == 1:
				f = True
				break
		if not f:
			c2 += 1
	r = min(c1, c2)
	if r % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		row = [int(i) for i in input().split()]
		a.append(row)
	d = {'row': set(), 'col': set()}
	wins = 'Vivek'
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				d['row'].add(i)
				d['col'].add(j)
	while len(d['row']) < n and len(d['col']) < m:
		r = 0
		while r in d['row']:
			r += 1
		c = 0
		while c in d['col']:
			c += 1
		a[r][c] = 1
		d['row'].add(r)
		d['col'].add(c)
		if wins == 'Ashish':
			wins = 'Vivek'
		else:
			wins = 'Ashish'
	print(wins)


n = int(input())
for i in range(n):
	(a, b) = map(int, input().split())
	r = []
	r1 = 0
	for i in range(a):
		k = 0
		l = list(map(int, input().split()))
		r.append(l)
		for i in l:
			k = k + i
		if k == 0:
			r1 = r1 + 1
	c = 0
	for i in range(b):
		r2 = 0
		for j in range(a):
			r2 = r2 + r[j][i]
		if r2 == 0:
			c = c + 1
	if r1 > c:
		sol = c
	elif r1 < c:
		sol = r1
	else:
		sol = c
	if sol % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def parseint():
	ln = input().split()
	for i in range(len(ln)):
		ln[i] = int(ln[i])
	return ln

def solve(mat):
	full_rows = {}
	full_cols = {}
	for i in range(len(mat)):
		for j in range(len(mat[i])):
			if mat[i][j] == 1:
				full_rows[i] = True
				full_cols[j] = True
	row_keys = list(full_rows.keys())
	col_keys = list(full_cols.keys())
	counter = min(len(mat) - len(row_keys), len(mat[0]) - len(col_keys))
	if counter % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for i in range(t):
	nm = parseint()
	mat = []
	for j in range(nm[0]):
		mat.append(parseint())
	solve(mat)


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = [[0] * m for i in range(n)]
	for i in range(n):
		a[i] = list(map(int, input().split()))
	countr = 0
	countc = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				countr += 1
				break
	for i in range(m):
		for j in range(n):
			if a[j][i] == 1:
				countc += 1
				break
	res = min(m - countc, n - countr)
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	ar = [list(map(int, input().split())) for i in range(n)]
	rowcount = 0
	colcount = 0
	for i in range(n):
		flag = 1
		for j in range(m):
			if ar[i][j] == 1:
				flag = 0
				break
		if flag == 1:
			rowcount += 1
	for i in range(m):
		flag = 1
		for j in range(n):
			if ar[j][i] == 1:
				flag = 0
				break
		if flag == 1:
			colcount += 1
	if min(rowcount, colcount) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
input = stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	(c1, c2) = ([0] * n, [0] * m)
	for x in range(n):
		t = [int(y) for y in input().split()]
		for y in range(m):
			if t[y] == 1:
				c1[x] = 1
				c2[y] = 1
	cnt = min(n - sum(c1), m - sum(c2))
	print('Ashish' if cnt % 2 else 'Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	r = 0
	y = []
	for i in range(n):
		x = list(map(int, input().split()))
		if x.count(0) == m:
			r += 1
		y.append(x)
	c = 0
	for j in range(0, m):
		flag = True
		for i in range(0, n):
			if y[i][j] == 1:
				flag = False
		if flag:
			c += 1
	if min(r, c) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = [list(map(int, input().split())) for _ in range(n)]
	c = 0
	for i in range(n):
		for j in range(m):
			if a[i][j] == 0:
				if 1 not in a[i] and 1 not in [a[k][j] for k in range(n)]:
					c += 1
					a[i][j] = 1
					break
	print(['Vivek', 'Ashish'][c % 2])


t = int(input())
while t > 0:
	(n, m) = [int(x) for x in input().split()]
	arr = []
	for i in range(n):
		a = [int(x) for x in input().split()]
		arr.append(a)
	t -= 1
	row = [0 for _ in range(n)]
	col = [0 for _ in range(m)]
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				row[i] = 1
				col[j] = 1
	rc = n
	cc = m
	for i in range(n):
		if row[i] == 1:
			rc -= 1
	for i in range(m):
		if col[i] == 1:
			cc -= 1
	count = 0
	if min(rc, cc) == rc:
		count = rc
	else:
		count = cc
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	(n, m) = input().split()
	n = int(n)
	m = int(m)
	matrix = []
	for row in range(n):
		mini = []
		t_row = input().split()
		for col in range(m):
			mini.append(int(t_row[col]))
		matrix.append(mini)
	switch = True
	done = False
	while not done:
		nex = False
		for row in range(n):
			if 1 not in matrix[row]:
				for col in range(m):
					for r in range(n):
						if matrix[r][col] == 1:
							nex = True
							break
					if not nex:
						matrix[row][col] = 1
						switch = not switch
						nex = True
						break
					else:
						nex = False
			if nex:
				break
		if nex == False:
			done = True
	if switch:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	matrix = []
	row = [0] * n
	col = [0] * m
	for i in range(n):
		r = list(map(int, input().split()))
		matrix.append(r)
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 1:
				row[i] = col[j] = 1
	total = min(n - sum(row), m - sum(col))
	if total % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	(freeRows, freeCols) = (n, m)
	matrix = []
	for _ in range(n):
		curRow = [int(x) for x in input().split()]
		matrix.append(curRow)
		if sum(curRow) > 0:
			freeRows -= 1
	for j in range(m):
		for i in range(n):
			if matrix[i][j] == 1:
				freeCols -= 1
				break
	minval = min(freeRows, freeCols)
	if minval % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append(list(map(int, input().split())))
	r = [0] * n
	c = [0] * m
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				r[i] = 1
				c[j] = 1
	k = 0
	while True:
		boo = False
		for i in range(n):
			for j in range(m):
				if r[i] != 1 and c[j] != 1:
					r[i] = 1
					c[j] = 1
					k ^= 1
					boo = True
					break
			if boo:
				break
		if not boo:
			if k == 1:
				print('Ashish')
			else:
				print('Vivek')
			break


q = int(input())
for _ in range(q):
	(r, c) = map(int, input().split())
	mat = [list(map(int, input().split())) for i in range(r)]
	row = 0
	for i in mat:
		if sum(i) == 0:
			row += 1
	col = 0
	for i in range(c):
		su = 0
		for j in range(r):
			su += mat[j][i]
		if su == 0:
			col += 1
	cyk = min(row, col)
	if cyk % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve():
	(n, m) = map(int, input().split())
	li = []
	for i in range(n):
		temp = [int(x) for x in input().split()]
		li.append(temp)
	avail = 0
	for i in range(n):
		for j in range(m):
			if li[i][j] == 1:
				possible = False
				break
		else:
			for j in range(m):
				for k in range(n):
					if li[k][j] == 1:
						s_possible = False
						break
				else:
					li[i][j] = 1
					avail += 1
					break
	if avail % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for i in range(t):
	solve()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	rs = set()
	cs = set()
	for i in range(n):
		l = list(map(int, input().split()))
		for j in range(m):
			if l[j] == 1:
				cs.add(j)
		if 1 in l:
			rs.add(i)
	lrs = n - len(rs)
	crs = m - len(cs)
	req = min(lrs, crs)
	if req & 1:
		print('Ashish')
	else:
		print('Vivek')


def solution():
	(n, m) = list(map(int, input().split()))
	arr = []
	h1 = {}
	h2 = {}
	for i in range(n):
		arr.append([])
		for (k, j) in enumerate(list(map(int, input().split()))):
			if j == 1:
				h1[i] = 1
				h2[k] = 1
			arr[i].append(j)
	p = 'Ashish'
	ans = 'Vivek'
	i = 0
	j = 0
	for i in range(n):
		for j in range(m):
			if i not in h1 and j not in h2:
				if arr[i][j] == 0:
					(ans, p) = (p, ans)
					h1[i] = 1
					h2[j] = 1
	print(ans)

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


t = int(input())
for _ in range(t):
	(m, n) = [int(d) for d in input().split()]
	l = []
	for i in range(m):
		row = [int(d) for d in input().split()]
		l.append(row)
	row_count = [False] * m
	col_count = [False] * n
	for i in range(m):
		for j in range(n):
			if l[i][j] == 1:
				row_count[i] = True
				col_count[j] = True
	row_c = 0
	col_c = 0
	for i in range(m):
		if row_count[i] == False:
			row_c += 1
	for i in range(n):
		if col_count[i] == False:
			col_c += 1
	a = min(row_c, col_c)
	if a % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for q in range(t):
	(n, m) = map(int, input().split())
	claimed = 0
	rows = []
	claimedcol = {}
	flag = False
	for x in range(n):
		flag = False
		a = list(map(int, input().split()))
		for x in range(m):
			if a[x] == 1:
				claimedcol[x] = 1
				flag = True
		if flag:
			claimed += 1
		rows.append(a)
	colcount = 0
	for x in claimedcol:
		if claimedcol[x] == 1:
			colcount += 1
	n -= claimed
	m -= colcount
	n = min(n, m)
	if n % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	A = []
	cnt = [0 for i in range(n)]
	for i in range(n):
		a = list(map(int, input().split()))
		cnt[i] = a.count(1)
		A.append(a)
	mov = 0
	for i in range(n):
		for j in range(m):
			if cnt[i] != 0:
				break
			if cnt[i] == 0:
				p = 1
				for k in range(n):
					if A[k][j] == 1:
						p = 0
						break
				if p == 1:
					A[i][j] = 1
					cnt[i] = 1
					mov += 1
					break
	if mov % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


num_inp = lambda : int(input())
arr_inp = lambda : list(map(int, input().split()))
sp_inp = lambda : map(int, input().split())
str_inp = lambda : input()
I = input
for _ in [0] * int(I()):
	(n, m) = map(int, I().split())
	k = l = 0
	for _ in [0] * n:
		x = int(I()[::2], 2)
		k += x < 1
		l |= x
	print('VAisvheiks h'[min(k, m - bin(l).count('1')) % 2::2])


for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	grid = [input().split() for _ in range(n)]
	row = set([i for i in range(n)])
	col = set([j for j in range(m)])
	for i in range(n):
		for j in range(m):
			if grid[i][j] == '1':
				if i in row:
					row.remove(i)
				if j in col:
					col.remove(j)
	left = min(len(row), len(col))
	if left & 1:
		print('Ashish')
	else:
		print('Vivek')


from sys import stdin
from math import ceil, gcd

def func():
	return
for _ in range(int(stdin.readline())):
	(n, m) = map(int, stdin.readline().split())
	a = 0
	mat = []
	for i in range(n):
		arr = list(map(int, stdin.readline().split()))
		if arr.count(0) == m:
			a += 1
		mat.append(arr)
	b = 0
	for i in range(m):
		count = 0
		for j in range(n):
			if mat[j][i] == 0:
				count += 1
			else:
				break
		if count == n:
			b += 1
	if min(a, b) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	r1 = 0
	r2 = 0
	for i in range(n):
		if a[i].count(1) == 0:
			r1 += 1
	for j in range(m):
		b = []
		for i in range(n):
			b.append(a[i][j])
		if b.count(1) == 0:
			r2 += 1
	if min(r1, r2) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = [int(x) for x in input().split()]
	mat = [[int(x) for x in input().split()] for y in range(n)]
	iMat = [[mat[i][j] for i in range(n)] for j in range(m)]
	w = 'V'
	covered = 0
	statusR = [0 for i in range(n)]
	statusC = [0 for i in range(m)]
	for i in range(n):
		if sum(mat[i]) > 0:
			statusR[i] = 1
			covered += 1
	for i in range(m):
		if sum(iMat[i]) > 0:
			statusC[i] = 1
	while covered != n:
		try:
			posR = statusR.index(0)
		except:
			break
		if posR == -1:
			break
		try:
			posC = statusC.index(0)
		except:
			break
		if posC == -1:
			break
		statusR[posR] = 1
		statusC[posC] = 1
		covered += 1
		if w == 'V':
			w = 'A'
		else:
			w = 'V'
	if w == 'V':
		print('Vivek')
	else:
		print('Ashish')


def ans(M, visH, visV):
	c = 0
	for i in range(len(visH)):
		if visH[i] == 0:
			for j in range(len(visV)):
				if visV[j] == 0:
					c += 1
					visH[i] = 1
					visV[j] = 1
					break
	return c
t = int(input())
L = []
for i in range(t):
	(n, m) = map(int, input().split())
	M = []
	visH = [0] * n
	visV = [0] * m
	for i in range(n):
		row = [int(x) for x in input().split()]
		M.append(row)
		for j in range(m):
			if row[j] == 1:
				visH[i] = 1
				visV[j] = 1
	if ans(M, visH, visV) % 2 == 0:
		L.append('Vivek')
	else:
		L.append('Ashish')
for w in L:
	print(w)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = [list(map(int, input().split())) for i in range(n)]
	(cr, cl) = (0, 0)
	for i in range(n):
		f = 0
		for j in range(m):
			if l[i][j] == 1:
				f = 1
				break
		if f == 0:
			cr += 1
	for i in range(m):
		f = 0
		for j in range(n):
			if l[j][i] == 1:
				f = 1
				break
		if f == 0:
			cl += 1
	m = min(cr, cl)
	if m % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
t = int(stdin.readline())
for _ in range(t):
	(n, m) = list(map(int, stdin.readline().rstrip().split(' ')))
	rows = [0] * n
	columns = [0] * m
	for i in range(n):
		line = list(map(int, stdin.readline().rstrip().split(' ')))
		for j in range(m):
			if line[j] == 1:
				rows[i] = 1
				columns[j] = 1
	rowCount = rows.count(0)
	colCount = columns.count(0)
	moves = min(rowCount, colCount)
	if moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


T = int(input())
for _ in range(T):
	(n, m) = map(int, input().strip().split())
	cols = [0] * m
	for _ in range(n):
		row = list(map(int, input().strip().split()))
		for (i, elem) in enumerate(row):
			cols[i] += elem
		if sum(row) > 0:
			n -= 1
	m -= sum([1 for c in cols if c > 0])
	optimal_move = min(m, n)
	if optimal_move % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	g = []
	for i in range(n):
		g.append(list(map(int, input().split())))
	one = []
	for i in range(n):
		for j in range(m):
			if g[i][j] == 1:
				one.append((i, j))
	for (x, y) in one:
		for i in range(n):
			g[i][y] = 1
		for i in range(m):
			g[x][i] = 1
	a = 0
	b = 0
	for j in range(m):
		h = 0
		for i in range(n):
			if g[i][j] == 0:
				h += 1
		a = max(a, h)
	for j in range(n):
		w = 0
		for i in range(m):
			if g[j][i] == 0:
				w += 1
		b = max(b, w)
	if min(a, b) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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

def solve():
	(n, m) = map(int, input().split())
	grid = [list(map(int, input().split())) for i in range(n)]
	(taken_rows, taken_cols) = ([False] * n, [False] * m)
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 1:
				taken_rows[i] = True
				taken_cols[j] = True
	turn = 'Vivek'
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 0 and (not taken_rows[i]) and (not taken_cols[j]):
				grid[i][j] = 1
				taken_rows[i] = True
				taken_cols[j] = True
				turn = 'Ashish' if turn == 'Vivek' else 'Vivek'
	print(turn)

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


from sys import stdin, stdout

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

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

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

def solve():
	(n, m) = MI()
	rows = {i for i in range(1, n + 1)}
	cols = {i for i in range(1, m + 1)}
	for i in range(n):
		r = LI()
		for j in range(m):
			if r[j] == 1:
				rows.discard(i + 1)
				cols.discard(j + 1)
	options = min(len(rows), len(cols))
	if options % 2 == 1:
		stdout.write('Ashish\n')
	else:
		stdout.write('Vivek\n')
t = II()
for _ in range(t):
	solve()


for t in range(int(input())):
	(n, m) = map(int, input().split())
	data = [list(map(int, input().split())) for i in range(n)]
	mr = [0] * n
	mc = [0] * m
	for i in range(n):
		for j in range(m):
			if data[i][j]:
				mr[i] += 1
				mc[j] += 1
	ur = sum((1 for i in range(n) if not mr[i]))
	uc = sum((1 for i in range(m) if not mc[i]))
	print('Ashish' if min(ur, uc) % 2 == 1 else 'Vivek')


import sys
INF = 10 ** 20
MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
from math import gcd
from math import ceil
from collections import defaultdict as dd, Counter
from bisect import bisect_left as bl, bisect_right as br

def solve():
	(n, m) = I()
	a = []
	row = set()
	col = set()
	for i in range(n):
		a.append(I())
		for j in range(m):
			if a[i][j] == 1:
				row.add(i)
				col.add(j)
	ok = min(n - len(row), m - len(col))
	ans = 'Vivek'
	if ok % 2:
		ans = 'Ashish'
	print(ans)
(t,) = I()
while t:
	t -= 1
	solve()


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	ml = []
	jl = set()
	il = set()
	for i in range(n):
		li = list(map(int, input().split()))
		ml.append(li)
		for j in range(len(li)):
			if li[j] == 1:
				jl.add(j)
				il.add(i)
	minn = min(n - len(il), m - len(jl), n, m)
	if minn % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = lambda : sys.stdin.readline().rstrip()
mod = 10 ** 9 + 7
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	ng_row = set()
	ng_c = set()
	a = []
	for i in range(n):
		temp = list(map(int, input().split()))
		for j in range(m):
			if temp[j] == 1:
				ng_row.add(i)
				ng_c.add(j)
		a.append(temp)
	cnt1 = m - len(ng_c)
	cnt2 = n - len(ng_row)
	cnt = min(cnt1, cnt2)
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def solve():
	(n, m) = map(int, input().split())
	a = [[] for _ in range(n)]
	for i in range(n):
		a[i] = list(map(int, input().split()))
	(row, col) = (0, 0)
	for i in range(n):
		flag = True
		for j in range(m):
			if a[i][j] == 1:
				flag = False
				break
		if flag:
			row += 1
	for j in range(m):
		for i in range(n):
			flag = True
			if a[i][j] == 1:
				flag = False
				break
		if flag:
			col += 1
	mi = min(row, col)
	print(['Ashish', 'Vivek'][mi % 2 ^ 1])
t = int(input())
for _ in range(t):
	solve()


q = int(input())
ones = 0
for k in range(0, q):
	(n, m) = map(int, input().split())
	s_row = set()
	s_column = set()
	for i in range(0, n):
		row = list(map(int, input().split()))
		for j in range(0, m):
			a = row[j]
			if a == 1:
				s_row.add(i)
				s_column.add(j)
	x = min(n - len(s_row), m - len(s_column))
	if x % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	s = [0] * m
	l = 0
	for i in range(n):
		b = list(map(int, input().split()))
		if sum(b) == 0:
			l += 1
		else:
			for j in range(m):
				s[j] += b[j]
	r = 0
	for x in s:
		if x == 0:
			r += 1
	r = min(l, r)
	if r % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


n_test = int(input())
for _ in range(n_test):
	(N, M) = map(int, input().split())
	(n, m) = (N, M)
	G = []
	for _ in range(N):
		G.append(list(map(int, input().split())))
	for r in range(N):
		for c in range(M):
			if G[r][c] == 1:
				n -= 1
				break
	for c in range(M):
		for r in range(N):
			if G[r][c] == 1:
				m -= 1
				break
	print('Vivek' if min(n, m) % 2 == 0 else 'Ashish')


t = int(input())
for i in range(t):
	hold = input().split(' ')
	r = int(hold[0])
	c = int(hold[1])
	mat = []
	urows = 0
	ucols = 0
	for i in range(r):
		hold = [int(x) for x in input().split(' ')]
		if not 1 in hold:
			urows += 1
		mat += [hold]
	for i in range(c):
		unclaimed = True
		for j in range(r):
			if mat[j][i] == 1:
				unclaimed = False
				break
		if unclaimed:
			ucols += 1
	m = min(urows, ucols)
	if m % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import sys
input = sys.stdin.readline
from collections import defaultdict as dc
import math

def solve():
	(N, M) = map(int, input().split())
	L = []
	p = min(N, M)
	for i in range(N):
		L.append(list(map(int, input().split())))
	RES = 0
	(r, c) = (0, 0)
	d1 = dc(lambda : 0)
	for i in range(N):
		F = True
		for j in range(M):
			if L[i][j] == 1:
				F = False
				break
		if F:
			d1[i] = 1
	d2 = dc(lambda : 0)
	for i in range(M):
		F = True
		for j in range(N):
			if L[j][i] == 1:
				F = False
				break
		if F:
			d2[i] = 1
	for i in range(N):
		for j in range(M):
			if L[i][j] == 0 and d1[i] == 1 and (d2[j] == 1):
				RES += 1
				d1[i] = 0
				d2[j] = 0
	if RES % 2:
		print('Ashish')
	else:
		print('Vivek')
for _ in range(int(input())):
	solve()


testcases = int(input())
for testcase in range(testcases):
	temparr = input()
	temparr = temparr.split()
	row = int(temparr[0])
	col = int(temparr[1])
	tempcol = [0] * col
	arr = [tempcol[:] for _ in range(row)]
	rowdicts = {}
	coldicts = {}
	ans = 0
	newrowdicts = {}
	for i in range(row):
		temp = input()
		temp = temp.split()
		temp1 = temp[:]
		for j in range(col):
			arr[i][j] = int(temp1[j])
			if int(temp1[j]) == 1:
				coldicts[j] = 1
				rowdicts[i] = 1
		sums = sum(arr[i])
		if sums == 0:
			newrowdicts[i] = 1
	freecol = 0
	for i in range(col):
		sums = 0
		for j in range(row):
			if arr[j][i] == 1:
				sums += 1
		if sums == 0:
			freecol += 1
	ans = min(len(newrowdicts), freecol)
	if ans == 0:
		print('Vivek')
		continue
	elif ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from math import *
from collections import *
from itertools import *
from bisect import *
from heapq import *
from operator import *
from sys import *
setrecursionlimit(100000000)
import os
import sys
from sys import *
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')

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()
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
z = lambda : sys.stdin.readline().rstrip('\r\n')

def op():
	return list(map(int, z().split()))

def o():
	return int(z())

def r(x):
	if type(x) == int:
		return range(x)
	else:
		return range(len(x))

def kl(con, x=0):
	if x == 0:
		print('Yes') if con else print('No')
	elif x == 1:
		print('yes') if con else print('no')
	elif x == 2:
		print('YES') if con else print('NO')
MOD = 1000000007
MAX = float('inf')
MIN = -float('inf')
for _ in r(o()):
	(n, m) = map(int, z().split())
	l = [op() for i in r(n)]
	r1 = [0] * n
	c = [0] * m
	for i in r(n):
		for j in r(m):
			if l[i][j] == 1:
				r1[i] = 1
				break
	for i in r(m):
		for j in r(n):
			if l[j][i] == 1:
				c[i] = 1
				break
	x = min(r1.count(0), c.count(0))
	if x & 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	q = []
	for i in range(n):
		q.append(list(map(int, input().split())))
	c = 0
	for i in range(n):
		for j in range(m):
			f = 0
			for k in range(m):
				if q[i][k] == 1:
					f = 1
					break
			if f == 0:
				g = 0
				for k in range(n):
					if q[k][j] == 1:
						g = 1
						break
				if g == 0:
					q[i][j] = 1
					c = c + 1
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def check_col(arr, col_ind):
	for i in range(len(arr)):
		if arr[i][col_ind] == 1:
			return False
	return True

def best_place(arr):
	for row_ind in range(len(arr)):
		if 1 in arr[row_ind]:
			continue
		for col_ind in range(len(arr[0])):
			if check_col(arr, col_ind):
				return (row_ind, col_ind)
	return (-1, -1)
t = int(input())
while t:
	(n, m) = [int(x) for x in input().split()]
	arr = []
	for _ in range(n):
		temp = [int(x) for x in input().split()]
		arr.append(temp)
	players = ['Ashish', 'Vivek']
	chance = 0
	while 1:
		(row, col) = best_place(arr)
		if not (row, col) == (-1, -1):
			arr[row][col] = 1
		else:
			print(f'{players[(chance + 1) % 2]}')
			break
		chance += 1
	t -= 1


test = int(input())
for t in range(test):
	a = input().split()
	r = int(a[0])
	c = int(a[1])
	mat = []
	for i in range(r):
		temp = input().split()
		mat.append(temp)
	row = 0
	col = 0
	for m in mat:
		if sum(map(int, m)) == 0:
			row += 1
	for i in range(c):
		p = []
		for m in mat:
			p.append(m[i])
		if sum(map(int, p)) == 0:
			col += 1
	count = min(row, col)
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	for i in range(n):
		matrix.append(list(map(int, input().split())))
	(col, row) = (set(), set())
	for i in range(n):
		for j in range(m):
			if matrix[i][j]:
				row.add(i)
				col.add(j)
	wari = 1
	while len(row) != n and len(col) != m:
		for i in range(n):
			if i not in row:
				for j in range(m):
					if j not in col and matrix[i][j] == 0:
						matrix[i][j] = 1
						row.add(i)
						col.add(j)
						wari += 1
						break
	if wari % 2 == 0:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		l.append([int(x) for x in input().split()])
	r = set()
	co = set()
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				r.add(i)
				co.add(j)
	f = 0
	c = 0
	while True:
		c = f
		for i in range(n):
			for j in range(m):
				if l[i][j] == 0:
					if i in r:
						break
					if j in co:
						continue
					l[i][j] = 1
					f += 1
					r.add(i)
					co.add(j)
		if c == f:
			break
	if f % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


(T,) = map(int, input().split())
for _ in range(T):
	(N, M) = map(int, input().split())
	X = []
	c = 0
	for _ in range(N):
		Y = list(map(int, input().split()))
		if sum(Y) > 0:
			c += 1
		X.append(Y)
	mx = N - c
	t = 0
	for i in range(M):
		for j in range(N):
			if X[j][i]:
				t += 1
				break
	mx = min(mx, M - t)
	if mx % 2:
		print('Ashish')
	else:
		print('Vivek')


import sys
input = sys.stdin.buffer.readline

def solution():
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		l = []
		x = []
		for i in range(n):
			s = list(map(int, input().split()))
			l.append(s)
			if s.count(0) == m:
				x.append(i)
		ans = 0
		for i in range(n):
			for j in range(m):
				cnt = 0
				if l[i][j] == 0:
					if l[i].count(0) == m:
						for k in range(n):
							if l[k][j] == 0:
								cnt += 1
						if cnt == n:
							ans += 1
							l[i][j] = 1
		if ans % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
solution()


t = int(input())
for case in range(t):
	[n, m] = list(map(int, input().split()))
	a = []
	for i in range(n):
		a.append(list(map(int, input().split())))
	emp_rows = 0
	for i in range(n):
		if sum(a[i]) == 0:
			emp_rows += 1
	emp_cols = 0
	for j in range(m):
		col_sum = 0
		for i in range(n):
			col_sum += a[i][j]
		if col_sum == 0:
			emp_cols += 1
	moves = min(emp_rows, emp_cols)
	if moves % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	ma = []
	c = [0] * m
	r = [0] * n
	for j in range(n):
		te = input().split()
		ma.append(te)
	for j in range(n):
		for k in range(m):
			if ma[j][k] == '1':
				r[j] = -1
				c[k] = -1
	co = 0
	p = r.count(0)
	q = c.count(0)
	co = min(p, q)
	if co % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


import sys, os
import math
from fractions import Fraction

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

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

def main():
	(n, m) = minput()
	a = []
	b = []
	c = []
	for i in range(n):
		x = linput()
		a.append(x)
		k = 0
		for j in range(m):
			if x[j] == 1:
				k += 1
		b.append(k)
	for j in range(m):
		k = 0
		for i in range(n):
			if a[i][j] == 1:
				k += 1
		c.append(k)
	(p, q) = (0, 0)
	for i in b:
		if i == 0:
			p += 1
	for i in c:
		if i == 0:
			q += 1
	if min(p, q) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
tc = int(input())
while tc != 0:
	tc -= 1
	main()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		temp = list(map(int, input().split()))
		arr.append(temp)
	row = 0
	for i in range(n):
		if 1 not in arr[i]:
			row += 1
	zero = [0] * m
	for i in range(n):
		for j in range(m):
			zero[j] += arr[i][j]
	col = zero.count(0)
	ans = min(row, col)
	if ans % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	(row, col) = [int(i) for i in input().split()]
	board = []
	for i in range(row):
		board.append([int(i) for i in input().split()])
	hor = []
	ver = []
	for i in range(row):
		for j in range(col):
			if board[i][j] == 1:
				hor.append(i)
				ver.append(j)
	turns = 0
	for i in range(row):
		for j in range(col):
			if board[i][j] == 0 and i not in hor and (j not in ver):
				board[i][j] == 1
				hor.append(i)
				ver.append(j)
				turns += 1
	print('Vivek' if turns % 2 == 0 else 'Ashish')


t = int(input())
for z in range(t):
	g = input().split()
	n = int(g[0])
	m = int(g[1])
	s = []
	for i in range(n):
		s.append(input().split())
	hor1 = 0
	ver1 = 0
	d = [i + 1 for i in range(m)]
	for i in range(n):
		hor = 0
		for j in range(m):
			if s[i][j] == '1':
				hor += 1
				try:
					d.remove(j + 1)
				except:
					pass
		if hor == 0:
			hor1 += 1
		hor = 0
	ver1 = len(d)
	k = min(ver1, hor1)
	if k % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


tc = int(input().strip())
while tc:
	(n, m) = map(int, input().strip().split())
	grid = [[0] * m] * n
	for i in range(n):
		grid[i] = list(map(int, input().strip().split()))
	rz = 0
	for i in range(n):
		if sum(grid[i]) == 0:
			rz += 1
	cz = 0
	for j in range(m):
		sm = 0
		for i in range(n):
			sm += grid[i][j]
		if sm == 0:
			cz += 1
	if min(rz, cz) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')
	tc -= 1


import sys
t = int(sys.stdin.readline())
for _ in range(t):
	(m, n) = map(int, input().split())
	mat = []
	for i in range(m):
		mat.append(list(map(int, input().split())))
	count = 0
	for i in mat:
		if 1 in i:
			count += 1
	x = m - count
	mat = list(zip(*mat))
	count = 0
	for i in mat:
		if 1 in i:
			count += 1
	y = n - count
	p = x if x < y else y
	print('Vivek' if p % 2 == 0 else 'Ashish')


import sys
fast_reader = sys.stdin.readline

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

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

def sep_input():
	return map(int, input().split())
for _ in range(int(input())):
	(n, m) = sep_input()
	l = []
	for i in range(n):
		l.append(list_input())
	c1 = [0 for i in range(n)]
	c2 = [0 for i in range(m)]
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				c1[i] += 1
				c2[j] += 1
	c1 = c1.count(0)
	c2 = c2.count(0)
	if min(c1, c2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


testcase = int(input())
for t in range(1, testcase + 1):
	(n, m) = map(int, input().split(' '))
	matrix = []
	player = {0: 'Ashish', 1: 'Vivek'}
	for i in range(n):
		row = list(map(int, input().split(' ')))
		matrix.append(row)
	cols = {}
	for row in matrix:
		flag = 0
		for i in range(m):
			if row[i]:
				flag = 1
				cols[i] = 1
		if flag:
			n -= 1
	for col in cols:
		m -= 1
	matrix = [[0] * m for i in range(n)]
	plr = 0
	while min(n, m):
		n -= 1
		m -= 1
		plr = (plr + 1) % 2
	print(player[(plr + 1) % 2])


for nt in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	row = {}
	col = {}
	for i in range(n):
		if 1 in mat[i]:
			row[i] = 1
	for i in range(m):
		flag = 0
		for j in range(n):
			if mat[j][i] == 1:
				flag = 1
				break
		if flag:
			col[i] = 1
	count = 0
	for i in range(n):
		for j in range(m):
			if i not in row and j not in col:
				row[i] = 1
				col[j] = 1
				count += 1
	if count % 2:
		print('Ashish')
	else:
		print('Vivek')


import functools

def solve():
	(h, w) = map(int, input().split(' '))
	lockedH = [0] * h
	lockedW = [0] * w
	for i in range(h):
		line = list(map(int, input().split(' ')))
		for j in range(w):
			if line[j] == 1:
				lockedH[i] = 1
				lockedW[j] = 1
	sum = min(h - functools.reduce(lambda a, b: a + b, lockedH), w - functools.reduce(lambda a, b: a + b, lockedW))
	if sum % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')

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


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = list(map(lambda _: list(map(int, input().split())), range(n)))
	(rows, cols) = ([True] * n, [True] * m)
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				(rows[i], cols[j]) = (False, False)
	print('Vivek' if min(rows.count(True), cols.count(True)) % 2 == 0 else 'Ashish')


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

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()):
		(n, m) = inputVars()
		arr = []
		for pos in range(n):
			arr.append(inputIntArray())
		rowCnt = 0
		colCnt = 0
		for row in range(n):
			check = True
			for col in range(m):
				if arr[row][col] == 1:
					check = False
					break
			if check:
				rowCnt += 1
		for col in range(m):
			check = True
			for row in range(n):
				if arr[row][col] == 1:
					check = False
					break
			if check:
				colCnt += 1
		minVal = min(colCnt, rowCnt)
		if minVal % 2 == 0:
			print('Vivek')
		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()


def transpose(A, N, M):
	B = [[0 for x in range(M)] for y in range(N)]
	for i in range(N):
		for j in range(M):
			B[i][j] = A[j][i]
	return B
t = int(input())
for _ in range(t):
	l = []
	(n, m) = map(int, input().split(' '))
	for _ in range(n):
		arr = [int(num) for num in input().split(' ')]
		l.append(arr)
	arr2 = transpose(l, m, n)
	for item in l:
		if 1 in item:
			n = n - 1
	for item in arr2:
		if 1 in item:
			m = m - 1
	x = min(n, m)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(N, M) = map(int, input().split())
	a = [list(map(int, input().split())) for _ in range(N)]
	t = [0] * M
	tt = [0] * N
	for i in range(N):
		for j in range(M):
			if a[i][j]:
				t[j] = 1
				tt[i] = 1
	res = min(M - sum(t), N - sum(tt))
	if res % 2:
		print('Ashish')
	else:
		print('Vivek')


def is_available(matrix, i, j):
	row = 0
	column = 0
	while column < len(matrix[i]):
		if matrix[i][column] == 1:
			return False
		column += 1
	while row < len(matrix):
		if matrix[row][j] == 1:
			return False
		row += 1
	return True
for t in range(int(input())):
	(n, m) = list(map(int, input().split()))
	matrix = [list(map(int, input().split())) for i in range(n)]
	available_spots = 0
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == 0 and is_available(matrix, i, j):
				available_spots += 1
				matrix[i][j] = 1
	if available_spots % 2 == 0:
		print('Vivek')
	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
import sys
input = sys.stdin.readline
M = mod = 998244353

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('\n').split()]

def st():
	return input().rstrip('\n')

def val():
	return int(input().rstrip('\n'))

def li2():
	return [i for i in input().rstrip('\n')]

def li3():
	return [int(i) for i in input().rstrip('\n')]
for _ in range(val()):
	(n, m) = li()
	l = []
	for i in range(n):
		l.append(li())
	rows = n
	cols = m
	for i in range(n):
		if sum(l[i]):
			rows -= 1
	for j in range(m):
		for i in range(n):
			if l[i][j]:
				cols -= 1
				break
	n = rows
	m = cols
	print('Ashish' if min(n, m) & 1 else 'Vivek')


for i in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	row = [0] * n
	col = [0] * m
	for i in range(n):
		array = list(map(int, input().split()))
		matrix.append(array)
		for j in range(m):
			if array[j] == 1:
				row[i] = 1
				col[j] = 1
	mat = min(n - sum(row), m - sum(col))
	if mat % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	inp = input().split()
	n = int(inp[0])
	m = int(inp[1])
	lst = []
	for i in range(n):
		ls = input().split()
		lst.append(ls)
	sm = [0 for i in range(m)]
	nn = 0
	for i in range(n):
		if '1' not in lst[i]:
			nn += 1
		for j in range(m):
			sm[j] += int(lst[i][j])
	mm = sm.count(0)
	if min(mm, nn) % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(row, col) = map(int, input().split())
	mat = []
	pr = []
	notc = []
	for i in range(row):
		l = list(map(int, input().split()))
		if l.count(1) == 0:
			pr.append(i)
		else:
			for j in range(col):
				if l[j] != 0 and j not in notc:
					notc.append(j)
	if min(len(pr), col - len(notc)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	ans = 0
	hang = []
	lie = []
	for i in range(600):
		hang.append(0)
		lie.append(0)
	(m, n) = input().split()
	m = int(m)
	n = int(n)
	l = [[0] * 500] * 500
	for i in range(m):
		l[i] = input().split(' ')
		for j in range(n):
			if l[i][j] != '0':
				hang[i] = 1
				lie[j] = 1
	q = 0
	w = 0
	for i in range(m):
		if hang[i] == 0:
			q = q + 1
	for i in range(n):
		if lie[i] == 0:
			w = w + 1
	s = 0
	if q > w:
		s = w
	else:
		s = q
	if s % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


import sys
input = sys.stdin.readline
for f in range(int(input())):
	(n, m) = map(int, input().split())
	b = [0] * n
	r = 0
	c = 0
	for i in range(n):
		b[i] = list(map(int, input().split()))
		if sum(b[i]) == 0:
			r += 1
	for j in range(m):
		s = 0
		i = 0
		while s == 0 and i < n:
			if b[i][j] == 1:
				s = 1
			i += 1
		if s == 0:
			c += 1
	sol = min(r, c)
	if sol % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


from sys import stdin, stdout
from collections import Counter, defaultdict
import math

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

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

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

def readListStr():
	return list(map(str, stdin.readline().split()))

def nextLine():
	stdout.write('\n')

def show(x):
	stdout.write(str(x) + '\n')

def showInline(x):
	stdout.write(str(x))

def showList(x):
	for i in x:
		stdout.write(str(i) + ' ')
	nextLine()

def show2D(x):
	for i in range(len(x)):
		for j in range(len(x[0])):
			stdout.write(str(x[i][j]) + ' ')
		nextLine()

def emptyList(length, value=-1):
	return [value] * length

def empty2D(row, col, val=-1):
	return [[val for i in range(col)] for j in range(row)]

def isSquare(x):
	if x ** 0.5 * 10 % 10 == 0:
		return 1
	return 0

def isLog(val, base):
	a = math.log(val, base)
	if a * 10 % 10 == 0:
		return 1
	else:
		return 0

def solve():
	for testcases in range(readInt()):
		(n, m) = map(int, stdin.readline().split())
		matrix = [[0 for i in range(m + 2)]]
		for i in range(n):
			a = readListInt()
			a.insert(0, 0)
			a.append(0)
			matrix.append(a)
		rows = []
		col = []
		a = [0 for j in range(len(matrix[0]))]
		matrix.append(a)
		for i in range(1, n + 1):
			for j in range(1, m + 1):
				if matrix[i][j] == 1:
					rows.append(i)
					col.append(j)
		total = 0
		for i in range(1, n + 1):
			for j in range(1, m + 1):
				if matrix[i][j] == 0:
					if i not in rows and j not in col:
						rows.append(i)
						col.append(j)
						matrix[i][j] = 1
						total += 1
		if total % 2 == 0:
			show('Vivek')
		else:
			show('Ashish')
solve()


T = int(input())
for test in range(T):
	(n, m) = map(int, input().split())
	l = []
	ans = 0
	for i in range(n):
		temp = input().split()
		l.append(temp)
	c1 = 0
	for i in range(n):
		if '1' not in l[i]:
			c1 += 1
	c2 = 0
	for i in range(m):
		c = True
		for j in range(n):
			if l[j][i] == '1':
				c = False
				break
		c2 += c
	if min(c1, c2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = [int(e) for e in input().split()]
	matrix = [[x for x in input().split()] for _ in range(n)]
	columns = set()
	rows = set()
	for i in range(n):
		for j in range(m):
			if matrix[i][j] == '1':
				columns.add(j)
				rows.add(i)
	res = min(n - len(rows), m - len(columns))
	print('Ashish' if res & 1 else 'Vivek')


from math import inf, sqrt, floor, ceil
from collections import Counter, defaultdict, deque
from heapq import heappush as hpush, heappop as hpop, heapify as h
from operator import itemgetter
from itertools import product
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	Row = 0
	Col = 0
	for i in range(n):
		if 1 not in mat[i]:
			Row += 1
	for j in range(m):
		check = 0
		for i in range(n):
			if mat[i][j]:
				check = 1
				break
		if not check:
			Col += 1
	ans = min(Row, Col)
	if ans & 1:
		print('Ashish')
	else:
		print('Vivek')


from sys import *
from collections import Counter
input = lambda : stdin.readline()
int_arr = lambda : list(map(int, stdin.readline().strip().split()))
str_arr = lambda : list(map(str, stdin.readline().split()))
get_str = lambda : map(str, stdin.readline().strip().split())
get_int = lambda : map(int, stdin.readline().strip().split())
get_float = lambda : map(float, stdin.readline().strip().split())
mod = 1000000007
setrecursionlimit(1000)
for _ in range(int(input())):
	(n, m) = get_int()
	lst = []
	row = [0] * n
	column = [0] * m
	for i in range(n):
		arr = int_arr()
		for j in range(len(arr)):
			if arr[j] == 1:
				row[i] = 1
				column[j] = 1
	ct = min(row.count(0), column.count(0))
	print('Ashish' if ct % 2 != 0 else 'Vivek')


import sys
import math
import operator as op
from functools import reduce
from bisect import *
from collections import deque

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
N = int(1000000.0) + 10
fenwick = [0] * N

def add(i, x, n):
	while i < n:
		fenwick[i] += x
		i = i | i + 1

def fsum(i, n):
	res = 0
	while i >= 0:
		res += fenwick[i]
		i = (i & i + 1) - 1
	return res

def fsum_range(i, j, n):
	return fsum(j, n) - fsum(i - 1, n)
mod = int(1000000000.0) + 7
mod2 = 998244353
t = read_int()
for i in range(t):
	(n, m) = read_int_line()
	a = []
	for i in range(n):
		r = read_int_line()
		a.append(r)
	row = [0] * n
	col = [0] * m
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				row[i] = 1
				col[j] = 1
	a1 = n - sum(row)
	a2 = m - sum(col)
	ans = min(a1, a2)
	if ans % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for x in range(t):
	n_m = input().split(' ')
	n = int(n_m[0])
	m = int(n_m[1])
	list_of_inputs = []
	for y in range(n):
		list_of_inputs += [input().split(' ')]
	število_potez = 0
	for item in list_of_inputs:
		številka = item.count('1')
		if številka == 0:
			d = 0
			preštej = 0
			for i in item:
				preštej = item.count('1')
				if preštej == 0:
					preštej2 = 0
					for x in range(n):
						if list_of_inputs[x][d] == '1':
							preštej2 += 1
						else:
							pass
					if preštej2 == 0:
						število_potez += 1
						list_of_inputs[list_of_inputs.index(item)][d] = '1'
					else:
						list_of_inputs[list_of_inputs.index(item)][d] = '0'
				else:
					list_of_inputs[list_of_inputs.index(item)][d] = '0'
				d += 1
		else:
			pass
	if število_potez % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	b = list(map(int, input().split()))
	n = b[0]
	m = b[1]
	flagc = [False] * 2000
	flagr = [False] * 2000
	cnt = 0
	for j in range(n):
		a = list(map(int, input().split()))
		for k in range(m):
			if a[k] == 1:
				flagc[k] = True
				flagr[j] = True
	for j in range(n):
		for k in range(m):
			if (flagc[k] == False) & (flagr[j] == False):
				cnt += 1
				flagr[j] = True
				flagc[k] = True
	if cnt % 2 == 0:
		print('Vivek')
	if cnt % 2 == 1:
		print('Ashish')


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(A):
	(n, m) = (0, 0)
	for row in A:
		if sum(row) == 0:
			n += 1
	if n == 0:
		return 'Vivek'
	for col in range(len(A[0])):
		s = 0
		for row in A:
			s += row[col]
		if s == 0:
			m += 1
	res = min(n, m)
	return 'Vivek' if res & 1 == 0 else 'Ashish'
t = inp()
for _ in range(t):
	(n, m) = invr()
	A = []
	for _ in range(n):
		A.append(inlt())
	print(solution(A))


from sys import stdin, stdout
from math import gcd, ceil, sqrt
from collections import Counter
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
tc = ii1()
for _ in range(tc):
	(n, m) = iia()
	arr = []
	for i in range(n):
		arr.append(iia())
	rows = col = 0
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				break
		else:
			rows += 1
	for i in range(m):
		for j in range(n):
			if arr[j][i] == 1:
				break
		else:
			col += 1
	res = min(rows, col)
	if res % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	mat = []
	(m, n) = map(int, input().split())
	for j in range(m):
		r = list(map(int, input().split()))
		mat.append(r)
	small = m if m < n else n
	claimed = [0] * small
	r = 0
	c = 0
	r = set()
	c = set()
	for i in range(m):
		for j in range(n):
			if mat[i][j] == 1:
				r.add(i)
				c.add(j)
	mn = min(m - len(r), n - len(c))
	if mn % 2:
		print('Ashish')
	else:
		print('Vivek')


def prog():
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		matrix = [list(map(int, input().split())) for i in range(n)]
		rows = n
		columns = m
		for row in matrix:
			for i in row:
				if i == 1:
					rows -= 1
					break
		for j in range(m):
			for i in range(n):
				if matrix[i][j] == 1:
					columns -= 1
					break
		optimal = min(rows, columns)
		if optimal % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
prog()


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 count2Dmatrix(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, m) = spin()
	l = matrix(n)
	row = []
	col = []
	c = 0
	for i in range(n):
		for j in range(m):
			if l[i][j] == 1:
				row.append(i)
				col.append(j)
	for i in range(n):
		if row.count(i) == 0:
			for j in range(m):
				if row.count(i) == 0 and col.count(j) == 0:
					if l[i][j] == 0:
						c += 1
						row.append(i)
						col.append(j)
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import sys
input = lambda : sys.stdin.readline().strip('\r\n')
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	mat = [list(map(int, input().split())) for _ in range(n)]
	rows = 0
	cols = 0
	for i in range(n):
		if 1 not in mat[i]:
			rows += 1
	for j in range(m):
		for i in range(n):
			if mat[i][j] == 1:
				break
		else:
			cols += 1
	if min(rows, cols) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
ans = [0] * t
for i in range(t):
	(n, m) = map(int, input().split())
	a = []
	Vr = [0] * n
	Vc = [0] * m
	for j in range(n):
		a.append(list(map(int, input().split())))
		if sum(a[j]) > 0:
			Vr[j] = 1
	for j in range(m):
		for k in range(n):
			if a[k][j] == 1:
				Vc[j] = 1
				break
	dif = min(Vr.count(0), Vc.count(0))
	if dif % 2 == 0:
		ans[i] = 'Vivek'
	else:
		ans[i] = 'Ashish'
for i in range(t):
	print(ans[i])


t = int(input())
for i in range(t):
	arr = []
	c = 0
	d = 0
	(n, m) = map(int, input().split())
	for j in range(n):
		arr.append(list(map(int, input().split())))
	for j in arr:
		if j.count(1) == 0:
			c += 1
	brr = list(zip(*arr))
	for j in brr:
		if j.count(1) == 0:
			d += 1
	if min(c, d) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def main():
	t = int(input())
	for i1 in range(0, t):
		line = input().split()
		m = int(line[0])
		n = int(line[1])
		table = []
		for i in range(m):
			line = input().split()
			table.append([int(j) for j in line])
		(cnt1, cnt2) = (0, 0)
		for i in range(m):
			flag = True
			for j in range(n):
				if table[i][j] == 1:
					flag = False
					break
			if flag:
				cnt1 = cnt1 + 1
		for i in range(n):
			flag = True
			for j in range(m):
				if table[j][i] == 1:
					flag = False
					break
			if flag:
				cnt2 = cnt2 + 1
		cnt = min(cnt1, cnt2)
		if cnt % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		arr.append(list(map(int, input().split())))
	row = 0
	col = 0
	for i in range(n):
		f = True
		for j in range(m):
			if arr[i][j] == 1:
				f = False
				break
		if f:
			row += 1
	for i in range(m):
		f = True
		for j in range(n):
			if arr[j][i] == 1:
				f = False
				break
		if f:
			col += 1
	ans = min(row, col)
	if ans % 2:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	l = []
	s = 0
	(t1, t2) = (0, 0)
	for i in range(n):
		l1 = list(map(int, input().split()))
		l.append(l1)
	for i in range(n):
		f = 1
		for j in range(m):
			if l[i][j] == 1:
				f = 0
		if f:
			t1 += 1
	for i in range(m):
		f = 1
		for j in range(n):
			if l[j][i] == 1:
				f = 0
		if f:
			t2 += 1
	if min(t1, t2) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import os
import sys
from io import BytesIO, IOBase

def solution(grid, n, m):
	row = set()
	col = set()
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 1:
				row.add(i)
				col.add(j)
	avail = 0
	winner = False
	for i in range(n):
		for j in range(m):
			if i in row or j in col:
				continue
			else:
				avail += 1
				row.add(i)
				col.add(j)
				winner = not winner
				break
	write('Ashish' if winner else 'Vivek')

def main():
	for _ in range(r_int()):
		(n, m) = r_array()
		grid = []
		for _ in range(n):
			grid.append(r_array())
		solution(grid, n, m)
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))

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

def write(*args, end='\n'):
	for x in args[:-1]:
		sys.stdout.write(str(x) + ' ')
	sys.stdout.write(str(args[-1]))
	sys.stdout.write(end)

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

def r_int():
	return int(input())
main()


def F():
	(n, m) = map(int, input().split())
	arr = []
	brr = [0] * m
	for i in range(n):
		arr.append(list(map(int, input().split())))
	for i in range(n):
		v = True
		for j in range(m):
			if arr[i][j] and v:
				v = False
				n -= 1
			if arr[i][j] == 1:
				brr[j] = 1
	m -= sum(brr)
	print('Vivek' if min(n, m) % 2 == 0 else 'Ashish')
for i in range(int(input())):
	F()


t = int(input())
for k in range(t):
	s = input().split(' ')
	n = int(s[0])
	m = int(s[1])
	a = []
	for i in range(n):
		s = input().split(' ')
		b = []
		for c in s:
			b.append(int(c))
		a.append(b)
	savecellbyhorizontal = m
	savecellbyvertical = n
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				savecellbyvertical -= 1
				break
	for j in range(m):
		for i in range(n):
			if a[i][j] == 1:
				savecellbyhorizontal -= 1
				break
	if min(savecellbyhorizontal, savecellbyvertical) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


cases = int(input())
for case in range(cases):
	(rows, cols) = map(int, input().split())
	matrix = [[]] * rows
	for i in range(rows):
		matrix[i] = list(map(int, input().split()))
	rows_set = set([i for i in range(rows)])
	cols_set = set([i for i in range(cols)])
	for index_y in range(rows):
		for index_x in range(cols):
			if matrix[index_y][index_x] == 1:
				if index_y in rows_set:
					rows_set.remove(index_y)
				if index_x in cols_set:
					cols_set.remove(index_x)
	steps = min(len(rows_set), len(cols_set))
	if steps % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for testcase in range(t):
	(n, m) = list(map(int, input().split(' ')))
	row_state = [0] * n
	column_state = [0] * m
	for i in range(n):
		row = list(map(int, input().split(' ')))
		row_length = len(row)
		for j in range(row_length):
			if row[j] == 1:
				if column_state[j] == 0:
					column_state[j] = 1
				if row_state[i] == 0:
					row_state[i] = 1
	occupied_row = sum(row_state)
	occupied_column = sum(column_state)
	min_non_occupied = min(n - occupied_row, m - occupied_column)
	if min_non_occupied % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	List = []
	for __ in range(n):
		temp = list(map(int, input().split()))
		List.append(temp)
	c_r = set()
	c_c = set()
	for x in range(n):
		for y in range(m):
			if List[x][y] != 0:
				c_r.add(x)
				c_c.add(y)
	if min(n - len(c_r), m - len(c_c)) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import *

def game(a, n, m):
	num_row_play = 0
	num_col_play = 0
	for i in range(n):
		found = True
		for j in range(m):
			if a[i][j] != 0:
				found = False
				break
		if found:
			num_row_play = num_row_play + 1
	for i in range(m):
		found = True
		for j in range(n):
			if a[j][i] != 0:
				found = False
				break
		if found:
			num_col_play = num_col_play + 1
	num_turn = min(num_row_play, num_col_play)
	if num_turn % 2 == 0:
		return 'Vivek'
	else:
		return 'Ashish'
t = int(input())
for i in range(t):
	b = list(map(int, input().strip().split()))[:2]
	n = b[0]
	m = b[1]
	a = [[0 for x in range(m)] for y in range(n)]
	for j in range(n):
		a[j] = list(map(int, input().strip().split()))[:m]
	print(game(a, n, m))


test = int(input())
while test > 0:
	size = input()
	size = size.split(' ')
	(m, n) = (int(size[0]), int(size[1]))
	t = [0] * n
	count = 0
	while m > 0:
		temp = input()
		temp = temp.split(' ')
		k = 0
		for i in range(n):
			if temp[i] == '1':
				t[i] = 1
			else:
				k += 1
		if k == n:
			count += 1
		m -= 1
	zeroes = 0
	for c in t:
		if c == 0:
			zeroes += 1
	final = min(count, zeroes)
	if final == 0 or final % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	test -= 1


for cas in range(int(input())):
	(n, m) = map(int, input().split())
	mtrx = []
	for i in range(n):
		a = list(map(int, input().split()))
		mtrx.append(a)
	row = []
	s = 0
	for i in range(n):
		for j in range(m):
			s += mtrx[i][j]
		row.append(s)
		s = 0
	s = 0
	col = []
	for i in range(m):
		for j in range(n):
			s += mtrx[j][i]
		col.append(s)
		s = 0
	cnt = 0
	for i in range(n):
		if row[i] == 0:
			for j in range(m):
				if col[j] == 0:
					col[j] = 1
					cnt += 1
					break
	if cnt & 1:
		print('Ashish')
	else:
		print('Vivek')


import sys, io, os, time
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, m) = map(int, input().split())
	arr = [list(map(int, input().split())) for i in range(n)]
	rem = 0
	valid = [[True] * m for i in range(n)]
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				for k in range(n):
					valid[k][j] = False
				for k in range(m):
					valid[i][k] = False
	for i in range(n):
		for j in range(m):
			if valid[i][j]:
				rem += 1
				for k in range(n):
					valid[k][j] = False
				for k in range(m):
					valid[i][k] = False
	if rem % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


n = int(input())
for i in range(n):
	ans1 = 0
	ans2 = 0
	r = [int(x) for x in input().split()]
	l = r[0]
	w = r[1]
	t = [0 for j in range(w)]
	for j in range(l):
		s = [int(x) for x in input().split()]
		o = sum(s)
		if o == 0:
			ans1 += 1
		t = [s[k] + t[k] for k in range(w)]
	for j in range(w):
		if t[j] == 0:
			ans2 += 1
	ans = min(ans1, ans2)
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	matrix = []
	row_c = []
	col_c = [0 for _ in range(m)]
	ans = 0
	for i in range(n):
		li = list(map(int, input().split()))
		matrix.append(li)
		for j in range(m):
			col_c[j] += li[j]
		if li.count(1) == 0:
			row_c.append(i)
	ans = min(col_c.count(0), len(row_c))
	if ans % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from math import gcd, ceil, log
n = int(input())
for _ in range(n):
	(a, b) = map(int, input().split())
	l = []
	for i in range(a):
		l.append(list(map(int, input().split(' '))))
	(p, q) = (0, 0)
	for i in l:
		if len(set(i)) == 1 and i[0] == 0:
			p += 1
	for i in range(b):
		h = 0
		for j in range(a):
			if l[j][i] == 0:
				h += 1
			else:
				break
		if h == a:
			q += 1
	x = min(p, q)
	if x % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


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

def main():
	t = int(input())
	for i in range(t):
		(n, m) = list(map(int, input().split()))
		arr = []
		for j in range(n):
			arr.append([0 for k in range(m)])
		rset = set()
		cset = set()
		for j in range(n):
			l = list(map(int, input().split()))
			for k in range(m):
				arr[j][k] = l[k]
				if arr[j][k] == 1:
					rset.add(j)
					cset.add(k)
		mn = min(n - len(rset), m - len(cset))
		if mn % 2 == 0:
			print('Vivek')
		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()


for t in range(int(input())):
	(n, m) = map(int, input().split())
	(r, c) = ([], [])
	arr = []
	for i in range(n):
		l = list(map(int, input().split()))
		if 1 in l:
			r.append(i)
			for j in range(m):
				if l[j] == 1:
					c.append(j)
	cnt = 0
	for i in range(n):
		if i not in r:
			for j in range(m):
				if j not in c:
					r.append(i)
					c.append(j)
					cnt += 1
					break
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def main():
	t = int(input())
	for i in range(t):
		(n, m) = map(int, input().split())
		matrix = [list(map(int, input().split())) for i in range(n)]
		lines = [0 for i in range(n)]
		columns = [0 for i in range(m)]
		for i in range(n):
			for j in range(m):
				if matrix[i][j]:
					lines[i] = 1
					columns[j] = 1
		count_line = 0
		count_columns = 0
		for i in lines:
			if i == 0:
				count_line += 1
		for i in columns:
			if i == 0:
				count_columns += 1
		c = min(count_line, count_columns)
		if c % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


import sys
input = sys.stdin.readline
t = int(input())
while t > 0:
	t -= 1
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		p = [int(x) for x in input().split()]
		a.append(p)
	r = set()
	c = set()
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				r.add(i)
				c.add(j)
	n -= len(r)
	m -= len(c)
	print('Ashish' if min(n, m) % 2 == 1 else 'Vivek')


for t in range(int(input())):
	(n, m) = [int(j) for j in input().split()]
	l = []
	for i in range(n):
		l.append([int(j) for j in input().split()])
	ans = 0
	for i in range(n):
		if l[i].count(1) == 0:
			ans += 1
	ans2 = 0
	for i in range(m):
		flag = True
		for j in range(n):
			if l[j][i] == 1:
				flag = False
				break
		if flag:
			ans2 += 1
	ans = min(ans2, ans)
	if ans % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


from sys import stdin
input = stdin.readline

def main():
	test = int(input())
	for _ in range(test):
		(n, m) = [int(i) for i in input().split(' ')]
		matrix = []
		row = set()
		col = set()
		for i in range(n):
			matrix.append([int(i) for i in input().split(' ')])
		for i in range(n):
			if 1 not in matrix[i]:
				row.add(i + 1)
		for j in range(m):
			l = []
			for i in range(n):
				l.append(matrix[i][j])
			if 1 not in l:
				col.add(j + 1)
		val = min(len(row), len(col))
		if val % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
main()


import sys
input = sys.stdin.buffer.readline
a = int(input())
for x in range(a):
	(b, c) = map(int, input().split())
	j = 0
	k = 0
	f = []
	for y in range(b):
		f.append(list(map(int, input().split())))
	h = 'Vivek'
	while j < b and k < c:
		if f[j][k] == 1:
			if j < b:
				j += 1
			if k < c:
				k += 1
		elif 1 in f[j]:
			if j < b:
				j += 1
		elif 1 not in f[j]:
			r = 0
			for z in range(b):
				if f[z][k] == 0:
					r += 1
				else:
					if k < c:
						k += 1
					break
			if r == b:
				if j < b:
					j += 1
				if k < c:
					k += 1
				if h == 'Vivek':
					h = 'Ashish'
				else:
					h = 'Vivek'
	print(h)


import sys
input = sys.stdin.buffer.readline
t = int(input())
ans = []
for _ in range(t):
	(h, w) = map(int, input().split())
	gr = [list(map(int, input().split())) for _ in range(h)]
	c1 = sum((all((x == 0 for x in gr[i])) for i in range(h)))
	ggr = list(zip(*gr))
	c2 = sum((all((x == 0 for x in ggr[i])) for i in range(w)))
	if min(c1, c2) % 2:
		ans.append('Ashish')
	else:
		ans.append('Vivek')
print('\n'.join(ans))


from sys import stdin
input = stdin.readline

def main():
	t = int(input())
	for __ in range(t):
		(n, m) = map(int, input().split())
		row_set = set()
		col_set = set()
		for i in range(n):
			row = list(map(int, input().split()))
			for j in range(m):
				if row[j] == 1:
					row_set.add(i)
					col_set.add(j)
		rows = n - len(row_set)
		cols = m - len(col_set)
		if min(rows, cols) % 2 == 1:
			print('Ashish')
		else:
			print('Vivek')
main()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	x = []
	y = []
	count = 0
	for i in range(n):
		l = list(map(int, input().split()))
		for j in range(m):
			if l[j] == 1:
				x.append(i)
				y.append(j)
	x = set(x)
	y = set(y)
	while len(x) < n and len(y) < m:
		count += 1
		n -= 1
		m -= 1
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	ans = []
	col = []
	row = []
	(n, m) = map(int, input().strip().split())
	for i in range(n):
		arr = list(map(int, input().split()))
		for j in range(len(arr)):
			if arr[j] == 1:
				col.append(j)
				row.append(i)
		ans.append(arr)
	new_m = []
	uc = 0
	for i in range(n):
		b = []
		for j in range(m):
			if i in row or j in col:
				continue
			else:
				uc += 1
				col.append(j)
				row.append(i)
	if uc % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
while t > 0:
	t -= 1
	c = 0
	(n, m) = map(int, input().split())
	l = []
	for i in range(n):
		p = list(map(int, input().split()))
		if 1 not in p:
			c += 1
		l.append(p)
	flag = 0
	if c == 0:
		print('Vivek')
	else:
		for i in range(m):
			k = 0
			for j in range(n):
				if l[j][i] == 1:
					k = 1
					break
			if k == 0:
				flag += 1
		if flag == c:
			if c % 2 == 0:
				print('Vivek')
			else:
				print('Ashish')
		else:
			a = min(flag, c)
			if a % 2 == 0:
				print('Vivek')
			else:
				print('Ashish')


t = int(input())
for i in range(t):
	(r, c) = map(int, input().split())
	tr = r
	tc = c
	data = []
	for j in range(r):
		temp = input().split()
		if '1' in temp:
			tr -= 1
		data.append(temp)
	for j in range(c):
		for k in range(r):
			if data[k][j] == '1':
				tc -= 1
				break
	t = min(tr, tc)
	if t % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for t in range(int(input())):
	(m, n) = map(int, input().split())
	arr = []
	row = []
	column = []
	for i in range(m):
		arr.append(list(map(int, input().split())))
		for j in range(n):
			if arr[i][j] == 1:
				row.append(i)
				column.append(j)
	row = list(set(row))
	column = list(set(column))
	unclaim_row = m - len(row)
	unclaim_column = n - len(column)
	if min(unclaim_column, unclaim_row) % 2 != 0:
		print('Ashish')
	else:
		print('Vivek')


from collections import defaultdict as dft
import sys
import math

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

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

def debug(name, val):
	print(name, ':', val)

def solve():
	(n, m) = mp()
	dct = {0: 'Ashish', 1: 'Vivek'}
	grid = []
	r = dft(int)
	c = dft(int)
	for i in range(n):
		ls = ml()
		grid.append(ls)
	for i in range(n):
		for j in range(m):
			if grid[i][j] == 1:
				r[i] = 1
				c[j] = 1
	turn = 0
	for i in range(n):
		if i in r:
			continue
		r[i] = 1
		for j in range(m):
			if j in c:
				continue
			c[j] = 1
			r[i] = 1
			turn = 1 - turn
			break
	print(dct[1 - turn])
t = int(input())
for _ in range(t):
	solve()


import sys

def read():
	return list(map(int, sys.stdin.readline().split()))
for t in range(int(input())):
	(n, m) = read()
	arr = []
	row = set()
	col = set()
	for i in range(n):
		p = read()
		if 1 in p:
			row.add(i)
			for j in range(m):
				if p[j] == 1:
					col.add(j)
	print('Ashish' if min(min(n, m - len(col)), min(m, n - len(row))) & 1 else 'Vivek')


I = input
for _ in range(int(I())):
	(n, m) = map(int, I().split())
	(sn, sm) = (set(), set())
	for i in range(n):
		for (j, k) in zip(range(m), I().split()):
			if k == '1':
				sn.add(i)
				sm.add(j)
	print(('Vivek', 'Ashish')[min(n - len(sn), m - len(sm)) % 2])


import sys
ip = lambda : sys.stdin.readline().rstrip()
for _ in range(int(ip())):
	(n, m) = map(int, ip().split())
	a = [list(map(int, ip().split())) for _ in range(n)]
	ct = 0
	usedi = set()
	usedj = set()
	for i in range(n):
		for j in range(m):
			if a[i][j] == 1:
				usedi.add(i)
				usedj.add(j)
	(b1, b2) = (set(), set())
	for i in range(n):
		if i in b1:
			continue
		for j in range(m):
			if j in b2:
				continue
			if a[i][j] == 0 and i not in usedi and (j not in usedj) and (i not in b1) and (j not in b2):
				b1.add(i)
				b2.add(j)
				ct += 1
	if ct % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


T = int(input())
FIRST_PLAYER = 'Ashish'
SECOND_PLAYER = 'Vivek'

def ans(A):
	N = len(A)
	M = len(A[0])
	num_rows = 0
	for i in range(N):
		if 1 not in A[i]:
			num_rows += 1
	A = list(zip(*A))
	num_cols = 0
	for i in range(M):
		if 1 not in A[i]:
			num_cols += 1
	parity = min(num_rows, num_cols)
	if parity % 2 == 0:
		return SECOND_PLAYER
	return FIRST_PLAYER
	return (num_rows, num_cols)
for t in range(T):
	(n, m) = input().split(' ')
	n = int(n)
	A = []
	for _ in range(n):
		row = input().split(' ')
		row = [int(x) for x in row]
		A += [row]
	print(ans(A))


def read_ints():
	temp = input().split()
	ints = [int(t) for t in temp]
	return ints
t = int(input())
for _ in range(t):
	(n, m) = read_ints()
	cols = [0] * m
	for _ in range(n):
		occupied = 0
		row = read_ints()
		for i in range(m):
			if row[i]:
				occupied = 1
				cols[i] = 1
		n -= occupied
	m -= sum(cols)
	if min(m, n) % 2:
		print('Ashish')
	else:
		print('Vivek')


test = int(input())
for x in range(test):
	(n, m) = map(int, input().split())
	arr = []
	for c in range(n):
		nowlist = list(map(int, input().split()))
		arr.append(nowlist)
	count = 0
	for row in range(n):
		for col in range(m):
			nowvalue = arr[row][col]
			if nowvalue == 0:
				ok = True
				for nowcol in range(m):
					if arr[row][nowcol] == 1:
						ok = False
						break
				if ok == True:
					for nowrow in range(n):
						if arr[nowrow][col] == 1:
							ok = False
							break
				if ok == True:
					count = count + 1
					arr[row][col] = 1.0
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	(row, col) = (0, 0)
	for i in range(n):
		l.append(list(map(int, input().split())))
		if 1 in l[-1]:
			row += 1
	for i in range(m):
		for j in l:
			if j[i] == 1:
				col += 1
				break
	prod = min(n - row, m - col)
	if prod % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for i in range(int(input())):
	(n, m) = map(int, input().split())
	l = []
	for j in range(n):
		p = list(map(int, input().split()))
		l.append(p)
	turn = 0
	while True:
		flag = 0
		for j in range(n):
			for k in range(m):
				if l[j][k] == 0:
					t1 = 1 in l[j]
					p = [row[k] for row in l]
					t2 = 1 in p
					if t1 or t2:
						pass
					else:
						l[j][k] = 1
						flag = 1
						if turn == 0:
							turn = 1
						elif turn == 1:
							turn = 2
						else:
							turn = 1
		if flag == 0:
			break
	if turn == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	mat = []
	claimed_row = set()
	claimed_col = set()
	for j in range(n):
		a = list(map(int, input().strip().split()))[:m]
		mat.append(a)
		for k in range(m):
			if mat[j][k] == 1:
				claimed_row.add(j)
				claimed_col.add(k)
	count = min(n - len(claimed_row), m - len(claimed_col))
	if count % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for i in range(int(input())):
	(row, col) = map(int, input().split())
	(r_set, c_set, get) = (set(), set(), 0)
	for j in range(row):
		arr = list(map(int, input().split()))
		for k in range(col):
			if arr[k] == 1:
				r_set.add(j)
				c_set.add(k)
	new = min(row - len(r_set), col - len(c_set))
	if new % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(row, col) = map(int, input().split())
	c = 0
	setr = set()
	setc = set()
	a = []
	for i in range(row):
		l = list(map(int, input().split()))
		a.append(l)
	for i in range(row):
		for j in range(col):
			if a[i][j] == 1:
				setr.add(i)
				setc.add(j)
	c = min(row - len(setr), col - len(setc))
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


N = int(input())
for _ in range(N):
	(n, m) = map(int, input().split(' '))
	r_z = set()
	c_z = set()
	for i in range(n):
		chase = input().split(' ')
		for j in range(m):
			if chase[j] == '1':
				r_z.add(i)
				c_z.add(j)
	res = min(n - len(r_z), m - len(c_z))
	if res % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


def get_col(mat, i):
	return [row[i] for row in mat]

def check_line(line):
	return not 1 in line

def f(mat, n, m):
	lines = 0
	cols = 0
	for line in mat:
		if check_line(line):
			lines += 1
	for line in [[row[e] for row in mat] for e in range(m)]:
		if check_line(line):
			cols += 1
	turn = min(lines, cols)
	print(turn % 2 == 0 and 'Vivek' or 'Ashish')
t = int(input())
for i in range(t):
	(n, m) = input().split(' ')
	matrix = []
	for j in range(int(n)):
		matrix.append(input().split(' '))
	matrix = [[int(l) for l in k] for k in matrix]
	f(matrix, int(n), int(m))


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	row = []
	for i in range(n):
		row.append(list(map(int, input().split())))
	col = []
	for i in range(m):
		aa = []
		for j in range(n):
			aa.append(row[j][i])
		col.append(aa)
	c = 0
	for i in range(n):
		for j in range(m):
			if row[i][j] == 1:
				break
			elif 1 not in col[j] and 1 not in row[i]:
				row[i][j] = 1
				col[j][i] = 1
				c += 1
				break
	if c % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


t = int(input())
while t > 0:
	(n, m) = map(int, input().split())
	arr = []
	for i in range(n):
		a = list(map(int, input().split()))[:m]
		arr.append(a)
	r = [0 for i in range(n)]
	c = [0 for i in range(m)]
	for i in range(n):
		for j in range(m):
			if arr[i][j] == 1:
				r[i] += 1
				c[j] += 1
	d = r.count(0)
	e = c.count(0)
	if min(d, e) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
	t = t - 1


class Solution:

	def __init__(self):
		for t in range(int(input())):
			(n, m) = list(map(int, input().split()))
			a = [list(map(int, input().split())) for i in range(n)]
			self.solve(n, m, a)

	def solve(self, n, m, a):
		row = sum([1 for i in range(n) if max(a[i]) == 0])
		col = sum([1 for j in range(m) if max([a[i][j] for i in range(n)]) == 0])
		move = min(row, col)
		print('Ashish' if move % 2 == 1 else 'Vivek')
Solution()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = []
	for i in range(n):
		a.append(input().split())
	rows = 0
	cols = 0
	count = 0
	for i in range(n):
		if '1' not in a[i]:
			rows += 1
	for i in range(m):
		for j in range(n):
			if a[j][i] == '1':
				count = 0
				break
			else:
				count += 1
		if count == n:
			cols += 1
			count = 0
	print('Vivek' if min(cols, rows) % 2 == 0 else 'Ashish')


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	dp = []
	for i in range(n):
		dp.append(list(map(int, input().split())))
	x = [0] * n
	y = [0] * m
	for i in range(n):
		for j in range(m):
			if dp[i][j] == 1:
				x[i] = 1
				y[j] = 1
	c = min(x.count(0), y.count(0))
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin, stdout
import math
input = stdin.readline

def print(x):
	stdout.write(str(x) + '\n')

def solve():
	(n, m) = map(int, input().split())
	mat = []
	for i in range(n):
		mat.append(list(map(int, input().split())))
	r = [0] * n
	c = [0] * m
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 1:
				r[i] = 1
				c[j] = 1
	if r.count(1) == n or c.count(1) == m:
		print('Vivek')
	else:
		pp = min(r.count(0), c.count(0))
		if pp % 2 == 0:
			print('Vivek')
		else:
			print('Ashish')
t = 1
t = int(input())
for _ in range(t):
	solve()


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = set()
	p = set()
	c1 = c2 = 0
	for i in range(n):
		l = list(map(int, input().split()))
		for j in range(m):
			if l[j] == 1:
				k.add(j)
				p.add(i)
	c = min(n - len(p), m - len(k))
	if c % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


import os
import sys
from io import BytesIO, IOBase
from math import ceil, floor
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())
from math import ceil

def main():
	for _ in range(inp()):
		(n, m) = invr()
		a = []
		row = [0] * n
		col = [0] * m
		for i in range(n):
			temp = inlt()
			a.append(temp)
			for j in range(m):
				if a[i][j] == 1:
					row[i] += 1
					col[j] += 1
		c = 0
		for i in range(n):
			for j in range(m):
				if a[i][j] == 0 and row[i] == 0 and (col[j] == 0):
					c += 1
					row[i] += 1
					col[j] += 1
					a[i][j] = 1
		if c & 1 == 0:
			print('Vivek')
		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()


for i in range(int(input())):
	line = input().split(' ')
	(n, m) = [int(k) for k in line]
	occupied = []
	availableRows = n
	for j in range(n):
		rowContents = input().split(' ')
		occupied.append(rowContents)
		if '1' in rowContents:
			availableRows -= 1
	availableCols = m
	for col in zip(*occupied):
		if '1' in col:
			availableCols -= 1
	score = min(availableRows, availableCols)
	if score % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	l = []
	lt = []
	cs = []
	rs = []
	for j in range(n):
		w = list(map(int, input().split()))
		rs.append(sum(w))
		l.append(w)
	for j in range(m):
		w1 = []
		for k in range(n):
			w1.append(l[k][j])
		cs.append(sum(w1))
		lt.append(w1)
	cnt = 0
	while 1:
		bnd = 0
		bnd1 = 0
		for j in range(n):
			if rs[j] == 0:
				rs[j] += 1
				break
			else:
				bnd += 1
		if bnd == n:
			if cnt % 2 == 0:
				print('Vivek')
			else:
				print('Ashish')
			break
		for j in range(m):
			if cs[j] == 0:
				cs[j] += 1
				cnt += 1
				break
			else:
				bnd1 += 1
		if bnd1 == m:
			if cnt % 2 == 0:
				print('Vivek')
			else:
				print('Ashish')
			break


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, m) = iia()
	a = []
	for i in range(n):
		a.append(iia())
	r = 0
	for i in range(n):
		c = 0
		for j in range(m):
			if a[i][j] == 0:
				c += 1
			else:
				break
		if c == m:
			r += 1
	cc = 0
	for i in range(m):
		rr = 0
		for j in range(n):
			if a[j][i] == 0:
				rr += 1
			else:
				break
		if rr == n:
			cc += 1
	ans = ['Vivek', 'Ashish']
	print(ans[min(r, cc) % 2])


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	temp = list(list())
	for i in range(n):
		temp.append(list(map(int, input().split())))
	row = [False for i in range(n)]
	col = [False for i in range(m)]
	for i in range(n):
		for j in range(m):
			if temp[i][j] == 1:
				col[j] = True
				row[i] = True
	turn = 'Ashish'
	for i in range(n):
		for j in range(m):
			if temp[i][j] == 0:
				if col[j] == False and row[i] == False:
					col[j] = True
					row[i] = True
					if turn == 'Ashish':
						turn = 'Vivek'
					else:
						turn = 'Ashish'
	if turn == 'Ashish':
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
for _ in range(int(stdin.readline())):
	(n, m) = map(int, input().split())
	row = [0] * n
	col = [0] * m
	for i in range(n):
		x = input().split()
		for r in range(m):
			if x[r] == '1':
				col[r] = 1
		if x.count('1') > 0:
			row[i] = 1
	hh = min(row.count(0), col.count(0))
	if hh % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


from sys import stdin
tt = int(stdin.readline())
for loop in range(tt):
	(n, m) = map(int, stdin.readline().split())
	lis = []
	for i in range(n):
		tmp = list(map(int, stdin.readline().split()))
		lis.append(tmp)
	l = n
	c = m
	for i in range(n):
		for j in range(m):
			if lis[i][j] == 1:
				l -= 1
				break
	for j in range(m):
		for i in range(n):
			if lis[i][j] == 1:
				c -= 1
				break
	if min(l, c) % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


def ca1(n, m, l):
	cr = 0
	for i in range(n):
		f = 0
		for j in range(m):
			if l[i][j] == 1:
				f = 1
				break
		if f == 0:
			cr += 1
	return cr

def ca2(n, m, l):
	cl = 0
	for i in range(m):
		f = 0
		for j in range(n):
			if l[j][i] == 1:
				f = 1
				break
		if f == 0:
			cl += 1
	return cl
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = [list(map(int, input().split())) for i in range(n)]
	c1 = ca1(n, m, l)
	c2 = ca2(n, m, l)
	m = min(c1, c2)
	if m % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


n = int(input())
for l in range(n):
	size = [int(x) for x in input().split()]
	mat = []
	rows = size[0]
	cols = size[1]
	for i in range(size[0]):
		mat.append([int(x) for x in input().split()])
	r = sum([max(x) for x in mat])
	for i in range(size[1]):
		for j in range(size[0]):
			if mat[j][i] > 0:
				cols -= 1
				break
	r = rows - r
	val = min(r, cols)
	if val % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	c = [False] * m
	r = [False] * n
	for j in range(n):
		s = input().split()
		for i in range(m):
			if s[i] == '1':
				c[i] = True
				r[j] = True
	move = min(r.count(False), c.count(False))
	print(['Vivek', 'Ashish'][move % 2])


inp = input
for _ in range(int(inp())):
	(n, m) = map(int, inp().strip().split(' '))
	rows = []
	ones = [1 for i in range(m)]
	rcp = []
	ccp = []
	for i in range(n):
		arr = list(map(int, inp().strip().split(' ')))
		if 1 not in arr:
			rcp.append(i)
		rows.append(arr)
	for i in range(m):
		flag = True
		for j in range(n):
			if rows[j][i] == 1:
				flag = False
				break
		if flag:
			ccp.append(i)
	mxs = min(len(rcp), len(ccp))
	if mxs % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')


def solve():
	(n, m) = map(int, input().split())
	matrix = []
	for _ in range(n):
		matrix.append(list(map(int, input().split())))
	(r, c) = (0, 0)
	for i in range(n):
		if matrix[i].count(1) == 0:
			r += 1
	for i in range(m):
		if [row[i] for row in matrix].count(1) == 0:
			c += 1
	cnt = min(r, c)
	if cnt % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')
t = int(input())
for _ in range(t):
	solve()


import sys
import collections as cc
import bisect as bi
I = lambda : list(map(int, input().split()))
for tc in range(int(input())):
	(n, m) = I()
	r = [0] * n
	c = [0] * m
	for i in range(n):
		t = I()
		for j in range(m):
			if t[j]:
				r[i] = 1
				c[j] = 1
	ans = 0
	for i in range(n):
		for j in range(m):
			if r[i] == 0 and c[j] == 0:
				r[i] = 1
				c[j] = 1
				ans += 1
	if ans % 2:
		print('Ashish')
	else:
		print('Vivek')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = 0
	b = 0
	B = []
	for i in range(n):
		A = list(map(int, input().split()))
		B.append(A)
	v = 0
	for i in range(n):
		for j in range(m):
			if B[i][j] == 0:
				c = 0
				for l in range(0, n):
					if B[l][j] == 1:
						c = 1
						break
				if 1 in B[i]:
					c = 1
				if c == 0:
					B[i][j] = 1
					v += 1
	if v % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


t = int(input())
for p in range(t):
	s = input().split(' ')
	n = int(s[0])
	m = int(s[1])
	used_rows = [0] * n
	used_columns = [0] * m
	for i in range(n):
		s = input().split(' ')
		for j in range(m):
			if int(s[j]) == 1:
				used_rows[i] = 1
				used_columns[j] = 1
	unused_columns = len(used_columns) - sum(used_columns)
	unused_rows = len(used_rows) - sum(used_rows)
	unused = min(unused_rows, unused_columns)
	if unused % 2 == 0:
		print('Vivek')
	else:
		print('Ashish')


ans = ['Vivek', 'Ashish']
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = set(range(n))
	c = set(range(m))
	for i in range(n):
		a = input().split()
		for j in range(m):
			if a[j] == '1':
				l.discard(i)
				c.discard(j)
	print(ans[min(len(l), len(c)) % 2])


player1 = 'Ashish'
player2 = 'Vivek'

def swapTurn(current_turn):
	if current_turn == player1:
		next_turn = player2
	else:
		next_turn = player1
	return next_turn

def winner(current_turn):
	if current_turn == player1:
		return player2
	else:
		return player1

def emptyRows(current_matrix):
	empty_rows = list()
	for (index, row) in enumerate(current_matrix):
		if row.count(1) == 0:
			empty_rows.append(index)
	return empty_rows

def emptyCols(current_matrix):
	current_matrix = list(map(list, zip(*current_matrix)))
	empty_cols = list()
	for (index, col) in enumerate(current_matrix):
		if col.count(1) == 0:
			empty_cols.append(index)
	return empty_cols

def placeMove(current_matrix):
	empty_rows = emptyRows(current_matrix)
	empty_cols = emptyCols(current_matrix)
	if len(empty_rows) == 0 or len(empty_cols) == 0:
		return (None, None)
	else:
		return (empty_rows[0], empty_cols[0])
for _ in range(int(input())):
	(rows, cols) = tuple(map(int, input().split()))
	matrix = list()
	for i in range(rows):
		matrix.append(list(map(int, input().split())))
	turn = player1
	while True:
		(move_row, move_col) = placeMove(matrix)
		if move_row is None and move_col is None:
			break
		else:
			matrix[move_row][move_col] = 1
			turn = swapTurn(turn)
	print(winner(turn))


from sys import stdin, stdout

def isSafe(mat, i, j, row, col):
	if i in row or j in col:
		return False
	for ii in range(len(mat)):
		if mat[ii][j] == 1:
			return False
	for ii in range(len(mat[0])):
		if mat[i][ii] == 1:
			return False
	return True
t = int(stdin.readline())
for _ in range(t):
	(n, m) = map(int, stdin.readline().strip().split())
	mat = []
	row = dict()
	col = dict()
	tot = 0
	for i in range(n):
		mat.append(list(map(int, stdin.readline().strip().split())))
	for i in range(n):
		for j in range(m):
			if mat[i][j] == 0 and isSafe(mat, i, j, row, col):
				row[i] = 1
				col[j] = 1
				tot += 1
	if tot % 2 == 1:
		print('Ashish')
	else:
		print('Vivek')