human
Give me a Python program to determine the winner of the game if both of them are playing optimally given the following:
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 ≤ t ≤ 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 ≤ n, m ≤ 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} ∈ \{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.
'''in
assistant
#Here is Python program to determine the winner of the game if both of them are playing optimally.
put
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

'''
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):
    # g = math.gcd(b, m)
    # if (g != 1):
    #     # print("Inverse doesn't exist")
    #     return -1
    return pow(b, mod - 2, mod)

def div_mod(a, b):
    a = a % mod
    inv = modInverse(b)
    # if(inv == -1):
    #     print("Division not defined")
    # else:
    #     print("Result of Division is ",(inv*a) % m)
    return (inv * a) % mod

# This class represents an undirected graph using adjacency list representation
class Graph:

    def __init__(self, vertices):
        self.V = vertices + 1  # No. of vertices
        self.graph = defaultdict(set)  # default dictionary to store graph
        self.Time = 0
        self.P = 0
        self.Q = 0

    # function to add an edge to graph
    def addEdge(self, u, v):
        self.graph[u].add(v)
        self.graph[v].add(u)

    '''A recursive function that finds and prints bridges
    using DFS traversal
    u --> The vertex to be visited next
    visited[] --> keeps tract of visited vertices
    disc[] --> Stores discovery times of visited vertices
    parent[] --> Stores parent vertices in DFS tree
    count[] --> Stores count of vertices in DFS subtree rooted at the vertex'''

    def bridgeUtil(self, u):
        # Mark the current node as visited and print it
        # self.visited[u] = True
        self.count[u] += 1

        # Initialize discovery time and low value
        self.disc[u] = self.Time
        self.low[u] = self.Time
        self.Time += 1

        # Recur for all the vertices adjacent to this vertex
        for v in...