#include<bits/stdc++.h>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
using namespace std;
// using namespace __gnu_pbds;
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Give shorthand names to data types using typedef.
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair< int , int > pii;
typedef vector< int > vi;
typedef vector< vi> vvi;
typedef vector< pii> vpii;
typedef vector< vpii> vvpii;
typedef pair< ll, ll> pll;
typedef vector< ll> vll;
typedef vector< vll> vvll;
typedef vector< pll> vpll;
typedef vector< vpll> vvpll;
typedef pair< ll,pair< ll,ll>> triplet;
// #define ordered_set tree<pair<int,int>, null_type, less<pair<int,int>>, rb_tree_tag, tree_order_statistics_node_update>
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
#define fo(i,n) for(int i=0;i<n;i++)
#define fo1(i,n) for(int i=1;i<=n;i++)
#define Fo(i,n) for(int i=n-1;i>=0;i--)
#define Fo1(i,n) for(int i=n;i>=1;i--)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define rep2(i,a,b) for(int i=a;i>=b;i--)
#define pb push_back
#define eb emplace_back
#define F first
#define S second
#define all(x) (x).begin(), (x).end()
#define set_bits __builtin_popcountll
#define PI 3.1415926535897932384626
#define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL)
mt19937 rnd( ( unsigned int ) chrono:: steady_clock :: now ( ) .time_since_epoch ( ) .count ( ) ) ;
const int MOD = 1e9 + 7 ;
const int MOD1 = 998244353 ;
const int MOD3 = 1610612741 ;
/* Alternate Prime nos where probability of collision is less for hashing for MOD3:
long long:
1000000000039
2000000000003
3000000000013
4000000000039
int:
1610612741(currently used).
*/
const ll INF = 1e18 + 9 ;
const ll NINF = - 1e18 - 9 ;
#define deb(x) cerr << #x <<" "; _print(x); cerr << endl;
template < class T> void _print( T x) { cerr << x; }
template < class T, class V> void _print( pair < T, V> p) { cerr << "{" ; _print( p.F ) ; cerr << "," ; _print( p.S ) ; cerr << "}" ; }
template < class T> void _print( vector < T> v) { cerr << "[ " ; for ( T i : v) { _print( i) ; cerr << " " ; } cerr << "]" ; }
template < class T> void _print( set < T> v) { cerr << "[ " ; for ( T i : v) { _print( i) ; cerr << " " ; } cerr << "]" ; }
template < class T> void _print( multiset < T> v) { cerr << "[ " ; for ( T i : v) { _print( i) ; cerr << " " ; } cerr << "]" ; }
template < class T, class V> void _print( map < T, V> v) { cerr << "[ " ; for ( auto i : v) { _print( i) ; cerr << " " ; } cerr << "]" ; }
vi primes;
vi spf;
vector< bool > prime;
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ll gcd( ll a, ll b) { if ( b > a) { return gcd( b, a) ; } if ( b == 0 ) { return a; } return gcd( b, a % b) ; }
ll mpow( ll base, ll exp , ll mod) { base % = mod; ll result = 1 ; while ( exp > 0 ) { if ( exp & 1 ) result = ( result * base) % mod; base = ( base * base) % mod; exp >>= 1 ; } return result; }
//Use when 'a' and 'b' are less than mod,but their addition can go beyond mod.
ll mAdd( ll a, ll b , ll mod) { return ( a + b >= mod ? a + b - mod : a + b) ; }
void extendgcd( ll a, ll b, ll* v) { if ( b == 0 ) { v[ 0 ] = 1 ; v[ 1 ] = 0 ; v[ 2 ] = a; return ; } extendgcd( b, a % b, v) ; ll x = v[ 1 ] ; v[ 1 ] = v[ 0 ] - v[ 1 ] * ( a / b) ; v[ 0 ] = x; return ; } //pass an arry of size1 3
ll mminv( ll a, ll b) { ll arr[ 3 ] ; extendgcd( a, b, arr) ; return arr[ 0 ] ; } //for non prime b
ll mminvprime( ll a, ll b) { return mpow( a, b - 2 , b) ; }
bool revsort( ll a, ll b) { return a > b; }
void swap( ll & x, ll & y) { int temp = x; x = y; y = temp; }
ll combination( ll n, ll r, ll m, ll * fact, ll * ifact) { ll val1 = fact[ n] ; ll val2 = ifact[ n - r] ; ll val3 = ifact[ r] ; return ( ( ( val1 * val2) % m) * val3) % m; }
void google( int t) { cout << "Case #" << t << ": " ; }
ll mod_add( ll a, ll b, ll m) { a = a % m; b = b % m; return ( ( ( a + b) % m) + m) % m; }
ll mod_mul( ll a, ll b, ll m) { a = a % m; b = b % m; return ( ( ( a * b) % m) + m) % m; }
ll mod_sub( ll a, ll b, ll m) { a = a % m; b = b % m; return ( ( ( a - b) % m) + m) % m; }
ll mod_div( ll a, ll b, ll m) { a = a % m; b = b % m; return ( mod_mul( a, mminvprime( b, m) , m) + m) % m; } //only for prime m
ll phin( ll n) { ll number = n; if ( n % 2 == 0 ) { number / = 2 ; while ( n % 2 == 0 ) n / = 2 ; } for ( ll i = 3 ; i <= sqrt ( n) ; i + = 2 ) { if ( n % i == 0 ) { while ( n % i == 0 ) n / = i; number = ( number / i * ( i - 1 ) ) ; } } if ( n > 1 ) number = ( number / n * ( n - 1 ) ) ; return number; }
vector< long long > computeHash( string & s) { ll str_len= s.length ( ) ; ll p_pow[ str_len] ; ll p= 123 ; p_pow[ 0 ] = 1 ; for ( int i= 1 ; i< str_len; i++ ) p_pow[ i] = ( p_pow[ i- 1 ] * p) % MOD3; vector< long long > hash( str_len+ 1 ) ; hash[ 0 ] = 0 ; for ( int i= 1 ; i<= str_len; i++ ) hash[ i] = ( hash[ i- 1 ] + ( ( s[ i- 1 ] - 'a' + 1 ) * p_pow[ i- 1 ] ) % MOD3 ) % MOD3; return hash; }
vector< int > makeZarray( string s) { int n = s.length ( ) ; vector< int > z( n) ; int l= 0 ,r= 0 ; for ( int i= 1 ; i< n; i++ ) { if ( i<= r) z[ i] = min( z[ i- l] ,r- i+ 1 ) ; while ( i+ z[ i] < n && s[ z[ i] ] == s[ i+ z[ i] ] ) z[ i] ++ ; if ( i+ z[ i] - 1 > r) l= i , r= i+ z[ i] - 1 ; } return z; }
//O(nloglogn)
void sieve( int n) { prime.assign ( n+ 1 ,true ) ; prime[ 0 ] = 0 ; prime[ 1 ] = 0 ; for ( int i = 2 ; i <= n; i++ ) if ( prime[ i] == 1 ) { primes.eb ( i) ; for ( ll j = ( ll) i * i; j <= n; j + = i) { if ( prime[ j] ) prime[ j] = 0 ; } } }
//O(nloglogn) Max value of n=1e6.
void find_spf( int n) { n = max( n,1 ) ; spf.assign ( n+ 1 ,0 ) ; prime.assign ( n+ 1 ,true ) ; prime[ 0 ] = prime[ 1 ] = false ; int i; for ( i= 2 ; i<= n; i++ ) { if ( prime[ i] ) { primes.eb ( i) ; spf[ i] = i; for ( ll j= ( ll) i* i; j<= n; j+ = i) { if ( prime[ j] ) { prime[ j] = false ; spf[ j] = i; } } } } }
//O(log2n) time at max. Before running this , Run sieve(if n larger than 1e6) or find_spf() if n<=1e6,both upto sqrt(n).
vpll prime_factorize( ll n) { vpll result; if ( n < spf.size ( ) ) { while ( n! = 1 ) { ll fact = spf[ n] ; ll exp = 0 ; do { n/ = fact; exp ++ ; } while ( n% fact== 0 ) ; result.eb ( fact,exp ) ; } return result; } else { for ( auto p : primes) { if ( p* p > n) break ; if ( n % p== 0 ) { result.emplace_back ( p, 0 ) ; do { n / = p; result.back ( ) .second ++ ; } while ( n % p == 0 ) ; } } if ( n> 1 ) result.eb ( n,1 ) ; return result; } }
ll sumprimeExp( ll n) { vpll prime_factors = prime_factorize( n) ; ll ans= 0 ; for ( auto p : prime_factors) { ans+ = p.second ; } return ans; }
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ll n;
ll helperEven( ll k,ll sum) {
if ( k== 0 ) return 1 ;
ll val1 = ( sum* helperEven( k- 1 ,sum) ) % MOD;
ll val2 = mpow( 2 ,n* ( k- 1 ) ,MOD) ;
return ( val1 + val2) % MOD;
}
ll helperOdd( ll k,ll sum) {
if ( k== 0 ) return 1 ;
ll val1 = ( sum* helperEven( k- 1 ,sum) ) % MOD;
return val1;
}
int32_t main( )
{
fast_io;
int t;
cin >> t;
ll Max = 2 * 1e5 + 1 ;
ll fact[ Max] ,ifact[ Max] ;
fact[ 0 ] = 1 ; ifact[ 0 ] = 1 ;
for ( ll i= 1 ; i<= Max- 1 ; i++ ) {
fact[ i] = ( fact[ i- 1 ] * i) % MOD;
ifact[ i] = mminvprime( fact[ i] ,MOD) ;
}
while ( t-- )
{
ll k; cin >> n>> k;
ll sum = 0 ;
if ( n% 2 == 0 ) {
for ( ll i= 0 ; i<= n- 2 ; i+ = 2 ) {
sum = ( sum + combination( n,i,MOD,fact,ifact) ) % MOD;
}
cout << helperEven( k,sum) ;
}
else {
for ( ll i= 0 ; i<= n- 1 ; i+ = 2 ) {
sum = ( sum + combination( n,i,MOD,fact,ifact) ) % MOD;
}
cout << helperOdd( k,( sum+ 1 ) % MOD) ;
}
cout << endl;
}
}
#include<bits/stdc++.h>
// #include<ext/pb_ds/assoc_container.hpp>
// #include<ext/pb_ds/tree_policy.hpp>
using  namespace std;
// using namespace __gnu_pbds;

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//Give shorthand names to data types using typedef.
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int>  pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;
typedef pair<ll, ll> pll;
typedef vector<ll>  vll;
typedef vector<vll> vvll;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef pair<ll,pair<ll,ll>> triplet;
// #define ordered_set tree<pair<int,int>, null_type, less<pair<int,int>>, rb_tree_tag, tree_order_statistics_node_update>

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
#define fo(i,n) for(int i=0;i<n;i++)
#define fo1(i,n) for(int i=1;i<=n;i++)
#define Fo(i,n) for(int i=n-1;i>=0;i--)
#define Fo1(i,n) for(int i=n;i>=1;i--)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define rep2(i,a,b) for(int i=a;i>=b;i--)

#define pb push_back
#define eb emplace_back
#define F first
#define S second
#define all(x) (x).begin(), (x).end()
#define set_bits __builtin_popcountll

#define PI 3.1415926535897932384626

#define fast_io ios_base::sync_with_stdio(false);cin.tie(NULL)
mt19937 rnd((unsigned int) chrono::steady_clock::now().time_since_epoch().count());

const int MOD = 1e9+7;
const int MOD1 = 998244353;
const int MOD3 = 1610612741;
/* Alternate Prime nos where probability of collision is less for hashing for MOD3:
    long long:
    1000000000039
    2000000000003
    3000000000013
    4000000000039
    int:
    1610612741(currently used).
*/
const ll INF = 1e18+9;
const ll NINF = -1e18-9;


#define deb(x) cerr << #x <<" "; _print(x); cerr << endl;

template <class T> void _print(T x){cerr<<x;}
template <class T, class V> void _print(pair <T, V> p) {cerr << "{"; _print(p.F); cerr << ","; _print(p.S); cerr << "}";}
template <class T> void _print(vector <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(set <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T> void _print(multiset <T> v) {cerr << "[ "; for (T i : v) {_print(i); cerr << " ";} cerr << "]";}
template <class T, class V> void _print(map <T, V> v) {cerr << "[ "; for (auto i : v) {_print(i); cerr << " ";} cerr << "]";}

vi primes;
vi spf;
vector<bool> prime;

//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ll gcd(ll a, ll b) {if (b > a) {return gcd(b, a);} if (b == 0) {return a;} return gcd(b, a % b);}
ll mpow(ll base, ll exp , ll mod) { base %= mod; ll result = 1; while (exp > 0) { if (exp & 1) result = (result * base) % mod; base = (base * base) % mod; exp >>= 1;} return result;}
//Use when 'a' and 'b' are less than mod,but their addition can go beyond mod.
ll mAdd(ll a, ll b , ll mod) {return (a + b >= mod ? a + b - mod : a + b);}
void extendgcd(ll a, ll b, ll*v) {if (b == 0) {v[0] = 1; v[1] = 0; v[2] = a; return ;} extendgcd(b, a % b, v); ll x = v[1]; v[1] = v[0] - v[1] * (a / b); v[0] = x; return;} //pass an arry of size1 3
ll mminv(ll a, ll b) {ll arr[3]; extendgcd(a, b, arr); return arr[0];} //for non prime b
ll mminvprime(ll a, ll b) {return mpow(a, b - 2, b);}
bool revsort(ll a, ll b) {return a > b;}
void swap(ll &x, ll &y) {int temp = x; x = y; y = temp;}
ll combination(ll n, ll r, ll m, ll *fact, ll *ifact) {ll val1 = fact[n]; ll val2 = ifact[n - r]; ll val3 = ifact[r]; return (((val1 * val2) % m) * val3) % m;}
void google(int t) {cout << "Case #" << t << ": ";}
ll mod_add(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a + b) % m) + m) % m;}
ll mod_mul(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a * b) % m) + m) % m;}
ll mod_sub(ll a, ll b, ll m) {a = a % m; b = b % m; return (((a - b) % m) + m) % m;}
ll mod_div(ll a, ll b, ll m) {a = a % m; b = b % m; return (mod_mul(a, mminvprime(b, m), m) + m) % m;}  //only for prime m
ll phin(ll n) {ll number = n; if (n % 2 == 0) {number /= 2; while (n % 2 == 0) n /= 2;} for (ll i = 3; i <= sqrt(n); i += 2) {if (n % i == 0) {while (n % i == 0)n /= i; number = (number / i * (i - 1));}} if (n > 1)number = (number / n * (n - 1)) ; return number;} 
vector<long long> computeHash(string &s) {ll str_len=s.length(); ll p_pow[str_len]; ll p=123; p_pow[0]=1; for(int i=1;i<str_len;i++) p_pow[i]=(p_pow[i-1]*p)%MOD3; vector<long long> hash(str_len+1); hash[0]=0; for(int i=1;i<=str_len;i++) hash[i] = ( hash[i-1] + ((s[i-1]-'a'+1)*p_pow[i-1]) %MOD3 )%MOD3; return hash; }
vector<int> makeZarray(string s) {int n = s.length(); vector<int> z(n); int l=0,r=0; for(int i=1;i<n;i++) {if(i<=r) z[i] = min(z[i-l],r-i+1); while(i+z[i]<n && s[z[i]]==s[i+z[i]]) z[i]++; if(i+z[i]-1 > r) l=i , r=i+z[i]-1; } return z; }
//O(nloglogn)
void sieve(int n) {prime.assign(n+1,true); prime[0]=0; prime[1]=0; for (int i = 2; i <= n; i++)if (prime[i] == 1) {primes.eb(i); for (ll j = (ll)i * i; j <= n; j += i) {if(prime[j]) prime[j]=0;} } }
//O(nloglogn) Max value of n=1e6.
void find_spf(int n) {n = max(n,1); spf.assign(n+1,0); prime.assign(n+1,true); prime[0] = prime[1] = false; int i; for(i=2; i<=n; i++) {if(prime[i]) {primes.eb(i); spf[i]=i; for(ll j=(ll)i*i; j<=n; j+=i) {if(prime[j]) {prime[j]=false; spf[j]=i; } } } } }
//O(log2n) time at max. Before running this , Run sieve(if n larger than 1e6) or find_spf() if n<=1e6,both  upto sqrt(n).
vpll prime_factorize(ll n) { vpll result; if(n < spf.size()) {while(n!=1) {ll fact = spf[n]; ll exp=0; do {n/=fact; exp++; } while(n%fact==0); result.eb(fact,exp); } return result; } else {for(auto p : primes) { if(p*p > n) break; if(n % p==0) {result.emplace_back(p, 0); do {n /= p; result.back().second++; } while (n % p == 0); } } if(n>1) result.eb(n,1); return result; } }
ll sumprimeExp(ll n) {vpll prime_factors = prime_factorize(n); ll ans=0; for(auto p : prime_factors) {ans+=p.second; } return ans; }
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

ll n;

ll helperEven(ll k,ll sum){
    if(k==0) return 1;

    ll val1 = (sum*helperEven(k-1,sum))%MOD;
    ll val2 = mpow(2,n*(k-1),MOD);

    return (val1 + val2)%MOD;
}

ll helperOdd(ll k,ll sum){
    if(k==0) return 1;

    ll val1 = (sum*helperEven(k-1,sum))%MOD;

    return val1;
}

int32_t main()
{
    fast_io;
    int t; 
    cin>>t;
    
    ll Max = 2*1e5 + 1;

    ll fact[Max],ifact[Max];
    fact[0]=1; ifact[0]=1;

    for(ll i=1;i<=Max-1;i++){
        fact[i] = (fact[i-1]*i)%MOD;
        ifact[i] = mminvprime(fact[i],MOD);
    }

    while(t--)
    {
        ll k; cin>>n>>k;

        ll sum = 0;
        if(n%2==0){
            for(ll i=0;i<=n-2;i+=2){
                sum = (sum + combination(n,i,MOD,fact,ifact))%MOD;
            }

            cout<<helperEven(k,sum);
        }   
        else{
            for(ll i=0;i<=n-1;i+=2){
                sum = (sum + combination(n,i,MOD,fact,ifact))%MOD;    
            }   
            cout<<helperOdd(k,(sum+1)%MOD);
        }       
        cout<<endl;
    }
}