import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;
import java.util.StringTokenizer;
import java.util.*;
public class A{
   static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
    public static void main(String args[]){
        FastReader sc=new FastReader();
        int t=sc.nextInt();
        StringBuilder sb=new StringBuilder();
        int m=1000000007;
        while(t-->0){
          int n=sc.nextInt();
          int k=sc.nextInt();
          int p=(int)Math.pow(2,k);
          p=p-1;
          p=p/2;
          long ans=(long)((long)n%m*(long)(n-1)%m)%m;
          ans=(ans%m*(long)p%m)%m;
          ans=(ans%m+(long)n%m)%m;
          System.out.println(ans%m);
        }
   }
}


/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Solution
{
    static long mod=1000000007;
    static FastReader sc=new FastReader();
    static long power(long x, long y)
    {
    long res = 1;     // Initialize result
    while (y > 0)
    {

        // If y is odd, multiply x with result
        if ((y & 1) != 0)
            res = res * x;

        // y must be even now
        y = y >> 1; // y = y/2
        x = (x%mod * x%mod)%mod;  // Change x to x^2
    }
    return res;
    }
	public static void main (String[] args) throws java.lang.Exception
	{
		int t=sc.nextInt();
		for(int y=0;y<t;++y)
		{
		    long n=sc.nextLong();
		    long k=sc.nextLong();
		    System.out.println(power(n,k)%mod);

		}
    }

	static void printintarray(int[] arr)
{
	int n=arr.length;
	for(int i=0;i<n;++i)
	{
		System.out.print(arr[i]+" ");
	}
	System.out.println();
}
	static void printlongarray(long[] arr)
{
	int n=arr.length;
	for(int i=0;i<n;++i)
	{
		System.out.print(arr[i]+" ");
	}
	System.out.println();
}

	static int[] arrayintinput(int n)
	{
	    int arr[]=new int[n];
	    for(int i=0;i<n;++i)
	    {
	        arr[i]=sc.nextInt();
	    }
	    return arr;
	}
	static long[] arraylonginput(int n)
	{
	    long arr[]=new long[n];
	    for(int i=0;i<n;++i)
	    {
	        arr[i]=sc.nextLong();
	    }
	    return arr;
	}
	static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(
                new InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() { return Integer.parseInt(next()); }

        long nextLong() { return Long.parseLong(next()); }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

}
//  System.out.println("Case #"+(y+1)+": "+ans);


import java.util.*;
import java.io.*;
import java.lang.Math;

public class A {

	static int INF = -2_000_000_000;
	static long MOD = 1_000_000_007;
	static int MAX_PRIME = 1_000_000_000;
	public static void main(String args[]) {
		FastScanner fs=new FastScanner();
		int t = fs.nextInt();
		System.out.println(modPow(3, 3));
		outer: for(int tt=0; tt < t; tt++) {
			int n=fs.nextInt();
			int k =fs.nextInt();

			System.out.println(modPow(n, k));
		}
	}
	static long modPow(long x, long y) {
		if(y == 0)
			return 1;

		long mid = modPow(x, y/2);
		if((y&1)==1) {
			return (((mid*mid)%MOD)*x)%MOD;
		} else {
			return (mid*mid)%MOD;
		}
	}

	static boolean perfectSquare(int x) {
		return (int)Math.sqrt(x) * (int)Math.sqrt(x) == x;
	}

	static class Pair implements Comparable<Pair>{
		long first, second;
		public Pair(long l, long i) {
			first=l;second=i;
		}
		public Pair() {
			first=0;second=0;
		}
		public int compareTo(Pair x) {
			if(this.first<x.first)
				return -1;
			if(this.first==x.first)
				return this.second<x.second?-1:(this.second==x.second?0:1);
			return 1;
		}
	}

	static class RangeMin {
		long logs[], st[][];
		// sparse table?
		int N, K;
		public RangeMin(int n) {
			N=n;
			K = (int)((double) (Math.log10((double)n) /(double) Math.log10((double)2) ));
			st = new long [N+2][K+2];
			logs = new long[N+2];
		}
		void init(ArrayList<Integer> A) {

			for(int i = 0; i < N; i++) {
				Arrays.fill(st[i], (long)1e18);
				st[i][0]=(long)A.get(i);
			}
			// NLOGN
			for(int j = 1; j <= K; j++) {
				for(int i = 0; i + (1<<j) <= N; i++) {
					st[i][j]=Math.min(st[i][j-1], st[i + (1 << (j-1))][j-1]);
				}
			}
			logs[1]=0;
			for(int i = 2; i <= N; i++) {
				logs[i]=logs[i/2]+1;
			}
		}
		void init(int [] A) {

			for(int i = 0; i < N; i++) {
				Arrays.fill(st[i], (long)1e18);
				st[i][0]=(long)A[i];
			}
			// NLOGN
			for(int j = 1; j <= K; j++) {
				for(int i = 0; i + (1<<j) <= N; i++) {
					st[i][j]=Math.min(st[i][j-1], st[i + (1 << (j-1))][j-1]);
				}
			}
			logs[1]=0;
			for(int i = 2; i <= N; i++) {
				logs[i]=logs[i/2]+1;
			}
		}

		long query(int L, int R) {
			int j = (int)logs[R-L+1];
			return Math.min(st[L][j], st[R - (1 << j) + 1][j]);
		}
	}

	static class FastScanner
    {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
        public int[] nextArray(int n) {
            int a[] = new int[n];
            for(int i =0; i < n; i++) a[i]=this.nextInt();
            return a;
        }
        public int max(int a[]) {
        	int mx = Integer.MIN_VALUE;
        	for(int i : a)
        		mx = Math.max(i, mx);
        	return mx;
        }
        public int count(int a[], int val) {
        	int ans =0;
        	for(int i : a)
        		ans += val == i ? 1 : 0;
        	return ans;
        }
        public int min(int a[]) {
        	int mn = Integer.MAX_VALUE;
        	for(int i : a)
        		mn = Math.min(i, mn);
        	return mn;
        }
        public void randomShuffleSort(int []a) {
			Random r = new Random();
            for(int i =0; i < (a.length)/2; i++) {
                int temp=a[i],p=r.nextInt(a.length);
                a[i]=a[p];
                a[p]=temp;
            }
            this.fine_sort(a);
        }
        public void fine_sort(int a[]) {
            ArrayList<Integer> A = new ArrayList<>();
            for(int i : a) A.add(i);
            Collections.sort(A);
            for(int i=0; i < a.length; i++) {
                a[i]=A.get(i);
            }
        }
    }

	static class SegmentTree {
    	int leftmost, rightmost;
    	SegmentTree lChild, rChild;
    	int sum;
    	long lz_val;

    	public SegmentTree(int l, int r, int a[]) {
    		leftmost = l;
    		rightmost = r;
    		lz_val=0;
    		if(l == r)
    			sum = a[l];
    		else {
    			int mid = (l + r) / 2;
    			lChild = new SegmentTree(l, mid, a);
    			rChild = new SegmentTree(mid+1, r, a);
    			update();
    		}
    	}
    	public void update() {
    		sum = lChild.sum + rChild.sum + (int)lChild.lz_val + (int)rChild.lz_val;
    	}
    	public void pointUpdate(int pos, int val) {
    		if(leftmost == rightmost) {
    			sum = val;
    		} else {
    			int mid = (leftmost + rightmost) / 2;
    			if(pos <= lChild.rightmost) lChild.pointUpdate(pos, val);
    			else rChild.pointUpdate(pos, val);
    			update();
    		}
    	}
    	public void rangeUpdate(int l, int r, int val) {
    		// first check if it's within the range
    		if(l <= leftmost && r >= rightmost) {
    			lz_val += val;
    		} else {
    			// its not within the range so lets update the left if we have to and update the right if we have to
    			if(lChild.rightmost >= l) lChild.rangeUpdate(l, r, val);
    			if(rChild.leftmost <= r) rChild.rangeUpdate(l, r, val);
    			update();
    		}
    	}
    	public long query(int l, int r) {
    		if(l > rightmost || r < leftmost) return 0;
    		else if(l <= leftmost && r >= rightmost) return sum + lz_val;

    		return (long) lChild.query(l, r) + (long) rChild.query(l, r);
    	}
    }
}


import java.util.*;
public class B {
	public static void main(String [] args) {
		Scanner sc = new Scanner(System.in);
		int t =0;
		long mod = (long) 1e9 + 7;
		for(int tt = 0 ;tt <t ;tt++) {
			int n = sc.nextInt() , k = sc.nextInt();

			long ans = 1;
			for (int i = 0; i < k; i++) ans = (ans * n) % mod;
			System.out.println(ans);		}
	}
}


import java.util.Scanner;

public class sumobig {
    static long big_mod(long base, long power, long mod)
    {
        if(power==0)    return 1;
            //কোন কিছুর power 0 হলে তার মান 1 হয়ে যায়
        else if(power%2==1) //power বেজোড় হলে
        {
            long p1 = base % mod;
            long p2 = (big_mod(base,power-1,mod))%mod;
            return (p1*p2)%mod;
        }
        else if(power%2==0) //power জোড় হলে
        {
            long p1 = (big_mod(base,power/2,mod))%mod;
            return (p1*p1)%mod;
        }
        return 1;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        long n = scanner.nextLong();
        long k = scanner.nextLong();
        System.out.println(big_mod(n,k ,1000000007));
    }
}


/*
 * akshaygupta26
 */
import java.io.*;
import java.util.*;
public class B
{
    public static void main(String[] args)
	{
		FastReader sc=new FastReader();
		StringBuffer ans=new StringBuffer();
		int test=sc.nextInt();
		while(test-->0)
		{
			int n=sc.nextInt();int bits=sc.nextInt();
			int mod = (int)(1e9+7);
			int xy= binexp(n,bits,mod);
			ans.append(xy+"\n");
		}
	    System.out.print(ans);
	}

    static int binexp(int a,int b,int mod) {
    	if(b == 0) return 1;
    	int temp =binexp(a,b/2,mod);
    	temp=(int)((temp*1l*(long)temp)%mod);
    	if(b%2 == 1) temp=(temp*a)%mod;
    	return temp;
    }

    static long _gcd(long a,long b) {
    	if(b == 0) return a;
    	return _gcd(b,a%b);
    }

    static final Random random=new Random();

	static void ruffleSort(int[] a) {
		int n=a.length;//shuffle, then sort
		for (int i=0; i<n; i++) {
			int oi=random.nextInt(n), temp=a[oi];
			a[oi]=a[i]; a[i]=temp;
		}
		Arrays.sort(a);
	}

	static void ruffleSort(long[] a) {
		int n=a.length;//shuffle, then sort
		for (int i=0; i<n; i++) {
			int oi=random.nextInt(n);
			long temp=a[oi];
			a[oi]=a[i]; a[i]=temp;
		}
		Arrays.sort(a);
	}

	static class FastReader
	{
		BufferedReader br;
		StringTokenizer st;

		public FastReader()
		{
			br = new BufferedReader(new
					InputStreamReader(System.in));
		}

		String next()
		{
			while (st == null || !st.hasMoreElements())
			{
				try
				{
					st = new StringTokenizer(br.readLine());
				}
				catch (IOException e)
				{
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt()
		{
			return Integer.parseInt(next());
		}

		long nextLong()
		{
			return Long.parseLong(next());
		}

		double nextDouble()
		{
			return Double.parseDouble(next());
		}

		String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
	}

}


//------------------>>>>>>>>>>>>>>>> HI . HOW ARE YOU? <<<<<<<<<<<<<<<<<<<<<<<<<<<<<------------------------------

import java.util.*;
import java.math.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

//---------------------------->>>>>>>>>>>>>>>>>>>>>> FK OFF <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<-------------------

public class practice{
    static long[] count,count1,count2;
    static boolean[] prime;
    static int[] spf;
    static Node[] nodes,nodes1,nodes2;
    static long[] arr;
    static long[][] cost;
    static int[] arrInt,darrInt,farrInt;
    static long[][] dp;
    static char[] ch,ch1,ch2;
    static long[] darr,farr;
    static char[][] mat,mat1;
    static boolean[] vis;
    static long x,h;
    static long maxl,sum,total;
    static double dec;
    static long mx = (long)1e7;
    static long inf = (long)1e18;
    static String s,s1,s2,s3,s4;
    static long minl;
    static long mod = (long)1e9+7;
    // static int minl = -1;
    // static long n;
    static int n,n1,n2,q,r1,c1,r2,c2;
    static int arr_size = (int)2e5+10;
    static long a;
    static long b;
    static long c;
    static long d;
    static  int centroids;
    static long y,z;
    static int m;
    static int ans;
    static long k;
    static FastScanner sc;
    static String[] str,str1;
    static Set<Long> set,set1,set2;
    static SortedSet<Long> ss;
    static List<Long> list,list1,list2,list3;
    static PriorityQueue<Node> pq,pq1;
    static LinkedList<Node> ll,ll1,ll2;
    static Map<Integer,List<Node>> map;
    static Map<Integer,Integer> map2;
    static Map<Integer,Node> map1;
    static StringBuilder sb,sb1,sb2;
    static int index;
    static int[] dx = {0,-1,0,1,-1,1,-1,1};
    static int[] dy = {-1,0,1,0,-1,-1,1,1};

    static class Node{
        int first;
        long wt;
        Node(int f,long s){
            this.first = f;
            this.wt = s;
        }
    }

    // public static void solve(){

    //    FastScanner sc = new FastScanner();
    //    int t = sc.nextInt();
    //    // int t = 1;
    //    for(int tt = 1 ; tt <= t ; tt++){

    //        System.out.println("Case #"+tt+": "+cost);

    //    }

    // }

    //--------------->>>>IF YOU ARE HERE FOR QUICKSORT HACK THEN SORRY NO HACK FOR YOU<<<------------------------------

    //------------>>>>>NEVER GIVE UP <<<<<--------------------------------------------------------------

    public static void solve(){

//        System.out.println(mod(a*a));
        if(a == 1){
            sb.append("0\n");
        }
        else
            sb.append(power(a,b)+"\n");

    }

    //------------>>>>>NEVER GIVE UP <<<<<--------------------------------------------------------------

    //----------->>>>>>> SPEED UP SPEED UP . THIS IS SPEEDFORCES . SPEED UP SPEEEEEEEEEEEEEEEEEEEEEEEEEEDDDDDD <<<<<<<------------------

    public static void main(String[] args) {

        sc = new FastScanner();
        // Scanner sc = new Scanner(System.in);
        sb = new StringBuilder();
         int t = sc.nextInt();
//        int t = 1;
        while(t > 0){

            // k = sc.nextLong();
            // x = sc.nextLong();
            // y = sc.nextLong();
            // z = sc.nextLong();

             a = sc.nextLong();
             b = sc.nextLong();
//             c = sc.nextLong();
//             d = sc.nextLong();

//             x = sc.nextLong();
//             y = sc.nextLong();
//             z = sc.nextLong();
            // d = sc.nextLong();

//            n = sc.nextInt();

            // n1 = sc.nextInt();

//            m = sc.nextInt();
//             q = sc.nextInt();

            // a = sc.nextLong();
            // b = sc.nextLong();

//             k = sc.nextLong();

            // x = sc.nextLong();
            // d = sc.nextLong();

            // s = sc.next();

//            ch = sc.next().toCharArray();
            // ch1 = sc.next().toCharArray();

//             m = sc.nextInt();
            // n = 6;

//             arr = new long[n];
//             for(int i = 0 ; i < n ; i++){
//                 arr[i] = sc.nextLong();
//             }

            // arrInt = new int[n+1];
            // for(int i = 1 ; i <= n ; i++){
            //     arrInt[i] = sc.nextInt();
            // }

            // x = sc.nextLong();
            // y = sc.nextLong();
//             ch = sc.next().toCharArray();
//             m = n;
////             m = sc.nextInt();
//             darr = new long[m];
//             for(int i = 0 ; i < m ; i++){
//                 darr[i] = sc.nextLong();
//             }
            // k = sc.nextLong();
            // m = n;
            // darrInt = new int[n];
            // for(int i = 0 ; i < n ; i++){
            //     darrInt[i] = sc.nextInt();
            // }

            // farr = new long[m];
            // for(int i = 0 ; i < m ; i++){
            //     farr[i] = sc.nextLong();
            // }

            // farrInt = new int[m];
            // for(int i = 0; i < m ; i++){
            //     farrInt[i] = sc.nextInt();
            // }

            // m = n;
//            mat = new long[n][m];
//            for(int i = 0 ; i < n ; i++){
//                for(int j = 0 ; j < m ; j++){
//                    mat[i][j] = sc.nextLong();
//                }
//            }

//             m = n;
//             mat = new char[n][m];
//             for(int i = 0 ; i < n ; i++){
//                 String s = sc.next();
//                 for(int j = 0 ; j < m ; j++){
//                     mat[i][j] = s.charAt(j);
//                 }
//             }

            // str = new String[n];
            // for(int i = 0 ; i < n ; i++)
            //     str[i] = sc.next();

            // nodes = new Node[n];
            // for(int i = 0 ; i < n ;i++)
            //     nodes[i] = new Node(sc.nextInt(),i);

            solve();
            t -= 1;
        }
        System.out.print(sb);

    }

    public static int log(double n,double base){

        if(n == 0 || n == 1)
            return 0;

        if(n == base)
            return 1;

        double num = Math.log(n);
        double den = Math.log(base);

        if(den == 0)
            return 0;

        return (int)(num/den);
    }

    public static boolean isPrime(long n) {
        // Corner cases
        if (n <= 1)
            return false;

        if (n <= 3)
            return true;

        // This is checked so that we can skip
        // middle five numbers in below loop
        if (n%2 == 0 || n%3 == 0)
            return false;

        for (int i=5; i*i<=n; i=i+6)
            if (n%i == 0 || n%(i+2) == 0)
                return false;

        return true;
    }

    public static void SpecialSieve(int MAXN)
    {
        spf = new int[MAXN];
        spf[1] = 1;
        for (int i=2; i<MAXN; i++)

            // marking smallest prime factor for every
            // number to be itself.
            spf[i] = i;

        // separately marking spf for every even
        // number as 2
        for (int i=4; i<MAXN; i+=2)
            spf[i] = 2;

        for (int i=3; i*i<MAXN; i++)
        {
            // checking if i is prime
            if (spf[i] == i)
            {
                // marking SPF for all numbers divisible by i
                for (int j=i*i; j<MAXN; j+=i)

                    // marking spf[j] if it is not
                    // previously marked
                    if (spf[j]==j)
                        spf[j] = i;
            }
        }
    }

    public static ArrayList<Integer> getFactorization(int x)
    {
        ArrayList<Integer> ret = new ArrayList<Integer>();
        while (x != 1)
        {
            ret.add(spf[x]);
            x = x / spf[x];
        }
        return ret;
    }

    public static long gcd(long a, long b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }

    public static long lcm(long a, long b)
    {
        return (b/gcd(b, a % b)) * a;
    }

    public static long mod_inverse(long a,long mod){
        long x1=1,x2=0;
        long p=mod,q,t;
        while(a%p!=0){
            q = a/p;
            t = x1-q*x2;
            x1=x2; x2=t;
            t=a%p;
            a=p; p=t;
        }
        return x2<0 ? x2+mod : x2;
    }

    public static void swapF(int[] curr,int l,int r){
        for(int i = l ; i < (r-l+1)/2 ; i++){
            swap(curr,i,r-i);
        }
    }

    public static void swap(int[] curr,int i,int j){
        int temp = curr[j];
        curr[j] = curr[i];
        curr[i] = temp;
    }

    static final Random random=new Random();

    static void ruffleSortLong(long[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n);
            long temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static void ruffleSortInt(int[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n);
            int temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static void ruffleSortChar(char[] a) {
        int n=a.length;//shuffle, then sort
        for (int i=0; i<n; i++) {
            int oi=random.nextInt(n);
            char temp=a[oi];
            a[oi]=a[i]; a[i]=temp;
        }
        Arrays.sort(a);
    }

    static long binomialCoeff(long n, long k){

        long res = 1;

        // Since C(n, k) = C(n, n-k)
        if (k > n - k)
            k = n - k;

        // Calculate value of
        // [n * (n-1) *---* (n-k+1)] / [k * (k-1) *----* 1]
        for (long i = 0; i < k; ++i) {
            res = (res*(n - i));
            res = (res/(i + 1));
        }

        return res;
    }

    static long mod(long x)
    {
        long y = mod;
        long result = x % y;
        if (result < 0)
        {
            result += y;
        }
        return result;
    }

    static long[] fact;

    public static long inv(long n){
        return power(n, mod-2);
    }

    public static void fact(int n){
        fact = new long[n+1];
        fact[0] = 1;
        for(int j = 1;j<=n;j++)
            fact[j] = (fact[j-1]*(long)j)%mod;
    }

    public static long binom(int n, int k){

        long prod = fact[n];
        prod*=inv(fact[n-k]);
        prod%=mod;
        prod*=inv(fact[k]);
        prod%=mod;
        return prod;
    }

    static long power(long x, long y){
        if (y == 0)
            return 1;
        if (y%2 == 1)
            return (x*power(x, y-1))%mod;
        return power((x*x)%mod, y/2)%mod;
    }

    public static long pow(long n,long p,long m){
        long  result = 1;
        if(p==0)
            return 1;

        while(p!=0)
        {
            if(p%2==1)
                result *= n;
            if(result>=m)
                result%=m;
            p >>=1;
            n*=n;
            if(n>=m)
                n%=m;
        }
        return result;
    }

    static void sieve(int n){

        prime = new boolean[n+1];
        for(int i=2;i<n;i++)
            prime[i] = true;

        for(int p = 2; p*p <=n; p++)
        {
            if(prime[p] == true)
            {
                for(int i = p*p; i <= n; i += p)
                    prime[i] = false;
            }
        }

    }

    static long abs(long a){
        return Math.abs(a);
    }

    static int abs(int a){
        return Math.abs(a);
    }

    static int max(int a,int b){
        if(a>b)
            return a;
        else
            return b;
    }
    static double max(double a,double b){
        if(a>b)
            return a;
        else
            return b;
    }
    static double min(double a,double b){
        if(a>b)
            return b;
        else
            return a;
    }

    static int min(int a,int b){
        if(a>b)
            return b;
        else
            return a;
    }

    static long max(long a,long b){
        if(a>b)
            return a;
        else
            return b;
    }

    static long min(long a,long b){
        if(a>b)
            return b;
        else
            return a;
    }

    static long sq(long num){
        return num*num;
    }

    static double sq(double num){
        return num*num;
    }

    static long sqrt(long num){
        return (long)Math.sqrt(num);
    }

    static double sqrt(double num){
        return Math.sqrt(num);
    }

    static class FastScanner {

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }
        void readArray(int n) {
            arr = new long[n];
            for (int i = 0; i < n; i++)
                arr[i] = nextLong();
        }
        long nextLong() {
            return Long.parseLong(next());
        }
    }

}


import java.util.*;
import java.io.*;

public class Main {
    public static void main(String args[]) {new Main().run();}

    FastReader in = new FastReader();
    PrintWriter out = new PrintWriter(System.out);
    void run() {
        work();
        out.flush();
    }
    long mod=998244353;
    long gcd(long a,long b) {
        return a==0?b:gcd(b%a,a);
    }
    void work() {
        int n=ni(),k=ni();
        long[][] dp=new long[251][251];
        for(int j=1;j<=k;j++){
            dp[1][j]=1;
        }
        long[][] pow=new long[251][251*251];
        long[][] C=new long[251][251];
        for(int i=1;i<=250;i++){
            pow[i][0]=1;
            for(int j=1;j<251*251;j++){
                pow[i][j]=pow[i][j-1]*i%mod;
            }
        }
        for(int i=0;i<=250;i++){
            for(int j=0;j<=i;j++){
                if(i==0||j==0){
                    C[i][j]=1;
                }else{
                    C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
                }
            }
        }
        for(int j=0;j<=k;j++){
            dp[0][j]=1;
        }
        for(int i=1;i<=n-1;i++){
            for(int j=1;j<=k;j++){
                dp[i][j]=dp[i][j-1];
                for(int p=1;p<=i;p++){
                    dp[i][j]+=dp[i-p][j-1]*C[i][p]%mod*pow[k-j+1][p*(i-p)+(p-1)*p/2]%mod;
                }
            }
        }
        out.println(dp[n-1][k]);
    }

    private ArrayList<Integer>[] ng(int n, int m) {
        ArrayList<Integer>[] graph=(ArrayList<Integer>[])new ArrayList[n];
        for(int i=0;i<n;i++) {
            graph[i]=new ArrayList<>();
        }
        for(int i=1;i<=m;i++) {
            int s=in.nextInt()-1,e=in.nextInt()-1;
            graph[s].add(e);
            graph[e].add(s);
        }
        return graph;
    }

    private ArrayList<long[]>[] ngw(int n, int m) {
        ArrayList<long[]>[] graph=(ArrayList<long[]>[])new ArrayList[n];
        for(int i=0;i<n;i++) {
            graph[i]=new ArrayList<>();
        }
        for(int i=1;i<=m;i++) {
            long s=in.nextLong()-1,e=in.nextLong()-1,w=in.nextLong();
            graph[(int)s].add(new long[] {e,w});
            graph[(int)e].add(new long[] {s,w});
        }
        return graph;
    }

    private ArrayList<int[]>[] ngwi(int n, int m) {
        ArrayList<int[]>[] graph=(ArrayList<int[]>[])new ArrayList[n];
        for(int i=0;i<n;i++) {
            graph[i]=new ArrayList<>();
        }
        for(int i=1;i<=m;i++) {
            int s=ni()-1,e=ni()-1,w=ni();
            graph[s].add(new int[] {e,w});
            graph[e].add(new int[] {s,w});
        }
        return graph;
    }

    private int ni() {
        return in.nextInt();
    }

    private long nl() {
        return in.nextLong();
    }
    private double nd() {
        return in.nextDouble();
    }
    private String ns() {
        return in.next();
    }

    private long[] na(int n) {
        long[] A=new long[n];
        for(int i=0;i<n;i++) {
            A[i]=in.nextLong();
        }
        return A;
    }

    private int[] nia(int n) {
        int[] A=new int[n];
        for(int i=0;i<n;i++) {
            A[i]=in.nextInt();
        }
        return A;
    }
}

class FastReader
{
    BufferedReader br;
    StringTokenizer st;
    InputStreamReader input;//no buffer
    public FastReader()
    {
        br=new BufferedReader(new InputStreamReader(System.in));
    }

    public FastReader(boolean isBuffer)
    {
        if(!isBuffer){
            input=new InputStreamReader(System.in);
        }else{
            br=new BufferedReader(new InputStreamReader(System.in));
        }
    }

    public boolean hasNext(){
        try{
            String s=br.readLine();
            if(s==null){
                return  false;
            }
            st=new StringTokenizer(s);
        }catch(IOException e){
            e.printStackTrace();
        }
        return true;
    }

    public String next()
    {
        if(input!=null){
            try {
                StringBuilder sb=new StringBuilder();
                int ch=input.read();
                while(ch=='\n'||ch=='\r'||ch==32){
                    ch=input.read();
                }
                while(ch!='\n'&&ch!='\r'&&ch!=32){
                    sb.append((char)ch);
                    ch=input.read();
                }
                return sb.toString();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        while(st==null || !st.hasMoreElements())//回车，空行情况
        {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    public int nextInt()
    {
        return (int)nextLong();
    }

    public long nextLong() {
        try {
            if(input!=null){
                long ret=0;
                int b=input.read();
                while(b<'0'||b>'9'){
                    b=input.read();
                }
                while(b>='0'&&b<='9'){
                    ret=ret*10+(b-'0');
                    b=input.read();
                }
                return ret;
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return Long.parseLong(next());
    }

    public double nextDouble()
    {
        return Double.parseDouble(next());
    }
}


import java.util.*;
import java.io.*;

public class _1657_E {
    static final long MOD = 998244353;
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        StringTokenizer line = new StringTokenizer(in.readLine());
        int n = Integer.parseInt(line.nextToken());
        int k = Integer.parseInt(line.nextToken());
        long[][][] dp = new long[n][k + 1][n];
        long[][] psum = new long[n][k + 1];
        for(int i = 1; i <= k; i++) {
            dp[1][i][1] = 1;
            psum[1][i] = modadd(psum[1][i - 1], 1);
        }
        long res = 0;
        for(int i = 2; i < n; i++) {
            for(int j = 1; j <= k; j++) {
                psum[i][j] = psum[i][j - 1];
                for(int a = 1; a <= i; a++) {
                    if(a > 1) {
                        long mult = modmult(modmult(i, modinv(a)), binpow(k - j + 1, i - 1));
                        dp[i][j][a] = modmult(dp[i - 1][j][a - 1], mult);
                    }else {
                        long mult = modmult(i, binpow(k - j + 1, i - 1));
                        dp[i][j][a] = modmult(psum[i - 1][j - 1], mult);
                    }
                    psum[i][j] = modadd(psum[i][j], dp[i][j][a]);
                    if(i == n - 1) {
                        res = modadd(res, dp[i][j][a]);
                    }
                }
            }
        }
        out.println(res);
        in.close();
        out.close();
    }
    static long modadd(long a, long b) {
        return (a + b + MOD) % MOD;
    }
    static long modmult(long a, long b) {
        return a * b % MOD;
    }
    static long modinv(long a) {
        return binpow(a, MOD - 2);
    }
    static long binpow(long a, long b) {
        if(b == 0) {
            return 1;
        }
        long small = binpow(a, b / 2);
        if(b % 2 == 0) {
            return modmult(small, small);
        }else {
            return modmult(modmult(small, small), a);
        }
    }
}


import java.util.*;
import java.io.*;

public class _1657_E {
    static final long MOD = 998244353;
    static long[][] pow = new long[255][255];
    static long[] inv = new long[255];
    public static void main(String[] args) throws IOException {
        for(int i = 0; i < 255; i++) {
            long prod = 1;
            for(int j = 0; j < 255; j++) {
                pow[i][j] = prod;
                prod = modmult(prod, i);
            }
            if(i > 0) {
                inv[i] = modinv(i);
            }
        }
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);
        StringTokenizer line = new StringTokenizer(in.readLine());
        int n = Integer.parseInt(line.nextToken());
        int k = Integer.parseInt(line.nextToken());
        long[][][] dp = new long[n][k + 1][n];
        long[][] psum = new long[n][k + 1];
        long res = 0;
        for(int i = 1; i <= k; i++) {
            dp[1][i][1] = 1;
            psum[1][i] = modadd(psum[1][i - 1], 1);
            if(i == n - 1) {
                res = modadd(res, 1);
            }
        }
        for(int i = 2; i < n; i++) {
            for(int j = 1; j <= k; j++) {
                psum[i][j] = psum[i][j - 1];
                for(int a = 1; a <= i; a++) {
                    if(a > 1) {
                        long mult = modmult(modmult(i, inv[a]), pow[k - j + 1][i - 1]);
                        dp[i][j][a] = modmult(dp[i - 1][j][a - 1], mult);
                    }else {
                        long mult = modmult(i, pow[k - j + 1][i - 1]);
                        dp[i][j][a] = modmult(psum[i - 1][j - 1], mult);
                    }
                    psum[i][j] = modadd(psum[i][j], dp[i][j][a]);
                    if(i == n - 1) {
                        res = modadd(res, dp[i][j][a]);
                    }
                }
            }
        }
        out.println(res);
        in.close();
        out.close();
    }
    static long modadd(long a, long b) {
        return (a + b + MOD) % MOD;
    }
    static long modmult(long a, long b) {
        return a * b % MOD;
    }
    static long modinv(long a) {
        return binpow(a, MOD - 2);
    }
    static long binpow(long a, long b) {
        if(b == 0) {
            return 1;
        }
        long small = binpow(a, b / 2);
        if(b % 2 == 0) {
            return modmult(small, small);
        }else {
            return modmult(modmult(small, small), a);
        }
    }
}