description: Moamen and Ezzat are playing a game. They create an array a of n non-negative integers where every element is less than 2^k.
  
  Moamen wins if a_1  \&  a_2  \&  a_3  \&  …  \&  a_n ≥ a_1 ⊕ a_2 ⊕ a_3 ⊕ … ⊕ a_n.
  
  Here \& denotes the [bitwise AND operation](https://en.wikipedia.org/wiki/Bitwise_operation#AND), and ⊕ denotes the [bitwise XOR operation](https://en.wikipedia.org/wiki/Bitwise_operation#XOR).
  
  Please calculate the number of winning for Moamen arrays a.
  
  As the result may be very large, print the value modulo 1 000 000 007 (10^9 + 7).
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 5)— the number of test cases. 
  
  Each test case consists of one line containing two integers n and k (1 ≤ n≤ 2⋅ 10^5, 0 ≤ k ≤ 2⋅ 10^5).
  
  Output
  
  For each test case, print a single value — the number of different arrays that Moamen wins with.
  
  Print the result modulo 1 000 000 007 (10^9 + 7).
  
  Example
  
  Input
  
  
  3
  3 1
  2 1
  4 0
  
  
  Output
  
  
  5
  2
  1
  
  Note
  
  In the first example, n = 3, k = 1. As a result, all the possible arrays are [0,0,0], [0,0,1], [0,1,0], [1,0,0], [1,1,0], [0,1,1], [1,0,1], and [1,1,1].
  
  Moamen wins in only 5 of them: [0,0,0], [1,1,0], [0,1,1], [1,0,1], and [1,1,1].
solution: # import math
  # from collections import deque
  # from bisect import bisect_right
  
  def power(base, num):
      bin_num = bin(num)[2:]
      store = [base]
      for _ in range(len(bin_num)-1):
          store.append((store[-1] ** 2) % (10**9+7))
      curr = 1
      for idx, ch in enumerate(bin_num[::-1]):
          if ch == '1':
              curr = curr * store[idx] % (10**9+7)
      
      return curr
      
  
  t = int(input()) # read a line with a single integer
  for i in range(1, t + 1):
      n, k = list(map(int, input().split()))
      if k == 0:
          print(1)
      else:
          if n % 2 == 0:
              perm = power(2, n-1)-1
              perf = power(2,n)
          else:
              perm = power(2, n-1) + 1
          
          res = 1
          
          if n % 2 == 1:
              print(power(perm, k))
          else:
              curr = 1
              curr_perf = 1
              for i in range(k):
                  curr = curr * perm + curr_perf
                  curr_perf *= perf
                  curr = curr % (10**9+7)
                  curr_perf = curr_perf % (10**9+7)
                  # print(curr, curr_perf)
              print(curr)
                  
                  
          
              
          
  
          
      
      
      
          
          