codefuse-ai/GALLa · Datasets at Hugging Face

node_ids sequencelengths 4 1.4k	edge_index sequencelengths 1 2.22k	text sequencelengths 4 1.4k	source stringlengths 14 427k
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 31, 2 ], [ 31, 15 ], [ 32, 19 ], [ 32, 22 ], [ 29, 25 ], [ 31, 29 ], [ 31, 32 ] ]	[ "n,k = map(int,input().rstrip().split(' '))\nprint(k(k-1)(n-1))", "n,k = map(int,input().rstrip().split(' '))", "n", "map(int,input().rstrip().split(' '))", "map", "int", "input().rstrip().split(' ')", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "' '", "k", "print(k(k-1)*(n-1))", "print", "k(k-1)(n-1)", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "n,k = map(int,input().rstrip().split(' '))", "map(int,input().rstrip().split(' '))", "n", "k = map(int,input().rstrip().split(' '))", "map(int,input().rstrip().split(' '))", "k" ]	n,k = map(int,input().rstrip().split(' ')) print(k(k-1)*(n-1))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 14, 2, 13, 17, 4, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13 ]	[ [ 40, 2 ], [ 40, 11 ], [ 43, 13 ], [ 38, 17 ], [ 41, 21 ], [ 46, 23 ], [ 41, 25 ], [ 41, 28 ], [ 38, 31 ], [ 47, 35 ], [ 44, 35 ], [ 40, 38 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ] ]	[ "n, k = map(int,input().split())\nans = 1\nif n == 1:\n\tprint(k)\nelse:\n\tans = k((k-1)(n-1))\n\tprint(ans)", "n, k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 1", "ans", "1", "if n == 1:\n\tprint(k)\nelse:\n\tans = k((k-1)*(n-1))\n\tprint(ans)", "n == 1", "n", "1", "print(k)", "print", "k", "ans = k((k-1)*(n-1))", "ans", "k((k-1)(n-1))", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "print(ans)", "print", "ans", "n, k = map(int,input().split())", "map(int,input().split())", "n", "k = map(int,input().split())", "map(int,input().split())", "k", "ans = 1", "1", "ans", "ans = k((k-1)(n-1))", "k((k-1)**(n-1))", "ans" ]	n, k = map(int,input().split()) ans = 1 if n == 1: print(k) else: ans = k((k-1)*(n-1)) print(ans)
[ 7, 0, 13, 4, 18, 4, 13, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13 ]	[ [ 51, 2 ], [ 42, 10 ], [ 52, 14 ], [ 45, 17 ], [ 52, 21 ], [ 54, 24 ], [ 46, 25 ], [ 28, 27 ], [ 43, 31 ], [ 48, 34 ], [ 46, 36 ], [ 49, 40 ], [ 55, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 46, 54 ], [ 54, 55 ] ]	[ "str_line = input().split(\" \")\nnum = int(str_line[0])\nkind = int(str_line[1])\nans = kind \n\nfor i in range(num-1):\n ans =(kind - 1)\n \nprint(ans)", "str_line = input().split(\" \")", "str_line", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "num = int(str_line[0])", "num", "int(str_line[0])", "int", "str_line[0]", "str_line", "0", "kind = int(str_line[1])", "kind", "int(str_line[1])", "int", "str_line[1]", "str_line", "1", "ans = kind", "ans", "kind", "for i in range(num-1):\n ans =(kind - 1)\n ", "i", "range(num-1)", "range", "num-1", "num", "1", "ans =(kind - 1)", "ans", "kind - 1", "kind", "1", "print(ans)", "print", "ans", "num = int(str_line[0])", "int(str_line[0])", "num", "kind = int(str_line[1])", "int(str_line[1])", "kind", "ans =(kind - 1)", "kind - 1", "ans", "str_line = input().split(\" \")", "input().split(\" \")", "str_line", "ans = kind", "kind", "ans" ]	str_line = input().split(" ") num = int(str_line[0]) kind = int(str_line[1]) ans = kind for i in range(num-1): ans *=(kind - 1) print(ans)
[ 7, 15, 13, 15, 13, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 33, 8 ], [ 33, 17 ], [ 31, 21 ], [ 31, 24 ], [ 34, 27 ], [ 33, 31 ], [ 33, 34 ] ]	[ "import sys\nimport math\nimport itertools\n#n=int(input())\nn, k = map(int, input().split())\nprint(k((k-1)(n-1)))", "import sys", "sys", "import math", "math", "import itertools", "itertools", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k((k-1)*(n-1)))", "print", "k((k-1)(n-1))", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "k = map(int, input().split())", "map(int, input().split())", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n" ]	import sys import math import itertools #n=int(input()) n, k = map(int, input().split()) print(k((k-1)*(n-1)))
[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]	[ [ 35, 2 ], [ 35, 16 ], [ 38, 18 ], [ 33, 20 ], [ 33, 23 ], [ 36, 26 ], [ 39, 30 ], [ 35, 33 ], [ 35, 36 ], [ 38, 39 ] ]	[ "# -- coding: utf-8 --\n\n#----------\nN,K = list(map(int, input().rstrip().split()))\n#----------\nans = K * (K-1)*(N-1)\nprint(ans)", "N,K = list(map(int, input().rstrip().split()))", "N", "list(map(int, input().rstrip().split()))", "list", "map(int, input().rstrip().split())", "map", "int", "input().rstrip().split()", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "K", "ans = K (K-1)*(N-1)", "ans", "K (K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "K = list(map(int, input().rstrip().split()))", "list(map(int, input().rstrip().split()))", "K", "N,K = list(map(int, input().rstrip().split()))", "list(map(int, input().rstrip().split()))", "N", "ans = K * (K-1)*(N-1)", "K (K-1)**(N-1)", "ans" ]	# -- coding: utf-8 -- #---------- N,K = list(map(int, input().rstrip().split())) #---------- ans = K * (K-1)**(N-1) print(ans)
[ 7, 12, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 5, 15 ], [ 18, 17 ], [ 15, 19 ], [ 15, 22 ], [ 4, 25 ], [ 17, 29 ], [ 34, 31 ] ]	[ "def resolve():\n N, K = list(map(int, input().split()))\n paint_way_count = K(K-1)(N-1)\n print(paint_way_count)\n\nresolve()", "def resolve():\n N, K = list(map(int, input().split()))\n paint_way_count = K(K-1)*(N-1)\n print(paint_way_count)", "resolve", "N, K = list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "paint_way_count = K(K-1)*(N-1)", "paint_way_count", "K(K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(paint_way_count)", "print", "paint_way_count", "resolve()", "resolve", "def resolve():\n N, K = list(map(int, input().split()))\n paint_way_count = K(K-1)(N-1)\n print(paint_way_count)", "def resolve():\n N, K = list(map(int, input().split()))\n paint_way_count = K(K-1)**(N-1)\n print(paint_way_count)", "resolve" ]	def resolve(): N, K = list(map(int, input().split())) paint_way_count = K(K-1)*(N-1) print(paint_way_count) resolve()
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 2, 13, 17, 4, 13, 2, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]	[ [ 44, 2 ], [ 44, 11 ], [ 38, 13 ], [ 47, 16 ], [ 45, 17 ], [ 20, 19 ], [ 42, 23 ], [ 50, 26 ], [ 39, 28 ], [ 51, 28 ], [ 45, 30 ], [ 48, 35 ], [ 51, 36 ], [ 39, 36 ], [ 38, 39 ], [ 44, 42 ], [ 44, 45 ], [ 45, 47 ], [ 47, 48 ], [ 50, 51 ] ]	[ "\nN,K = map(int, input().split())\n\nc = 1\nans = K\n\nfor i in range(N-1):\n c = c(K-1)\n\nprint(ansc)", "N,K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "c = 1", "c", "1", "ans = K", "ans", "K", "for i in range(N-1):\n c = c(K-1)", "i", "range(N-1)", "range", "N-1", "N", "1", "c = c(K-1)", "c", "c(K-1)", "c", "K-1", "K", "1", "print(ansc)", "print", "ansc", "ans", "c", "c = 1", "1", "c", "N,K = map(int, input().split())", "map(int, input().split())", "N", "K = map(int, input().split())", "map(int, input().split())", "K", "ans = K", "K", "ans", "c = c(K-1)", "c*(K-1)", "c" ]	N,K = map(int, input().split()) c = 1 ans = K for i in range(N-1): c = c(K-1) print(ansc)
[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 15, 0, 13, 2, 17, 17, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 14, 40, 13, 17, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13 ]	[ [ 66, 13 ], [ 69, 25 ], [ 69, 34 ], [ 57, 36 ], [ 61, 37 ], [ 70, 40 ], [ 63, 43 ], [ 61, 45 ], [ 61, 48 ], [ 70, 51 ], [ 64, 55 ], [ 58, 55 ], [ 61, 57 ], [ 57, 58 ], [ 69, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]	[ "import itertools\nimport math\nimport sys\nimport heapq\nfrom collections import Counter\nfrom collections import deque\nfrom fractions import gcd\nINF = 1 << 60\nsys.setrecursionlimit(10 ** 6)\n\n#ここから書き始める\nn, k = map(int, input().split())\nans = k\nif n >= 2:\n ans = k * (k - 1) (n - 1)\nprint(ans)", "import itertools", "itertools", "import math", "math", "import sys", "sys", "import heapq", "heapq", "from collections import Counter", "from collections import deque", "from fractions import gcd", "INF = 1 << 60", "INF", "1 << 60", "1", "60", "sys.setrecursionlimit(10 6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 6", "10", "6", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k", "ans", "k", "if n >= 2:\n ans = k * (k - 1) ** (n - 1)", "n >= 2", "n", "2", "ans = k * (k - 1) ** (n - 1)", "ans", "k * (k - 1) (n - 1)", "k", "(k - 1) (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "print(ans)", "print", "ans", "ans = k", "k", "ans", "k = map(int, input().split())", "map(int, input().split())", "k", "ans = k * (k - 1) ** (n - 1)", "k * (k - 1) ** (n - 1)", "ans", "INF = 1 << 60", "1 << 60", "INF", "n, k = map(int, input().split())", "map(int, input().split())", "n" ]	import itertools import math import sys import heapq from collections import Counter from collections import deque from fractions import gcd INF = 1 << 60 sys.setrecursionlimit(10 ** 6) #ここから書き始める n, k = map(int, input().split()) ans = k if n >= 2: ans = k * (k - 1) ** (n - 1) print(ans)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]	[ [ 35, 2 ], [ 35, 11 ], [ 38, 13 ], [ 36, 14 ], [ 17, 16 ], [ 33, 20 ], [ 41, 22 ], [ 39, 24 ], [ 42, 24 ], [ 36, 26 ], [ 42, 30 ], [ 39, 30 ], [ 35, 33 ], [ 35, 36 ], [ 36, 38 ], [ 38, 39 ], [ 41, 42 ] ]	[ "N,K=map(int,input().split())\nres = K\nfor i in range(1,N):\n res=res(K-1)\nprint(res)", "N,K=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "res = K", "res", "K", "for i in range(1,N):\n res=res(K-1)", "i", "range(1,N)", "range", "1", "N", "res=res(K-1)", "res", "res(K-1)", "res", "K-1", "K", "1", "print(res)", "print", "res", "N,K=map(int,input().split())", "map(int,input().split())", "N", "K=map(int,input().split())", "map(int,input().split())", "K", "res = K", "K", "res", "res=res(K-1)", "res(K-1)", "res" ]	N,K=map(int,input().split()) res = K for i in range(1,N): res=res*(K-1) print(res)
[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]	[ [ 42, 2 ], [ 42, 13 ], [ 39, 15 ], [ 37, 16 ], [ 19, 18 ], [ 43, 22 ], [ 33, 25 ], [ 37, 27 ], [ 34, 31 ], [ 40, 31 ], [ 33, 34 ], [ 42, 37 ], [ 37, 39 ], [ 39, 40 ], [ 42, 43 ] ]	[ "N,K=list(map(int, input().split()))\nc=K\nfor i in range(N-1):\n c= K-1\n\nprint(c)", "N,K=list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "c=K", "c", "K", "for i in range(N-1):\n c= K-1", "i", "range(N-1)", "range", "N-1", "N", "1", "c= K-1", "c", "K-1", "K", "1", "print(c)", "print", "c", "c= K-1", "K-1", "c", "K=list(map(int, input().split()))", "list(map(int, input().split()))", "K", "c=K", "K", "c", "N,K=list(map(int, input().split()))", "list(map(int, input().split()))", "N" ]	N,K=list(map(int, input().split())) c=K for i in range(N-1): c*= K-1 print(c)
[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 19, 18 ], [ 4, 21 ], [ 18, 24 ], [ 28, 27 ], [ 13, 28 ], [ 31, 30 ], [ 13, 32 ], [ 30, 36 ], [ 27, 36 ], [ 15, 36 ], [ 45, 42 ] ]	[ "# -- coding: utf-8 --\n\ndef main():\n\n N, K = map(int, input().split())\n ans = 1\n\n for i in range(N):\n if i == 0:\n ans = K\n\n else:\n ans = (K-1)\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n\n N, K = map(int, input().split())\n ans = 1\n\n for i in range(N):\n if i == 0:\n ans = K\n\n else:\n ans = (K-1)\n\n print(ans)", "main", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = 1", "ans", "1", "for i in range(N):\n if i == 0:\n ans = K\n\n else:\n ans = (K-1)\n\n ", "i", "range(N)", "range", "N", "if i == 0:\n ans = K\n\n else:\n ans = (K-1)\n\n ", "i == 0", "i", "0", "ans = K", "ans", "K", "ans = (K-1)", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n\n N, K = map(int, input().split())\n ans = 1\n\n for i in range(N):\n if i == 0:\n ans = K\n\n else:\n ans = (K-1)\n\n print(ans)", "def main():\n\n N, K = map(int, input().split())\n ans = 1\n\n for i in range(N):\n if i == 0:\n ans = K\n\n else:\n ans = (K-1)\n\n print(ans)", "main" ]	# -- coding: utf-8 -- def main(): N, K = map(int, input().split()) ans = 1 for i in range(N): if i == 0: ans = K else: ans = (K-1) print(ans) if __name__ == "__main__": main()
[ 7, 15, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 12, 4, 18, 4, 18, 18, 13, 13, 13, 13, 0, 13, 12, 4, 13, 8, 13, 39, 4, 13, 17, 4, 13, 17, 23, 0, 13, 12, 4, 13, 8, 13, 39, 4, 13, 17, 4, 13, 17, 23, 0, 13, 12, 2, 4, 13, 13, 17, 23, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13 ]	[ [ 114, 11 ], [ 126, 16 ], [ 111, 23 ], [ 117, 35 ], [ 129, 50 ], [ 123, 65 ], [ 77, 76 ], [ 112, 83 ], [ 77, 85 ], [ 88, 87 ], [ 85, 88 ], [ 91, 90 ], [ 76, 94 ], [ 98, 97 ], [ 85, 99 ], [ 97, 103 ], [ 87, 103 ], [ 121, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 123, 124 ], [ 126, 127 ], [ 129, 130 ] ]	[ "# -- coding: utf-8 --\nimport sys\nsys.setrecursionlimit(109)\nINF=1018\nMOD=10*9+7\ninput=lambda: sys.stdin.readline().rstrip()\nYesNo=lambda b: bool([print('Yes')] if b else print('No'))\nYESNO=lambda b: bool([print('YES')] if b else print('NO'))\nint1=lambda x:int(x)-1\n\ndef main():\n N,K=map(int,input().split())\n ans=K\n for i in range(N-1):\n ans=K-1\n print(ans)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(109)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "109", "10", "9", "INF=1018", "INF", "1018", "10", "18", "MOD=109+7", "MOD", "109+7", "10*9", "10", "9", "7", "input=lambda: sys.stdin.readline().rstrip()", "input", "lambda: sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "YesNo=lambda b: bool([print('Yes')] if b else print('No'))", "YesNo", "lambda b: bool([print('Yes')] if b else print('No'))", "bool([print('Yes')] if b else print('No'))", "bool", "[print('Yes')] if b else print('No')", "b", "[print('Yes')]", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "b", "YESNO=lambda b: bool([print('YES')] if b else print('NO'))", "YESNO", "lambda b: bool([print('YES')] if b else print('NO'))", "bool([print('YES')] if b else print('NO'))", "bool", "[print('YES')] if b else print('NO')", "b", "[print('YES')]", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "b", "int1=lambda x:int(x)-1", "int1", "lambda x:int(x)-1", "int(x)-1", "int(x)", "int", "x", "1", "x", "def main():\n N,K=map(int,input().split())\n ans=K\n for i in range(N-1):\n ans=K-1\n print(ans)", "main", "N,K=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans=K", "ans", "K", "for i in range(N-1):\n ans=K-1\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "ans=K-1", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "input=lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "input", "INF=1018", "1018", "INF", "YesNo=lambda b: bool([print('Yes')] if b else print('No'))", "lambda b: bool([print('Yes')] if b else print('No'))", "YesNo", "def main():\n N,K=map(int,input().split())\n ans=K\n for i in range(N-1):\n ans=K-1\n print(ans)", "def main():\n N,K=map(int,input().split())\n ans=K\n for i in range(N-1):\n ans=K-1\n print(ans)", "main", "int1=lambda x:int(x)-1", "lambda x:int(x)-1", "int1", "MOD=109+7", "109+7", "MOD", "YESNO=lambda b: bool([print('YES')] if b else print('NO'))", "lambda b: bool([print('YES')] if b else print('NO'))", "YESNO" ]	# -- coding: utf-8 -- import sys sys.setrecursionlimit(109) INF=1018 MOD=10*9+7 input=lambda: sys.stdin.readline().rstrip() YesNo=lambda b: bool([print('Yes')] if b else print('No')) YESNO=lambda b: bool([print('YES')] if b else print('NO')) int1=lambda x:int(x)-1 def main(): N,K=map(int,input().split()) ans=K for i in range(N-1): ans=K-1 print(ans) if __name__ == '__main__': main()
[ 7, 0, 13, 4, 18, 4, 13, 13, 17, 0, 13, 39, 4, 13, 18, 13, 17, 4, 13, 18, 13, 17, 4, 13, 2, 18, 13, 17, 2, 2, 18, 13, 17, 17, 2, 18, 13, 17, 17, 10, 4, 13, 10, 39, 13 ]	[ [ 40, 2 ], [ 43, 10 ], [ 41, 15 ], [ 41, 20 ], [ 44, 26 ], [ 44, 31 ], [ 44, 36 ], [ 40, 41 ], [ 43, 44 ] ]	[ "s=input().split(' ')\n\na=[int(s[0]),int(s[1])]\n\nprint(a[1]((a[1]-1)(a[0]-1)))", "s=input().split(' ')", "s", "input().split(' ')", "().split", "()", "input", "split", "' '", "a=[int(s[0]),int(s[1])]", "a", "[int(s[0]),int(s[1])]", "int(s[0])", "int", "s[0]", "s", "0", "int(s[1])", "int", "s[1]", "s", "1", "print(a[1]((a[1]-1)*(a[0]-1)))", "print", "a[1]((a[1]-1)(a[0]-1))", "a[1]", "a", "1", "(a[1]-1)(a[0]-1)", "a[1]-1", "a[1]", "a", "1", "1", "a[0]-1", "a[0]", "a", "0", "1", "s=input().split(' ')", "input().split(' ')", "s", "a=[int(s[0]),int(s[1])]", "[int(s[0]),int(s[1])]", "a" ]	s=input().split(' ') a=[int(s[0]),int(s[1])] print(a[1]((a[1]-1)*(a[0]-1)))
[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 18, 13, 17, 0, 13, 18, 13, 17, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 18, 13, 10, 18, 13, 10, 4, 13 ]	[ [ 41, 2 ], [ 38, 14 ], [ 42, 16 ], [ 35, 19 ], [ 42, 21 ], [ 36, 26 ], [ 36, 29 ], [ 39, 32 ], [ 35, 36 ], [ 38, 39 ], [ 41, 42 ] ]	[ "x = list(map(int,input().split()))\na = x[0]\nb = x[1]\nprint(b((b-1) * (a-1)))", "x = list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a = x[0]", "a", "x[0]", "x", "0", "b = x[1]", "b", "x[1]", "x", "1", "print(b((b-1) * (a-1)))", "print", "b((b-1) * (a-1))", "b", "(b-1) ** (a-1)", "b-1", "b", "1", "a-1", "a", "1", "b = x[1]", "x[1]", "b", "a = x[0]", "x[0]", "a", "x = list(map(int,input().split()))", "list(map(int,input().split()))", "x" ]	x = list(map(int,input().split())) a = x[0] b = x[1] print(b((b-1) * (a-1)))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 34, 2 ], [ 34, 11 ], [ 35, 14 ], [ 32, 18 ], [ 32, 22 ], [ 32, 25 ], [ 35, 28 ], [ 34, 32 ], [ 34, 35 ] ]	[ "N,K = map(int,input().split())\n\nif N ==1:\n print(K)\nelse:\n print(K(K-1)(N-1))", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "if N ==1:\n print(K)\nelse:\n print(K(K-1)*(N-1))", "N ==1", "N", "1", "print(K)", "print", "K", "print(K(K-1)*(N-1))", "print", "K(K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "K = map(int,input().split())", "map(int,input().split())", "K", "N,K = map(int,input().split())", "map(int,input().split())", "N" ]	N,K = map(int,input().split()) if N ==1: print(K) else: print(K(K-1)*(N-1))
[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 4, 18, 13, 13, 2, 17, 17, 12, 13, 12, 13, 12, 13, 12, 13, 14, 4, 18, 13, 13, 17, 0, 13, 2, 18, 4, 18, 18, 13, 13, 13, 4, 18, 18, 13, 13, 13, 13, 17, 17, 0, 13, 2, 0, 18, 13, 13, 4, 13, 13, 17, 0, 13, 4, 13, 17, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13 ]	[ [ 128, 32 ], [ 128, 51 ], [ 57, 54 ], [ 114, 59 ], [ 131, 62 ], [ 101, 67 ], [ 110, 72 ], [ 122, 79 ], [ 99, 81 ], [ 122, 82 ], [ 125, 84 ], [ 123, 86 ], [ 123, 89 ], [ 108, 92 ], [ 126, 96 ], [ 101, 102 ], [ 122, 108 ], [ 110, 111 ], [ 128, 114 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ] ]	[ "import math\nimport numpy as np\nimport sys\nimport os\nfrom operator import mul\n\nsys.setrecursionlimit(107)\n\ndef _S(): return sys.stdin.readline().rstrip()\ndef I(): return int(_S())\ndef LS(): return list(_S().split())\ndef LI(): return list(map(int,LS()))\n\nif os.getenv(\"LOCAL\"):\n inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'\n sys.stdin = open(inputFile, \"r\")\nINF = float(\"inf\")\nIINF = 10 18\nMOD = 10 ** 9 + 7\n# MOD = 998244353 \n\nN,K = LI()\n\nans = K(K-1)(N-1)\nprint(ans)", "import math", "math", "import numpy as np", "numpy", "import sys", "sys", "import os", "os", "from operator import mul", "sys.setrecursionlimit(107)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "107", "10", "7", "def _S(): return sys.stdin.readline().rstrip()", "_S", "def I(): return int(_S())", "I", "def LS(): return list(_S().split())", "LS", "def LI(): return list(map(int,LS()))", "LI", "if os.getenv(\"LOCAL\"):\n inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'\n sys.stdin = open(inputFile, \"r\")", "os.getenv(\"LOCAL\")", "os.getenv", "os", "getenv", "\"LOCAL\"", "inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "inputFile", "os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "os.path.splitext(os.path.basename(__file__))[0]", "os.path.splitext(os.path.basename(__file__))", "os.path.splitext", "os.path", "os", "path", "splitext", "os.path.basename(__file__)", "os.path.basename", "os.path", "os", "path", "basename", "__file__", "0", "'.txt'", "= basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "basename_without_ext", "os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "sys.stdin = open(inputFile, \"r\")", "sys.stdin", "sys", "stdin", "open(inputFile, \"r\")", "open", "inputFile", "\"r\"", "INF = float(\"inf\")", "INF", "float(\"inf\")", "float", "\"inf\"", "IINF = 10 * 18", "IINF", "10 18", "10", "18", "MOD = 10 9 + 7", "MOD", "10 9 + 7", "10 9", "10", "9", "7", "N,K = LI()", "N", "LI()", "LI", "K", "ans = K(K-1)(N-1)", "ans", "K(K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "def LI(): return list(map(int,LS()))", "def LI(): return list(map(int,LS()))", "LI", "IINF = 10 18", "10 18", "IINF", "def LS(): return list(_S().split())", "def LS(): return list(_S().split())", "LS", "N,K = LI()", "LI()", "N", "MOD = 10 9 + 7", "10 9 + 7", "MOD", "inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "inputFile", "def _S(): return sys.stdin.readline().rstrip()", "def _S(): return sys.stdin.readline().rstrip()", "_S", "def I(): return int(_S())", "def I(): return int(_S())", "I", "K = LI()", "LI()", "K", "ans = K(K-1)(N-1)", "K(K-1)**(N-1)", "ans", "basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "basename_without_ext", "INF = float(\"inf\")", "float(\"inf\")", "INF" ]	import math import numpy as np import sys import os from operator import mul sys.setrecursionlimit(107) def _S(): return sys.stdin.readline().rstrip() def I(): return int(_S()) def LS(): return list(_S().split()) def LI(): return list(map(int,LS())) if os.getenv("LOCAL"): inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt' sys.stdin = open(inputFile, "r") INF = float("inf") IINF = 10 18 MOD = 10 ** 9 + 7 # MOD = 998244353 N,K = LI() ans = K(K-1)*(N-1) print(ans)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 33, 2 ], [ 33, 11 ], [ 27, 13 ], [ 31, 15 ], [ 31, 18 ], [ 34, 21 ], [ 28, 25 ], [ 27, 28 ], [ 33, 31 ], [ 33, 34 ] ]	[ "n, k = map(int, input().split())\n\nanswer = k((k-1)(n-1))\nprint(answer)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "answer = k((k-1)*(n-1))", "answer", "k((k-1)(n-1))", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "print(answer)", "print", "answer", "answer = k((k-1)(n-1))", "k((k-1)**(n-1))", "answer", "k = map(int, input().split())", "map(int, input().split())", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n" ]	n, k = map(int, input().split()) answer = k((k-1)*(n-1)) print(answer)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 33, 2 ], [ 33, 11 ], [ 27, 13 ], [ 34, 15 ], [ 34, 18 ], [ 31, 21 ], [ 28, 25 ], [ 27, 28 ], [ 33, 31 ], [ 33, 34 ] ]	[ "n,m=map(int,input().split())\nk=m((m-1)(n-1))\nprint(k)", "n,m=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "k=m((m-1)*(n-1))", "k", "m((m-1)(n-1))", "m", "(m-1)(n-1)", "m-1", "m", "1", "n-1", "n", "1", "print(k)", "print", "k", "k=m((m-1)(n-1))", "m((m-1)**(n-1))", "k", "n,m=map(int,input().split())", "map(int,input().split())", "n", "m=map(int,input().split())", "map(int,input().split())", "m" ]	n,m=map(int,input().split()) k=m((m-1)*(n-1)) print(k)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13 ]	[ [ 46, 2 ], [ 46, 11 ], [ 43, 13 ], [ 47, 17 ], [ 40, 20 ], [ 38, 21 ], [ 49, 23 ], [ 38, 25 ], [ 38, 28 ], [ 47, 31 ], [ 50, 35 ], [ 41, 35 ], [ 44, 35 ], [ 46, 38 ], [ 38, 40 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ] ]	[ "N, K = map(int, input().split())\nans = 0\n\nif(N == 1):\n ans = K\nelse:\n ans = K(K-1)(N-1)\n \nprint(ans)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = 0", "ans", "0", "if(N == 1):\n ans = K\nelse:\n ans = K(K-1)*(N-1)\n ", "N == 1", "N", "1", "ans = K", "ans", "K", "ans = K(K-1)*(N-1)", "ans", "K(K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "K = map(int, input().split())", "map(int, input().split())", "K", "ans = K", "K", "ans", "ans = 0", "0", "ans", "N, K = map(int, input().split())", "map(int, input().split())", "N", "ans = K(K-1)(N-1)", "K(K-1)**(N-1)", "ans" ]	N, K = map(int, input().split()) ans = 0 if(N == 1): ans = K else: ans = K(K-1)*(N-1) print(ans)
[ 7, 15, 14, 2, 13, 17, 41, 28, 13, 4, 18, 13, 13, 4, 4, 18, 13, 13, 0, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 18, 13, 17, 13, 17, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]	[ [ 9, 8 ], [ 8, 16 ], [ 51, 19 ], [ 60, 22 ], [ 52, 31 ], [ 60, 35 ], [ 57, 37 ], [ 61, 39 ], [ 61, 42 ], [ 55, 45 ], [ 58, 49 ], [ 51, 52 ], [ 60, 55 ], [ 57, 58 ], [ 60, 61 ] ]	[ "from sys import stdin\n\n\nif __name__ == \"__main__\":\n _in = [_.rstrip() for _ in stdin.readlines()]\n N, K = list(map(int,_in[0].split(' '))) # type:list(int)\n # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n cnt = K(K-1)(N-1)\n # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n print(cnt)", "from sys import stdin", "if __name__ == \"__main__\":\n _in = [_.rstrip() for _ in stdin.readlines()]\n N, K = list(map(int,_in[0].split(' '))) # type:list(int)\n # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n cnt = K(K-1)*(N-1)\n # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n print(cnt)", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "_.rstrip() for _ in stdin.readlines()", "for _ in stdin.readlines()", "_", "stdin.readlines()", "stdin.readlines", "stdin", "readlines", "for _ in stdin.readlines()", "_.rstrip()", "_.rstrip", "_", "rstrip", "_in = [_.rstrip() for _ in stdin.readlines()]", "_in", "[_.rstrip() for _ in stdin.readlines()]", "N, K = list(map(int,_in[0].split(' ')))", "N", "list(map(int,_in[0].split(' ')))", "list", "map(int,_in[0].split(' '))", "map", "int", "_in[0].split(' ')", "[0].split", "[0]", "_in", "0", "split", "' '", "K", "cnt = K(K-1)*(N-1)", "cnt", "K(K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(cnt)", "print", "cnt", "_in = [_.rstrip() for _ in stdin.readlines()]", "[_.rstrip() for _ in stdin.readlines()]", "_in", "N, K = list(map(int,_in[0].split(' ')))", "list(map(int,_in[0].split(' ')))", "N", "cnt = K(K-1)(N-1)", "K(K-1)**(N-1)", "cnt", "K = list(map(int,_in[0].split(' ')))", "list(map(int,_in[0].split(' ')))", "K" ]	from sys import stdin if __name__ == "__main__": _in = [_.rstrip() for _ in stdin.readlines()] N, K = list(map(int,_in[0].split(' '))) # type:list(int) # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv cnt = K(K-1)*(N-1) # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ print(cnt)
[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 33, 4 ], [ 33, 17 ], [ 34, 21 ], [ 34, 24 ], [ 31, 27 ], [ 33, 31 ], [ 33, 34 ] ]	[ "import sys\n\nN, K = map(int, sys.stdin.readline().split())\nprint(K * (K - 1) ** (N - 1))", "import sys", "sys", "N, K = map(int, sys.stdin.readline().split())", "N", "map(int, sys.stdin.readline().split())", "map", "int", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "K", "print(K * (K - 1) ** (N - 1))", "print", "K * (K - 1) (N - 1)", "K", "(K - 1) (N - 1)", "K - 1", "K", "1", "N - 1", "N", "1", "N, K = map(int, sys.stdin.readline().split())", "map(int, sys.stdin.readline().split())", "N", "K = map(int, sys.stdin.readline().split())", "map(int, sys.stdin.readline().split())", "K" ]	import sys N, K = map(int, sys.stdin.readline().split()) print(K * (K - 1) ** (N - 1))
[ 7, 15, 13, 15, 13, 15, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 11, 10 ], [ 11, 19 ], [ 22, 21 ], [ 25, 24 ], [ 10, 27 ], [ 24, 30 ], [ 34, 33 ], [ 19, 34 ], [ 37, 36 ], [ 19, 38 ], [ 36, 42 ], [ 33, 42 ], [ 21, 42 ], [ 51, 48 ] ]	[ "import sys\nimport math\nimport bisect\n\ndef main():\n n, k = map(int, input().split())\n ans = 1\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n print(ans)\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "import math", "math", "import bisect", "bisect", "def main():\n n, k = map(int, input().split())\n ans = 1\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n print(ans)", "main", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 1", "ans", "1", "for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n ", "i", "range(n)", "range", "n", "if i == 0:\n ans = k\n else:\n ans = k - 1\n ", "i == 0", "i", "0", "ans = k", "ans", "k", "ans = k - 1", "ans", "k - 1", "k", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n, k = map(int, input().split())\n ans = 1\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n print(ans)", "def main():\n n, k = map(int, input().split())\n ans = 1\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n print(ans)", "main" ]	import sys import math import bisect def main(): n, k = map(int, input().split()) ans = 1 for i in range(n): if i == 0: ans = k else: ans = k - 1 print(ans) if __name__ == "__main__": main()
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 33, 2 ], [ 33, 11 ], [ 27, 13 ], [ 34, 15 ], [ 34, 18 ], [ 31, 21 ], [ 28, 25 ], [ 27, 28 ], [ 33, 31 ], [ 33, 34 ] ]	[ "N,K = map(int,input().split())\n\nres = K((K-1)(N-1))\nprint(res)", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "res = K((K-1)*(N-1))", "res", "K((K-1)(N-1))", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(res)", "print", "res", "res = K((K-1)(N-1))", "K((K-1)**(N-1))", "res", "N,K = map(int,input().split())", "map(int,input().split())", "N", "K = map(int,input().split())", "map(int,input().split())", "K" ]	N,K = map(int,input().split()) res = K((K-1)*(N-1)) print(res)
[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 4, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 38, 2 ], [ 38, 13 ], [ 36, 16 ], [ 39, 26 ], [ 39, 29 ], [ 36, 32 ], [ 38, 36 ], [ 38, 39 ] ]	[ "n, k = list(map(int, input().split()))\n\nif n == 0:\n print(0)\n exit()\n\nprint(k * (k-1)*(n-1))", "n, k = list(map(int, input().split()))", "n", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "if n == 0:\n print(0)\n exit()", "n == 0", "n", "0", "print(0)", "print", "0", "exit()", "exit", "print(k (k-1)*(n-1))", "print", "k (k-1)(n-1)", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "n, k = list(map(int, input().split()))", "list(map(int, input().split()))", "n", "k = list(map(int, input().split()))", "list(map(int, input().split()))", "k" ]	n, k = list(map(int, input().split())) if n == 0: print(0) exit() print(k * (k-1)**(n-1))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 26, 2 ], [ 26, 11 ], [ 27, 14 ], [ 27, 17 ], [ 24, 20 ], [ 26, 24 ], [ 26, 27 ] ]	[ "n,k = map(int, raw_input().split())\nprint k * ((k-1) ** (n-1))", "n,k = map(int, raw_input().split())", "n", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "k", "print", "k * ((k-1) (n-1))", "k", "(k-1) (n-1)", "k-1", "k", "1", "n-1", "n", "1", "n,k = map(int, raw_input().split())", "map(int, raw_input().split())", "n", "k = map(int, raw_input().split())", "map(int, raw_input().split())", "k" ]	n,k = map(int, raw_input().split()) print k * ((k-1) ** (n-1))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 17, 4, 13, 2, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13 ]	[ [ 38, 2 ], [ 38, 11 ], [ 41, 13 ], [ 17, 16 ], [ 33, 20 ], [ 35, 22 ], [ 39, 24 ], [ 36, 29 ], [ 42, 29 ], [ 39, 30 ], [ 38, 33 ], [ 35, 36 ], [ 38, 39 ], [ 41, 42 ] ]	[ "n, k = map(int, input().split())\n\nresult = 1\nfor _ in range(1, n):\n result = k - 1\nprint(result k)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "result = 1", "result", "1", "for _ in range(1, n):\n result = k - 1", "_", "range(1, n)", "range", "1", "n", "result = k - 1", "result", "k - 1", "k", "1", "print(result * k)", "print", "result * k", "result", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n", "result *= k - 1", "k - 1", "result", "k = map(int, input().split())", "map(int, input().split())", "k", "result = 1", "1", "result" ]	n, k = map(int, input().split()) result = 1 for _ in range(1, n): result = k - 1 print(result k)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 28, 13, 4, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]	[ [ 35, 2 ], [ 35, 11 ], [ 14, 13 ], [ 33, 16 ], [ 38, 18 ], [ 36, 20 ], [ 36, 23 ], [ 33, 26 ], [ 39, 30 ], [ 35, 33 ], [ 35, 36 ], [ 38, 39 ] ]	[ "N, K = map(int, input().split())\nfor i in range(N):\n ans = K * (K-1)*(N-1)\n\nprint(ans)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "for i in range(N):\n ans = K (K-1)*(N-1)", "i", "range(N)", "range", "N", "ans = K (K-1)*(N-1)", "ans", "K (K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "N, K = map(int, input().split())", "map(int, input().split())", "N", "K = map(int, input().split())", "map(int, input().split())", "K", "ans = K * (K-1)*(N-1)", "K (K-1)**(N-1)", "ans" ]	N, K = map(int, input().split()) for i in range(N): ans = K * (K-1)**(N-1) print(ans)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 0, 13, 17, 14, 13, 28, 13, 4, 13, 13, 0, 13, 2, 2, 13, 17, 13, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13 ]	[ [ 45, 2 ], [ 45, 11 ], [ 36, 13 ], [ 40, 14 ], [ 48, 16 ], [ 22, 21 ], [ 49, 24 ], [ 46, 24 ], [ 42, 26 ], [ 40, 29 ], [ 37, 31 ], [ 43, 31 ], [ 43, 34 ], [ 37, 34 ], [ 40, 36 ], [ 36, 37 ], [ 45, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]	[ "N, K = map(int, input().split())\n\n\np = K\nN -= 1\nif N:\n for i in range(N):\n p = (K - 1) * p\nprint(p)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "p = K", "p", "K", "N -= 1", "N", "1", "if N:\n for i in range(N):\n p = (K - 1) * p", "N", "for i in range(N):\n p = (K - 1) * p", "i", "range(N)", "range", "N", "p = (K - 1) * p", "p", "(K - 1) * p", "K - 1", "K", "1", "p", "print(p)", "print", "p", "p = K", "K", "p", "K = map(int, input().split())", "map(int, input().split())", "K", "p = (K - 1) * p", "(K - 1) * p", "p", "N, K = map(int, input().split())", "map(int, input().split())", "N", "N -= 1", "1", "N" ]	N, K = map(int, input().split()) p = K N -= 1 if N: for i in range(N): p = (K - 1) * p print(p)
[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 21, 20 ], [ 18, 22 ], [ 18, 25 ], [ 16, 28 ], [ 20, 32 ], [ 41, 38 ] ]	[ "def main():\n n, k = [int(e) for e in input().split()]\n ans = k * ((k - 1)*(n - 1))\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n n, k = [int(e) for e in input().split()]\n ans = k ((k - 1)*(n - 1))\n\n print(ans)", "main", "int(e) for e in input().split()", "for e in input().split()", "e", "input().split()", "().split", "()", "input", "split", "for e in input().split()", "int(e)", "int", "e", "n, k = [int(e) for e in input().split()]", "n", "[int(e) for e in input().split()]", "k", "ans = k ((k - 1)*(n - 1))", "ans", "k ((k - 1)(n - 1))", "k", "(k - 1)(n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n, k = [int(e) for e in input().split()]\n ans = k * ((k - 1)*(n - 1))\n\n print(ans)", "def main():\n n, k = [int(e) for e in input().split()]\n ans = k ((k - 1)**(n - 1))\n\n print(ans)", "main" ]	def main(): n, k = [int(e) for e in input().split()] ans = k * ((k - 1)**(n - 1)) print(ans) if __name__ == "__main__": main()
[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 29, 2 ], [ 29, 13 ], [ 30, 17 ], [ 30, 20 ], [ 27, 23 ], [ 29, 27 ], [ 29, 30 ] ]	[ "n, k = list(map(int, input().split()))\nprint(k * ((k - 1) ** (n - 1)))", "n, k = list(map(int, input().split()))", "n", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k * ((k - 1) ** (n - 1)))", "print", "k * ((k - 1) (n - 1))", "k", "(k - 1) (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "n, k = list(map(int, input().split()))", "list(map(int, input().split()))", "n", "k = list(map(int, input().split()))", "list(map(int, input().split()))", "k" ]	n, k = list(map(int, input().split())) print(k * ((k - 1) ** (n - 1)))
[ 7, 15, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 38, 4 ], [ 38, 15 ], [ 32, 17 ], [ 39, 19 ], [ 39, 23 ], [ 36, 26 ], [ 33, 30 ], [ 32, 33 ], [ 38, 36 ], [ 38, 39 ] ]	[ "import math\nk,m=list(map(int,input().split()))\nres=mpow(m-1,k-1)\nprint(res)", "import math", "math", "k,m=list(map(int,input().split()))", "k", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "res=mpow(m-1,k-1)", "res", "mpow(m-1,k-1)", "m", "pow(m-1,k-1)", "pow", "m-1", "m", "1", "k-1", "k", "1", "print(res)", "print", "res", "res=mpow(m-1,k-1)", "m*pow(m-1,k-1)", "res", "k,m=list(map(int,input().split()))", "list(map(int,input().split()))", "k", "m=list(map(int,input().split()))", "list(map(int,input().split()))", "m" ]	import math k,m=list(map(int,input().split())) res=m*pow(m-1,k-1) print(res)
[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 17, 13, 0, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 37, 2 ], [ 37, 14 ], [ 31, 16 ], [ 38, 18 ], [ 38, 22 ], [ 35, 25 ], [ 32, 29 ], [ 31, 32 ], [ 37, 35 ], [ 37, 38 ] ]	[ "\na, b = list(map(int, input().split(' ')))\nans = b * pow(b-1, a-1)\nprint(ans)\n", "a, b = list(map(int, input().split(' ')))", "a", "list(map(int, input().split(' ')))", "list", "map(int, input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "b", "ans = b * pow(b-1, a-1)", "ans", "b * pow(b-1, a-1)", "b", "pow(b-1, a-1)", "pow", "b-1", "b", "1", "a-1", "a", "1", "print(ans)", "print", "ans", "ans = b * pow(b-1, a-1)", "b * pow(b-1, a-1)", "ans", "a, b = list(map(int, input().split(' ')))", "list(map(int, input().split(' ')))", "a", "b = list(map(int, input().split(' ')))", "list(map(int, input().split(' ')))", "b" ]	a, b = list(map(int, input().split(' '))) ans = b * pow(b-1, a-1) print(ans)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 2, 2, 13, 17, 2, 13, 17, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 27, 2 ], [ 27, 11 ], [ 28, 17 ], [ 25, 20 ], [ 28, 22 ], [ 27, 25 ], [ 27, 28 ] ]	[ "a,b=map(int,input().split())\nprint(((b-1)*(a-1))b)", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "print(((b-1)*(a-1))b)", "print", "((b-1)*(a-1))b", "(b-1)**(a-1)", "b-1", "b", "1", "a-1", "a", "1", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a", "b=map(int,input().split())", "map(int,input().split())", "b" ]	a,b=map(int,input().split()) print(((b-1)*(a-1))b)
[ 7, 12, 13, 15, 13, 0, 13, 18, 18, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 15, 15, 15, 15, 15, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 7, 6 ], [ 26, 25 ], [ 6, 32 ], [ 26, 34 ], [ 34, 38 ], [ 34, 41 ], [ 25, 44 ], [ 54, 51 ] ]	[ "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(107)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 1017\n #mod = 10*9 + 7\n\n n,k = map(int, input().split())\n print(k((k-1)(n-1)))\n\nif __name__ == '__main__':\n main()", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(107)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 1017\n #mod = 109 + 7\n\n n,k = map(int, input().split())\n print(k((k-1)(n-1)))", "main", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "sys.setrecursionlimit(107)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "107", "10", "7", "from collections import Counter, deque", "from itertools import combinations, permutations, accumulate, groupby, product", "from bisect import bisect_left,bisect_right", "from heapq import heapify, heappop, heappush", "from math import floor, ceil", "n,k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k((k-1)*(n-1)))", "print", "k((k-1)(n-1))", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(107)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 1017\n #mod = 10*9 + 7\n\n n,k = map(int, input().split())\n print(k((k-1)(n-1)))", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(107)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 1017\n #mod = 109 + 7\n\n n,k = map(int, input().split())\n print(k((k-1)*(n-1)))", "main" ]	def main(): import sys input = sys.stdin.readline sys.setrecursionlimit(107) from collections import Counter, deque #from collections import defaultdict from itertools import combinations, permutations, accumulate, groupby, product from bisect import bisect_left,bisect_right from heapq import heapify, heappop, heappush from math import floor, ceil #from operator import itemgetter #inf = 1017 #mod = 10*9 + 7 n,k = map(int, input().split()) print(k((k-1)**(n-1))) if __name__ == '__main__': main()
[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 5, 13 ], [ 4, 16 ], [ 13, 20 ], [ 13, 24 ], [ 13, 27 ], [ 4, 30 ], [ 36, 33 ] ]	[ "def resolve():\n\tn, k = map(int, input().split())\n\tif n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k((k-1)(n-1)))\nresolve()", "def resolve():\n\tn, k = map(int, input().split())\n\tif n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k((k-1)*(n-1)))", "resolve", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "if n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k((k-1)*(n-1)))", "n == 1", "n", "1", "print(k)", "print", "k", "print(k((k-1)*(n-1)))", "print", "k((k-1)(n-1))", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "resolve()", "resolve", "def resolve():\n\tn, k = map(int, input().split())\n\tif n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k((k-1)(n-1)))", "def resolve():\n\tn, k = map(int, input().split())\n\tif n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k((k-1)**(n-1)))", "resolve" ]	def resolve(): n, k = map(int, input().split()) if n == 1: print(k) else: print(k((k-1)*(n-1))) resolve()
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]	[ [ 33, 2 ], [ 33, 11 ], [ 30, 13 ], [ 28, 15 ], [ 28, 18 ], [ 34, 21 ], [ 31, 25 ], [ 33, 28 ], [ 30, 31 ], [ 33, 34 ] ]	[ "n, k = map(int, input().split())\nansw = k * (k - 1) ** (n - 1)\nprint(answ)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "answ = k * (k - 1) ** (n - 1)", "answ", "k * (k - 1) (n - 1)", "k", "(k - 1) (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "print(answ)", "print", "answ", "k = map(int, input().split())", "map(int, input().split())", "k", "answ = k * (k - 1) ** (n - 1)", "k * (k - 1) ** (n - 1)", "answ", "n, k = map(int, input().split())", "map(int, input().split())", "n" ]	n, k = map(int, input().split()) answ = k * (k - 1) ** (n - 1) print(answ)
[ 7, 15, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 29, 3 ], [ 29, 12 ], [ 27, 16 ], [ 27, 20 ], [ 30, 23 ], [ 29, 27 ], [ 29, 30 ] ]	[ "from sys import exit\n\nn,k = map(int, input().split())\nprint(kpow(k-1,n-1))", "from sys import exit", "n,k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(kpow(k-1,n-1))", "print", "k*pow(k-1,n-1)", "k", "pow(k-1,n-1)", "pow", "k-1", "k", "1", "n-1", "n", "1", "k = map(int, input().split())", "map(int, input().split())", "k", "n,k = map(int, input().split())", "map(int, input().split())", "n" ]	from sys import exit n,k = map(int, input().split()) print(k*pow(k-1,n-1))
[ 7, 0, 13, 4, 13, 0, 13, 4, 18, 13, 13, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 66, 2 ], [ 54, 6 ], [ 67, 9 ], [ 69, 12 ], [ 55, 16 ], [ 60, 19 ], [ 55, 23 ], [ 57, 26 ], [ 61, 27 ], [ 70, 31 ], [ 61, 34 ], [ 41, 40 ], [ 70, 44 ], [ 63, 46 ], [ 61, 48 ], [ 64, 52 ], [ 58, 52 ], [ 54, 55 ], [ 61, 57 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]	[ "i = input()\nj = i.split()\nnum_balls = int(j[0])\nnum_colors = int(j[1])\nproduct = num_colors\nif(num_balls > 1 and num_colors == 1):\n print(0)\nelse:\n for i in range(1, num_balls):\n product = (num_colors - 1)\n print(product)", "i = input()", "i", "input()", "input", "j = i.split()", "j", "i.split()", "i.split", "i", "split", "num_balls = int(j[0])", "num_balls", "int(j[0])", "int", "j[0]", "j", "0", "num_colors = int(j[1])", "num_colors", "int(j[1])", "int", "j[1]", "j", "1", "product = num_colors", "product", "num_colors", "if(num_balls > 1 and num_colors == 1):\n print(0)\nelse:\n for i in range(1, num_balls):\n product = (num_colors - 1)\n print(product)", "num_balls > 1 and num_colors == 1", "num_balls > 1", "num_balls", "1", "num_colors == 1", "num_colors", "1", "print(0)", "print", "0", "for i in range(1, num_balls):\n product = (num_colors - 1)\n ", "i", "range(1, num_balls)", "range", "1", "num_balls", "product = (num_colors - 1)", "product", "num_colors - 1", "num_colors", "1", "print(product)", "print", "product", "j = i.split()", "i.split()", "j", "product = num_colors", "num_colors", "product", "num_colors = int(j[1])", "int(j[1])", "num_colors", "product *= (num_colors - 1)", "num_colors - 1", "product", "i = input()", "input()", "i", "num_balls = int(j[0])", "int(j[0])", "num_balls" ]	i = input() j = i.split() num_balls = int(j[0]) num_colors = int(j[1]) product = num_colors if(num_balls > 1 and num_colors == 1): print(0) else: for i in range(1, num_balls): product *= (num_colors - 1) print(product)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 13, 13 ]	[ [ 41, 2 ], [ 41, 11 ], [ 47, 13 ], [ 17, 16 ], [ 42, 19 ], [ 16, 22 ], [ 50, 25 ], [ 39, 26 ], [ 44, 28 ], [ 48, 30 ], [ 45, 30 ], [ 51, 30 ], [ 39, 32 ], [ 45, 36 ], [ 51, 36 ], [ 48, 36 ], [ 41, 39 ], [ 41, 42 ], [ 44, 45 ], [ 47, 48 ], [ 39, 50 ], [ 50, 51 ] ]	[ "n, k = map(int, input().split())\nv = 0\nfor i in range(n):\n\tif i == 0:\n\t\tv = k\n\telse:\n\t\tv = v(k-1)\nprint(v)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "v = 0", "v", "0", "for i in range(n):\n\tif i == 0:\n\t\tv = k\n\telse:\n\t\tv = v(k-1)", "i", "range(n)", "range", "n", "if i == 0:\n\t\tv = k\n\telse:\n\t\tv = v(k-1)", "i == 0", "i", "0", "v = k", "v", "k", "v = v(k-1)", "v", "v(k-1)", "v", "k-1", "k", "1", "print(v)", "print", "v", "k = map(int, input().split())", "map(int, input().split())", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n", "v = v(k-1)", "v*(k-1)", "v", "v = 0", "0", "v", "v = k", "k", "v" ]	n, k = map(int, input().split()) v = 0 for i in range(n): if i == 0: v = k else: v = v*(k-1) print(v)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 14, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 46, 2 ], [ 46, 11 ], [ 14, 13 ], [ 47, 16 ], [ 13, 19 ], [ 37, 22 ], [ 44, 23 ], [ 13, 26 ], [ 40, 29 ], [ 44, 31 ], [ 41, 35 ], [ 38, 35 ], [ 44, 37 ], [ 37, 38 ], [ 40, 41 ], [ 46, 44 ], [ 46, 47 ] ]	[ "N,K=map(int,input().split())\nfor i in range(N):\n if i==0:\n ans=K\n if i>0:\n ans=(K-1)\nprint(ans)", "N,K=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "for i in range(N):\n if i==0:\n ans=K\n if i>0:\n ans=(K-1)", "i", "range(N)", "range", "N", "if i==0:\n ans=K\n ", "i==0", "i", "0", "ans=K", "ans", "K", "if i>0:\n ans=(K-1)", "i>0", "i", "0", "ans=(K-1)", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "ans=K", "K", "ans", "ans*=(K-1)", "K-1", "ans", "K=map(int,input().split())", "map(int,input().split())", "K", "N,K=map(int,input().split())", "map(int,input().split())", "N" ]	N,K=map(int,input().split()) for i in range(N): if i==0: ans=K if i>0: ans*=(K-1) print(ans)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]	[ [ 44, 2 ], [ 44, 11 ], [ 42, 14 ], [ 45, 18 ], [ 47, 20 ], [ 45, 21 ], [ 24, 23 ], [ 42, 27 ], [ 38, 30 ], [ 45, 32 ], [ 39, 36 ], [ 48, 36 ], [ 38, 39 ], [ 44, 42 ], [ 44, 45 ], [ 45, 47 ], [ 47, 48 ] ]	[ "n,k=map(int,input().split())\nif n==1:\n print(k)\nelse:\n sum=k\n for i in range(n-1):\n sum=k-1\n print(sum)", "n,k=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "if n==1:\n print(k)\nelse:\n sum=k\n for i in range(n-1):\n sum=k-1\n print(sum)", "n==1", "n", "1", "print(k)", "print", "k", "sum=k", "sum", "k", "for i in range(n-1):\n sum=k-1\n ", "i", "range(n-1)", "range", "n-1", "n", "1", "sum=k-1", "sum", "k-1", "k", "1", "print(sum)", "print", "sum", "sum*=k-1", "k-1", "sum", "n,k=map(int,input().split())", "map(int,input().split())", "n", "k=map(int,input().split())", "map(int,input().split())", "k", "sum=k", "k", "sum" ]	n,k=map(int,input().split()) if n==1: print(k) else: sum=k for i in range(n-1): sum*=k-1 print(sum)
[ 7, 0, 13, 4, 18, 4, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 4, 13, 18, 13, 17, 14, 2, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 2, 13, 2, 4, 13, 18, 13, 17, 17, 4, 13, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 53, 2 ], [ 47, 10 ], [ 14, 13 ], [ 54, 19 ], [ 13, 23 ], [ 56, 26 ], [ 54, 30 ], [ 50, 33 ], [ 48, 35 ], [ 51, 35 ], [ 57, 35 ], [ 54, 40 ], [ 51, 45 ], [ 57, 45 ], [ 48, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ] ]	[ "a=input().split(\" \")\npart=0\n \nfor i in range(int(a[0])):\n\tif i==0:\n\t\tpart=int(a[1])\n\telse:\n\t\tpart=part(int(a[1])-1)\n \nprint(part)\n", "a=input().split(\" \")", "a", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "part=0", "part", "0", "for i in range(int(a[0])):\n\tif i==0:\n\t\tpart=int(a[1])\n\telse:\n\t\tpart=part(int(a[1])-1)\n ", "i", "range(int(a[0]))", "range", "int(a[0])", "int", "a[0]", "a", "0", "if i==0:\n\t\tpart=int(a[1])\n\telse:\n\t\tpart=part(int(a[1])-1)\n ", "i==0", "i", "0", "part=int(a[1])", "part", "int(a[1])", "int", "a[1]", "a", "1", "part=part(int(a[1])-1)", "part", "part(int(a[1])-1)", "part", "int(a[1])-1", "int(a[1])", "int", "a[1]", "a", "1", "1", "print(part)", "print", "part", "part=0", "0", "part", "part=part(int(a[1])-1)", "part*(int(a[1])-1)", "part", "a=input().split(\" \")", "input().split(\" \")", "a", "part=int(a[1])", "int(a[1])", "part" ]	a=input().split(" ") part=0 for i in range(int(a[0])): if i==0: part=int(a[1]) else: part=part*(int(a[1])-1) print(part)
[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 13, 13, 10, 13, 13 ]	[ [ 4, 3 ], [ 3, 12 ], [ 32, 14 ], [ 32, 16 ], [ 33, 20 ], [ 33, 23 ], [ 30, 26 ], [ 32, 30 ], [ 32, 33 ] ]	[ "N, K = [int(x) for x in input().split()]\nprint(K(K-1)(N-1))", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "N, K = [int(x) for x in input().split()]", "N", "[int(x) for x in input().split()]", "K", "print(K(K-1)*(N-1))", "print", "K(K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "N, K = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "N", "K = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "K" ]	N, K = [int(x) for x in input().split()] print(K(K-1)*(N-1))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13 ]	[ [ 48, 2 ], [ 48, 11 ], [ 39, 13 ], [ 17, 16 ], [ 43, 21 ], [ 16, 25 ], [ 51, 28 ], [ 49, 29 ], [ 45, 31 ], [ 49, 33 ], [ 46, 37 ], [ 52, 37 ], [ 40, 37 ], [ 39, 40 ], [ 48, 43 ], [ 45, 46 ], [ 48, 49 ], [ 49, 51 ], [ 51, 52 ] ]	[ "balls, colors = map(int,input().split())\n\nans = 1\n\nfor i in range(1,balls+1):\n if i == 1:\n ans = colors\n else:\n ans = colors - 1\n\nprint(ans)", "balls, colors = map(int,input().split())", "balls", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "colors", "ans = 1", "ans", "1", "for i in range(1,balls+1):\n if i == 1:\n ans = colors\n else:\n ans = colors - 1", "i", "range(1,balls+1)", "range", "1", "balls+1", "balls", "1", "if i == 1:\n ans = colors\n else:\n ans = colors - 1", "i == 1", "i", "1", "ans = colors", "ans", "colors", "ans = colors - 1", "ans", "colors - 1", "colors", "1", "print(ans)", "print", "ans", "ans = 1", "1", "ans", "balls, colors = map(int,input().split())", "map(int,input().split())", "balls", "ans = colors - 1", "colors - 1", "ans", "colors = map(int,input().split())", "map(int,input().split())", "colors", "ans = colors", "colors", "ans" ]	balls, colors = map(int,input().split()) ans = 1 for i in range(1,balls+1): if i == 1: ans = colors else: ans = colors - 1 print(ans)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 17, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 28, 2 ], [ 28, 12 ], [ 29, 16 ], [ 29, 19 ], [ 26, 22 ], [ 28, 26 ], [ 28, 29 ] ]	[ "N, K = map(int,input().split(' '))\nprint(K(K-1)(N-1))", "N, K = map(int,input().split(' '))", "N", "map(int,input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "K", "print(K(K-1)*(N-1))", "print", "K(K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "N, K = map(int,input().split(' '))", "map(int,input().split(' '))", "N", "K = map(int,input().split(' '))", "map(int,input().split(' '))", "K" ]	N, K = map(int,input().split(' ')) print(K(K-1)*(N-1))
[ 7, 0, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 0, 13, 13, 4, 13, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13 ]	[ [ 55, 2 ], [ 52, 9 ], [ 56, 13 ], [ 46, 16 ], [ 56, 20 ], [ 49, 23 ], [ 27, 26 ], [ 53, 30 ], [ 58, 33 ], [ 47, 35 ], [ 61, 38 ], [ 47, 39 ], [ 62, 44 ], [ 59, 44 ], [ 50, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 47, 61 ], [ 61, 62 ] ]	[ "s = input().split()\n\n# ボールの数n\nn = int(s[0])\n\n# 色の種類k\nk = int(s[1])\n\nanswer = 1\n\nfor num in range(n - 1):\n answer = k - 1\n\nanswer = k\n\nprint(int(answer))\n\n", "s = input().split()", "s", "input().split()", "().split", "()", "input", "split", "n = int(s[0])", "n", "int(s[0])", "int", "s[0]", "s", "0", "k = int(s[1])", "k", "int(s[1])", "int", "s[1]", "s", "1", "answer = 1", "answer", "1", "for num in range(n - 1):\n answer = k - 1", "num", "range(n - 1)", "range", "n - 1", "n", "1", "answer = k - 1", "answer", "k - 1", "k", "1", "answer = k", "answer", "k", "print(int(answer))", "print", "int(answer)", "int", "answer", "k = int(s[1])", "int(s[1])", "k", "answer = 1", "1", "answer", "n = int(s[0])", "int(s[0])", "n", "s = input().split()", "input().split()", "s", "answer = k - 1", "k - 1", "answer", "answer *= k", "k", "answer" ]	s = input().split() # ボールの数n n = int(s[0]) # 色の種類k k = int(s[1]) answer = 1 for num in range(n - 1): answer = k - 1 answer = k print(int(answer))
[ 7, 15, 13, 12, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]	[ [ 9, 8 ], [ 41, 15 ], [ 9, 17 ], [ 17, 21 ], [ 17, 25 ], [ 8, 28 ], [ 38, 35 ] ]	[ "import sys\ndef input(): return sys.stdin.readline().strip()\n\ndef main():\n n, k = map(int, input().split())\n print(k * pow(k - 1, n - 1))\n\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "def main():\n n, k = map(int, input().split())\n print(k * pow(k - 1, n - 1))", "main", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k * pow(k - 1, n - 1))", "print", "k * pow(k - 1, n - 1)", "k", "pow(k - 1, n - 1)", "pow", "k - 1", "k", "1", "n - 1", "n", "1", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n, k = map(int, input().split())\n print(k * pow(k - 1, n - 1))", "def main():\n n, k = map(int, input().split())\n print(k * pow(k - 1, n - 1))", "main", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input" ]	import sys def input(): return sys.stdin.readline().strip() def main(): n, k = map(int, input().split()) print(k * pow(k - 1, n - 1)) if __name__ == "__main__": main()
[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 29, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 13, 17 ], [ 13, 20 ], [ 4, 23 ], [ 15, 27 ], [ 37, 34 ] ]	[ "def resolve():\n n, k = map(int, input().split())\n ans = k * ((k-1) ** (n-1))\n print(ans)\n return\n\nif __name__ == \"__main__\":\n resolve()", "def resolve():\n n, k = map(int, input().split())\n ans = k * ((k-1) ** (n-1))\n print(ans)\n return", "resolve", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k * ((k-1) ** (n-1))", "ans", "k * ((k-1) (n-1))", "k", "(k-1) (n-1)", "k-1", "k", "1", "n-1", "n", "1", "print(ans)", "print", "ans", "return", "if __name__ == \"__main__\":\n resolve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "resolve()", "resolve", "def resolve():\n n, k = map(int, input().split())\n ans = k * ((k-1) ** (n-1))\n print(ans)\n return", "def resolve():\n n, k = map(int, input().split())\n ans = k * ((k-1) ** (n-1))\n print(ans)\n return", "resolve" ]	def resolve(): n, k = map(int, input().split()) ans = k * ((k-1) ** (n-1)) print(ans) return if __name__ == "__main__": resolve()
[ 7, 15, 13, 15, 4, 18, 13, 13, 2, 17, 17, 0, 13, 12, 4, 18, 4, 18, 18, 13, 13, 13, 13, 0, 13, 4, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 51, 12 ], [ 54, 24 ], [ 60, 29 ], [ 52, 36 ], [ 60, 38 ], [ 58, 42 ], [ 58, 45 ], [ 61, 48 ], [ 51, 52 ], [ 54, 55 ], [ 60, 58 ], [ 60, 61 ] ]	[ "import sys\nfrom math import factorial\nsys.setrecursionlimit(10*6)\ninput = lambda: sys.stdin.readline().rstrip()\ninf = float(\"inf\") # 無限\n\nn,k = map(int,input().split())\n\nprint(k((k-1)(n-1)))", "import sys", "sys", "from math import factorial", "sys.setrecursionlimit(106)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10*6", "10", "6", "input = lambda: sys.stdin.readline().rstrip()", "input", "lambda: sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "inf = float(\"inf\")", "inf", "float(\"inf\")", "float", "\"inf\"", "n,k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k((k-1)*(n-1)))", "print", "k((k-1)(n-1))", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "input = lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "input", "inf = float(\"inf\")", "float(\"inf\")", "inf", "k = map(int,input().split())", "map(int,input().split())", "k", "n,k = map(int,input().split())", "map(int,input().split())", "n" ]	import sys from math import factorial sys.setrecursionlimit(10*6) input = lambda: sys.stdin.readline().rstrip() inf = float("inf") # 無限 n,k = map(int,input().split()) print(k((k-1)**(n-1)))
[ 7, 15, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 12, 2, 4, 13, 13, 17, 23, 0, 13, 12, 4, 13, 31, 13, 0, 13, 17, 23, 12, 13, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 12, 13, 12, 13, 0, 13, 4, 13, 13, 4, 13, 2, 4, 13, 2, 13, 17, 2, 13, 17, 13, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]	[ [ 91, 11 ], [ 73, 20 ], [ 28, 27 ], [ 39, 38 ], [ 95, 44 ], [ 48, 48 ], [ 55, 54 ], [ 80, 56 ], [ 55, 57 ], [ 57, 64 ], [ 54, 67 ], [ 57, 69 ], [ 89, 71 ], [ 73, 74 ], [ 91, 92 ] ]	[ "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\ndef SI(): return sys.stdin.readline()[:-1]\n\ndef main():\n n,k=MI()\n print(pow(k-1,n-1)k)\n\nmain()", "import sys", "sys", "sys.setrecursionlimit(10 6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 6", "10", "6", "int1 = lambda x: int(x) - 1", "int1", "lambda x: int(x) - 1", "int(x) - 1", "int(x)", "int", "x", "1", "x", "p2D = lambda x: print(x, sep=\"\\n\")", "p2D", "lambda x: print(x, sep=\"\\n\")", "print(x, sep=\"\\n\")", "print", "x", "x", "sep=\"\\n\"", "sep", "\"\\n\"", "x", "def II(): return int(sys.stdin.readline())", "II", "def MI(): return map(int, sys.stdin.readline().split())", "MI", "def LI(): return list(map(int, sys.stdin.readline().split()))", "LI", "LI() for _ in range(rows_number)", "for _ in range(rows_number)", "_", "range(rows_number)", "range", "rows_number", "for _ in range(rows_number)", "LI()", "LI", "def LLI(rows_number): return [LI() for _ in range(rows_number)]", "LLI", "rows_number", "rows_number", "def SI(): return sys.stdin.readline()[:-1]", "SI", "def main():\n n,k=MI()\n print(pow(k-1,n-1)k)", "main", "n,k=MI()", "n", "MI()", "MI", "k", "print(pow(k-1,n-1)k)", "print", "pow(k-1,n-1)k", "pow(k-1,n-1)", "pow", "k-1", "k", "1", "n-1", "n", "1", "k", "main()", "main", "p2D = lambda x: print(x, sep=\"\\n\")", "lambda x: print(x, sep=\"\\n\")", "p2D", "def II(): return int(sys.stdin.readline())", "def II(): return int(sys.stdin.readline())", "II", "def MI(): return map(int, sys.stdin.readline().split())", "def MI(): return map(int, sys.stdin.readline().split())", "MI", "def LLI(rows_number): return [LI() for _ in range(rows_number)]", "def LLI(rows_number): return [LI() for _ in range(rows_number)]", "LLI", "def SI(): return sys.stdin.readline()[:-1]", "def SI(): return sys.stdin.readline()[:-1]", "SI", "def main():\n n,k=MI()\n print(pow(k-1,n-1)k)", "def main():\n n,k=MI()\n print(pow(k-1,n-1)*k)", "main", "int1 = lambda x: int(x) - 1", "lambda x: int(x) - 1", "int1", "def LI(): return list(map(int, sys.stdin.readline().split()))", "def LI(): return list(map(int, sys.stdin.readline().split()))", "LI" ]	import sys sys.setrecursionlimit(10 ** 6) 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(): n,k=MI() print(pow(k-1,n-1)k) main()
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 27, 2 ], [ 27, 11 ], [ 25, 15 ], [ 25, 18 ], [ 28, 21 ], [ 27, 25 ], [ 27, 28 ] ]	[ "n,k=map(int,input().split())\nprint(k(k-1)(n-1))", "n,k=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k(k-1)*(n-1))", "print", "k(k-1)(n-1)", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "k=map(int,input().split())", "map(int,input().split())", "k", "n,k=map(int,input().split())", "map(int,input().split())", "n" ]	n,k=map(int,input().split()) print(k(k-1)*(n-1))
[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 13, 17, 17, 0, 13, 2, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 13, 16 ], [ 19, 18 ], [ 4, 22 ], [ 13, 27 ], [ 32, 31 ], [ 15, 33 ], [ 31, 33 ], [ 13, 35 ], [ 31, 39 ], [ 15, 39 ], [ 48, 45 ] ]	[ "def main():\n N,K= map(int, input().split())\n sum = K\n for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n print(sum)\n\n\n \nif __name__ == '__main__':\n main()", "def main():\n N,K= map(int, input().split())\n sum = K\n for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n print(sum)\n\n\n ", "main", "N,K= map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "sum = K", "sum", "K", "for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if K-1 !=0:\n sum = sum * (K-1)\n\n ", "K-1 !=0", "K-1", "K", "1", "0", "sum = sum * (K-1)", "sum", "sum * (K-1)", "sum", "K-1", "K", "1", "print(sum)", "print", "sum", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N,K= map(int, input().split())\n sum = K\n for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n print(sum)\n\n\n ", "def main():\n N,K= map(int, input().split())\n sum = K\n for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n print(sum)\n\n\n ", "main" ]	def main(): N,K= map(int, input().split()) sum = K for i in range(N-1): if K-1 !=0: sum = sum * (K-1) print(sum) if __name__ == '__main__': main()
[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 18, 22 ], [ 18, 25 ], [ 16, 28 ], [ 38, 35 ] ]	[ "def solve():\n N, K = [int(i) for i in input().split()]\n print(K * (K - 1) ** (N - 1))\n\nif __name__ == \"__main__\":\n solve()", "def solve():\n N, K = [int(i) for i in input().split()]\n print(K * (K - 1) ** (N - 1))", "solve", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "N, K = [int(i) for i in input().split()]", "N", "[int(i) for i in input().split()]", "K", "print(K * (K - 1) ** (N - 1))", "print", "K * (K - 1) (N - 1)", "K", "(K - 1) (N - 1)", "K - 1", "K", "1", "N - 1", "N", "1", "if __name__ == \"__main__\":\n solve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "solve()", "solve", "def solve():\n N, K = [int(i) for i in input().split()]\n print(K * (K - 1) ** (N - 1))", "def solve():\n N, K = [int(i) for i in input().split()]\n print(K * (K - 1) ** (N - 1))", "solve" ]	def solve(): N, K = [int(i) for i in input().split()] print(K * (K - 1) ** (N - 1)) if __name__ == "__main__": solve()
[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 12, 13 ]	[ [ 44, 4 ], [ 14, 13 ], [ 45, 20 ], [ 14, 22 ], [ 25, 24 ], [ 22, 26 ], [ 22, 29 ], [ 13, 32 ], [ 24, 36 ], [ 48, 42 ], [ 44, 45 ] ]	[ "import sys\n\ninput = sys.stdin.readline\n\n\ndef main():\n N, K = map(int, input().split())\n ans = K * (K - 1)*(N - 1)\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def main():\n N, K = map(int, input().split())\n ans = K (K - 1)*(N - 1)\n print(ans)", "main", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = K (K - 1)*(N - 1)", "ans", "K (K - 1)(N - 1)", "K", "(K - 1)(N - 1)", "K - 1", "K", "1", "N - 1", "N", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def main():\n N, K = map(int, input().split())\n ans = K * (K - 1)*(N - 1)\n print(ans)", "def main():\n N, K = map(int, input().split())\n ans = K (K - 1)**(N - 1)\n print(ans)", "main" ]	import sys input = sys.stdin.readline def main(): N, K = map(int, input().split()) ans = K * (K - 1)**(N - 1) print(ans) if __name__ == "__main__": main()
[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 13, 4, 18, 13, 13, 0, 13, 13, 0, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 18, 13, 10, 12, 13 ]	[ [ 64, 4 ], [ 67, 11 ], [ 21, 20 ], [ 21, 29 ], [ 20, 32 ], [ 29, 36 ], [ 43, 42 ], [ 29, 43 ], [ 46, 45 ], [ 29, 49 ], [ 20, 52 ], [ 45, 56 ], [ 42, 56 ], [ 71, 62 ], [ 64, 65 ], [ 67, 68 ] ]	[ "import sys\nread = sys.stdin.read\nreadlines = sys.stdin.readlines\ndef main():\n n, k = map(int, input().split())\n if n == 1:\n print(k)\n sys.exit()\n r = k\n r = pow(k - 1, n - 1)\n print(r)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "read = sys.stdin.read", "read", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "readlines = sys.stdin.readlines", "readlines", "sys.stdin.readlines", "sys.stdin", "sys", "stdin", "readlines", "def main():\n n, k = map(int, input().split())\n if n == 1:\n print(k)\n sys.exit()\n r = k\n r = pow(k - 1, n - 1)\n print(r)", "main", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "if n == 1:\n print(k)\n sys.exit()\n ", "n == 1", "n", "1", "print(k)", "print", "k", "sys.exit()", "sys.exit", "sys", "exit", "r = k", "r", "k", "r = pow(k - 1, n - 1)", "r", "pow(k - 1, n - 1)", "pow", "k - 1", "k", "1", "n - 1", "n", "1", "print(r)", "print", "r", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "read = sys.stdin.read", "sys.stdin.read", "read", "readlines = sys.stdin.readlines", "sys.stdin.readlines", "readlines", "def main():\n n, k = map(int, input().split())\n if n == 1:\n print(k)\n sys.exit()\n r = k\n r = pow(k - 1, n - 1)\n print(r)", "def main():\n n, k = map(int, input().split())\n if n == 1:\n print(k)\n sys.exit()\n r = k\n r *= pow(k - 1, n - 1)\n print(r)", "main" ]	import sys read = sys.stdin.read readlines = sys.stdin.readlines def main(): n, k = map(int, input().split()) if n == 1: print(k) sys.exit() r = k r *= pow(k - 1, n - 1) print(r) if __name__ == '__main__': main()
[ 7, 15, 13, 15, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 29, 39, 13, 13, 0, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 12, 13, 10, 4, 13 ]	[ [ 9, 8 ], [ 9, 17 ], [ 52, 23 ], [ 50, 25 ], [ 52, 26 ], [ 47, 29 ], [ 53, 33 ], [ 47, 37 ], [ 47, 40 ], [ 53, 43 ], [ 52, 47 ], [ 52, 53 ] ]	[ "import re\nimport copy\n\ndef accept_input():\n N,K = map(int,input().split())\n return N,K\n\nN,K = accept_input()\n\n\nif K == 1:\n print(N)\nelse:\n print(K((K-1)(N-1)))", "import re", "re", "import copy", "copy", "def accept_input():\n N,K = map(int,input().split())\n return N,K", "accept_input", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "return N,K", "return N,K", "N", "K", "N,K = accept_input()", "N", "accept_input()", "accept_input", "K", "if K == 1:\n print(N)\nelse:\n print(K((K-1)*(N-1)))", "K == 1", "K", "1", "print(N)", "print", "N", "print(K((K-1)*(N-1)))", "print", "K((K-1)(N-1))", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "K = accept_input()", "accept_input()", "K", "def accept_input():\n N,K = map(int,input().split())\n return N,K", "def accept_input():\n N,K = map(int,input().split())\n return N,K", "accept_input", "N,K = accept_input()", "accept_input()", "N" ]	import re import copy def accept_input(): N,K = map(int,input().split()) return N,K N,K = accept_input() if K == 1: print(N) else: print(K((K-1)*(N-1)))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]	[ [ 45, 2 ], [ 45, 11 ], [ 39, 13 ], [ 17, 16 ], [ 43, 19 ], [ 16, 22 ], [ 36, 25 ], [ 46, 26 ], [ 48, 28 ], [ 46, 30 ], [ 49, 34 ], [ 37, 34 ], [ 40, 34 ], [ 46, 36 ], [ 36, 37 ], [ 39, 40 ], [ 45, 43 ], [ 45, 46 ], [ 48, 49 ] ]	[ "n, k = map(int, input().split())\ncnt = 1\nfor i in range(n):\n if i == 0:\n cnt = k\n else:\n cnt = (k-1)\nprint(cnt)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "cnt = 1", "cnt", "1", "for i in range(n):\n if i == 0:\n cnt = k\n else:\n cnt = (k-1)", "i", "range(n)", "range", "n", "if i == 0:\n cnt = k\n else:\n cnt = (k-1)", "i == 0", "i", "0", "cnt = k", "cnt", "k", "cnt = (k-1)", "cnt", "k-1", "k", "1", "print(cnt)", "print", "cnt", "cnt = k", "k", "cnt", "cnt = 1", "1", "cnt", "n, k = map(int, input().split())", "map(int, input().split())", "n", "k = map(int, input().split())", "map(int, input().split())", "k", "cnt = (k-1)", "k-1", "cnt" ]	n, k = map(int, input().split()) cnt = 1 for i in range(n): if i == 0: cnt = k else: cnt = (k-1) print(cnt)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 14, 2, 13, 17, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 47, 2 ], [ 47, 11 ], [ 38, 13 ], [ 45, 14 ], [ 48, 17 ], [ 39, 21 ], [ 24, 23 ], [ 48, 27 ], [ 41, 30 ], [ 45, 32 ], [ 42, 36 ], [ 39, 36 ], [ 45, 38 ], [ 38, 39 ], [ 41, 42 ], [ 47, 45 ], [ 47, 48 ] ]	[ "N, K = map(int, input().split())\nans = K\n\nif N == 1:\n print(ans)\n \nelse:\n for i in range(N-1):\n ans = K-1\n \n print(ans)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = K", "ans", "K", "if N == 1:\n print(ans)\n \nelse:\n for i in range(N-1):\n ans = K-1\n \n print(ans)", "N == 1", "N", "1", "print(ans)", "print", "ans", "for i in range(N-1):\n ans = K-1\n \n ", "i", "range(N-1)", "range", "N-1", "N", "1", "ans = K-1", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "ans = K", "K", "ans", "ans *= K-1", "K-1", "ans", "K = map(int, input().split())", "map(int, input().split())", "K", "N, K = map(int, input().split())", "map(int, input().split())", "N" ]	N, K = map(int, input().split()) ans = K if N == 1: print(ans) else: for i in range(N-1): ans *= K-1 print(ans)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]	[ [ 33, 2 ], [ 33, 11 ], [ 30, 13 ], [ 28, 15 ], [ 28, 18 ], [ 34, 21 ], [ 31, 25 ], [ 33, 28 ], [ 30, 31 ], [ 33, 34 ] ]	[ "N, K = map(int,input().split())\n\nans = K * ((K-1)*(N-1))\nprint(ans)", "N, K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = K ((K-1)*(N-1))", "ans", "K ((K-1)(N-1))", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "K = map(int,input().split())", "map(int,input().split())", "K", "ans = K * ((K-1)*(N-1))", "K ((K-1)**(N-1))", "ans", "N, K = map(int,input().split())", "map(int,input().split())", "N" ]	N, K = map(int,input().split()) ans = K * ((K-1)**(N-1)) print(ans)
[ 7, 12, 13, 29, 2, 13, 2, 2, 13, 17, 2, 13, 17, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]	[ [ 16, 5 ], [ 16, 8 ], [ 14, 11 ], [ 14, 14 ], [ 16, 16 ], [ 21, 20 ], [ 21, 29 ], [ 47, 33 ], [ 20, 34 ], [ 29, 35 ], [ 44, 41 ] ]	[ "def answer(n: int, k: int) -> int:\n return k * (k - 1) ** (n - 1)\n\n\ndef main():\n n, k = map(int, input().split())\n print(answer(n, k))\n\n\nif __name__ == '__main__':\n main()", "def answer(n: int, k: int) -> int:\n return k * (k - 1) ** (n - 1)", "answer", "return k * (k - 1) ** (n - 1)", "k * (k - 1) (n - 1)", "k", "(k - 1) (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "n: int", "n", "k: int", "k", "def main():\n n, k = map(int, input().split())\n print(answer(n, k))", "main", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(answer(n, k))", "print", "answer(n, k)", "answer", "n", "k", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n n, k = map(int, input().split())\n print(answer(n, k))", "def main():\n n, k = map(int, input().split())\n print(answer(n, k))", "main", "def answer(n: int, k: int) -> int:\n return k * (k - 1) ** (n - 1)", "def answer(n: int, k: int) -> int:\n return k * (k - 1) ** (n - 1)", "answer" ]	def answer(n: int, k: int) -> int: return k * (k - 1) ** (n - 1) def main(): n, k = map(int, input().split()) print(answer(n, k)) if __name__ == '__main__': main()
[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13 ]	[ [ 4, 3 ], [ 3, 12 ], [ 38, 14 ], [ 38, 16 ], [ 32, 18 ], [ 39, 20 ], [ 39, 23 ], [ 36, 26 ], [ 33, 30 ], [ 32, 33 ], [ 38, 36 ], [ 38, 39 ] ]	[ "n,k = [int(x) for x in input().split()]\n\nans = k * (k - 1)*(n - 1)\nprint(ans)", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "n,k = [int(x) for x in input().split()]", "n", "[int(x) for x in input().split()]", "k", "ans = k (k - 1)*(n - 1)", "ans", "k (k - 1)(n - 1)", "k", "(k - 1)(n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "print(ans)", "print", "ans", "ans = k * (k - 1)*(n - 1)", "k (k - 1)**(n - 1)", "ans", "n,k = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "n", "k = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "k" ]	n,k = [int(x) for x in input().split()] ans = k * (k - 1)**(n - 1) print(ans)
[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 29, 4 ], [ 29, 13 ], [ 30, 17 ], [ 30, 20 ], [ 27, 23 ], [ 29, 27 ], [ 29, 30 ] ]	[ "import math \nN,K = map(int,input().split())\nprint(K(K-1)(N-1))", "import math", "math", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "print(K(K-1)*(N-1))", "print", "K(K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "N,K = map(int,input().split())", "map(int,input().split())", "N", "K = map(int,input().split())", "map(int,input().split())", "K" ]	import math N,K = map(int,input().split()) print(K(K-1)*(N-1))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 9, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13 ]	[ [ 49, 2 ], [ 49, 11 ], [ 46, 13 ], [ 17, 16 ], [ 38, 19 ], [ 16, 22 ], [ 43, 25 ], [ 50, 26 ], [ 40, 29 ], [ 50, 31 ], [ 41, 35 ], [ 44, 35 ], [ 47, 35 ], [ 49, 38 ], [ 40, 41 ], [ 50, 43 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ] ]	[ "n,k = map(int,input().split())\nans = 1\nfor i in range(n):\n if i == 0:\n ans = k\n continue\n ans = (k - 1)\nprint(ans)", "n,k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 1", "ans", "1", "for i in range(n):\n if i == 0:\n ans = k\n continue\n ans = (k - 1)", "i", "range(n)", "range", "n", "if i == 0:\n ans = k\n continue\n ", "i == 0", "i", "0", "ans = k", "ans", "k", "continue", "ans = (k - 1)", "ans", "k - 1", "k", "1", "print(ans)", "print", "ans", "n,k = map(int,input().split())", "map(int,input().split())", "n", "ans = (k - 1)", "k - 1", "ans", "ans *= k", "k", "ans", "ans = 1", "1", "ans", "k = map(int,input().split())", "map(int,input().split())", "k" ]	n,k = map(int,input().split()) ans = 1 for i in range(n): if i == 0: ans = k continue ans = (k - 1) print(ans)
[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 19, 18 ], [ 4, 21 ], [ 18, 24 ], [ 28, 27 ], [ 13, 28 ], [ 31, 30 ], [ 13, 32 ], [ 30, 36 ], [ 27, 36 ], [ 15, 36 ], [ 45, 42 ] ]	[ "def resolve():\n n, k = map(int, input().split())\n ans = 0\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n print(ans)\n\nif __name__ == '__main__':\n resolve()", "def resolve():\n n, k = map(int, input().split())\n ans = 0\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n print(ans)", "resolve", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 0", "ans", "0", "for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n ", "i", "range(n)", "range", "n", "if i == 0:\n ans = k\n else:\n ans = k - 1\n ", "i == 0", "i", "0", "ans = k", "ans", "k", "ans = k - 1", "ans", "k - 1", "k", "1", "print(ans)", "print", "ans", "if __name__ == '__main__':\n resolve()", "__name__ == '__main__'", "__name__", "'__main__'", "resolve()", "resolve", "def resolve():\n n, k = map(int, input().split())\n ans = 0\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n print(ans)", "def resolve():\n n, k = map(int, input().split())\n ans = 0\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans *= k - 1\n print(ans)", "resolve" ]	def resolve(): n, k = map(int, input().split()) ans = 0 for i in range(n): if i == 0: ans = k else: ans *= k - 1 print(ans) if __name__ == '__main__': resolve()
[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 4, 18 ], [ 15, 21 ], [ 25, 24 ], [ 13, 25 ], [ 28, 27 ], [ 13, 29 ], [ 27, 33 ], [ 24, 33 ], [ 42, 39 ] ]	[ "# B - AtCoDeerくんとボール色塗り\ndef main():\n n, k = map(int,input().split())\n\n for i in range(n):\n if i == 0:\n val = k\n else:\n val = (k-1)\n else:\n print(val)\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n n, k = map(int,input().split())\n\n for i in range(n):\n if i == 0:\n val = k\n else:\n val = (k-1)\n else:\n print(val)", "main", "n, k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "for i in range(n):\n if i == 0:\n val = k\n else:\n val = (k-1)\n else:\n print(val)", "i", "range(n)", "range", "n", "if i == 0:\n val = k\n else:\n val = (k-1)\n ", "i == 0", "i", "0", "val = k", "val", "k", "val = (k-1)", "val", "k-1", "k", "1", "print(val)", "print", "val", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n, k = map(int,input().split())\n\n for i in range(n):\n if i == 0:\n val = k\n else:\n val = (k-1)\n else:\n print(val)", "def main():\n n, k = map(int,input().split())\n\n for i in range(n):\n if i == 0:\n val = k\n else:\n val *= (k-1)\n else:\n print(val)", "main" ]	# B - AtCoDeerくんとボール色塗り def main(): n, k = map(int,input().split()) for i in range(n): if i == 0: val = k else: val *= (k-1) else: print(val) if __name__ == "__main__": main()
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]	[ [ 45, 2 ], [ 45, 11 ], [ 48, 13 ], [ 17, 16 ], [ 43, 19 ], [ 16, 22 ], [ 39, 25 ], [ 46, 26 ], [ 36, 28 ], [ 46, 30 ], [ 37, 34 ], [ 40, 34 ], [ 49, 34 ], [ 36, 37 ], [ 46, 39 ], [ 39, 40 ], [ 45, 43 ], [ 45, 46 ], [ 48, 49 ] ]	[ "N, K = map(int, input().split())\n\nres = 1\n\nfor i in range(N):\n if i == 0:\n res = K\n else:\n res = (K-1)\n\nprint(res)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "res = 1", "res", "1", "for i in range(N):\n if i == 0:\n res = K\n else:\n res = (K-1)", "i", "range(N)", "range", "N", "if i == 0:\n res = K\n else:\n res = (K-1)", "i == 0", "i", "0", "res = K", "res", "K", "res = (K-1)", "res", "K-1", "K", "1", "print(res)", "print", "res", "res = (K-1)", "K-1", "res", "res = K", "K", "res", "N, K = map(int, input().split())", "map(int, input().split())", "N", "K = map(int, input().split())", "map(int, input().split())", "K", "res = 1", "1", "res" ]	N, K = map(int, input().split()) res = 1 for i in range(N): if i == 0: res = K else: res = (K-1) print(res)
[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 14, 13, 0, 13, 13, 0, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13 ]	[ [ 54, 4 ], [ 54, 13 ], [ 48, 15 ], [ 57, 18 ], [ 22, 21 ], [ 43, 24 ], [ 60, 28 ], [ 55, 29 ], [ 51, 31 ], [ 45, 34 ], [ 55, 36 ], [ 46, 40 ], [ 61, 40 ], [ 49, 40 ], [ 54, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ], [ 55, 60 ], [ 60, 61 ] ]	[ "import itertools\nN,K=map(int,input().split())\nans=1\nflag=True\n\nfor i in range(N):\n if flag:\n ans=K\n flag=False\n else:\n ans=(K-1)\n\nprint(ans)", "import itertools", "itertools", "N,K=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans=1", "ans", "1", "flag=True", "flag", "True", "for i in range(N):\n if flag:\n ans=K\n flag=False\n else:\n ans=(K-1)", "i", "range(N)", "range", "N", "if flag:\n ans=K\n flag=False\n else:\n ans=(K-1)", "flag", "ans=K", "ans", "K", "flag=False", "flag", "False", "ans=(K-1)", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "N,K=map(int,input().split())", "map(int,input().split())", "N", "ans=(K-1)", "K-1", "ans", "ans=1", "1", "ans", "flag=False", "False", "flag", "K=map(int,input().split())", "map(int,input().split())", "K", "flag=True", "True", "flag", "ans=K", "K", "ans" ]	import itertools N,K=map(int,input().split()) ans=1 flag=True for i in range(N): if flag: ans=K flag=False else: ans=(K-1) print(ans)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 27, 2 ], [ 27, 11 ], [ 25, 15 ], [ 25, 18 ], [ 28, 21 ], [ 27, 25 ], [ 27, 28 ] ]	[ "n , c = map(int,input().split())\nprint(c * ((c - 1) ** (n - 1)))", "n , c = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "c", "print(c * ((c - 1) ** (n - 1)))", "print", "c * ((c - 1) (n - 1))", "c", "(c - 1) (n - 1)", "c - 1", "c", "1", "n - 1", "n", "1", "c = map(int,input().split())", "map(int,input().split())", "c", "n , c = map(int,input().split())", "map(int,input().split())", "n" ]	n , c = map(int,input().split()) print(c * ((c - 1) ** (n - 1)))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]	[ [ 34, 2 ], [ 34, 11 ], [ 31, 13 ], [ 35, 15 ], [ 35, 19 ], [ 29, 22 ], [ 32, 26 ], [ 34, 29 ], [ 31, 32 ], [ 34, 35 ] ]	[ "n, k = map(int, input().split())\nans = k * pow(k-1, n-1)\nprint(ans)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k * pow(k-1, n-1)", "ans", "k * pow(k-1, n-1)", "k", "pow(k-1, n-1)", "pow", "k-1", "k", "1", "n-1", "n", "1", "print(ans)", "print", "ans", "n, k = map(int, input().split())", "map(int, input().split())", "n", "ans = k * pow(k-1, n-1)", "k * pow(k-1, n-1)", "ans", "k = map(int, input().split())", "map(int, input().split())", "k" ]	n, k = map(int, input().split()) ans = k * pow(k-1, n-1) print(ans)
[ 7, 15, 15, 15, 15, 15, 15, 13, 15, 13, 4, 18, 13, 13, 17, 0, 13, 2, 2, 17, 17, 17, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13 ]	[ [ 60, 16 ], [ 39, 38 ], [ 64, 40 ], [ 39, 41 ], [ 41, 45 ], [ 41, 48 ], [ 38, 51 ], [ 67, 58 ], [ 60, 61 ] ]	[ "from statistics import median\n#import collections\n#aa = collections.Counter(a) # list to list \|\| .most_common(2)で最大の2個とりだせるお a[0][0]\nfrom fractions import gcd\nfrom itertools import combinations # (string,3) 3回\nfrom collections import deque\nfrom collections import defaultdict\nimport bisect\n#\n# d = m - k[i] - k[j]\n# if kk[bisect.bisect_right(kk,d) - 1] == d:\n#\n#\n#\n# pythonで無理なときは、pypyでやると正解するかも！！\n#\n#\n\nimport sys\nsys.setrecursionlimit(10000000)\nmod = 10*9 + 7\n\ndef readInts():\n return list(map(int,input().split()))\n\ndef main():\n n,k = readInts()\n print(k(k-1)(n-1))\nif __name__ == '__main__':\n main()", "from statistics import median", "from fractions import gcd", "from itertools import combinations", "from collections import deque", "from collections import defaultdict", "import bisect", "bisect", "import sys", "sys", "sys.setrecursionlimit(10000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000000", "mod = 109 + 7", "mod", "109 + 7", "109", "10", "9", "7", "def readInts():\n return list(map(int,input().split()))", "readInts", "return list(map(int,input().split()))", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def main():\n n,k = readInts()\n print(k(k-1)(n-1))", "main", "n,k = readInts()", "n", "readInts()", "readInts", "k", "print(k(k-1)*(n-1))", "print", "k(k-1)(n-1)", "k", "(k-1)(n-1)", "k-1", "k", "1", "n-1", "n", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "mod = 109 + 7", "109 + 7", "mod", "def readInts():\n return list(map(int,input().split()))", "def readInts():\n return list(map(int,input().split()))", "readInts", "def main():\n n,k = readInts()\n print(k(k-1)(n-1))", "def main():\n n,k = readInts()\n print(k(k-1)**(n-1))", "main" ]	from statistics import median #import collections #aa = collections.Counter(a) # list to list \|\| .most_common(2)で最大の2個とりだせるお a[0][0] from fractions import gcd from itertools import combinations # (string,3) 3回 from collections import deque from collections import defaultdict import bisect # # d = m - k[i] - k[j] # if kk[bisect.bisect_right(kk,d) - 1] == d: # # # # pythonで無理なときは、pypyでやると正解するかも！！ # # import sys sys.setrecursionlimit(10000000) mod = 10*9 + 7 def readInts(): return list(map(int,input().split())) def main(): n,k = readInts() print(k(k-1)**(n-1)) if __name__ == '__main__': main()
[ 7, 12, 13, 29, 4, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 12, 13, 0, 13, 4, 13, 13, 29, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]	[ [ 32, 31 ], [ 55, 33 ], [ 32, 34 ], [ 34, 37 ], [ 34, 40 ], [ 31, 43 ], [ 61, 52 ] ]	[ "\n\ndef read_int():\n return int(input().strip())\n\n\ndef read_ints():\n return list(map(int, input().strip().split(' ')))\n\n\ndef solve():\n N, K = read_ints()\n return K(K-1)(N-1)\n\n\nif __name__ == '__main__':\n print(solve())", "def read_int():\n return int(input().strip())", "read_int", "return int(input().strip())", "int(input().strip())", "int", "input().strip()", "().strip", "()", "input", "strip", "def read_ints():\n return list(map(int, input().strip().split(' ')))", "read_ints", "return list(map(int, input().strip().split(' ')))", "list(map(int, input().strip().split(' ')))", "list", "map(int, input().strip().split(' '))", "map", "int", "input().strip().split(' ')", "().strip().split", "().strip()", "().strip", "()", "input", "strip", "split", "' '", "def solve():\n N, K = read_ints()\n return K(K-1)*(N-1)", "solve", "N, K = read_ints()", "N", "read_ints()", "read_ints", "K", "return K(K-1)*(N-1)", "K(K-1)(N-1)", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "if __name__ == '__main__':\n print(solve())", "__name__ == '__main__'", "__name__", "'__main__'", "print(solve())", "print", "solve()", "solve", "def read_ints():\n return list(map(int, input().strip().split(' ')))", "def read_ints():\n return list(map(int, input().strip().split(' ')))", "read_ints", "def read_int():\n return int(input().strip())", "def read_int():\n return int(input().strip())", "read_int", "def solve():\n N, K = read_ints()\n return K(K-1)(N-1)", "def solve():\n N, K = read_ints()\n return K(K-1)**(N-1)", "solve" ]	def read_int(): return int(input().strip()) def read_ints(): return list(map(int, input().strip().split(' '))) def solve(): N, K = read_ints() return K(K-1)*(N-1) if __name__ == '__main__': print(solve())
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 27, 2 ], [ 27, 11 ], [ 25, 15 ], [ 25, 18 ], [ 28, 21 ], [ 27, 25 ], [ 27, 28 ] ]	[ "a,b=map(int,input().split())\nprint(b(b-1)(a-1))", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "print(b(b-1)*(a-1))", "print", "b(b-1)(a-1)", "b", "(b-1)(a-1)", "b-1", "b", "1", "a-1", "a", "1", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]	a,b=map(int,input().split()) print(b(b-1)*(a-1))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13 ]	[ [ 37, 2 ], [ 37, 11 ], [ 34, 13 ], [ 38, 14 ], [ 17, 16 ], [ 32, 20 ], [ 40, 23 ], [ 38, 25 ], [ 41, 29 ], [ 35, 29 ], [ 37, 32 ], [ 38, 34 ], [ 34, 35 ], [ 37, 38 ], [ 40, 41 ] ]	[ "N, K = map(int, input().split())\nans = K\nfor i in range(N - 1):\n ans = K - 1\n \nprint(ans) \n\n", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = K", "ans", "K", "for i in range(N - 1):\n ans = K - 1\n ", "i", "range(N - 1)", "range", "N - 1", "N", "1", "ans = K - 1", "ans", "K - 1", "K", "1", "print(ans)", "print", "ans", "N, K = map(int, input().split())", "map(int, input().split())", "N", "ans = K", "K", "ans", "K = map(int, input().split())", "map(int, input().split())", "K", "ans = K - 1", "K - 1", "ans" ]	N, K = map(int, input().split()) ans = K for i in range(N - 1): ans *= K - 1 print(ans)
[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 13, 16 ], [ 19, 18 ], [ 4, 22 ], [ 26, 25 ], [ 13, 27 ], [ 25, 31 ], [ 15, 31 ], [ 40, 37 ] ]	[ "def main():\n N, K = map(int, input().split())\n\n ret = K\n for _ in range(N - 1):\n ret = K - 1\n print(ret)\n\n\nif __name__ == '__main__':\n main()\n\n# import sys\n#\n# sys.setrecursionlimit(10 * 7)\n#\n# input = sys.stdin.readline\n# rstrip()\n# int(input())\n# map(int, input().split())", "def main():\n N, K = map(int, input().split())\n\n ret = K\n for _ in range(N - 1):\n ret = K - 1\n print(ret)", "main", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ret = K", "ret", "K", "for _ in range(N - 1):\n ret = K - 1\n ", "_", "range(N - 1)", "range", "N - 1", "N", "1", "ret = K - 1", "ret", "K - 1", "K", "1", "print(ret)", "print", "ret", "if __name__ == '__main__':\n main()\n\n# import sys\n#\n# sys.setrecursionlimit(10 * 7)\n#\n# input = sys.stdin.readline\n# rstrip()\n# int(input())\n# map(int, input().split())", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, K = map(int, input().split())\n\n ret = K\n for _ in range(N - 1):\n ret = K - 1\n print(ret)", "def main():\n N, K = map(int, input().split())\n\n ret = K\n for _ in range(N - 1):\n ret = K - 1\n print(ret)", "main" ]	def main(): N, K = map(int, input().split()) ret = K for _ in range(N - 1): ret = K - 1 print(ret) if __name__ == '__main__': main() # import sys # # sys.setrecursionlimit(10 * 7) # # input = sys.stdin.readline # rstrip() # int(input()) # map(int, input().split())
[ 7, 15, 12, 13, 0, 13, 4, 13, 41, 28, 13, 4, 13, 17, 4, 4, 18, 13, 13, 17, 0, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 13, 13 ]	[ [ 48, 5 ], [ 55, 7 ], [ 11, 10 ], [ 49, 17 ], [ 57, 21 ], [ 57, 23 ], [ 42, 25 ], [ 58, 26 ], [ 29, 28 ], [ 46, 32 ], [ 51, 34 ], [ 58, 36 ], [ 52, 40 ], [ 43, 40 ], [ 58, 42 ], [ 42, 43 ], [ 57, 46 ], [ 48, 49 ], [ 51, 52 ], [ 57, 58 ] ]	[ "from sys import stdin\ndef LI(): return list(map(int,stdin.readline().rstrip().split()))\nli = LI()\n\nn,k = [li.pop(0) for i in range(2)]\n\nans = k\nfor i in range(1,n):\n ans = (k-1)\n\nprint(ans)", "from sys import stdin", "def LI(): return list(map(int,stdin.readline().rstrip().split()))", "LI", "li = LI()", "li", "LI()", "LI", "li.pop(0) for i in range(2)", "for i in range(2)", "i", "range(2)", "range", "2", "for i in range(2)", "li.pop(0)", "li.pop", "li", "pop", "0", "n,k = [li.pop(0) for i in range(2)]", "n", "[li.pop(0) for i in range(2)]", "k", "ans = k", "ans", "k", "for i in range(1,n):\n ans = (k-1)", "i", "range(1,n)", "range", "1", "n", "ans = (k-1)", "ans", "k-1", "k", "1", "print(ans)", "print", "ans", "ans = k", "k", "ans", "n,k = [li.pop(0) for i in range(2)]", "[li.pop(0) for i in range(2)]", "n", "li = LI()", "LI()", "li", "ans = (k-1)", "k-1", "ans", "def LI(): return list(map(int,stdin.readline().rstrip().split()))", "def LI(): return list(map(int,stdin.readline().rstrip().split()))", "LI", "k = [li.pop(0) for i in range(2)]", "[li.pop(0) for i in range(2)]", "k" ]	from sys import stdin def LI(): return list(map(int,stdin.readline().rstrip().split())) li = LI() n,k = [li.pop(0) for i in range(2)] ans = k for i in range(1,n): ans *= (k-1) print(ans)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]	[ [ 34, 2 ], [ 34, 11 ], [ 37, 13 ], [ 32, 14 ], [ 17, 16 ], [ 35, 20 ], [ 40, 23 ], [ 32, 25 ], [ 41, 29 ], [ 38, 29 ], [ 34, 32 ], [ 34, 35 ], [ 32, 37 ], [ 37, 38 ], [ 40, 41 ] ]	[ "x,y = map(int,input().split())\n\ncount = y\n\nfor i in range(x-1):\n count = y-1\nprint(count)", "x,y = map(int,input().split())", "x", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "count = y", "count", "y", "for i in range(x-1):\n count = y-1", "i", "range(x-1)", "range", "x-1", "x", "1", "count = y-1", "count", "y-1", "y", "1", "print(count)", "print", "count", "y = map(int,input().split())", "map(int,input().split())", "y", "x,y = map(int,input().split())", "map(int,input().split())", "x", "count = y", "y", "count", "count = y-1", "y-1", "count" ]	x,y = map(int,input().split()) count = y for i in range(x-1): count *= y-1 print(count)
[ 7, 15, 13, 15, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 29, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 9, 8 ], [ 9, 17 ], [ 17, 21 ], [ 17, 24 ], [ 8, 27 ], [ 38, 35 ] ]	[ "#! env python\n# -- coding: utf-8 --\n\nimport os\nimport sys\n\n\n# ac_py.main\n# Date: 2020/06/14\n# Filename: main \n# Author: acto_mini\n\ndef main():\n N, K = map(int, input().split())\n # all = K ** N\n # out_single, out_multi = 0, 0\n # for i in range(2, N + 1):\n # out_multi += (N - i + 1) * K\n print(K * ((K - 1) (N - 1)))\n return\n\n\nif __name__ == '__main__':\n main()", "import os", "os", "import sys", "sys", "def main():\n N, K = map(int, input().split())\n # all = K N\n # out_single, out_multi = 0, 0\n # for i in range(2, N + 1):\n # out_multi += (N - i + 1) * K\n print(K * ((K - 1) ** (N - 1)))\n return", "main", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "print(K * ((K - 1) ** (N - 1)))", "print", "K * ((K - 1) (N - 1))", "K", "(K - 1) (N - 1)", "K - 1", "K", "1", "N - 1", "N", "1", "return", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, K = map(int, input().split())\n # all = K ** N\n # out_single, out_multi = 0, 0\n # for i in range(2, N + 1):\n # out_multi += (N - i + 1) * K\n print(K * ((K - 1) (N - 1)))\n return", "def main():\n N, K = map(int, input().split())\n # all = K N\n # out_single, out_multi = 0, 0\n # for i in range(2, N + 1):\n # out_multi += (N - i + 1) * K\n print(K * ((K - 1) ** (N - 1)))\n return", "main" ]	#! env python # -- coding: utf-8 -- import os import sys # ac_py.main # Date: 2020/06/14 # Filename: main # Author: acto_mini def main(): N, K = map(int, input().split()) # all = K ** N # out_single, out_multi = 0, 0 # for i in range(2, N + 1): # out_multi += (N - i + 1) * K print(K * ((K - 1) ** (N - 1))) return if __name__ == '__main__': main()
[ 7, 0, 13, 4, 13, 0, 13, 4, 18, 13, 13, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 14, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 2, 13, 2, 13, 17, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 76, 2 ], [ 79, 6 ], [ 77, 9 ], [ 67, 12 ], [ 80, 16 ], [ 77, 16 ], [ 70, 19 ], [ 80, 23 ], [ 77, 23 ], [ 68, 27 ], [ 71, 31 ], [ 68, 34 ], [ 71, 39 ], [ 71, 41 ], [ 64, 44 ], [ 71, 45 ], [ 48, 47 ], [ 68, 51 ], [ 73, 54 ], [ 65, 56 ], [ 74, 56 ], [ 71, 58 ], [ 74, 62 ], [ 65, 62 ], [ 71, 64 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ] ]	[ "s = input()\ns = s.split()\nn = int(s[0])\nk = int(s[1])\n\nif n==1:\n print(k)\nelif n==2:\n print(k(k-1))\nelse:\n ans = k\n for i in range(n-1):\n ans = ans(k-1)\n print(ans)", "s = input()", "s", "input()", "input", "s = s.split()", "s", "s.split()", "s.split", "s", "split", "n = int(s[0])", "n", "int(s[0])", "int", "s[0]", "s", "0", "k = int(s[1])", "k", "int(s[1])", "int", "s[1]", "s", "1", "if n==1:\n print(k)\nelif n==2:\n print(k(k-1))\nelse:\n ans = k\n for i in range(n-1):\n ans = ans(k-1)\n print(ans)", "n==1", "n", "1", "print(k)", "print", "k", "elif n==2:\n print(k(k-1))", "n==2", "n", "2", "print(k(k-1))", "print", "k(k-1)", "k", "k-1", "k", "1", "ans = k", "ans", "k", "for i in range(n-1):\n ans = ans(k-1)\n ", "i", "range(n-1)", "range", "n-1", "n", "1", "ans = ans(k-1)", "ans", "ans(k-1)", "ans", "k-1", "k", "1", "print(ans)", "print", "ans", "ans = k", "k", "ans", "n = int(s[0])", "int(s[0])", "n", "k = int(s[1])", "int(s[1])", "k", "ans = ans(k-1)", "ans(k-1)", "ans", "s = input()", "input()", "s", "s = s.split()", "s.split()", "s" ]	s = input() s = s.split() n = int(s[0]) k = int(s[1]) if n==1: print(k) elif n==2: print(k(k-1)) else: ans = k for i in range(n-1): ans = ans(k-1) print(ans)
[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 29, 39, 13, 13, 12, 13, 0, 13, 13, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 2, 13, 17, 14, 2, 13, 2, 2, 17, 17, 17, 29, 2, 2, 17, 17, 17, 29, 13, 23, 13, 23, 13, 14, 2, 13, 17, 0, 13, 4, 13, 13, 0, 13, 4, 13, 13, 13, 4, 13, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 5, 4 ], [ 5, 13 ], [ 22, 21 ], [ 55, 22 ], [ 25, 24 ], [ 53, 28 ], [ 31, 30 ], [ 21, 32 ], [ 30, 32 ], [ 55, 34 ], [ 30, 38 ], [ 21, 38 ], [ 30, 51 ], [ 21, 51 ], [ 53, 53 ], [ 55, 55 ], [ 87, 61 ], [ 76, 63 ], [ 87, 64 ], [ 81, 66 ], [ 79, 68 ], [ 85, 69 ], [ 88, 70 ], [ 82, 73 ], [ 81, 82 ], [ 87, 85 ], [ 87, 88 ] ]	[ "def readinput():\n n,k=map(int,input().split())\n return n,k\n\ndef main(n,k):\n ans=k\n for i in range(1,n):\n ans=ans(k-1)\n if ans >231-1:\n return 231-1\n return ans\n\nif __name__=='__main__':\n n,k=readinput()\n ans=main(n,k)\n print(ans)", "def readinput():\n n,k=map(int,input().split())\n return n,k", "readinput", "n,k=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "return n,k", "return n,k", "n", "k", "def main(n,k):\n ans=k\n for i in range(1,n):\n ans=ans(k-1)\n if ans >231-1:\n return 231-1\n return ans", "main", "ans=k", "ans", "k", "for i in range(1,n):\n ans=ans(k-1)\n if ans >231-1:\n return 231-1\n ", "i", "range(1,n)", "range", "1", "n", "ans=ans(k-1)", "ans", "ans(k-1)", "ans", "k-1", "k", "1", "if ans >231-1:\n return 231-1\n ", "ans >231-1", "ans", "231-1", "231", "2", "31", "1", "return 231-1", "231-1", "231", "2", "31", "1", "return ans", "ans", "n", "n", "k", "k", "if __name__=='__main__':\n n,k=readinput()\n ans=main(n,k)\n print(ans)", "__name__=='__main__'", "__name__", "'__main__'", "n,k=readinput()", "n", "readinput()", "readinput", "k", "ans=main(n,k)", "ans", "main(n,k)", "main", "n", "k", "print(ans)", "print", "ans", "def readinput():\n n,k=map(int,input().split())\n return n,k", "def readinput():\n n,k=map(int,input().split())\n return n,k", "readinput", "def main(n,k):\n ans=k\n for i in range(1,n):\n ans=ans(k-1)\n if ans >231-1:\n return 231-1\n return ans", "def main(n,k):\n ans=k\n for i in range(1,n):\n ans=ans(k-1)\n if ans >231-1:\n return 2*31-1\n return ans", "main", "ans=main(n,k)", "main(n,k)", "ans", "n,k=readinput()", "readinput()", "n", "k=readinput()", "readinput()", "k" ]	def readinput(): n,k=map(int,input().split()) return n,k def main(n,k): ans=k for i in range(1,n): ans=ans(k-1) if ans >231-1: return 2*31-1 return ans if __name__=='__main__': n,k=readinput() ans=main(n,k) print(ans)
[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13 ]	[ [ 42, 2 ], [ 42, 13 ], [ 39, 15 ], [ 34, 16 ], [ 19, 18 ], [ 43, 22 ], [ 36, 25 ], [ 34, 27 ], [ 37, 31 ], [ 40, 31 ], [ 42, 34 ], [ 36, 37 ], [ 34, 39 ], [ 39, 40 ], [ 42, 43 ] ]	[ "a, b = list(map(int, input().split()))\n \nans = b\nfor i in range(a - 1):\n ans = b - 1\n \nprint(ans)", "a, b = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "ans = b", "ans", "b", "for i in range(a - 1):\n ans = b - 1\n ", "i", "range(a - 1)", "range", "a - 1", "a", "1", "ans = b - 1", "ans", "b - 1", "b", "1", "print(ans)", "print", "ans", "b = list(map(int, input().split()))", "list(map(int, input().split()))", "b", "ans = b - 1", "b - 1", "ans", "ans = b", "b", "ans", "a, b = list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]	a, b = list(map(int, input().split())) ans = b for i in range(a - 1): ans *= b - 1 print(ans)
[ 7, 15, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 4, 13, 2, 13, 4, 18, 13, 13, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 36, 4 ], [ 36, 15 ], [ 37, 21 ], [ 37, 27 ], [ 34, 30 ], [ 36, 34 ], [ 36, 37 ] ]	[ "import math\n\nN, K = list(map(int, input().split()))\nprint(int(K * math.pow(K - 1, N - 1)))", "import math", "math", "N, K = list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "print(int(K * math.pow(K - 1, N - 1)))", "print", "int(K * math.pow(K - 1, N - 1))", "int", "K * math.pow(K - 1, N - 1)", "K", "math.pow(K - 1, N - 1)", "math.pow", "math", "pow", "K - 1", "K", "1", "N - 1", "N", "1", "N, K = list(map(int, input().split()))", "list(map(int, input().split()))", "N", "K = list(map(int, input().split()))", "list(map(int, input().split()))", "K" ]	import math N, K = list(map(int, input().split())) print(int(K * math.pow(K - 1, N - 1)))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 27, 2 ], [ 27, 11 ], [ 25, 15 ], [ 25, 18 ], [ 28, 21 ], [ 27, 25 ], [ 27, 28 ] ]	[ "# solution\n\nnim, mike = map(int, input().split())\nprint(mike * (mike - 1) ** (nim - 1))", "nim, mike = map(int, input().split())", "nim", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "mike", "print(mike * (mike - 1) ** (nim - 1))", "print", "mike * (mike - 1) (nim - 1)", "mike", "(mike - 1) (nim - 1)", "mike - 1", "mike", "1", "nim - 1", "nim", "1", "mike = map(int, input().split())", "map(int, input().split())", "mike", "nim, mike = map(int, input().split())", "map(int, input().split())", "nim" ]	# solution nim, mike = map(int, input().split()) print(mike * (mike - 1) ** (nim - 1))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 33, 2 ], [ 33, 11 ], [ 27, 13 ], [ 34, 15 ], [ 34, 18 ], [ 31, 21 ], [ 28, 25 ], [ 27, 28 ], [ 33, 31 ], [ 33, 34 ] ]	[ "N, K = map(int,input().split())\n\noutput = K * (K -1) ** (N-1)\n\nprint(output)", "N, K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "output = K * (K -1) ** (N-1)", "output", "K * (K -1) (N-1)", "K", "(K -1) (N-1)", "K -1", "K", "1", "N-1", "N", "1", "print(output)", "print", "output", "output = K * (K -1) ** (N-1)", "K * (K -1) ** (N-1)", "output", "N, K = map(int,input().split())", "map(int,input().split())", "N", "K = map(int,input().split())", "map(int,input().split())", "K" ]	N, K = map(int,input().split()) output = K * (K -1) ** (N-1) print(output)
[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 30, 2 ], [ 30, 13 ], [ 31, 17 ], [ 31, 21 ], [ 28, 24 ], [ 30, 28 ], [ 30, 31 ] ]	[ "n,m = list(map(int, input().split()))\nprint(mpow(m-1,n-1))", "n,m = list(map(int, input().split()))", "n", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "print(mpow(m-1,n-1))", "print", "m*pow(m-1,n-1)", "m", "pow(m-1,n-1)", "pow", "m-1", "m", "1", "n-1", "n", "1", "n,m = list(map(int, input().split()))", "list(map(int, input().split()))", "n", "m = list(map(int, input().split()))", "list(map(int, input().split()))", "m" ]	n,m = list(map(int, input().split())) print(m*pow(m-1,n-1))
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13 ]	[ [ 37, 2 ], [ 37, 11 ], [ 34, 13 ], [ 38, 14 ], [ 17, 16 ], [ 32, 20 ], [ 40, 23 ], [ 38, 25 ], [ 41, 29 ], [ 35, 29 ], [ 37, 32 ], [ 38, 34 ], [ 34, 35 ], [ 37, 38 ], [ 40, 41 ] ]	[ "n, k = map(int, input().split())\nans = k\nfor _ in range(n-1):\n ans = (k-1)\nprint(ans)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k", "ans", "k", "for _ in range(n-1):\n ans = (k-1)", "_", "range(n-1)", "range", "n-1", "n", "1", "ans = (k-1)", "ans", "k-1", "k", "1", "print(ans)", "print", "ans", "n, k = map(int, input().split())", "map(int, input().split())", "n", "ans = k", "k", "ans", "k = map(int, input().split())", "map(int, input().split())", "k", "ans = (k-1)", "k-1", "ans" ]	n, k = map(int, input().split()) ans = k for _ in range(n-1): ans *= (k-1) print(ans)
[ 7, 15, 13, 4, 18, 13, 13, 17, 0, 13, 2, 2, 17, 17, 17, 12, 13, 29, 18, 4, 18, 18, 13, 13, 13, 39, 17, 12, 13, 29, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 0, 13, 13, 41, 28, 13, 4, 13, 31, 13, 4, 4, 13, 13, 29, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13 ]	[ [ 120, 9 ], [ 124, 36 ], [ 124, 44 ], [ 50, 49 ], [ 75, 52 ], [ 118, 57 ], [ 60, 59 ], [ 64, 63 ], [ 59, 67 ], [ 63, 71 ], [ 75, 75 ], [ 80, 79 ], [ 118, 81 ], [ 80, 82 ], [ 85, 84 ], [ 82, 85 ], [ 88, 87 ], [ 79, 91 ], [ 95, 94 ], [ 82, 96 ], [ 94, 100 ], [ 84, 100 ], [ 112, 106 ], [ 120, 121 ] ]	[ "import sys\nsys.setrecursionlimit(500000)\nMOD = 10*9+7\n\ndef input():\n return sys.stdin.readline()[:-1]\n\ndef mi():\n return map(int, input().split())\n\ndef ii():\n return int(input())\n\ndef i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(tmp)]\n\ndef main():\n N, K = mi()\n ans = K\n for i in range(N-1):\n ans = K-1\n print(ans)\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(500000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "500000", "MOD = 109+7", "MOD", "109+7", "109", "10", "9", "7", "def input():\n return sys.stdin.readline()[:-1]", "input", "return sys.stdin.readline()[:-1]", "sys.stdin.readline()[:-1]", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", ":-1", "-1", "def mi():\n return map(int, input().split())", "mi", "return map(int, input().split())", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def ii():\n return int(input())", "ii", "return int(input())", "int(input())", "int", "input()", "input", "def i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(tmp)]", "i2", "list(mi()) for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "list(mi())", "list", "mi()", "mi", "tmp = [list(mi()) for i in range(n)]", "tmp", "[list(mi()) for i in range(n)]", "list(i) for i in zip(tmp)", "for i in zip(tmp)", "i", "zip(tmp)", "zip", "tmp", "tmp", "for i in zip(tmp)", "list(i)", "list", "i", "return [list(i) for i in zip(tmp)]", "[list(i) for i in zip(tmp)]", "n", "n", "def main():\n N, K = mi()\n ans = K\n for i in range(N-1):\n ans = K-1\n print(ans)", "main", "N, K = mi()", "N", "mi()", "mi", "K", "ans = K", "ans", "K", "for i in range(N-1):\n ans = K-1\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "ans = K-1", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(tmp)]", "def i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(tmp)]", "i2", "def main():\n N, K = mi()\n ans = K\n for i in range(N-1):\n ans = K-1\n print(ans)", "def main():\n N, K = mi()\n ans = K\n for i in range(N-1):\n ans = K-1\n print(ans)", "main", "def ii():\n return int(input())", "def ii():\n return int(input())", "ii", "def mi():\n return map(int, input().split())", "def mi():\n return map(int, input().split())", "mi", "MOD = 109+7", "109+7", "MOD", "def input():\n return sys.stdin.readline()[:-1]", "def input():\n return sys.stdin.readline()[:-1]", "input" ]	import sys sys.setrecursionlimit(500000) MOD = 10*9+7 def input(): return sys.stdin.readline()[:-1] def mi(): return map(int, input().split()) def ii(): return int(input()) def i2(n): tmp = [list(mi()) for i in range(n)] return [list(i) for i in zip(tmp)] def main(): N, K = mi() ans = K for i in range(N-1): ans *= K-1 print(ans) if __name__ == '__main__': main()
[ 7, 15, 15, 15, 13, 13, 13, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 17, 12, 13, 12, 13, 0, 13, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]	[ [ 86, 18 ], [ 83, 25 ], [ 80, 34 ], [ 78, 36 ], [ 80, 37 ], [ 68, 39 ], [ 43, 42 ], [ 66, 45 ], [ 42, 48 ], [ 71, 51 ], [ 81, 52 ], [ 62, 54 ], [ 81, 56 ], [ 63, 60 ], [ 72, 60 ], [ 69, 60 ], [ 62, 63 ], [ 80, 66 ], [ 68, 69 ], [ 81, 71 ], [ 71, 72 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ] ]	[ "from collections import Counter,defaultdict,deque\nfrom heapq import heappop,heappush,heapify\nimport sys,bisect,math,itertools,fractions,pprint\nsys.setrecursionlimit(108)\nmod = 109+7\nINF = float('inf')\ndef inp(): return int(sys.stdin.readline())\ndef inpl(): return list(map(int, sys.stdin.readline().split()))\n\nn,k = inpl()\nres = 1\nfor i in range(n):\n if i == 0:\n res = k\n else:\n res = k-1\nprint(res)", "from collections import Counter,defaultdict,deque", "from heapq import heappop,heappush,heapify", "import sys,bisect,math,itertools,fractions,pprint", "sys", "bisect", "math", "itertools", "fractions", "pprint", "sys.setrecursionlimit(108)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "108", "10", "8", "mod = 109+7", "mod", "109+7", "10*9", "10", "9", "7", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "def inp(): return int(sys.stdin.readline())", "inp", "def inpl(): return list(map(int, sys.stdin.readline().split()))", "inpl", "n,k = inpl()", "n", "inpl()", "inpl", "k", "res = 1", "res", "1", "for i in range(n):\n if i == 0:\n res = k\n else:\n res = k-1", "i", "range(n)", "range", "n", "if i == 0:\n res = k\n else:\n res = k-1", "i == 0", "i", "0", "res = k", "res", "k", "res = k-1", "res", "k-1", "k", "1", "print(res)", "print", "res", "res = k-1", "k-1", "res", "n,k = inpl()", "inpl()", "n", "res = 1", "1", "res", "res = k", "k", "res", "def inp(): return int(sys.stdin.readline())", "def inp(): return int(sys.stdin.readline())", "inp", "def inpl(): return list(map(int, sys.stdin.readline().split()))", "def inpl(): return list(map(int, sys.stdin.readline().split()))", "inpl", "k = inpl()", "inpl()", "k", "INF = float('inf')", "float('inf')", "INF", "mod = 109+7", "10*9+7", "mod" ]	from collections import Counter,defaultdict,deque from heapq import heappop,heappush,heapify import sys,bisect,math,itertools,fractions,pprint sys.setrecursionlimit(108) mod = 109+7 INF = float('inf') def inp(): return int(sys.stdin.readline()) def inpl(): return list(map(int, sys.stdin.readline().split())) n,k = inpl() res = 1 for i in range(n): if i == 0: res = k else: res = k-1 print(res)
[ 7, 0, 13, 4, 13, 0, 13, 4, 18, 13, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 0, 13, 13, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]	[ [ 55, 2 ], [ 64, 6 ], [ 56, 9 ], [ 61, 13 ], [ 65, 17 ], [ 58, 20 ], [ 65, 24 ], [ 62, 29 ], [ 59, 32 ], [ 67, 38 ], [ 59, 39 ], [ 42, 41 ], [ 62, 45 ], [ 70, 47 ], [ 59, 49 ], [ 71, 53 ], [ 68, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 59, 67 ], [ 67, 68 ], [ 70, 71 ] ]	[ "sample = input() # two numbers in a string\nnew_sample = sample.split(\" \")\n\nball = int(new_sample[0]) # number of balls\ncolor = int(new_sample[1]) # number of colors\nif ball > 1 and color == 1:\n print(0)\nelse:\n product = color\n for i in range(1, ball):\n product = (color-1)\n print(product)\n\n \n# 3 balls, 10 colors\n# 1st spot, 10 choices\n# 2nd spot, 9 choices\n# 3rd spot, 9 choices", "sample = input()", "sample", "input()", "input", "new_sample = sample.split(\" \")", "new_sample", "sample.split(\" \")", "sample.split", "sample", "split", "\" \"", "ball = int(new_sample[0])", "ball", "int(new_sample[0])", "int", "new_sample[0]", "new_sample", "0", "color = int(new_sample[1])", "color", "int(new_sample[1])", "int", "new_sample[1]", "new_sample", "1", "if ball > 1 and color == 1:\n print(0)\nelse:\n product = color\n for i in range(1, ball):\n product = (color-1)\n print(product)\n\n \n# 3 balls, 10 colors\n# 1st spot, 10 choices\n# 2nd spot, 9 choices\n# 3rd spot, 9 choices", "ball > 1 and color == 1", "ball > 1", "ball", "1", "color == 1", "color", "1", "print(0)", "print", "0", "product = color", "product", "color", "for i in range(1, ball):\n product = (color-1)\n ", "i", "range(1, ball)", "range", "1", "ball", "product = (color-1)", "product", "color-1", "color", "1", "print(product)", "print", "product", "sample = input()", "input()", "sample", "color = int(new_sample[1])", "int(new_sample[1])", "color", "ball = int(new_sample[0])", "int(new_sample[0])", "ball", "new_sample = sample.split(\" \")", "sample.split(\" \")", "new_sample", "product = color", "color", "product", "product *= (color-1)", "color-1", "product" ]	sample = input() # two numbers in a string new_sample = sample.split(" ") ball = int(new_sample[0]) # number of balls color = int(new_sample[1]) # number of colors if ball > 1 and color == 1: print(0) else: product = color for i in range(1, ball): product *= (color-1) print(product) # 3 balls, 10 colors # 1st spot, 10 choices # 2nd spot, 9 choices # 3rd spot, 9 choices
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]	[ [ 37, 2 ], [ 37, 11 ], [ 35, 14 ], [ 40, 17 ], [ 38, 18 ], [ 43, 20 ], [ 38, 22 ], [ 38, 25 ], [ 35, 28 ], [ 44, 32 ], [ 41, 32 ], [ 37, 35 ], [ 37, 38 ], [ 38, 40 ], [ 40, 41 ], [ 43, 44 ] ]	[ "N,K = map(int,input().split())\nif N ==1:\n ans=K\nelse:\n ans = K * ((K-1)*(N-1))\n\nprint(ans)", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "if N ==1:\n ans=K\nelse:\n ans = K ((K-1)*(N-1))", "N ==1", "N", "1", "ans=K", "ans", "K", "ans = K ((K-1)*(N-1))", "ans", "K ((K-1)(N-1))", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "N,K = map(int,input().split())", "map(int,input().split())", "N", "K = map(int,input().split())", "map(int,input().split())", "K", "ans=K", "K", "ans", "ans = K * ((K-1)*(N-1))", "K ((K-1)**(N-1))", "ans" ]	N,K = map(int,input().split()) if N ==1: ans=K else: ans = K * ((K-1)**(N-1)) print(ans)
[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 18, 22 ], [ 18, 25 ], [ 16, 28 ], [ 38, 35 ] ]	[ "def main():\n N, K = (int(i) for i in input().split())\n print(K((K-1)(N-1)))\n\n\nif __name__ == '__main__':\n main()", "def main():\n N, K = (int(i) for i in input().split())\n print(K((K-1)*(N-1)))", "main", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "N, K = (int(i) for i in input().split())", "N", "(int(i) for i in input().split())", "K", "print(K((K-1)*(N-1)))", "print", "K((K-1)(N-1))", "K", "(K-1)(N-1)", "K-1", "K", "1", "N-1", "N", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, K = (int(i) for i in input().split())\n print(K((K-1)(N-1)))", "def main():\n N, K = (int(i) for i in input().split())\n print(K((K-1)**(N-1)))", "main" ]	def main(): N, K = (int(i) for i in input().split()) print(K((K-1)*(N-1))) if __name__ == '__main__': main()
[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 13, 13, 10, 13, 13 ]	[ [ 4, 3 ], [ 3, 12 ], [ 32, 14 ], [ 32, 16 ], [ 33, 20 ], [ 33, 23 ], [ 30, 26 ], [ 32, 30 ], [ 32, 33 ] ]	[ "a, b = [int(i) for i in input().split()]\n\nprint(b * (b-1) ** (a - 1))", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a, b = [int(i) for i in input().split()]", "a", "[int(i) for i in input().split()]", "b", "print(b * (b-1) ** (a - 1))", "print", "b * (b-1) (a - 1)", "b", "(b-1) (a - 1)", "b-1", "b", "1", "a - 1", "a", "1", "a, b = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a", "b = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "b" ]	a, b = [int(i) for i in input().split()] print(b * (b-1) ** (a - 1))
[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 13, 13, 10, 18, 13, 10, 13, 13 ]	[ [ 41, 4 ], [ 13, 12 ], [ 42, 16 ], [ 12, 21 ], [ 44, 23 ], [ 44, 25 ], [ 39, 29 ], [ 39, 32 ], [ 45, 35 ], [ 44, 39 ], [ 41, 42 ], [ 44, 45 ] ]	[ "import sys\ninput = sys.stdin.readline\n\nn, k = [int(x) for x in input().split()]\n\nprint(k * (k - 1)*(n - 1))", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "n, k = [int(x) for x in input().split()]", "n", "[int(x) for x in input().split()]", "k", "print(k (k - 1)*(n - 1))", "print", "k (k - 1)(n - 1)", "k", "(k - 1)(n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "k = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "k", "input = sys.stdin.readline", "sys.stdin.readline", "input", "n, k = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "n" ]	import sys input = sys.stdin.readline n, k = [int(x) for x in input().split()] print(k * (k - 1)**(n - 1))
[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 5, 13 ], [ 13, 17 ], [ 13, 20 ], [ 4, 23 ], [ 29, 26 ] ]	[ "def resolve():\n N, M = map(int, input().split())\n print(M(M-1)(N-1))\nresolve()", "def resolve():\n N, M = map(int, input().split())\n print(M(M-1)*(N-1))", "resolve", "N, M = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "print(M(M-1)*(N-1))", "print", "M(M-1)(N-1)", "M", "(M-1)(N-1)", "M-1", "M", "1", "N-1", "N", "1", "resolve()", "resolve", "def resolve():\n N, M = map(int, input().split())\n print(M(M-1)(N-1))", "def resolve():\n N, M = map(int, input().split())\n print(M(M-1)**(N-1))", "resolve" ]	def resolve(): N, M = map(int, input().split()) print(M(M-1)*(N-1)) resolve()
[ 7, 14, 2, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]	[ [ 32, 6 ], [ 32, 15 ], [ 30, 19 ], [ 30, 23 ], [ 33, 26 ], [ 32, 30 ], [ 32, 33 ] ]	[ "if __name__ == \"__main__\":\n N, K = map(int, input().split())\n print(Kpow(K-1, N-1))", "if __name__ == \"__main__\":\n N, K = map(int, input().split())\n print(Kpow(K-1, N-1))", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "print(Kpow(K-1, N-1))", "print", "Kpow(K-1, N-1)", "K", "pow(K-1, N-1)", "pow", "K-1", "K", "1", "N-1", "N", "1", "K = map(int, input().split())", "map(int, input().split())", "K", "N, K = map(int, input().split())", "map(int, input().split())", "N" ]	if __name__ == "__main__": N, K = map(int, input().split()) print(K*pow(K-1, N-1))
[ 7, 14, 2, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13 ]	[ [ 52, 6 ], [ 52, 15 ], [ 43, 17 ], [ 21, 20 ], [ 50, 23 ], [ 20, 26 ], [ 46, 29 ], [ 53, 30 ], [ 40, 32 ], [ 53, 34 ], [ 41, 38 ], [ 47, 38 ], [ 44, 38 ], [ 40, 41 ], [ 43, 44 ], [ 53, 46 ], [ 46, 47 ], [ 52, 50 ], [ 52, 53 ] ]	[ "if __name__ == \"__main__\":\n n, k = map(int, input().split())\n\n ans = 1\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n\n print(ans)", "if __name__ == \"__main__\":\n n, k = map(int, input().split())\n\n ans = 1\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n\n print(ans)", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 1", "ans", "1", "for i in range(n):\n if i == 0:\n ans = k\n else:\n ans = k - 1\n\n ", "i", "range(n)", "range", "n", "if i == 0:\n ans = k\n else:\n ans = k - 1\n\n ", "i == 0", "i", "0", "ans = k", "ans", "k", "ans = k - 1", "ans", "k - 1", "k", "1", "print(ans)", "print", "ans", "ans = k - 1", "k - 1", "ans", "ans = 1", "1", "ans", "ans = k", "k", "ans", "n, k = map(int, input().split())", "map(int, input().split())", "n", "k = map(int, input().split())", "map(int, input().split())", "k" ]	if __name__ == "__main__": n, k = map(int, input().split()) ans = 1 for i in range(n): if i == 0: ans = k else: ans = k - 1 print(ans)
[ 7, 12, 13, 15, 13, 0, 13, 18, 18, 13, 13, 13, 41, 28, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 7, 6 ], [ 15, 14 ], [ 6, 20 ], [ 14, 27 ], [ 30, 29 ], [ 30, 31 ], [ 31, 35 ], [ 31, 38 ], [ 29, 41 ], [ 51, 48 ] ]	[ "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, k = [int(x) for x in input().rstrip().split(\" \")]\n\n print(k * ((k - 1) ** (n - 1)))\n\n\nif __name__ == \"__main__\":\n resolve()", "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, k = [int(x) for x in input().rstrip().split(\" \")]\n\n print(k * ((k - 1) ** (n - 1)))", "resolve", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "int(x) for x in input().rstrip().split(\" \")", "for x in input().rstrip().split(\" \")", "x", "input().rstrip().split(\" \")", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "\" \"", "for x in input().rstrip().split(\" \")", "int(x)", "int", "x", "n, k = [int(x) for x in input().rstrip().split(\" \")]", "n", "[int(x) for x in input().rstrip().split(\" \")]", "k", "print(k * ((k - 1) ** (n - 1)))", "print", "k * ((k - 1) (n - 1))", "k", "(k - 1) (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "if __name__ == \"__main__\":\n resolve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "resolve()", "resolve", "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, k = [int(x) for x in input().rstrip().split(\" \")]\n\n print(k * ((k - 1) ** (n - 1)))", "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, k = [int(x) for x in input().rstrip().split(\" \")]\n\n print(k * ((k - 1) ** (n - 1)))", "resolve" ]	def resolve(): import sys input = sys.stdin.readline n, k = [int(x) for x in input().rstrip().split(" ")] print(k * ((k - 1) ** (n - 1))) if __name__ == "__main__": resolve()
[ 7, 15, 13, 12, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 4, 13, 13, 29, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 7, 6 ], [ 14, 13 ], [ 6, 20 ], [ 14, 22 ], [ 25, 24 ], [ 22, 25 ], [ 28, 27 ], [ 13, 31 ], [ 24, 35 ], [ 46, 43 ] ]	[ "import sys\n\ndef solve():\n input = sys.stdin.readline\n N, K = map(int, input().split())\n total = K\n for i in range(N-1): total = (K - 1)\n print(total)\n return 0\n\nif __name__ == \"__main__\":\n solve()", "import sys", "sys", "def solve():\n input = sys.stdin.readline\n N, K = map(int, input().split())\n total = K\n for i in range(N-1): total = (K - 1)\n print(total)\n return 0", "solve", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "total = K", "total", "K", "for i in range(N-1): total = (K - 1)\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "print(total)", "print", "total", "return 0", "0", "if __name__ == \"__main__\":\n solve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "solve()", "solve", "def solve():\n input = sys.stdin.readline\n N, K = map(int, input().split())\n total = K\n for i in range(N-1): total = (K - 1)\n print(total)\n return 0", "def solve():\n input = sys.stdin.readline\n N, K = map(int, input().split())\n total = K\n for i in range(N-1): total *= (K - 1)\n print(total)\n return 0", "solve" ]	import sys def solve(): input = sys.stdin.readline N, K = map(int, input().split()) total = K for i in range(N-1): total *= (K - 1) print(total) return 0 if __name__ == "__main__": solve()
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 17, 4, 13, 2, 2, 2, 13, 17, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]	[ [ 33, 2 ], [ 33, 11 ], [ 30, 13 ], [ 28, 15 ], [ 34, 22 ], [ 31, 24 ], [ 28, 24 ], [ 34, 25 ], [ 33, 28 ], [ 30, 31 ], [ 33, 34 ] ]	[ "n, k = map(int, input().split())\n\nn = n-1\n\nprint((k-1)*n k)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "n = n-1", "n", "n-1", "n", "1", "print((k-1)*n k)", "print", "(k-1)*n k", "(k-1)**n", "k-1", "k", "1", "n", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n", "n = n-1", "n-1", "n", "k = map(int, input().split())", "map(int, input().split())", "k" ]	n, k = map(int, input().split()) n = n-1 print((k-1)*n k)
[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]	[ [ 41, 2 ], [ 41, 11 ], [ 38, 13 ], [ 36, 14 ], [ 17, 16 ], [ 42, 21 ], [ 32, 24 ], [ 36, 26 ], [ 33, 30 ], [ 39, 30 ], [ 32, 33 ], [ 41, 36 ], [ 36, 38 ], [ 38, 39 ], [ 41, 42 ] ]	[ "n,k = map(int,input().split())\n\nans = k\nfor i in range(2,n+1):\n ans = (k-1)\nprint(ans)", "n,k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k", "ans", "k", "for i in range(2,n+1):\n ans = (k-1)", "i", "range(2,n+1)", "range", "2", "n+1", "n", "1", "ans = (k-1)", "ans", "k-1", "k", "1", "print(ans)", "print", "ans", "ans = (k-1)", "k-1", "ans", "k = map(int,input().split())", "map(int,input().split())", "k", "ans = k", "k", "ans", "n,k = map(int,input().split())", "map(int,input().split())", "n" ]	n,k = map(int,input().split()) ans = k for i in range(2,n+1): ans *= (k-1) print(ans)
[ 7, 12, 13, 0, 13, 4, 13, 4, 13, 41, 28, 13, 4, 13, 13, 4, 13, 0, 13, 13, 0, 13, 18, 13, 17, 13, 28, 13, 4, 13, 17, 13, 0, 13, 18, 13, 13, 13, 14, 40, 2, 13, 13, 17, 0, 13, 2, 13, 2, 13, 13, 14, 2, 2, 2, 13, 13, 13, 13, 14, 40, 2, 13, 13, 17, 0, 13, 2, 13, 2, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 4, 13, 2, 13, 13, 29, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]	[ [ 5, 4 ], [ 12, 11 ], [ 4, 14 ], [ 19, 18 ], [ 22, 21 ], [ 18, 23 ], [ 22, 25 ], [ 28, 27 ], [ 4, 31 ], [ 34, 33 ], [ 18, 35 ], [ 27, 36 ], [ 34, 37 ], [ 21, 41 ], [ 73, 41 ], [ 45, 41 ], [ 33, 42 ], [ 46, 45 ], [ 33, 47 ], [ 21, 49 ], [ 73, 49 ], [ 45, 49 ], [ 33, 50 ], [ 37, 55 ], [ 45, 56 ], [ 21, 56 ], [ 73, 56 ], [ 33, 57 ], [ 25, 58 ], [ 80, 58 ], [ 66, 58 ], [ 25, 62 ], [ 80, 62 ], [ 66, 62 ], [ 37, 63 ], [ 67, 66 ], [ 37, 68 ], [ 25, 70 ], [ 80, 70 ], [ 66, 70 ], [ 37, 71 ], [ 74, 73 ], [ 33, 76 ], [ 66, 77 ], [ 25, 77 ], [ 80, 77 ], [ 37, 78 ], [ 81, 80 ], [ 37, 83 ], [ 45, 84 ], [ 21, 84 ], [ 73, 84 ], [ 33, 85 ], [ 73, 89 ], [ 45, 89 ], [ 21, 89 ], [ 80, 90 ], [ 66, 90 ], [ 25, 90 ], [ 100, 97 ] ]	[ "def main():\n N = int(input())\n TA = [[int(_) for _ in input().split()] for __ in range(N)]\n x, y = TA[0] #初期値\n for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n print(x+y)\n return\n\nif __name__ == '__main__':\n main()", "def main():\n N = int(input())\n TA = [[int(_) for _ in input().split()] for __ in range(N)]\n x, y = TA[0] #初期値\n for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n print(x+y)\n return", "main", "N = int(input())", "N", "int(input())", "int", "input()", "input", "[int(_) for _ in input().split()] for __ in range(N)", "for __ in range(N)", "__", "range(N)", "range", "N", "for __ in range(N)", "[int(_) for _ in input().split()]", "TA = [[int(_) for _ in input().split()] for __ in range(N)]", "TA", "[[int(_) for _ in input().split()] for __ in range(N)]", "x, y = TA[0]", "x", "TA[0]", "TA", "0", "y", "for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n ", "i", "range(1, N)", "range", "1", "N", "T, A = TA[i]", "T", "TA[i]", "TA", "i", "A", "if x%T != 0:\n x += T - x%T\n ", "x%T != 0", "x%T", "x", "T", "0", "x += T - x%T", "x", "T - x%T", "T", "x%T", "x", "T", "if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n ", "A * x // T < y", "A * x // T", "A * x", "A", "x", "T", "y", "if y%A != 0:\n y += A - y%A\n ", "y%A != 0", "y%A", "y", "A", "0", "y += A - y%A", "y", "A - y%A", "A", "y%A", "y", "A", "x = T * y // A", "x", "T * y // A", "T * y", "T", "y", "A", "y = A * x // T", "y", "A * x // T", "A * x", "A", "x", "T", "print(x+y)", "print", "x+y", "x", "y", "return", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N = int(input())\n TA = [[int(_) for _ in input().split()] for __ in range(N)]\n x, y = TA[0] #初期値\n for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n print(x+y)\n return", "def main():\n N = int(input())\n TA = [[int(_) for _ in input().split()] for __ in range(N)]\n x, y = TA[0] #初期値\n for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n print(x+y)\n return", "main" ]	def main(): N = int(input()) TA = [[int(_) for _ in input().split()] for __ in range(N)] x, y = TA[0] #初期値 for i in range(1, N): T, A = TA[i] if x%T != 0: x += T - x%T if A * x // T < y: if y%A != 0: y += A - y%A x = T * y // A else: y = A * x // T print(x+y) return if __name__ == '__main__': main()

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 31, 2 ], [ 31, 15 ], [ 32, 19 ], [ 32, 22 ], [ 29, 25 ], [ 31, 29 ], [ 31, 32 ] ]

[ "n,k = map(int,input().rstrip().split(' '))\nprint(k*(k-1)**(n-1))", "n,k = map(int,input().rstrip().split(' '))", "n", "map(int,input().rstrip().split(' '))", "map", "int", "input().rstrip().split(' ')", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "' '", "k", "print(k*(k-1)**(n-1))", "print", "k*(k-1)**(n-1)", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "n,k = map(int,input().rstrip().split(' '))", "map(int,input().rstrip().split(' '))", "n", "k = map(int,input().rstrip().split(' '))", "map(int,input().rstrip().split(' '))", "k" ]

n,k = map(int,input().rstrip().split(' ')) print(k*(k-1)**(n-1))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 14, 2, 13, 17, 4, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13, 10, 2, 13 ]

[ [ 40, 2 ], [ 40, 11 ], [ 43, 13 ], [ 38, 17 ], [ 41, 21 ], [ 46, 23 ], [ 41, 25 ], [ 41, 28 ], [ 38, 31 ], [ 47, 35 ], [ 44, 35 ], [ 40, 38 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ] ]

[ "n, k = map(int,input().split())\nans = 1\nif n == 1:\n\tprint(k)\nelse:\n\tans = k*((k-1)**(n-1))\n\tprint(ans)", "n, k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 1", "ans", "1", "if n == 1:\n\tprint(k)\nelse:\n\tans = k*((k-1)**(n-1))\n\tprint(ans)", "n == 1", "n", "1", "print(k)", "print", "k", "ans = k*((k-1)**(n-1))", "ans", "k*((k-1)**(n-1))", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "print(ans)", "print", "ans", "n, k = map(int,input().split())", "map(int,input().split())", "n", "k = map(int,input().split())", "map(int,input().split())", "k", "ans = 1", "1", "ans", "ans = k*((k-1)**(n-1))", "k*((k-1)**(n-1))", "ans" ]

n, k = map(int,input().split()) ans = 1 if n == 1: print(k) else: ans = k*((k-1)**(n-1)) print(ans)

[ 7, 0, 13, 4, 18, 4, 13, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 51, 2 ], [ 42, 10 ], [ 52, 14 ], [ 45, 17 ], [ 52, 21 ], [ 54, 24 ], [ 46, 25 ], [ 28, 27 ], [ 43, 31 ], [ 48, 34 ], [ 46, 36 ], [ 49, 40 ], [ 55, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 46, 54 ], [ 54, 55 ] ]

[ "str_line = input().split(\" \")\nnum = int(str_line[0])\nkind = int(str_line[1])\nans = kind \n\nfor i in range(num-1):\n ans *=(kind - 1)\n \nprint(ans)", "str_line = input().split(\" \")", "str_line", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "num = int(str_line[0])", "num", "int(str_line[0])", "int", "str_line[0]", "str_line", "0", "kind = int(str_line[1])", "kind", "int(str_line[1])", "int", "str_line[1]", "str_line", "1", "ans = kind", "ans", "kind", "for i in range(num-1):\n ans *=(kind - 1)\n ", "i", "range(num-1)", "range", "num-1", "num", "1", "ans *=(kind - 1)", "ans", "kind - 1", "kind", "1", "print(ans)", "print", "ans", "num = int(str_line[0])", "int(str_line[0])", "num", "kind = int(str_line[1])", "int(str_line[1])", "kind", "ans *=(kind - 1)", "kind - 1", "ans", "str_line = input().split(\" \")", "input().split(\" \")", "str_line", "ans = kind", "kind", "ans" ]

str_line = input().split(" ") num = int(str_line[0]) kind = int(str_line[1]) ans = kind for i in range(num-1): ans *=(kind - 1) print(ans)

[ 7, 15, 13, 15, 13, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 33, 8 ], [ 33, 17 ], [ 31, 21 ], [ 31, 24 ], [ 34, 27 ], [ 33, 31 ], [ 33, 34 ] ]

[ "import sys\nimport math\nimport itertools\n#n=int(input())\nn, k = map(int, input().split())\nprint(k*((k-1)**(n-1)))", "import sys", "sys", "import math", "math", "import itertools", "itertools", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k*((k-1)**(n-1)))", "print", "k*((k-1)**(n-1))", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "k = map(int, input().split())", "map(int, input().split())", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n" ]

import sys import math import itertools #n=int(input()) n, k = map(int, input().split()) print(k*((k-1)**(n-1)))

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 35, 2 ], [ 35, 16 ], [ 38, 18 ], [ 33, 20 ], [ 33, 23 ], [ 36, 26 ], [ 39, 30 ], [ 35, 33 ], [ 35, 36 ], [ 38, 39 ] ]

[ "# -*- coding: utf-8 -*-\n\n#----------\nN,K = list(map(int, input().rstrip().split()))\n#----------\nans = K * (K-1)**(N-1)\nprint(ans)", "N,K = list(map(int, input().rstrip().split()))", "N", "list(map(int, input().rstrip().split()))", "list", "map(int, input().rstrip().split())", "map", "int", "input().rstrip().split()", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "K", "ans = K * (K-1)**(N-1)", "ans", "K * (K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "K = list(map(int, input().rstrip().split()))", "list(map(int, input().rstrip().split()))", "K", "N,K = list(map(int, input().rstrip().split()))", "list(map(int, input().rstrip().split()))", "N", "ans = K * (K-1)**(N-1)", "K * (K-1)**(N-1)", "ans" ]

# -*- coding: utf-8 -*- #---------- N,K = list(map(int, input().rstrip().split())) #---------- ans = K * (K-1)**(N-1) print(ans)

[ 7, 12, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 15 ], [ 18, 17 ], [ 15, 19 ], [ 15, 22 ], [ 4, 25 ], [ 17, 29 ], [ 34, 31 ] ]

[ "def resolve():\n N, K = list(map(int, input().split()))\n paint_way_count = K*(K-1)**(N-1)\n print(paint_way_count)\n\nresolve()", "def resolve():\n N, K = list(map(int, input().split()))\n paint_way_count = K*(K-1)**(N-1)\n print(paint_way_count)", "resolve", "N, K = list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "paint_way_count = K*(K-1)**(N-1)", "paint_way_count", "K*(K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(paint_way_count)", "print", "paint_way_count", "resolve()", "resolve", "def resolve():\n N, K = list(map(int, input().split()))\n paint_way_count = K*(K-1)**(N-1)\n print(paint_way_count)", "def resolve():\n N, K = list(map(int, input().split()))\n paint_way_count = K*(K-1)**(N-1)\n print(paint_way_count)", "resolve" ]

def resolve(): N, K = list(map(int, input().split())) paint_way_count = K*(K-1)**(N-1) print(paint_way_count) resolve()

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 2, 13, 17, 4, 13, 2, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 44, 2 ], [ 44, 11 ], [ 38, 13 ], [ 47, 16 ], [ 45, 17 ], [ 20, 19 ], [ 42, 23 ], [ 50, 26 ], [ 39, 28 ], [ 51, 28 ], [ 45, 30 ], [ 48, 35 ], [ 51, 36 ], [ 39, 36 ], [ 38, 39 ], [ 44, 42 ], [ 44, 45 ], [ 45, 47 ], [ 47, 48 ], [ 50, 51 ] ]

[ "\nN,K = map(int, input().split())\n\nc = 1\nans = K\n\nfor i in range(N-1):\n c = c*(K-1)\n\nprint(ans*c)", "N,K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "c = 1", "c", "1", "ans = K", "ans", "K", "for i in range(N-1):\n c = c*(K-1)", "i", "range(N-1)", "range", "N-1", "N", "1", "c = c*(K-1)", "c", "c*(K-1)", "c", "K-1", "K", "1", "print(ans*c)", "print", "ans*c", "ans", "c", "c = 1", "1", "c", "N,K = map(int, input().split())", "map(int, input().split())", "N", "K = map(int, input().split())", "map(int, input().split())", "K", "ans = K", "K", "ans", "c = c*(K-1)", "c*(K-1)", "c" ]

N,K = map(int, input().split()) c = 1 ans = K for i in range(N-1): c = c*(K-1) print(ans*c)

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 15, 15, 0, 13, 2, 17, 17, 4, 18, 13, 13, 2, 17, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 14, 40, 13, 17, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 66, 13 ], [ 69, 25 ], [ 69, 34 ], [ 57, 36 ], [ 61, 37 ], [ 70, 40 ], [ 63, 43 ], [ 61, 45 ], [ 61, 48 ], [ 70, 51 ], [ 64, 55 ], [ 58, 55 ], [ 61, 57 ], [ 57, 58 ], [ 69, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "import itertools\nimport math\nimport sys\nimport heapq\nfrom collections import Counter\nfrom collections import deque\nfrom fractions import gcd\nINF = 1 << 60\nsys.setrecursionlimit(10 ** 6)\n\n#ここから書き始める\nn, k = map(int, input().split())\nans = k\nif n >= 2:\n ans = k * (k - 1) ** (n - 1)\nprint(ans)", "import itertools", "itertools", "import math", "math", "import sys", "sys", "import heapq", "heapq", "from collections import Counter", "from collections import deque", "from fractions import gcd", "INF = 1 << 60", "INF", "1 << 60", "1", "60", "sys.setrecursionlimit(10 ** 6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 6", "10", "6", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k", "ans", "k", "if n >= 2:\n ans = k * (k - 1) ** (n - 1)", "n >= 2", "n", "2", "ans = k * (k - 1) ** (n - 1)", "ans", "k * (k - 1) ** (n - 1)", "k", "(k - 1) ** (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "print(ans)", "print", "ans", "ans = k", "k", "ans", "k = map(int, input().split())", "map(int, input().split())", "k", "ans = k * (k - 1) ** (n - 1)", "k * (k - 1) ** (n - 1)", "ans", "INF = 1 << 60", "1 << 60", "INF", "n, k = map(int, input().split())", "map(int, input().split())", "n" ]

import itertools import math import sys import heapq from collections import Counter from collections import deque from fractions import gcd INF = 1 << 60 sys.setrecursionlimit(10 ** 6) #ここから書き始める n, k = map(int, input().split()) ans = k if n >= 2: ans = k * (k - 1) ** (n - 1) print(ans)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 35, 2 ], [ 35, 11 ], [ 38, 13 ], [ 36, 14 ], [ 17, 16 ], [ 33, 20 ], [ 41, 22 ], [ 39, 24 ], [ 42, 24 ], [ 36, 26 ], [ 42, 30 ], [ 39, 30 ], [ 35, 33 ], [ 35, 36 ], [ 36, 38 ], [ 38, 39 ], [ 41, 42 ] ]

[ "N,K=map(int,input().split())\nres = K\nfor i in range(1,N):\n res=res*(K-1)\nprint(res)", "N,K=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "res = K", "res", "K", "for i in range(1,N):\n res=res*(K-1)", "i", "range(1,N)", "range", "1", "N", "res=res*(K-1)", "res", "res*(K-1)", "res", "K-1", "K", "1", "print(res)", "print", "res", "N,K=map(int,input().split())", "map(int,input().split())", "N", "K=map(int,input().split())", "map(int,input().split())", "K", "res = K", "K", "res", "res=res*(K-1)", "res*(K-1)", "res" ]

N,K=map(int,input().split()) res = K for i in range(1,N): res=res*(K-1) print(res)

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 42, 2 ], [ 42, 13 ], [ 39, 15 ], [ 37, 16 ], [ 19, 18 ], [ 43, 22 ], [ 33, 25 ], [ 37, 27 ], [ 34, 31 ], [ 40, 31 ], [ 33, 34 ], [ 42, 37 ], [ 37, 39 ], [ 39, 40 ], [ 42, 43 ] ]

[ "N,K=list(map(int, input().split()))\nc=K\nfor i in range(N-1):\n c*= K-1\n\nprint(c)", "N,K=list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "c=K", "c", "K", "for i in range(N-1):\n c*= K-1", "i", "range(N-1)", "range", "N-1", "N", "1", "c*= K-1", "c", "K-1", "K", "1", "print(c)", "print", "c", "c*= K-1", "K-1", "c", "K=list(map(int, input().split()))", "list(map(int, input().split()))", "K", "c=K", "K", "c", "N,K=list(map(int, input().split()))", "list(map(int, input().split()))", "N" ]

N,K=list(map(int, input().split())) c=K for i in range(N-1): c*= K-1 print(c)

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 19, 18 ], [ 4, 21 ], [ 18, 24 ], [ 28, 27 ], [ 13, 28 ], [ 31, 30 ], [ 13, 32 ], [ 30, 36 ], [ 27, 36 ], [ 15, 36 ], [ 45, 42 ] ]

[ "# -*- coding: utf-8 -*-\n\ndef main():\n\n N, K = map(int, input().split())\n ans = 1\n\n for i in range(N):\n if i == 0:\n ans *= K\n\n else:\n ans *= (K-1)\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n\n N, K = map(int, input().split())\n ans = 1\n\n for i in range(N):\n if i == 0:\n ans *= K\n\n else:\n ans *= (K-1)\n\n print(ans)", "main", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = 1", "ans", "1", "for i in range(N):\n if i == 0:\n ans *= K\n\n else:\n ans *= (K-1)\n\n ", "i", "range(N)", "range", "N", "if i == 0:\n ans *= K\n\n else:\n ans *= (K-1)\n\n ", "i == 0", "i", "0", "ans *= K", "ans", "K", "ans *= (K-1)", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n\n N, K = map(int, input().split())\n ans = 1\n\n for i in range(N):\n if i == 0:\n ans *= K\n\n else:\n ans *= (K-1)\n\n print(ans)", "def main():\n\n N, K = map(int, input().split())\n ans = 1\n\n for i in range(N):\n if i == 0:\n ans *= K\n\n else:\n ans *= (K-1)\n\n print(ans)", "main" ]

# -*- coding: utf-8 -*- def main(): N, K = map(int, input().split()) ans = 1 for i in range(N): if i == 0: ans *= K else: ans *= (K-1) print(ans) if __name__ == "__main__": main()

[ 7, 15, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 12, 4, 18, 4, 18, 18, 13, 13, 13, 13, 0, 13, 12, 4, 13, 8, 13, 39, 4, 13, 17, 4, 13, 17, 23, 0, 13, 12, 4, 13, 8, 13, 39, 4, 13, 17, 4, 13, 17, 23, 0, 13, 12, 2, 4, 13, 13, 17, 23, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 114, 11 ], [ 126, 16 ], [ 111, 23 ], [ 117, 35 ], [ 129, 50 ], [ 123, 65 ], [ 77, 76 ], [ 112, 83 ], [ 77, 85 ], [ 88, 87 ], [ 85, 88 ], [ 91, 90 ], [ 76, 94 ], [ 98, 97 ], [ 85, 99 ], [ 97, 103 ], [ 87, 103 ], [ 121, 109 ], [ 111, 112 ], [ 114, 115 ], [ 117, 118 ], [ 123, 124 ], [ 126, 127 ], [ 129, 130 ] ]

[ "# -*- coding: utf-8 -*-\nimport sys\nsys.setrecursionlimit(10**9)\nINF=10**18\nMOD=10**9+7\ninput=lambda: sys.stdin.readline().rstrip()\nYesNo=lambda b: bool([print('Yes')] if b else print('No'))\nYESNO=lambda b: bool([print('YES')] if b else print('NO'))\nint1=lambda x:int(x)-1\n\ndef main():\n N,K=map(int,input().split())\n ans=K\n for i in range(N-1):\n ans*=K-1\n print(ans)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(10**9)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**9", "10", "9", "INF=10**18", "INF", "10**18", "10", "18", "MOD=10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "input=lambda: sys.stdin.readline().rstrip()", "input", "lambda: sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "YesNo=lambda b: bool([print('Yes')] if b else print('No'))", "YesNo", "lambda b: bool([print('Yes')] if b else print('No'))", "bool([print('Yes')] if b else print('No'))", "bool", "[print('Yes')] if b else print('No')", "b", "[print('Yes')]", "print('Yes')", "print", "'Yes'", "print('No')", "print", "'No'", "b", "YESNO=lambda b: bool([print('YES')] if b else print('NO'))", "YESNO", "lambda b: bool([print('YES')] if b else print('NO'))", "bool([print('YES')] if b else print('NO'))", "bool", "[print('YES')] if b else print('NO')", "b", "[print('YES')]", "print('YES')", "print", "'YES'", "print('NO')", "print", "'NO'", "b", "int1=lambda x:int(x)-1", "int1", "lambda x:int(x)-1", "int(x)-1", "int(x)", "int", "x", "1", "x", "def main():\n N,K=map(int,input().split())\n ans=K\n for i in range(N-1):\n ans*=K-1\n print(ans)", "main", "N,K=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans=K", "ans", "K", "for i in range(N-1):\n ans*=K-1\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "ans*=K-1", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "input=lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "input", "INF=10**18", "10**18", "INF", "YesNo=lambda b: bool([print('Yes')] if b else print('No'))", "lambda b: bool([print('Yes')] if b else print('No'))", "YesNo", "def main():\n N,K=map(int,input().split())\n ans=K\n for i in range(N-1):\n ans*=K-1\n print(ans)", "def main():\n N,K=map(int,input().split())\n ans=K\n for i in range(N-1):\n ans*=K-1\n print(ans)", "main", "int1=lambda x:int(x)-1", "lambda x:int(x)-1", "int1", "MOD=10**9+7", "10**9+7", "MOD", "YESNO=lambda b: bool([print('YES')] if b else print('NO'))", "lambda b: bool([print('YES')] if b else print('NO'))", "YESNO" ]

# -*- coding: utf-8 -*- import sys sys.setrecursionlimit(10**9) INF=10**18 MOD=10**9+7 input=lambda: sys.stdin.readline().rstrip() YesNo=lambda b: bool([print('Yes')] if b else print('No')) YESNO=lambda b: bool([print('YES')] if b else print('NO')) int1=lambda x:int(x)-1 def main(): N,K=map(int,input().split()) ans=K for i in range(N-1): ans*=K-1 print(ans) if __name__ == '__main__': main()

[ 7, 0, 13, 4, 18, 4, 13, 13, 17, 0, 13, 39, 4, 13, 18, 13, 17, 4, 13, 18, 13, 17, 4, 13, 2, 18, 13, 17, 2, 2, 18, 13, 17, 17, 2, 18, 13, 17, 17, 10, 4, 13, 10, 39, 13 ]

[ [ 40, 2 ], [ 43, 10 ], [ 41, 15 ], [ 41, 20 ], [ 44, 26 ], [ 44, 31 ], [ 44, 36 ], [ 40, 41 ], [ 43, 44 ] ]

[ "s=input().split(' ')\n\na=[int(s[0]),int(s[1])]\n\nprint(a[1]*((a[1]-1)**(a[0]-1)))", "s=input().split(' ')", "s", "input().split(' ')", "().split", "()", "input", "split", "' '", "a=[int(s[0]),int(s[1])]", "a", "[int(s[0]),int(s[1])]", "int(s[0])", "int", "s[0]", "s", "0", "int(s[1])", "int", "s[1]", "s", "1", "print(a[1]*((a[1]-1)**(a[0]-1)))", "print", "a[1]*((a[1]-1)**(a[0]-1))", "a[1]", "a", "1", "(a[1]-1)**(a[0]-1)", "a[1]-1", "a[1]", "a", "1", "1", "a[0]-1", "a[0]", "a", "0", "1", "s=input().split(' ')", "input().split(' ')", "s", "a=[int(s[0]),int(s[1])]", "[int(s[0]),int(s[1])]", "a" ]

s=input().split(' ') a=[int(s[0]),int(s[1])] print(a[1]*((a[1]-1)**(a[0]-1)))

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 0, 13, 18, 13, 17, 0, 13, 18, 13, 17, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 18, 13, 10, 18, 13, 10, 4, 13 ]

[ [ 41, 2 ], [ 38, 14 ], [ 42, 16 ], [ 35, 19 ], [ 42, 21 ], [ 36, 26 ], [ 36, 29 ], [ 39, 32 ], [ 35, 36 ], [ 38, 39 ], [ 41, 42 ] ]

[ "x = list(map(int,input().split()))\na = x[0]\nb = x[1]\nprint(b*((b-1) ** (a-1)))", "x = list(map(int,input().split()))", "x", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "a = x[0]", "a", "x[0]", "x", "0", "b = x[1]", "b", "x[1]", "x", "1", "print(b*((b-1) ** (a-1)))", "print", "b*((b-1) ** (a-1))", "b", "(b-1) ** (a-1)", "b-1", "b", "1", "a-1", "a", "1", "b = x[1]", "x[1]", "b", "a = x[0]", "x[0]", "a", "x = list(map(int,input().split()))", "list(map(int,input().split()))", "x" ]

x = list(map(int,input().split())) a = x[0] b = x[1] print(b*((b-1) ** (a-1)))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 34, 2 ], [ 34, 11 ], [ 35, 14 ], [ 32, 18 ], [ 32, 22 ], [ 32, 25 ], [ 35, 28 ], [ 34, 32 ], [ 34, 35 ] ]

[ "N,K = map(int,input().split())\n\nif N ==1:\n print(K)\nelse:\n print(K*(K-1)**(N-1))", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "if N ==1:\n print(K)\nelse:\n print(K*(K-1)**(N-1))", "N ==1", "N", "1", "print(K)", "print", "K", "print(K*(K-1)**(N-1))", "print", "K*(K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "K = map(int,input().split())", "map(int,input().split())", "K", "N,K = map(int,input().split())", "map(int,input().split())", "N" ]

N,K = map(int,input().split()) if N ==1: print(K) else: print(K*(K-1)**(N-1))

[ 7, 15, 13, 15, 13, 15, 13, 15, 13, 15, 4, 18, 13, 13, 2, 17, 17, 12, 13, 12, 13, 12, 13, 12, 13, 14, 4, 18, 13, 13, 17, 0, 13, 2, 18, 4, 18, 18, 13, 13, 13, 4, 18, 18, 13, 13, 13, 13, 17, 17, 0, 13, 2, 0, 18, 13, 13, 4, 13, 13, 17, 0, 13, 4, 13, 17, 0, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 2, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 128, 32 ], [ 128, 51 ], [ 57, 54 ], [ 114, 59 ], [ 131, 62 ], [ 101, 67 ], [ 110, 72 ], [ 122, 79 ], [ 99, 81 ], [ 122, 82 ], [ 125, 84 ], [ 123, 86 ], [ 123, 89 ], [ 108, 92 ], [ 126, 96 ], [ 101, 102 ], [ 122, 108 ], [ 110, 111 ], [ 128, 114 ], [ 122, 123 ], [ 125, 126 ], [ 128, 129 ], [ 131, 132 ] ]

[ "import math\nimport numpy as np\nimport sys\nimport os\nfrom operator import mul\n\nsys.setrecursionlimit(10**7)\n\ndef _S(): return sys.stdin.readline().rstrip()\ndef I(): return int(_S())\ndef LS(): return list(_S().split())\ndef LI(): return list(map(int,LS()))\n\nif os.getenv(\"LOCAL\"):\n inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'\n sys.stdin = open(inputFile, \"r\")\nINF = float(\"inf\")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n# MOD = 998244353 \n\nN,K = LI()\n\nans = K*(K-1)**(N-1)\nprint(ans)", "import math", "math", "import numpy as np", "numpy", "import sys", "sys", "import os", "os", "from operator import mul", "sys.setrecursionlimit(10**7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**7", "10", "7", "def _S(): return sys.stdin.readline().rstrip()", "_S", "def I(): return int(_S())", "I", "def LS(): return list(_S().split())", "LS", "def LI(): return list(map(int,LS()))", "LI", "if os.getenv(\"LOCAL\"):\n inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'\n sys.stdin = open(inputFile, \"r\")", "os.getenv(\"LOCAL\")", "os.getenv", "os", "getenv", "\"LOCAL\"", "inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "inputFile", "os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "os.path.splitext(os.path.basename(__file__))[0]", "os.path.splitext(os.path.basename(__file__))", "os.path.splitext", "os.path", "os", "path", "splitext", "os.path.basename(__file__)", "os.path.basename", "os.path", "os", "path", "basename", "__file__", "0", "'.txt'", "= basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "basename_without_ext", "os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "sys.stdin = open(inputFile, \"r\")", "sys.stdin", "sys", "stdin", "open(inputFile, \"r\")", "open", "inputFile", "\"r\"", "INF = float(\"inf\")", "INF", "float(\"inf\")", "float", "\"inf\"", "IINF = 10 ** 18", "IINF", "10 ** 18", "10", "18", "MOD = 10 ** 9 + 7", "MOD", "10 ** 9 + 7", "10 ** 9", "10", "9", "7", "N,K = LI()", "N", "LI()", "LI", "K", "ans = K*(K-1)**(N-1)", "ans", "K*(K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "def LI(): return list(map(int,LS()))", "def LI(): return list(map(int,LS()))", "LI", "IINF = 10 ** 18", "10 ** 18", "IINF", "def LS(): return list(_S().split())", "def LS(): return list(_S().split())", "LS", "N,K = LI()", "LI()", "N", "MOD = 10 ** 9 + 7", "10 ** 9 + 7", "MOD", "inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "inputFile", "def _S(): return sys.stdin.readline().rstrip()", "def _S(): return sys.stdin.readline().rstrip()", "_S", "def I(): return int(_S())", "def I(): return int(_S())", "I", "K = LI()", "LI()", "K", "ans = K*(K-1)**(N-1)", "K*(K-1)**(N-1)", "ans", "basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "os.path.splitext(os.path.basename(__file__))[0]+'.txt'", "basename_without_ext", "INF = float(\"inf\")", "float(\"inf\")", "INF" ]

import math import numpy as np import sys import os from operator import mul sys.setrecursionlimit(10**7) def _S(): return sys.stdin.readline().rstrip() def I(): return int(_S()) def LS(): return list(_S().split()) def LI(): return list(map(int,LS())) if os.getenv("LOCAL"): inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt' sys.stdin = open(inputFile, "r") INF = float("inf") IINF = 10 ** 18 MOD = 10 ** 9 + 7 # MOD = 998244353 N,K = LI() ans = K*(K-1)**(N-1) print(ans)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 33, 2 ], [ 33, 11 ], [ 27, 13 ], [ 31, 15 ], [ 31, 18 ], [ 34, 21 ], [ 28, 25 ], [ 27, 28 ], [ 33, 31 ], [ 33, 34 ] ]

[ "n, k = map(int, input().split())\n\nanswer = k*((k-1)**(n-1))\nprint(answer)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "answer = k*((k-1)**(n-1))", "answer", "k*((k-1)**(n-1))", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "print(answer)", "print", "answer", "answer = k*((k-1)**(n-1))", "k*((k-1)**(n-1))", "answer", "k = map(int, input().split())", "map(int, input().split())", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n" ]

n, k = map(int, input().split()) answer = k*((k-1)**(n-1)) print(answer)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 33, 2 ], [ 33, 11 ], [ 27, 13 ], [ 34, 15 ], [ 34, 18 ], [ 31, 21 ], [ 28, 25 ], [ 27, 28 ], [ 33, 31 ], [ 33, 34 ] ]

[ "n,m=map(int,input().split())\nk=m*((m-1)**(n-1))\nprint(k)", "n,m=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "k=m*((m-1)**(n-1))", "k", "m*((m-1)**(n-1))", "m", "(m-1)**(n-1)", "m-1", "m", "1", "n-1", "n", "1", "print(k)", "print", "k", "k=m*((m-1)**(n-1))", "m*((m-1)**(n-1))", "k", "n,m=map(int,input().split())", "map(int,input().split())", "n", "m=map(int,input().split())", "map(int,input().split())", "m" ]

n,m=map(int,input().split()) k=m*((m-1)**(n-1)) print(k)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 46, 2 ], [ 46, 11 ], [ 43, 13 ], [ 47, 17 ], [ 40, 20 ], [ 38, 21 ], [ 49, 23 ], [ 38, 25 ], [ 38, 28 ], [ 47, 31 ], [ 50, 35 ], [ 41, 35 ], [ 44, 35 ], [ 46, 38 ], [ 38, 40 ], [ 40, 41 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ] ]

[ "N, K = map(int, input().split())\nans = 0\n\nif(N == 1):\n ans = K\nelse:\n ans = K*(K-1)**(N-1)\n \nprint(ans)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = 0", "ans", "0", "if(N == 1):\n ans = K\nelse:\n ans = K*(K-1)**(N-1)\n ", "N == 1", "N", "1", "ans = K", "ans", "K", "ans = K*(K-1)**(N-1)", "ans", "K*(K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "K = map(int, input().split())", "map(int, input().split())", "K", "ans = K", "K", "ans", "ans = 0", "0", "ans", "N, K = map(int, input().split())", "map(int, input().split())", "N", "ans = K*(K-1)**(N-1)", "K*(K-1)**(N-1)", "ans" ]

N, K = map(int, input().split()) ans = 0 if(N == 1): ans = K else: ans = K*(K-1)**(N-1) print(ans)

[ 7, 15, 14, 2, 13, 17, 41, 28, 13, 4, 18, 13, 13, 4, 4, 18, 13, 13, 0, 13, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 18, 13, 17, 13, 17, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 9, 8 ], [ 8, 16 ], [ 51, 19 ], [ 60, 22 ], [ 52, 31 ], [ 60, 35 ], [ 57, 37 ], [ 61, 39 ], [ 61, 42 ], [ 55, 45 ], [ 58, 49 ], [ 51, 52 ], [ 60, 55 ], [ 57, 58 ], [ 60, 61 ] ]

[ "from sys import stdin\n\n\nif __name__ == \"__main__\":\n _in = [_.rstrip() for _ in stdin.readlines()]\n N, K = list(map(int,_in[0].split(' '))) # type:list(int)\n # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n cnt = K*(K-1)**(N-1)\n # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n print(cnt)", "from sys import stdin", "if __name__ == \"__main__\":\n _in = [_.rstrip() for _ in stdin.readlines()]\n N, K = list(map(int,_in[0].split(' '))) # type:list(int)\n # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv\n cnt = K*(K-1)**(N-1)\n # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n print(cnt)", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "_.rstrip() for _ in stdin.readlines()", "for _ in stdin.readlines()", "_", "stdin.readlines()", "stdin.readlines", "stdin", "readlines", "for _ in stdin.readlines()", "_.rstrip()", "_.rstrip", "_", "rstrip", "_in = [_.rstrip() for _ in stdin.readlines()]", "_in", "[_.rstrip() for _ in stdin.readlines()]", "N, K = list(map(int,_in[0].split(' ')))", "N", "list(map(int,_in[0].split(' ')))", "list", "map(int,_in[0].split(' '))", "map", "int", "_in[0].split(' ')", "[0].split", "[0]", "_in", "0", "split", "' '", "K", "cnt = K*(K-1)**(N-1)", "cnt", "K*(K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(cnt)", "print", "cnt", "_in = [_.rstrip() for _ in stdin.readlines()]", "[_.rstrip() for _ in stdin.readlines()]", "_in", "N, K = list(map(int,_in[0].split(' ')))", "list(map(int,_in[0].split(' ')))", "N", "cnt = K*(K-1)**(N-1)", "K*(K-1)**(N-1)", "cnt", "K = list(map(int,_in[0].split(' ')))", "list(map(int,_in[0].split(' ')))", "K" ]

from sys import stdin if __name__ == "__main__": _in = [_.rstrip() for _ in stdin.readlines()] N, K = list(map(int,_in[0].split(' '))) # type:list(int) # vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv cnt = K*(K-1)**(N-1) # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ print(cnt)

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 18, 18, 13, 13, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 33, 4 ], [ 33, 17 ], [ 34, 21 ], [ 34, 24 ], [ 31, 27 ], [ 33, 31 ], [ 33, 34 ] ]

[ "import sys\n\nN, K = map(int, sys.stdin.readline().split())\nprint(K * (K - 1) ** (N - 1))", "import sys", "sys", "N, K = map(int, sys.stdin.readline().split())", "N", "map(int, sys.stdin.readline().split())", "map", "int", "sys.stdin.readline().split()", "sys.stdin.readline().split", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "split", "K", "print(K * (K - 1) ** (N - 1))", "print", "K * (K - 1) ** (N - 1)", "K", "(K - 1) ** (N - 1)", "K - 1", "K", "1", "N - 1", "N", "1", "N, K = map(int, sys.stdin.readline().split())", "map(int, sys.stdin.readline().split())", "N", "K = map(int, sys.stdin.readline().split())", "map(int, sys.stdin.readline().split())", "K" ]

import sys N, K = map(int, sys.stdin.readline().split()) print(K * (K - 1) ** (N - 1))

[ 7, 15, 13, 15, 13, 15, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 11, 10 ], [ 11, 19 ], [ 22, 21 ], [ 25, 24 ], [ 10, 27 ], [ 24, 30 ], [ 34, 33 ], [ 19, 34 ], [ 37, 36 ], [ 19, 38 ], [ 36, 42 ], [ 33, 42 ], [ 21, 42 ], [ 51, 48 ] ]

[ "import sys\nimport math\nimport bisect\n\ndef main():\n n, k = map(int, input().split())\n ans = 1\n for i in range(n):\n if i == 0:\n ans *= k\n else:\n ans *= k - 1\n print(ans)\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "import math", "math", "import bisect", "bisect", "def main():\n n, k = map(int, input().split())\n ans = 1\n for i in range(n):\n if i == 0:\n ans *= k\n else:\n ans *= k - 1\n print(ans)", "main", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 1", "ans", "1", "for i in range(n):\n if i == 0:\n ans *= k\n else:\n ans *= k - 1\n ", "i", "range(n)", "range", "n", "if i == 0:\n ans *= k\n else:\n ans *= k - 1\n ", "i == 0", "i", "0", "ans *= k", "ans", "k", "ans *= k - 1", "ans", "k - 1", "k", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n, k = map(int, input().split())\n ans = 1\n for i in range(n):\n if i == 0:\n ans *= k\n else:\n ans *= k - 1\n print(ans)", "def main():\n n, k = map(int, input().split())\n ans = 1\n for i in range(n):\n if i == 0:\n ans *= k\n else:\n ans *= k - 1\n print(ans)", "main" ]

import sys import math import bisect def main(): n, k = map(int, input().split()) ans = 1 for i in range(n): if i == 0: ans *= k else: ans *= k - 1 print(ans) if __name__ == "__main__": main()

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 33, 2 ], [ 33, 11 ], [ 27, 13 ], [ 34, 15 ], [ 34, 18 ], [ 31, 21 ], [ 28, 25 ], [ 27, 28 ], [ 33, 31 ], [ 33, 34 ] ]

[ "N,K = map(int,input().split())\n\nres = K*((K-1)**(N-1))\nprint(res)", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "res = K*((K-1)**(N-1))", "res", "K*((K-1)**(N-1))", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(res)", "print", "res", "res = K*((K-1)**(N-1))", "K*((K-1)**(N-1))", "res", "N,K = map(int,input().split())", "map(int,input().split())", "N", "K = map(int,input().split())", "map(int,input().split())", "K" ]

N,K = map(int,input().split()) res = K*((K-1)**(N-1)) print(res)

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 17, 4, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 38, 2 ], [ 38, 13 ], [ 36, 16 ], [ 39, 26 ], [ 39, 29 ], [ 36, 32 ], [ 38, 36 ], [ 38, 39 ] ]

[ "n, k = list(map(int, input().split()))\n\nif n == 0:\n print(0)\n exit()\n\nprint(k * (k-1)**(n-1))", "n, k = list(map(int, input().split()))", "n", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "if n == 0:\n print(0)\n exit()", "n == 0", "n", "0", "print(0)", "print", "0", "exit()", "exit", "print(k * (k-1)**(n-1))", "print", "k * (k-1)**(n-1)", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "n, k = list(map(int, input().split()))", "list(map(int, input().split()))", "n", "k = list(map(int, input().split()))", "list(map(int, input().split()))", "k" ]

n, k = list(map(int, input().split())) if n == 0: print(0) exit() print(k * (k-1)**(n-1))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 26, 2 ], [ 26, 11 ], [ 27, 14 ], [ 27, 17 ], [ 24, 20 ], [ 26, 24 ], [ 26, 27 ] ]

[ "n,k = map(int, raw_input().split())\nprint k * ((k-1) ** (n-1))", "n,k = map(int, raw_input().split())", "n", "map(int, raw_input().split())", "map", "int", "raw_input().split()", "().split", "()", "raw_input", "split", "k", "print", "k * ((k-1) ** (n-1))", "k", "(k-1) ** (n-1)", "k-1", "k", "1", "n-1", "n", "1", "n,k = map(int, raw_input().split())", "map(int, raw_input().split())", "n", "k = map(int, raw_input().split())", "map(int, raw_input().split())", "k" ]

n,k = map(int, raw_input().split()) print k * ((k-1) ** (n-1))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 17, 4, 13, 2, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 38, 2 ], [ 38, 11 ], [ 41, 13 ], [ 17, 16 ], [ 33, 20 ], [ 35, 22 ], [ 39, 24 ], [ 36, 29 ], [ 42, 29 ], [ 39, 30 ], [ 38, 33 ], [ 35, 36 ], [ 38, 39 ], [ 41, 42 ] ]

[ "n, k = map(int, input().split())\n\nresult = 1\nfor _ in range(1, n):\n result *= k - 1\nprint(result * k)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "result = 1", "result", "1", "for _ in range(1, n):\n result *= k - 1", "_", "range(1, n)", "range", "1", "n", "result *= k - 1", "result", "k - 1", "k", "1", "print(result * k)", "print", "result * k", "result", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n", "result *= k - 1", "k - 1", "result", "k = map(int, input().split())", "map(int, input().split())", "k", "result = 1", "1", "result" ]

n, k = map(int, input().split()) result = 1 for _ in range(1, n): result *= k - 1 print(result * k)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 28, 13, 4, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 35, 2 ], [ 35, 11 ], [ 14, 13 ], [ 33, 16 ], [ 38, 18 ], [ 36, 20 ], [ 36, 23 ], [ 33, 26 ], [ 39, 30 ], [ 35, 33 ], [ 35, 36 ], [ 38, 39 ] ]

[ "N, K = map(int, input().split())\nfor i in range(N):\n ans = K * (K-1)**(N-1)\n\nprint(ans)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "for i in range(N):\n ans = K * (K-1)**(N-1)", "i", "range(N)", "range", "N", "ans = K * (K-1)**(N-1)", "ans", "K * (K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "N, K = map(int, input().split())", "map(int, input().split())", "N", "K = map(int, input().split())", "map(int, input().split())", "K", "ans = K * (K-1)**(N-1)", "K * (K-1)**(N-1)", "ans" ]

N, K = map(int, input().split()) for i in range(N): ans = K * (K-1)**(N-1) print(ans)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 0, 13, 17, 14, 13, 28, 13, 4, 13, 13, 0, 13, 2, 2, 13, 17, 13, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 45, 2 ], [ 45, 11 ], [ 36, 13 ], [ 40, 14 ], [ 48, 16 ], [ 22, 21 ], [ 49, 24 ], [ 46, 24 ], [ 42, 26 ], [ 40, 29 ], [ 37, 31 ], [ 43, 31 ], [ 43, 34 ], [ 37, 34 ], [ 40, 36 ], [ 36, 37 ], [ 45, 40 ], [ 42, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "N, K = map(int, input().split())\n\n\np = K\nN -= 1\nif N:\n for i in range(N):\n p = (K - 1) * p\nprint(p)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "p = K", "p", "K", "N -= 1", "N", "1", "if N:\n for i in range(N):\n p = (K - 1) * p", "N", "for i in range(N):\n p = (K - 1) * p", "i", "range(N)", "range", "N", "p = (K - 1) * p", "p", "(K - 1) * p", "K - 1", "K", "1", "p", "print(p)", "print", "p", "p = K", "K", "p", "K = map(int, input().split())", "map(int, input().split())", "K", "p = (K - 1) * p", "(K - 1) * p", "p", "N, K = map(int, input().split())", "map(int, input().split())", "N", "N -= 1", "1", "N" ]

N, K = map(int, input().split()) p = K N -= 1 if N: for i in range(N): p = (K - 1) * p print(p)

[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 21, 20 ], [ 18, 22 ], [ 18, 25 ], [ 16, 28 ], [ 20, 32 ], [ 41, 38 ] ]

[ "def main():\n n, k = [int(e) for e in input().split()]\n ans = k * ((k - 1)**(n - 1))\n\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n n, k = [int(e) for e in input().split()]\n ans = k * ((k - 1)**(n - 1))\n\n print(ans)", "main", "int(e) for e in input().split()", "for e in input().split()", "e", "input().split()", "().split", "()", "input", "split", "for e in input().split()", "int(e)", "int", "e", "n, k = [int(e) for e in input().split()]", "n", "[int(e) for e in input().split()]", "k", "ans = k * ((k - 1)**(n - 1))", "ans", "k * ((k - 1)**(n - 1))", "k", "(k - 1)**(n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n, k = [int(e) for e in input().split()]\n ans = k * ((k - 1)**(n - 1))\n\n print(ans)", "def main():\n n, k = [int(e) for e in input().split()]\n ans = k * ((k - 1)**(n - 1))\n\n print(ans)", "main" ]

def main(): n, k = [int(e) for e in input().split()] ans = k * ((k - 1)**(n - 1)) print(ans) if __name__ == "__main__": main()

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 29, 2 ], [ 29, 13 ], [ 30, 17 ], [ 30, 20 ], [ 27, 23 ], [ 29, 27 ], [ 29, 30 ] ]

[ "n, k = list(map(int, input().split()))\nprint(k * ((k - 1) ** (n - 1)))", "n, k = list(map(int, input().split()))", "n", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k * ((k - 1) ** (n - 1)))", "print", "k * ((k - 1) ** (n - 1))", "k", "(k - 1) ** (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "n, k = list(map(int, input().split()))", "list(map(int, input().split()))", "n", "k = list(map(int, input().split()))", "list(map(int, input().split()))", "k" ]

n, k = list(map(int, input().split())) print(k * ((k - 1) ** (n - 1)))

[ 7, 15, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 38, 4 ], [ 38, 15 ], [ 32, 17 ], [ 39, 19 ], [ 39, 23 ], [ 36, 26 ], [ 33, 30 ], [ 32, 33 ], [ 38, 36 ], [ 38, 39 ] ]

[ "import math\nk,m=list(map(int,input().split()))\nres=m*pow(m-1,k-1)\nprint(res)", "import math", "math", "k,m=list(map(int,input().split()))", "k", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "res=m*pow(m-1,k-1)", "res", "m*pow(m-1,k-1)", "m", "pow(m-1,k-1)", "pow", "m-1", "m", "1", "k-1", "k", "1", "print(res)", "print", "res", "res=m*pow(m-1,k-1)", "m*pow(m-1,k-1)", "res", "k,m=list(map(int,input().split()))", "list(map(int,input().split()))", "k", "m=list(map(int,input().split()))", "list(map(int,input().split()))", "m" ]

import math k,m=list(map(int,input().split())) res=m*pow(m-1,k-1) print(res)

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 17, 13, 0, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 37, 2 ], [ 37, 14 ], [ 31, 16 ], [ 38, 18 ], [ 38, 22 ], [ 35, 25 ], [ 32, 29 ], [ 31, 32 ], [ 37, 35 ], [ 37, 38 ] ]

[ "\na, b = list(map(int, input().split(' ')))\nans = b * pow(b-1, a-1)\nprint(ans)\n", "a, b = list(map(int, input().split(' ')))", "a", "list(map(int, input().split(' ')))", "list", "map(int, input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "b", "ans = b * pow(b-1, a-1)", "ans", "b * pow(b-1, a-1)", "b", "pow(b-1, a-1)", "pow", "b-1", "b", "1", "a-1", "a", "1", "print(ans)", "print", "ans", "ans = b * pow(b-1, a-1)", "b * pow(b-1, a-1)", "ans", "a, b = list(map(int, input().split(' ')))", "list(map(int, input().split(' ')))", "a", "b = list(map(int, input().split(' ')))", "list(map(int, input().split(' ')))", "b" ]

a, b = list(map(int, input().split(' '))) ans = b * pow(b-1, a-1) print(ans)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 2, 2, 13, 17, 2, 13, 17, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 27, 2 ], [ 27, 11 ], [ 28, 17 ], [ 25, 20 ], [ 28, 22 ], [ 27, 25 ], [ 27, 28 ] ]

[ "a,b=map(int,input().split())\nprint(((b-1)**(a-1))*b)", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "print(((b-1)**(a-1))*b)", "print", "((b-1)**(a-1))*b", "(b-1)**(a-1)", "b-1", "b", "1", "a-1", "a", "1", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a", "b=map(int,input().split())", "map(int,input().split())", "b" ]

a,b=map(int,input().split()) print(((b-1)**(a-1))*b)

[ 7, 12, 13, 15, 13, 0, 13, 18, 18, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 15, 15, 15, 15, 15, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 7, 6 ], [ 26, 25 ], [ 6, 32 ], [ 26, 34 ], [ 34, 38 ], [ 34, 41 ], [ 25, 44 ], [ 54, 51 ] ]

[ "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n,k = map(int, input().split())\n print(k*((k-1)**(n-1)))\n\nif __name__ == '__main__':\n main()", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n,k = map(int, input().split())\n print(k*((k-1)**(n-1)))", "main", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "sys.setrecursionlimit(10**7)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**7", "10", "7", "from collections import Counter, deque", "from itertools import combinations, permutations, accumulate, groupby, product", "from bisect import bisect_left,bisect_right", "from heapq import heapify, heappop, heappush", "from math import floor, ceil", "n,k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k*((k-1)**(n-1)))", "print", "k*((k-1)**(n-1))", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n,k = map(int, input().split())\n print(k*((k-1)**(n-1)))", "def main():\n import sys\n input = sys.stdin.readline\n sys.setrecursionlimit(10**7)\n from collections import Counter, deque\n #from collections import defaultdict\n from itertools import combinations, permutations, accumulate, groupby, product\n from bisect import bisect_left,bisect_right\n from heapq import heapify, heappop, heappush\n from math import floor, ceil\n #from operator import itemgetter\n\n #inf = 10**17\n #mod = 10**9 + 7\n\n n,k = map(int, input().split())\n print(k*((k-1)**(n-1)))", "main" ]

def main(): import sys input = sys.stdin.readline sys.setrecursionlimit(10**7) from collections import Counter, deque #from collections import defaultdict from itertools import combinations, permutations, accumulate, groupby, product from bisect import bisect_left,bisect_right from heapq import heapify, heappop, heappush from math import floor, ceil #from operator import itemgetter #inf = 10**17 #mod = 10**9 + 7 n,k = map(int, input().split()) print(k*((k-1)**(n-1))) if __name__ == '__main__': main()

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 4, 16 ], [ 13, 20 ], [ 13, 24 ], [ 13, 27 ], [ 4, 30 ], [ 36, 33 ] ]

[ "def resolve():\n\tn, k = map(int, input().split())\n\tif n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k*((k-1)**(n-1)))\nresolve()", "def resolve():\n\tn, k = map(int, input().split())\n\tif n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k*((k-1)**(n-1)))", "resolve", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "if n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k*((k-1)**(n-1)))", "n == 1", "n", "1", "print(k)", "print", "k", "print(k*((k-1)**(n-1)))", "print", "k*((k-1)**(n-1))", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "resolve()", "resolve", "def resolve():\n\tn, k = map(int, input().split())\n\tif n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k*((k-1)**(n-1)))", "def resolve():\n\tn, k = map(int, input().split())\n\tif n == 1:\n\t\tprint(k)\n\telse:\n\t\tprint(k*((k-1)**(n-1)))", "resolve" ]

def resolve(): n, k = map(int, input().split()) if n == 1: print(k) else: print(k*((k-1)**(n-1))) resolve()

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 33, 2 ], [ 33, 11 ], [ 30, 13 ], [ 28, 15 ], [ 28, 18 ], [ 34, 21 ], [ 31, 25 ], [ 33, 28 ], [ 30, 31 ], [ 33, 34 ] ]

[ "n, k = map(int, input().split())\nansw = k * (k - 1) ** (n - 1)\nprint(answ)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "answ = k * (k - 1) ** (n - 1)", "answ", "k * (k - 1) ** (n - 1)", "k", "(k - 1) ** (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "print(answ)", "print", "answ", "k = map(int, input().split())", "map(int, input().split())", "k", "answ = k * (k - 1) ** (n - 1)", "k * (k - 1) ** (n - 1)", "answ", "n, k = map(int, input().split())", "map(int, input().split())", "n" ]

n, k = map(int, input().split()) answ = k * (k - 1) ** (n - 1) print(answ)

[ 7, 15, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 29, 3 ], [ 29, 12 ], [ 27, 16 ], [ 27, 20 ], [ 30, 23 ], [ 29, 27 ], [ 29, 30 ] ]

[ "from sys import exit\n\nn,k = map(int, input().split())\nprint(k*pow(k-1,n-1))", "from sys import exit", "n,k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k*pow(k-1,n-1))", "print", "k*pow(k-1,n-1)", "k", "pow(k-1,n-1)", "pow", "k-1", "k", "1", "n-1", "n", "1", "k = map(int, input().split())", "map(int, input().split())", "k", "n,k = map(int, input().split())", "map(int, input().split())", "n" ]

from sys import exit n,k = map(int, input().split()) print(k*pow(k-1,n-1))

[ 7, 0, 13, 4, 13, 0, 13, 4, 18, 13, 13, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 13, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 66, 2 ], [ 54, 6 ], [ 67, 9 ], [ 69, 12 ], [ 55, 16 ], [ 60, 19 ], [ 55, 23 ], [ 57, 26 ], [ 61, 27 ], [ 70, 31 ], [ 61, 34 ], [ 41, 40 ], [ 70, 44 ], [ 63, 46 ], [ 61, 48 ], [ 64, 52 ], [ 58, 52 ], [ 54, 55 ], [ 61, 57 ], [ 57, 58 ], [ 60, 61 ], [ 63, 64 ], [ 66, 67 ], [ 69, 70 ] ]

[ "i = input()\nj = i.split()\nnum_balls = int(j[0])\nnum_colors = int(j[1])\nproduct = num_colors\nif(num_balls > 1 and num_colors == 1):\n print(0)\nelse:\n for i in range(1, num_balls):\n product *= (num_colors - 1)\n print(product)", "i = input()", "i", "input()", "input", "j = i.split()", "j", "i.split()", "i.split", "i", "split", "num_balls = int(j[0])", "num_balls", "int(j[0])", "int", "j[0]", "j", "0", "num_colors = int(j[1])", "num_colors", "int(j[1])", "int", "j[1]", "j", "1", "product = num_colors", "product", "num_colors", "if(num_balls > 1 and num_colors == 1):\n print(0)\nelse:\n for i in range(1, num_balls):\n product *= (num_colors - 1)\n print(product)", "num_balls > 1 and num_colors == 1", "num_balls > 1", "num_balls", "1", "num_colors == 1", "num_colors", "1", "print(0)", "print", "0", "for i in range(1, num_balls):\n product *= (num_colors - 1)\n ", "i", "range(1, num_balls)", "range", "1", "num_balls", "product *= (num_colors - 1)", "product", "num_colors - 1", "num_colors", "1", "print(product)", "print", "product", "j = i.split()", "i.split()", "j", "product = num_colors", "num_colors", "product", "num_colors = int(j[1])", "int(j[1])", "num_colors", "product *= (num_colors - 1)", "num_colors - 1", "product", "i = input()", "input()", "i", "num_balls = int(j[0])", "int(j[0])", "num_balls" ]

i = input() j = i.split() num_balls = int(j[0]) num_colors = int(j[1]) product = num_colors if(num_balls > 1 and num_colors == 1): print(0) else: for i in range(1, num_balls): product *= (num_colors - 1) print(product)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 13, 13 ]

[ [ 41, 2 ], [ 41, 11 ], [ 47, 13 ], [ 17, 16 ], [ 42, 19 ], [ 16, 22 ], [ 50, 25 ], [ 39, 26 ], [ 44, 28 ], [ 48, 30 ], [ 45, 30 ], [ 51, 30 ], [ 39, 32 ], [ 45, 36 ], [ 51, 36 ], [ 48, 36 ], [ 41, 39 ], [ 41, 42 ], [ 44, 45 ], [ 47, 48 ], [ 39, 50 ], [ 50, 51 ] ]

[ "n, k = map(int, input().split())\nv = 0\nfor i in range(n):\n\tif i == 0:\n\t\tv = k\n\telse:\n\t\tv = v*(k-1)\nprint(v)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "v = 0", "v", "0", "for i in range(n):\n\tif i == 0:\n\t\tv = k\n\telse:\n\t\tv = v*(k-1)", "i", "range(n)", "range", "n", "if i == 0:\n\t\tv = k\n\telse:\n\t\tv = v*(k-1)", "i == 0", "i", "0", "v = k", "v", "k", "v = v*(k-1)", "v", "v*(k-1)", "v", "k-1", "k", "1", "print(v)", "print", "v", "k = map(int, input().split())", "map(int, input().split())", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n", "v = v*(k-1)", "v*(k-1)", "v", "v = 0", "0", "v", "v = k", "k", "v" ]

n, k = map(int, input().split()) v = 0 for i in range(n): if i == 0: v = k else: v = v*(k-1) print(v)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 14, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 46, 2 ], [ 46, 11 ], [ 14, 13 ], [ 47, 16 ], [ 13, 19 ], [ 37, 22 ], [ 44, 23 ], [ 13, 26 ], [ 40, 29 ], [ 44, 31 ], [ 41, 35 ], [ 38, 35 ], [ 44, 37 ], [ 37, 38 ], [ 40, 41 ], [ 46, 44 ], [ 46, 47 ] ]

[ "N,K=map(int,input().split())\nfor i in range(N):\n if i==0:\n ans=K\n if i>0:\n ans*=(K-1)\nprint(ans)", "N,K=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "for i in range(N):\n if i==0:\n ans=K\n if i>0:\n ans*=(K-1)", "i", "range(N)", "range", "N", "if i==0:\n ans=K\n ", "i==0", "i", "0", "ans=K", "ans", "K", "if i>0:\n ans*=(K-1)", "i>0", "i", "0", "ans*=(K-1)", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "ans=K", "K", "ans", "ans*=(K-1)", "K-1", "ans", "K=map(int,input().split())", "map(int,input().split())", "K", "N,K=map(int,input().split())", "map(int,input().split())", "N" ]

N,K=map(int,input().split()) for i in range(N): if i==0: ans=K if i>0: ans*=(K-1) print(ans)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 44, 2 ], [ 44, 11 ], [ 42, 14 ], [ 45, 18 ], [ 47, 20 ], [ 45, 21 ], [ 24, 23 ], [ 42, 27 ], [ 38, 30 ], [ 45, 32 ], [ 39, 36 ], [ 48, 36 ], [ 38, 39 ], [ 44, 42 ], [ 44, 45 ], [ 45, 47 ], [ 47, 48 ] ]

[ "n,k=map(int,input().split())\nif n==1:\n print(k)\nelse:\n sum=k\n for i in range(n-1):\n sum*=k-1\n print(sum)", "n,k=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "if n==1:\n print(k)\nelse:\n sum=k\n for i in range(n-1):\n sum*=k-1\n print(sum)", "n==1", "n", "1", "print(k)", "print", "k", "sum=k", "sum", "k", "for i in range(n-1):\n sum*=k-1\n ", "i", "range(n-1)", "range", "n-1", "n", "1", "sum*=k-1", "sum", "k-1", "k", "1", "print(sum)", "print", "sum", "sum*=k-1", "k-1", "sum", "n,k=map(int,input().split())", "map(int,input().split())", "n", "k=map(int,input().split())", "map(int,input().split())", "k", "sum=k", "k", "sum" ]

n,k=map(int,input().split()) if n==1: print(k) else: sum=k for i in range(n-1): sum*=k-1 print(sum)

[ 7, 0, 13, 4, 18, 4, 13, 13, 17, 0, 13, 17, 28, 13, 4, 13, 4, 13, 18, 13, 17, 14, 2, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 2, 13, 2, 4, 13, 18, 13, 17, 17, 4, 13, 13, 10, 17, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 53, 2 ], [ 47, 10 ], [ 14, 13 ], [ 54, 19 ], [ 13, 23 ], [ 56, 26 ], [ 54, 30 ], [ 50, 33 ], [ 48, 35 ], [ 51, 35 ], [ 57, 35 ], [ 54, 40 ], [ 51, 45 ], [ 57, 45 ], [ 48, 45 ], [ 47, 48 ], [ 50, 51 ], [ 53, 54 ], [ 56, 57 ] ]

[ "a=input().split(\" \")\npart=0\n \nfor i in range(int(a[0])):\n\tif i==0:\n\t\tpart=int(a[1])\n\telse:\n\t\tpart=part*(int(a[1])-1)\n \nprint(part)\n", "a=input().split(\" \")", "a", "input().split(\" \")", "().split", "()", "input", "split", "\" \"", "part=0", "part", "0", "for i in range(int(a[0])):\n\tif i==0:\n\t\tpart=int(a[1])\n\telse:\n\t\tpart=part*(int(a[1])-1)\n ", "i", "range(int(a[0]))", "range", "int(a[0])", "int", "a[0]", "a", "0", "if i==0:\n\t\tpart=int(a[1])\n\telse:\n\t\tpart=part*(int(a[1])-1)\n ", "i==0", "i", "0", "part=int(a[1])", "part", "int(a[1])", "int", "a[1]", "a", "1", "part=part*(int(a[1])-1)", "part", "part*(int(a[1])-1)", "part", "int(a[1])-1", "int(a[1])", "int", "a[1]", "a", "1", "1", "print(part)", "print", "part", "part=0", "0", "part", "part=part*(int(a[1])-1)", "part*(int(a[1])-1)", "part", "a=input().split(\" \")", "input().split(\" \")", "a", "part=int(a[1])", "int(a[1])", "part" ]

a=input().split(" ") part=0 for i in range(int(a[0])): if i==0: part=int(a[1]) else: part=part*(int(a[1])-1) print(part)

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 32, 14 ], [ 32, 16 ], [ 33, 20 ], [ 33, 23 ], [ 30, 26 ], [ 32, 30 ], [ 32, 33 ] ]

[ "N, K = [int(x) for x in input().split()]\nprint(K*(K-1)**(N-1))", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "N, K = [int(x) for x in input().split()]", "N", "[int(x) for x in input().split()]", "K", "print(K*(K-1)**(N-1))", "print", "K*(K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "N, K = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "N", "K = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "K" ]

N, K = [int(x) for x in input().split()] print(K*(K-1)**(N-1))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 17, 2, 13, 17, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 17, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13 ]

[ [ 48, 2 ], [ 48, 11 ], [ 39, 13 ], [ 17, 16 ], [ 43, 21 ], [ 16, 25 ], [ 51, 28 ], [ 49, 29 ], [ 45, 31 ], [ 49, 33 ], [ 46, 37 ], [ 52, 37 ], [ 40, 37 ], [ 39, 40 ], [ 48, 43 ], [ 45, 46 ], [ 48, 49 ], [ 49, 51 ], [ 51, 52 ] ]

[ "balls, colors = map(int,input().split())\n\nans = 1\n\nfor i in range(1,balls+1):\n if i == 1:\n ans *= colors\n else:\n ans *= colors - 1\n\nprint(ans)", "balls, colors = map(int,input().split())", "balls", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "colors", "ans = 1", "ans", "1", "for i in range(1,balls+1):\n if i == 1:\n ans *= colors\n else:\n ans *= colors - 1", "i", "range(1,balls+1)", "range", "1", "balls+1", "balls", "1", "if i == 1:\n ans *= colors\n else:\n ans *= colors - 1", "i == 1", "i", "1", "ans *= colors", "ans", "colors", "ans *= colors - 1", "ans", "colors - 1", "colors", "1", "print(ans)", "print", "ans", "ans = 1", "1", "ans", "balls, colors = map(int,input().split())", "map(int,input().split())", "balls", "ans *= colors - 1", "colors - 1", "ans", "colors = map(int,input().split())", "map(int,input().split())", "colors", "ans *= colors", "colors", "ans" ]

balls, colors = map(int,input().split()) ans = 1 for i in range(1,balls+1): if i == 1: ans *= colors else: ans *= colors - 1 print(ans)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 17, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 28, 2 ], [ 28, 12 ], [ 29, 16 ], [ 29, 19 ], [ 26, 22 ], [ 28, 26 ], [ 28, 29 ] ]

[ "N, K = map(int,input().split(' '))\nprint(K*(K-1)**(N-1))", "N, K = map(int,input().split(' '))", "N", "map(int,input().split(' '))", "map", "int", "input().split(' ')", "().split", "()", "input", "split", "' '", "K", "print(K*(K-1)**(N-1))", "print", "K*(K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "N, K = map(int,input().split(' '))", "map(int,input().split(' '))", "N", "K = map(int,input().split(' '))", "map(int,input().split(' '))", "K" ]

N, K = map(int,input().split(' ')) print(K*(K-1)**(N-1))

[ 7, 0, 13, 4, 18, 4, 13, 13, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 17, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 0, 13, 13, 4, 13, 4, 13, 13, 10, 4, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13 ]

[ [ 55, 2 ], [ 52, 9 ], [ 56, 13 ], [ 46, 16 ], [ 56, 20 ], [ 49, 23 ], [ 27, 26 ], [ 53, 30 ], [ 58, 33 ], [ 47, 35 ], [ 61, 38 ], [ 47, 39 ], [ 62, 44 ], [ 59, 44 ], [ 50, 44 ], [ 46, 47 ], [ 49, 50 ], [ 52, 53 ], [ 55, 56 ], [ 58, 59 ], [ 47, 61 ], [ 61, 62 ] ]

[ "s = input().split()\n\n# ボールの数n\nn = int(s[0])\n\n# 色の種類k\nk = int(s[1])\n\nanswer = 1\n\nfor num in range(n - 1):\n answer *= k - 1\n\nanswer *= k\n\nprint(int(answer))\n\n", "s = input().split()", "s", "input().split()", "().split", "()", "input", "split", "n = int(s[0])", "n", "int(s[0])", "int", "s[0]", "s", "0", "k = int(s[1])", "k", "int(s[1])", "int", "s[1]", "s", "1", "answer = 1", "answer", "1", "for num in range(n - 1):\n answer *= k - 1", "num", "range(n - 1)", "range", "n - 1", "n", "1", "answer *= k - 1", "answer", "k - 1", "k", "1", "answer *= k", "answer", "k", "print(int(answer))", "print", "int(answer)", "int", "answer", "k = int(s[1])", "int(s[1])", "k", "answer = 1", "1", "answer", "n = int(s[0])", "int(s[0])", "n", "s = input().split()", "input().split()", "s", "answer *= k - 1", "k - 1", "answer", "answer *= k", "k", "answer" ]

s = input().split() # ボールの数n n = int(s[0]) # 色の種類k k = int(s[1]) answer = 1 for num in range(n - 1): answer *= k - 1 answer *= k print(int(answer))

[ 7, 15, 13, 12, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 9, 8 ], [ 41, 15 ], [ 9, 17 ], [ 17, 21 ], [ 17, 25 ], [ 8, 28 ], [ 38, 35 ] ]

[ "import sys\ndef input(): return sys.stdin.readline().strip()\n\ndef main():\n n, k = map(int, input().split())\n print(k * pow(k - 1, n - 1))\n\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "def input(): return sys.stdin.readline().strip()", "input", "def main():\n n, k = map(int, input().split())\n print(k * pow(k - 1, n - 1))", "main", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k * pow(k - 1, n - 1))", "print", "k * pow(k - 1, n - 1)", "k", "pow(k - 1, n - 1)", "pow", "k - 1", "k", "1", "n - 1", "n", "1", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n, k = map(int, input().split())\n print(k * pow(k - 1, n - 1))", "def main():\n n, k = map(int, input().split())\n print(k * pow(k - 1, n - 1))", "main", "def input(): return sys.stdin.readline().strip()", "def input(): return sys.stdin.readline().strip()", "input" ]

import sys def input(): return sys.stdin.readline().strip() def main(): n, k = map(int, input().split()) print(k * pow(k - 1, n - 1)) if __name__ == "__main__": main()

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 29, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 13, 17 ], [ 13, 20 ], [ 4, 23 ], [ 15, 27 ], [ 37, 34 ] ]

[ "def resolve():\n n, k = map(int, input().split())\n ans = k * ((k-1) ** (n-1))\n print(ans)\n return\n\nif __name__ == \"__main__\":\n resolve()", "def resolve():\n n, k = map(int, input().split())\n ans = k * ((k-1) ** (n-1))\n print(ans)\n return", "resolve", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k * ((k-1) ** (n-1))", "ans", "k * ((k-1) ** (n-1))", "k", "(k-1) ** (n-1)", "k-1", "k", "1", "n-1", "n", "1", "print(ans)", "print", "ans", "return", "if __name__ == \"__main__\":\n resolve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "resolve()", "resolve", "def resolve():\n n, k = map(int, input().split())\n ans = k * ((k-1) ** (n-1))\n print(ans)\n return", "def resolve():\n n, k = map(int, input().split())\n ans = k * ((k-1) ** (n-1))\n print(ans)\n return", "resolve" ]

def resolve(): n, k = map(int, input().split()) ans = k * ((k-1) ** (n-1)) print(ans) return if __name__ == "__main__": resolve()

[ 7, 15, 13, 15, 4, 18, 13, 13, 2, 17, 17, 0, 13, 12, 4, 18, 4, 18, 18, 13, 13, 13, 13, 0, 13, 4, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 51, 12 ], [ 54, 24 ], [ 60, 29 ], [ 52, 36 ], [ 60, 38 ], [ 58, 42 ], [ 58, 45 ], [ 61, 48 ], [ 51, 52 ], [ 54, 55 ], [ 60, 58 ], [ 60, 61 ] ]

[ "import sys\nfrom math import factorial\nsys.setrecursionlimit(10**6)\ninput = lambda: sys.stdin.readline().rstrip()\ninf = float(\"inf\") # 無限\n\nn,k = map(int,input().split())\n\nprint(k*((k-1)**(n-1)))", "import sys", "sys", "from math import factorial", "sys.setrecursionlimit(10**6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**6", "10", "6", "input = lambda: sys.stdin.readline().rstrip()", "input", "lambda: sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip()", "sys.stdin.readline().rstrip", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "rstrip", "inf = float(\"inf\")", "inf", "float(\"inf\")", "float", "\"inf\"", "n,k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k*((k-1)**(n-1)))", "print", "k*((k-1)**(n-1))", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "input = lambda: sys.stdin.readline().rstrip()", "lambda: sys.stdin.readline().rstrip()", "input", "inf = float(\"inf\")", "float(\"inf\")", "inf", "k = map(int,input().split())", "map(int,input().split())", "k", "n,k = map(int,input().split())", "map(int,input().split())", "n" ]

import sys from math import factorial sys.setrecursionlimit(10**6) input = lambda: sys.stdin.readline().rstrip() inf = float("inf") # 無限 n,k = map(int,input().split()) print(k*((k-1)**(n-1)))

[ 7, 15, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 12, 2, 4, 13, 13, 17, 23, 0, 13, 12, 4, 13, 31, 13, 0, 13, 17, 23, 12, 13, 12, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 12, 13, 23, 13, 12, 13, 12, 13, 0, 13, 4, 13, 13, 4, 13, 2, 4, 13, 2, 13, 17, 2, 13, 17, 13, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 91, 11 ], [ 73, 20 ], [ 28, 27 ], [ 39, 38 ], [ 95, 44 ], [ 48, 48 ], [ 55, 54 ], [ 80, 56 ], [ 55, 57 ], [ 57, 64 ], [ 54, 67 ], [ 57, 69 ], [ 89, 71 ], [ 73, 74 ], [ 91, 92 ] ]

[ "import sys\n\nsys.setrecursionlimit(10 ** 6)\nint1 = lambda x: int(x) - 1\np2D = lambda x: print(*x, sep=\"\\n\")\ndef II(): return int(sys.stdin.readline())\ndef MI(): return map(int, sys.stdin.readline().split())\ndef LI(): return list(map(int, sys.stdin.readline().split()))\ndef LLI(rows_number): return [LI() for _ in range(rows_number)]\ndef SI(): return sys.stdin.readline()[:-1]\n\ndef main():\n n,k=MI()\n print(pow(k-1,n-1)*k)\n\nmain()", "import sys", "sys", "sys.setrecursionlimit(10 ** 6)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10 ** 6", "10", "6", "int1 = lambda x: int(x) - 1", "int1", "lambda x: int(x) - 1", "int(x) - 1", "int(x)", "int", "x", "1", "x", "p2D = lambda x: print(*x, sep=\"\\n\")", "p2D", "lambda x: print(*x, sep=\"\\n\")", "print(*x, sep=\"\\n\")", "print", "*x", "x", "sep=\"\\n\"", "sep", "\"\\n\"", "x", "def II(): return int(sys.stdin.readline())", "II", "def MI(): return map(int, sys.stdin.readline().split())", "MI", "def LI(): return list(map(int, sys.stdin.readline().split()))", "LI", "LI() for _ in range(rows_number)", "for _ in range(rows_number)", "_", "range(rows_number)", "range", "rows_number", "for _ in range(rows_number)", "LI()", "LI", "def LLI(rows_number): return [LI() for _ in range(rows_number)]", "LLI", "rows_number", "rows_number", "def SI(): return sys.stdin.readline()[:-1]", "SI", "def main():\n n,k=MI()\n print(pow(k-1,n-1)*k)", "main", "n,k=MI()", "n", "MI()", "MI", "k", "print(pow(k-1,n-1)*k)", "print", "pow(k-1,n-1)*k", "pow(k-1,n-1)", "pow", "k-1", "k", "1", "n-1", "n", "1", "k", "main()", "main", "p2D = lambda x: print(*x, sep=\"\\n\")", "lambda x: print(*x, sep=\"\\n\")", "p2D", "def II(): return int(sys.stdin.readline())", "def II(): return int(sys.stdin.readline())", "II", "def MI(): return map(int, sys.stdin.readline().split())", "def MI(): return map(int, sys.stdin.readline().split())", "MI", "def LLI(rows_number): return [LI() for _ in range(rows_number)]", "def LLI(rows_number): return [LI() for _ in range(rows_number)]", "LLI", "def SI(): return sys.stdin.readline()[:-1]", "def SI(): return sys.stdin.readline()[:-1]", "SI", "def main():\n n,k=MI()\n print(pow(k-1,n-1)*k)", "def main():\n n,k=MI()\n print(pow(k-1,n-1)*k)", "main", "int1 = lambda x: int(x) - 1", "lambda x: int(x) - 1", "int1", "def LI(): return list(map(int, sys.stdin.readline().split()))", "def LI(): return list(map(int, sys.stdin.readline().split()))", "LI" ]

import sys sys.setrecursionlimit(10 ** 6) 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(): n,k=MI() print(pow(k-1,n-1)*k) main()

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 27, 2 ], [ 27, 11 ], [ 25, 15 ], [ 25, 18 ], [ 28, 21 ], [ 27, 25 ], [ 27, 28 ] ]

[ "n,k=map(int,input().split())\nprint(k*(k-1)**(n-1))", "n,k=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(k*(k-1)**(n-1))", "print", "k*(k-1)**(n-1)", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "k=map(int,input().split())", "map(int,input().split())", "k", "n,k=map(int,input().split())", "map(int,input().split())", "n" ]

n,k=map(int,input().split()) print(k*(k-1)**(n-1))

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 14, 40, 2, 13, 17, 17, 0, 13, 2, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 13, 16 ], [ 19, 18 ], [ 4, 22 ], [ 13, 27 ], [ 32, 31 ], [ 15, 33 ], [ 31, 33 ], [ 13, 35 ], [ 31, 39 ], [ 15, 39 ], [ 48, 45 ] ]

[ "def main():\n N,K= map(int, input().split())\n sum = K\n for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n print(sum)\n\n\n \nif __name__ == '__main__':\n main()", "def main():\n N,K= map(int, input().split())\n sum = K\n for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n print(sum)\n\n\n ", "main", "N,K= map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "sum = K", "sum", "K", "for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "if K-1 !=0:\n sum = sum * (K-1)\n\n ", "K-1 !=0", "K-1", "K", "1", "0", "sum = sum * (K-1)", "sum", "sum * (K-1)", "sum", "K-1", "K", "1", "print(sum)", "print", "sum", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N,K= map(int, input().split())\n sum = K\n for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n print(sum)\n\n\n ", "def main():\n N,K= map(int, input().split())\n sum = K\n for i in range(N-1):\n if K-1 !=0:\n sum = sum * (K-1)\n\n print(sum)\n\n\n ", "main" ]

def main(): N,K= map(int, input().split()) sum = K for i in range(N-1): if K-1 !=0: sum = sum * (K-1) print(sum) if __name__ == '__main__': main()

[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 18, 22 ], [ 18, 25 ], [ 16, 28 ], [ 38, 35 ] ]

[ "def solve():\n N, K = [int(i) for i in input().split()]\n print(K * (K - 1) ** (N - 1))\n\nif __name__ == \"__main__\":\n solve()", "def solve():\n N, K = [int(i) for i in input().split()]\n print(K * (K - 1) ** (N - 1))", "solve", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "N, K = [int(i) for i in input().split()]", "N", "[int(i) for i in input().split()]", "K", "print(K * (K - 1) ** (N - 1))", "print", "K * (K - 1) ** (N - 1)", "K", "(K - 1) ** (N - 1)", "K - 1", "K", "1", "N - 1", "N", "1", "if __name__ == \"__main__\":\n solve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "solve()", "solve", "def solve():\n N, K = [int(i) for i in input().split()]\n print(K * (K - 1) ** (N - 1))", "def solve():\n N, K = [int(i) for i in input().split()]\n print(K * (K - 1) ** (N - 1))", "solve" ]

def solve(): N, K = [int(i) for i in input().split()] print(K * (K - 1) ** (N - 1)) if __name__ == "__main__": solve()

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 44, 4 ], [ 14, 13 ], [ 45, 20 ], [ 14, 22 ], [ 25, 24 ], [ 22, 26 ], [ 22, 29 ], [ 13, 32 ], [ 24, 36 ], [ 48, 42 ], [ 44, 45 ] ]

[ "import sys\n\ninput = sys.stdin.readline\n\n\ndef main():\n N, K = map(int, input().split())\n ans = K * (K - 1)**(N - 1)\n print(ans)\n\n\nif __name__ == \"__main__\":\n main()", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "def main():\n N, K = map(int, input().split())\n ans = K * (K - 1)**(N - 1)\n print(ans)", "main", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = K * (K - 1)**(N - 1)", "ans", "K * (K - 1)**(N - 1)", "K", "(K - 1)**(N - 1)", "K - 1", "K", "1", "N - 1", "N", "1", "print(ans)", "print", "ans", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "input = sys.stdin.readline", "sys.stdin.readline", "input", "def main():\n N, K = map(int, input().split())\n ans = K * (K - 1)**(N - 1)\n print(ans)", "def main():\n N, K = map(int, input().split())\n ans = K * (K - 1)**(N - 1)\n print(ans)", "main" ]

import sys input = sys.stdin.readline def main(): N, K = map(int, input().split()) ans = K * (K - 1)**(N - 1) print(ans) if __name__ == "__main__": main()

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 18, 18, 13, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 13, 4, 18, 13, 13, 0, 13, 13, 0, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 18, 13, 10, 18, 13, 10, 12, 13 ]

[ [ 64, 4 ], [ 67, 11 ], [ 21, 20 ], [ 21, 29 ], [ 20, 32 ], [ 29, 36 ], [ 43, 42 ], [ 29, 43 ], [ 46, 45 ], [ 29, 49 ], [ 20, 52 ], [ 45, 56 ], [ 42, 56 ], [ 71, 62 ], [ 64, 65 ], [ 67, 68 ] ]

[ "import sys\nread = sys.stdin.read\nreadlines = sys.stdin.readlines\ndef main():\n n, k = map(int, input().split())\n if n == 1:\n print(k)\n sys.exit()\n r = k\n r *= pow(k - 1, n - 1)\n print(r)\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "read = sys.stdin.read", "read", "sys.stdin.read", "sys.stdin", "sys", "stdin", "read", "readlines = sys.stdin.readlines", "readlines", "sys.stdin.readlines", "sys.stdin", "sys", "stdin", "readlines", "def main():\n n, k = map(int, input().split())\n if n == 1:\n print(k)\n sys.exit()\n r = k\n r *= pow(k - 1, n - 1)\n print(r)", "main", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "if n == 1:\n print(k)\n sys.exit()\n ", "n == 1", "n", "1", "print(k)", "print", "k", "sys.exit()", "sys.exit", "sys", "exit", "r = k", "r", "k", "r *= pow(k - 1, n - 1)", "r", "pow(k - 1, n - 1)", "pow", "k - 1", "k", "1", "n - 1", "n", "1", "print(r)", "print", "r", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "read = sys.stdin.read", "sys.stdin.read", "read", "readlines = sys.stdin.readlines", "sys.stdin.readlines", "readlines", "def main():\n n, k = map(int, input().split())\n if n == 1:\n print(k)\n sys.exit()\n r = k\n r *= pow(k - 1, n - 1)\n print(r)", "def main():\n n, k = map(int, input().split())\n if n == 1:\n print(k)\n sys.exit()\n r = k\n r *= pow(k - 1, n - 1)\n print(r)", "main" ]

import sys read = sys.stdin.read readlines = sys.stdin.readlines def main(): n, k = map(int, input().split()) if n == 1: print(k) sys.exit() r = k r *= pow(k - 1, n - 1) print(r) if __name__ == '__main__': main()

[ 7, 15, 13, 15, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 29, 39, 13, 13, 0, 13, 4, 13, 13, 14, 2, 13, 17, 4, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 12, 13, 10, 4, 13 ]

[ [ 9, 8 ], [ 9, 17 ], [ 52, 23 ], [ 50, 25 ], [ 52, 26 ], [ 47, 29 ], [ 53, 33 ], [ 47, 37 ], [ 47, 40 ], [ 53, 43 ], [ 52, 47 ], [ 52, 53 ] ]

[ "import re\nimport copy\n\ndef accept_input():\n N,K = map(int,input().split())\n return N,K\n\nN,K = accept_input()\n\n\nif K == 1:\n print(N)\nelse:\n print(K*((K-1)**(N-1)))", "import re", "re", "import copy", "copy", "def accept_input():\n N,K = map(int,input().split())\n return N,K", "accept_input", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "return N,K", "return N,K", "N", "K", "N,K = accept_input()", "N", "accept_input()", "accept_input", "K", "if K == 1:\n print(N)\nelse:\n print(K*((K-1)**(N-1)))", "K == 1", "K", "1", "print(N)", "print", "N", "print(K*((K-1)**(N-1)))", "print", "K*((K-1)**(N-1))", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "K = accept_input()", "accept_input()", "K", "def accept_input():\n N,K = map(int,input().split())\n return N,K", "def accept_input():\n N,K = map(int,input().split())\n return N,K", "accept_input", "N,K = accept_input()", "accept_input()", "N" ]

import re import copy def accept_input(): N,K = map(int,input().split()) return N,K N,K = accept_input() if K == 1: print(N) else: print(K*((K-1)**(N-1)))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 45, 2 ], [ 45, 11 ], [ 39, 13 ], [ 17, 16 ], [ 43, 19 ], [ 16, 22 ], [ 36, 25 ], [ 46, 26 ], [ 48, 28 ], [ 46, 30 ], [ 49, 34 ], [ 37, 34 ], [ 40, 34 ], [ 46, 36 ], [ 36, 37 ], [ 39, 40 ], [ 45, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "n, k = map(int, input().split())\ncnt = 1\nfor i in range(n):\n if i == 0:\n cnt *= k\n else:\n cnt *= (k-1)\nprint(cnt)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "cnt = 1", "cnt", "1", "for i in range(n):\n if i == 0:\n cnt *= k\n else:\n cnt *= (k-1)", "i", "range(n)", "range", "n", "if i == 0:\n cnt *= k\n else:\n cnt *= (k-1)", "i == 0", "i", "0", "cnt *= k", "cnt", "k", "cnt *= (k-1)", "cnt", "k-1", "k", "1", "print(cnt)", "print", "cnt", "cnt *= k", "k", "cnt", "cnt = 1", "1", "cnt", "n, k = map(int, input().split())", "map(int, input().split())", "n", "k = map(int, input().split())", "map(int, input().split())", "k", "cnt *= (k-1)", "k-1", "cnt" ]

n, k = map(int, input().split()) cnt = 1 for i in range(n): if i == 0: cnt *= k else: cnt *= (k-1) print(cnt)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 14, 2, 13, 17, 4, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 47, 2 ], [ 47, 11 ], [ 38, 13 ], [ 45, 14 ], [ 48, 17 ], [ 39, 21 ], [ 24, 23 ], [ 48, 27 ], [ 41, 30 ], [ 45, 32 ], [ 42, 36 ], [ 39, 36 ], [ 45, 38 ], [ 38, 39 ], [ 41, 42 ], [ 47, 45 ], [ 47, 48 ] ]

[ "N, K = map(int, input().split())\nans = K\n\nif N == 1:\n print(ans)\n \nelse:\n for i in range(N-1):\n ans *= K-1\n \n print(ans)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = K", "ans", "K", "if N == 1:\n print(ans)\n \nelse:\n for i in range(N-1):\n ans *= K-1\n \n print(ans)", "N == 1", "N", "1", "print(ans)", "print", "ans", "for i in range(N-1):\n ans *= K-1\n \n ", "i", "range(N-1)", "range", "N-1", "N", "1", "ans *= K-1", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "ans = K", "K", "ans", "ans *= K-1", "K-1", "ans", "K = map(int, input().split())", "map(int, input().split())", "K", "N, K = map(int, input().split())", "map(int, input().split())", "N" ]

N, K = map(int, input().split()) ans = K if N == 1: print(ans) else: for i in range(N-1): ans *= K-1 print(ans)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 33, 2 ], [ 33, 11 ], [ 30, 13 ], [ 28, 15 ], [ 28, 18 ], [ 34, 21 ], [ 31, 25 ], [ 33, 28 ], [ 30, 31 ], [ 33, 34 ] ]

[ "N, K = map(int,input().split())\n\nans = K * ((K-1)**(N-1))\nprint(ans)", "N, K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = K * ((K-1)**(N-1))", "ans", "K * ((K-1)**(N-1))", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "K = map(int,input().split())", "map(int,input().split())", "K", "ans = K * ((K-1)**(N-1))", "K * ((K-1)**(N-1))", "ans", "N, K = map(int,input().split())", "map(int,input().split())", "N" ]

N, K = map(int,input().split()) ans = K * ((K-1)**(N-1)) print(ans)

[ 7, 12, 13, 29, 2, 13, 2, 2, 13, 17, 2, 13, 17, 23, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 4, 13, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 16, 5 ], [ 16, 8 ], [ 14, 11 ], [ 14, 14 ], [ 16, 16 ], [ 21, 20 ], [ 21, 29 ], [ 47, 33 ], [ 20, 34 ], [ 29, 35 ], [ 44, 41 ] ]

[ "def answer(n: int, k: int) -> int:\n return k * (k - 1) ** (n - 1)\n\n\ndef main():\n n, k = map(int, input().split())\n print(answer(n, k))\n\n\nif __name__ == '__main__':\n main()", "def answer(n: int, k: int) -> int:\n return k * (k - 1) ** (n - 1)", "answer", "return k * (k - 1) ** (n - 1)", "k * (k - 1) ** (n - 1)", "k", "(k - 1) ** (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "n: int", "n", "k: int", "k", "def main():\n n, k = map(int, input().split())\n print(answer(n, k))", "main", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "print(answer(n, k))", "print", "answer(n, k)", "answer", "n", "k", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n n, k = map(int, input().split())\n print(answer(n, k))", "def main():\n n, k = map(int, input().split())\n print(answer(n, k))", "main", "def answer(n: int, k: int) -> int:\n return k * (k - 1) ** (n - 1)", "def answer(n: int, k: int) -> int:\n return k * (k - 1) ** (n - 1)", "answer" ]

def answer(n: int, k: int) -> int: return k * (k - 1) ** (n - 1) def main(): n, k = map(int, input().split()) print(answer(n, k)) if __name__ == '__main__': main()

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 38, 14 ], [ 38, 16 ], [ 32, 18 ], [ 39, 20 ], [ 39, 23 ], [ 36, 26 ], [ 33, 30 ], [ 32, 33 ], [ 38, 36 ], [ 38, 39 ] ]

[ "n,k = [int(x) for x in input().split()]\n\nans = k * (k - 1)**(n - 1)\nprint(ans)", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "n,k = [int(x) for x in input().split()]", "n", "[int(x) for x in input().split()]", "k", "ans = k * (k - 1)**(n - 1)", "ans", "k * (k - 1)**(n - 1)", "k", "(k - 1)**(n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "print(ans)", "print", "ans", "ans = k * (k - 1)**(n - 1)", "k * (k - 1)**(n - 1)", "ans", "n,k = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "n", "k = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "k" ]

n,k = [int(x) for x in input().split()] ans = k * (k - 1)**(n - 1) print(ans)

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 29, 4 ], [ 29, 13 ], [ 30, 17 ], [ 30, 20 ], [ 27, 23 ], [ 29, 27 ], [ 29, 30 ] ]

[ "import math \nN,K = map(int,input().split())\nprint(K*(K-1)**(N-1))", "import math", "math", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "print(K*(K-1)**(N-1))", "print", "K*(K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "N,K = map(int,input().split())", "map(int,input().split())", "N", "K = map(int,input().split())", "map(int,input().split())", "K" ]

import math N,K = map(int,input().split()) print(K*(K-1)**(N-1))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 9, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 17, 13, 10, 4, 13 ]

[ [ 49, 2 ], [ 49, 11 ], [ 46, 13 ], [ 17, 16 ], [ 38, 19 ], [ 16, 22 ], [ 43, 25 ], [ 50, 26 ], [ 40, 29 ], [ 50, 31 ], [ 41, 35 ], [ 44, 35 ], [ 47, 35 ], [ 49, 38 ], [ 40, 41 ], [ 50, 43 ], [ 43, 44 ], [ 46, 47 ], [ 49, 50 ] ]

[ "n,k = map(int,input().split())\nans = 1\nfor i in range(n):\n if i == 0:\n ans *= k\n continue\n ans *= (k - 1)\nprint(ans)", "n,k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 1", "ans", "1", "for i in range(n):\n if i == 0:\n ans *= k\n continue\n ans *= (k - 1)", "i", "range(n)", "range", "n", "if i == 0:\n ans *= k\n continue\n ", "i == 0", "i", "0", "ans *= k", "ans", "k", "continue", "ans *= (k - 1)", "ans", "k - 1", "k", "1", "print(ans)", "print", "ans", "n,k = map(int,input().split())", "map(int,input().split())", "n", "ans *= (k - 1)", "k - 1", "ans", "ans *= k", "k", "ans", "ans = 1", "1", "ans", "k = map(int,input().split())", "map(int,input().split())", "k" ]

n,k = map(int,input().split()) ans = 1 for i in range(n): if i == 0: ans *= k continue ans *= (k - 1) print(ans)

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 19, 18 ], [ 4, 21 ], [ 18, 24 ], [ 28, 27 ], [ 13, 28 ], [ 31, 30 ], [ 13, 32 ], [ 30, 36 ], [ 27, 36 ], [ 15, 36 ], [ 45, 42 ] ]

[ "def resolve():\n n, k = map(int, input().split())\n ans = 0\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans *= k - 1\n print(ans)\n\nif __name__ == '__main__':\n resolve()", "def resolve():\n n, k = map(int, input().split())\n ans = 0\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans *= k - 1\n print(ans)", "resolve", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 0", "ans", "0", "for i in range(n):\n if i == 0:\n ans = k\n else:\n ans *= k - 1\n ", "i", "range(n)", "range", "n", "if i == 0:\n ans = k\n else:\n ans *= k - 1\n ", "i == 0", "i", "0", "ans = k", "ans", "k", "ans *= k - 1", "ans", "k - 1", "k", "1", "print(ans)", "print", "ans", "if __name__ == '__main__':\n resolve()", "__name__ == '__main__'", "__name__", "'__main__'", "resolve()", "resolve", "def resolve():\n n, k = map(int, input().split())\n ans = 0\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans *= k - 1\n print(ans)", "def resolve():\n n, k = map(int, input().split())\n ans = 0\n for i in range(n):\n if i == 0:\n ans = k\n else:\n ans *= k - 1\n print(ans)", "resolve" ]

def resolve(): n, k = map(int, input().split()) ans = 0 for i in range(n): if i == 0: ans = k else: ans *= k - 1 print(ans) if __name__ == '__main__': resolve()

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 4, 18 ], [ 15, 21 ], [ 25, 24 ], [ 13, 25 ], [ 28, 27 ], [ 13, 29 ], [ 27, 33 ], [ 24, 33 ], [ 42, 39 ] ]

[ "# B - AtCoDeerくんとボール色塗り\ndef main():\n n, k = map(int,input().split())\n\n for i in range(n):\n if i == 0:\n val = k\n else:\n val *= (k-1)\n else:\n print(val)\n\n\nif __name__ == \"__main__\":\n main()", "def main():\n n, k = map(int,input().split())\n\n for i in range(n):\n if i == 0:\n val = k\n else:\n val *= (k-1)\n else:\n print(val)", "main", "n, k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "for i in range(n):\n if i == 0:\n val = k\n else:\n val *= (k-1)\n else:\n print(val)", "i", "range(n)", "range", "n", "if i == 0:\n val = k\n else:\n val *= (k-1)\n ", "i == 0", "i", "0", "val = k", "val", "k", "val *= (k-1)", "val", "k-1", "k", "1", "print(val)", "print", "val", "if __name__ == \"__main__\":\n main()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "main()", "main", "def main():\n n, k = map(int,input().split())\n\n for i in range(n):\n if i == 0:\n val = k\n else:\n val *= (k-1)\n else:\n print(val)", "def main():\n n, k = map(int,input().split())\n\n for i in range(n):\n if i == 0:\n val = k\n else:\n val *= (k-1)\n else:\n print(val)", "main" ]

# B - AtCoDeerくんとボール色塗り def main(): n, k = map(int,input().split()) for i in range(n): if i == 0: val = k else: val *= (k-1) else: print(val) if __name__ == "__main__": main()

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 17, 13 ]

[ [ 45, 2 ], [ 45, 11 ], [ 48, 13 ], [ 17, 16 ], [ 43, 19 ], [ 16, 22 ], [ 39, 25 ], [ 46, 26 ], [ 36, 28 ], [ 46, 30 ], [ 37, 34 ], [ 40, 34 ], [ 49, 34 ], [ 36, 37 ], [ 46, 39 ], [ 39, 40 ], [ 45, 43 ], [ 45, 46 ], [ 48, 49 ] ]

[ "N, K = map(int, input().split())\n\nres = 1\n\nfor i in range(N):\n if i == 0:\n res *= K\n else:\n res *= (K-1)\n\nprint(res)", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "res = 1", "res", "1", "for i in range(N):\n if i == 0:\n res *= K\n else:\n res *= (K-1)", "i", "range(N)", "range", "N", "if i == 0:\n res *= K\n else:\n res *= (K-1)", "i == 0", "i", "0", "res *= K", "res", "K", "res *= (K-1)", "res", "K-1", "K", "1", "print(res)", "print", "res", "res *= (K-1)", "K-1", "res", "res *= K", "K", "res", "N, K = map(int, input().split())", "map(int, input().split())", "N", "K = map(int, input().split())", "map(int, input().split())", "K", "res = 1", "1", "res" ]

N, K = map(int, input().split()) res = 1 for i in range(N): if i == 0: res *= K else: res *= (K-1) print(res)

[ 7, 15, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 0, 13, 17, 28, 13, 4, 13, 13, 14, 13, 0, 13, 13, 0, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 17, 13, 10, 17, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13 ]

[ [ 54, 4 ], [ 54, 13 ], [ 48, 15 ], [ 57, 18 ], [ 22, 21 ], [ 43, 24 ], [ 60, 28 ], [ 55, 29 ], [ 51, 31 ], [ 45, 34 ], [ 55, 36 ], [ 46, 40 ], [ 61, 40 ], [ 49, 40 ], [ 54, 43 ], [ 45, 46 ], [ 48, 49 ], [ 51, 52 ], [ 54, 55 ], [ 57, 58 ], [ 55, 60 ], [ 60, 61 ] ]

[ "import itertools\nN,K=map(int,input().split())\nans=1\nflag=True\n\nfor i in range(N):\n if flag:\n ans*=K\n flag=False\n else:\n ans*=(K-1)\n\nprint(ans)", "import itertools", "itertools", "N,K=map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans=1", "ans", "1", "flag=True", "flag", "True", "for i in range(N):\n if flag:\n ans*=K\n flag=False\n else:\n ans*=(K-1)", "i", "range(N)", "range", "N", "if flag:\n ans*=K\n flag=False\n else:\n ans*=(K-1)", "flag", "ans*=K", "ans", "K", "flag=False", "flag", "False", "ans*=(K-1)", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "N,K=map(int,input().split())", "map(int,input().split())", "N", "ans*=(K-1)", "K-1", "ans", "ans=1", "1", "ans", "flag=False", "False", "flag", "K=map(int,input().split())", "map(int,input().split())", "K", "flag=True", "True", "flag", "ans*=K", "K", "ans" ]

import itertools N,K=map(int,input().split()) ans=1 flag=True for i in range(N): if flag: ans*=K flag=False else: ans*=(K-1) print(ans)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 27, 2 ], [ 27, 11 ], [ 25, 15 ], [ 25, 18 ], [ 28, 21 ], [ 27, 25 ], [ 27, 28 ] ]

[ "n , c = map(int,input().split())\nprint(c * ((c - 1) ** (n - 1)))", "n , c = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "c", "print(c * ((c - 1) ** (n - 1)))", "print", "c * ((c - 1) ** (n - 1))", "c", "(c - 1) ** (n - 1)", "c - 1", "c", "1", "n - 1", "n", "1", "c = map(int,input().split())", "map(int,input().split())", "c", "n , c = map(int,input().split())", "map(int,input().split())", "n" ]

n , c = map(int,input().split()) print(c * ((c - 1) ** (n - 1)))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 34, 2 ], [ 34, 11 ], [ 31, 13 ], [ 35, 15 ], [ 35, 19 ], [ 29, 22 ], [ 32, 26 ], [ 34, 29 ], [ 31, 32 ], [ 34, 35 ] ]

[ "n, k = map(int, input().split())\nans = k * pow(k-1, n-1)\nprint(ans)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k * pow(k-1, n-1)", "ans", "k * pow(k-1, n-1)", "k", "pow(k-1, n-1)", "pow", "k-1", "k", "1", "n-1", "n", "1", "print(ans)", "print", "ans", "n, k = map(int, input().split())", "map(int, input().split())", "n", "ans = k * pow(k-1, n-1)", "k * pow(k-1, n-1)", "ans", "k = map(int, input().split())", "map(int, input().split())", "k" ]

n, k = map(int, input().split()) ans = k * pow(k-1, n-1) print(ans)

[ 7, 15, 15, 15, 15, 15, 15, 13, 15, 13, 4, 18, 13, 13, 17, 0, 13, 2, 2, 17, 17, 17, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 0, 13, 4, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 2, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 60, 16 ], [ 39, 38 ], [ 64, 40 ], [ 39, 41 ], [ 41, 45 ], [ 41, 48 ], [ 38, 51 ], [ 67, 58 ], [ 60, 61 ] ]

[ "from statistics import median\n#import collections\n#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]\nfrom fractions import gcd\nfrom itertools import combinations # (string,3) 3回\nfrom collections import deque\nfrom collections import defaultdict\nimport bisect\n#\n# d = m - k[i] - k[j]\n# if kk[bisect.bisect_right(kk,d) - 1] == d:\n#\n#\n#\n# pythonで無理なときは、pypyでやると正解するかも！！\n#\n#\n\nimport sys\nsys.setrecursionlimit(10000000)\nmod = 10**9 + 7\n\ndef readInts():\n return list(map(int,input().split()))\n\ndef main():\n n,k = readInts()\n print(k*(k-1)**(n-1))\nif __name__ == '__main__':\n main()", "from statistics import median", "from fractions import gcd", "from itertools import combinations", "from collections import deque", "from collections import defaultdict", "import bisect", "bisect", "import sys", "sys", "sys.setrecursionlimit(10000000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10000000", "mod = 10**9 + 7", "mod", "10**9 + 7", "10**9", "10", "9", "7", "def readInts():\n return list(map(int,input().split()))", "readInts", "return list(map(int,input().split()))", "list(map(int,input().split()))", "list", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def main():\n n,k = readInts()\n print(k*(k-1)**(n-1))", "main", "n,k = readInts()", "n", "readInts()", "readInts", "k", "print(k*(k-1)**(n-1))", "print", "k*(k-1)**(n-1)", "k", "(k-1)**(n-1)", "k-1", "k", "1", "n-1", "n", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "mod = 10**9 + 7", "10**9 + 7", "mod", "def readInts():\n return list(map(int,input().split()))", "def readInts():\n return list(map(int,input().split()))", "readInts", "def main():\n n,k = readInts()\n print(k*(k-1)**(n-1))", "def main():\n n,k = readInts()\n print(k*(k-1)**(n-1))", "main" ]

from statistics import median #import collections #aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0] from fractions import gcd from itertools import combinations # (string,3) 3回 from collections import deque from collections import defaultdict import bisect # # d = m - k[i] - k[j] # if kk[bisect.bisect_right(kk,d) - 1] == d: # # # # pythonで無理なときは、pypyでやると正解するかも！！ # # import sys sys.setrecursionlimit(10000000) mod = 10**9 + 7 def readInts(): return list(map(int,input().split())) def main(): n,k = readInts() print(k*(k-1)**(n-1)) if __name__ == '__main__': main()

[ 7, 12, 13, 29, 4, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 12, 13, 0, 13, 4, 13, 13, 29, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13 ]

[ [ 32, 31 ], [ 55, 33 ], [ 32, 34 ], [ 34, 37 ], [ 34, 40 ], [ 31, 43 ], [ 61, 52 ] ]

[ "\n\ndef read_int():\n return int(input().strip())\n\n\ndef read_ints():\n return list(map(int, input().strip().split(' ')))\n\n\ndef solve():\n N, K = read_ints()\n return K*(K-1)**(N-1)\n\n\nif __name__ == '__main__':\n print(solve())", "def read_int():\n return int(input().strip())", "read_int", "return int(input().strip())", "int(input().strip())", "int", "input().strip()", "().strip", "()", "input", "strip", "def read_ints():\n return list(map(int, input().strip().split(' ')))", "read_ints", "return list(map(int, input().strip().split(' ')))", "list(map(int, input().strip().split(' ')))", "list", "map(int, input().strip().split(' '))", "map", "int", "input().strip().split(' ')", "().strip().split", "().strip()", "().strip", "()", "input", "strip", "split", "' '", "def solve():\n N, K = read_ints()\n return K*(K-1)**(N-1)", "solve", "N, K = read_ints()", "N", "read_ints()", "read_ints", "K", "return K*(K-1)**(N-1)", "K*(K-1)**(N-1)", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "if __name__ == '__main__':\n print(solve())", "__name__ == '__main__'", "__name__", "'__main__'", "print(solve())", "print", "solve()", "solve", "def read_ints():\n return list(map(int, input().strip().split(' ')))", "def read_ints():\n return list(map(int, input().strip().split(' ')))", "read_ints", "def read_int():\n return int(input().strip())", "def read_int():\n return int(input().strip())", "read_int", "def solve():\n N, K = read_ints()\n return K*(K-1)**(N-1)", "def solve():\n N, K = read_ints()\n return K*(K-1)**(N-1)", "solve" ]

def read_int(): return int(input().strip()) def read_ints(): return list(map(int, input().strip().split(' '))) def solve(): N, K = read_ints() return K*(K-1)**(N-1) if __name__ == '__main__': print(solve())

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 27, 2 ], [ 27, 11 ], [ 25, 15 ], [ 25, 18 ], [ 28, 21 ], [ 27, 25 ], [ 27, 28 ] ]

[ "a,b=map(int,input().split())\nprint(b*(b-1)**(a-1))", "a,b=map(int,input().split())", "a", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "print(b*(b-1)**(a-1))", "print", "b*(b-1)**(a-1)", "b", "(b-1)**(a-1)", "b-1", "b", "1", "a-1", "a", "1", "b=map(int,input().split())", "map(int,input().split())", "b", "a,b=map(int,input().split())", "map(int,input().split())", "a" ]

a,b=map(int,input().split()) print(b*(b-1)**(a-1))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 37, 2 ], [ 37, 11 ], [ 34, 13 ], [ 38, 14 ], [ 17, 16 ], [ 32, 20 ], [ 40, 23 ], [ 38, 25 ], [ 41, 29 ], [ 35, 29 ], [ 37, 32 ], [ 38, 34 ], [ 34, 35 ], [ 37, 38 ], [ 40, 41 ] ]

[ "N, K = map(int, input().split())\nans = K\nfor i in range(N - 1):\n ans *= K - 1\n \nprint(ans) \n\n", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ans = K", "ans", "K", "for i in range(N - 1):\n ans *= K - 1\n ", "i", "range(N - 1)", "range", "N - 1", "N", "1", "ans *= K - 1", "ans", "K - 1", "K", "1", "print(ans)", "print", "ans", "N, K = map(int, input().split())", "map(int, input().split())", "N", "ans = K", "K", "ans", "K = map(int, input().split())", "map(int, input().split())", "K", "ans *= K - 1", "K - 1", "ans" ]

N, K = map(int, input().split()) ans = K for i in range(N - 1): ans *= K - 1 print(ans)

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 16, 15 ], [ 13, 16 ], [ 19, 18 ], [ 4, 22 ], [ 26, 25 ], [ 13, 27 ], [ 25, 31 ], [ 15, 31 ], [ 40, 37 ] ]

[ "def main():\n N, K = map(int, input().split())\n\n ret = K\n for _ in range(N - 1):\n ret *= K - 1\n print(ret)\n\n\nif __name__ == '__main__':\n main()\n\n# import sys\n#\n# sys.setrecursionlimit(10 ** 7)\n#\n# input = sys.stdin.readline\n# rstrip()\n# int(input())\n# map(int, input().split())", "def main():\n N, K = map(int, input().split())\n\n ret = K\n for _ in range(N - 1):\n ret *= K - 1\n print(ret)", "main", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "ret = K", "ret", "K", "for _ in range(N - 1):\n ret *= K - 1\n ", "_", "range(N - 1)", "range", "N - 1", "N", "1", "ret *= K - 1", "ret", "K - 1", "K", "1", "print(ret)", "print", "ret", "if __name__ == '__main__':\n main()\n\n# import sys\n#\n# sys.setrecursionlimit(10 ** 7)\n#\n# input = sys.stdin.readline\n# rstrip()\n# int(input())\n# map(int, input().split())", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, K = map(int, input().split())\n\n ret = K\n for _ in range(N - 1):\n ret *= K - 1\n print(ret)", "def main():\n N, K = map(int, input().split())\n\n ret = K\n for _ in range(N - 1):\n ret *= K - 1\n print(ret)", "main" ]

def main(): N, K = map(int, input().split()) ret = K for _ in range(N - 1): ret *= K - 1 print(ret) if __name__ == '__main__': main() # import sys # # sys.setrecursionlimit(10 ** 7) # # input = sys.stdin.readline # rstrip() # int(input()) # map(int, input().split())

[ 7, 15, 12, 13, 0, 13, 4, 13, 41, 28, 13, 4, 13, 17, 4, 4, 18, 13, 13, 17, 0, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13, 10, 12, 13, 10, 13, 13 ]

[ [ 48, 5 ], [ 55, 7 ], [ 11, 10 ], [ 49, 17 ], [ 57, 21 ], [ 57, 23 ], [ 42, 25 ], [ 58, 26 ], [ 29, 28 ], [ 46, 32 ], [ 51, 34 ], [ 58, 36 ], [ 52, 40 ], [ 43, 40 ], [ 58, 42 ], [ 42, 43 ], [ 57, 46 ], [ 48, 49 ], [ 51, 52 ], [ 57, 58 ] ]

[ "from sys import stdin\ndef LI(): return list(map(int,stdin.readline().rstrip().split()))\nli = LI()\n\nn,k = [li.pop(0) for i in range(2)]\n\nans = k\nfor i in range(1,n):\n ans *= (k-1)\n\nprint(ans)", "from sys import stdin", "def LI(): return list(map(int,stdin.readline().rstrip().split()))", "LI", "li = LI()", "li", "LI()", "LI", "li.pop(0) for i in range(2)", "for i in range(2)", "i", "range(2)", "range", "2", "for i in range(2)", "li.pop(0)", "li.pop", "li", "pop", "0", "n,k = [li.pop(0) for i in range(2)]", "n", "[li.pop(0) for i in range(2)]", "k", "ans = k", "ans", "k", "for i in range(1,n):\n ans *= (k-1)", "i", "range(1,n)", "range", "1", "n", "ans *= (k-1)", "ans", "k-1", "k", "1", "print(ans)", "print", "ans", "ans = k", "k", "ans", "n,k = [li.pop(0) for i in range(2)]", "[li.pop(0) for i in range(2)]", "n", "li = LI()", "LI()", "li", "ans *= (k-1)", "k-1", "ans", "def LI(): return list(map(int,stdin.readline().rstrip().split()))", "def LI(): return list(map(int,stdin.readline().rstrip().split()))", "LI", "k = [li.pop(0) for i in range(2)]", "[li.pop(0) for i in range(2)]", "k" ]

from sys import stdin def LI(): return list(map(int,stdin.readline().rstrip().split())) li = LI() n,k = [li.pop(0) for i in range(2)] ans = k for i in range(1,n): ans *= (k-1) print(ans)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 34, 2 ], [ 34, 11 ], [ 37, 13 ], [ 32, 14 ], [ 17, 16 ], [ 35, 20 ], [ 40, 23 ], [ 32, 25 ], [ 41, 29 ], [ 38, 29 ], [ 34, 32 ], [ 34, 35 ], [ 32, 37 ], [ 37, 38 ], [ 40, 41 ] ]

[ "x,y = map(int,input().split())\n\ncount = y\n\nfor i in range(x-1):\n count *= y-1\nprint(count)", "x,y = map(int,input().split())", "x", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "y", "count = y", "count", "y", "for i in range(x-1):\n count *= y-1", "i", "range(x-1)", "range", "x-1", "x", "1", "count *= y-1", "count", "y-1", "y", "1", "print(count)", "print", "count", "y = map(int,input().split())", "map(int,input().split())", "y", "x,y = map(int,input().split())", "map(int,input().split())", "x", "count = y", "y", "count", "count *= y-1", "y-1", "count" ]

x,y = map(int,input().split()) count = y for i in range(x-1): count *= y-1 print(count)

[ 7, 15, 13, 15, 13, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 29, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 9, 8 ], [ 9, 17 ], [ 17, 21 ], [ 17, 24 ], [ 8, 27 ], [ 38, 35 ] ]

[ "#! env python\n# -*- coding: utf-8 -*-\n\nimport os\nimport sys\n\n\n# ac_py.main\n# Date: 2020/06/14\n# Filename: main \n# Author: acto_mini\n\ndef main():\n N, K = map(int, input().split())\n # all = K ** N\n # out_single, out_multi = 0, 0\n # for i in range(2, N + 1):\n # out_multi += (N - i + 1) * K\n print(K * ((K - 1) ** (N - 1)))\n return\n\n\nif __name__ == '__main__':\n main()", "import os", "os", "import sys", "sys", "def main():\n N, K = map(int, input().split())\n # all = K ** N\n # out_single, out_multi = 0, 0\n # for i in range(2, N + 1):\n # out_multi += (N - i + 1) * K\n print(K * ((K - 1) ** (N - 1)))\n return", "main", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "print(K * ((K - 1) ** (N - 1)))", "print", "K * ((K - 1) ** (N - 1))", "K", "(K - 1) ** (N - 1)", "K - 1", "K", "1", "N - 1", "N", "1", "return", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, K = map(int, input().split())\n # all = K ** N\n # out_single, out_multi = 0, 0\n # for i in range(2, N + 1):\n # out_multi += (N - i + 1) * K\n print(K * ((K - 1) ** (N - 1)))\n return", "def main():\n N, K = map(int, input().split())\n # all = K ** N\n # out_single, out_multi = 0, 0\n # for i in range(2, N + 1):\n # out_multi += (N - i + 1) * K\n print(K * ((K - 1) ** (N - 1)))\n return", "main" ]

#! env python # -*- coding: utf-8 -*- import os import sys # ac_py.main # Date: 2020/06/14 # Filename: main # Author: acto_mini def main(): N, K = map(int, input().split()) # all = K ** N # out_single, out_multi = 0, 0 # for i in range(2, N + 1): # out_multi += (N - i + 1) * K print(K * ((K - 1) ** (N - 1))) return if __name__ == '__main__': main()

[ 7, 0, 13, 4, 13, 0, 13, 4, 18, 13, 13, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 14, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 2, 13, 2, 13, 17, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 2, 13, 17, 4, 13, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 76, 2 ], [ 79, 6 ], [ 77, 9 ], [ 67, 12 ], [ 80, 16 ], [ 77, 16 ], [ 70, 19 ], [ 80, 23 ], [ 77, 23 ], [ 68, 27 ], [ 71, 31 ], [ 68, 34 ], [ 71, 39 ], [ 71, 41 ], [ 64, 44 ], [ 71, 45 ], [ 48, 47 ], [ 68, 51 ], [ 73, 54 ], [ 65, 56 ], [ 74, 56 ], [ 71, 58 ], [ 74, 62 ], [ 65, 62 ], [ 71, 64 ], [ 64, 65 ], [ 67, 68 ], [ 70, 71 ], [ 73, 74 ], [ 76, 77 ], [ 79, 80 ] ]

[ "s = input()\ns = s.split()\nn = int(s[0])\nk = int(s[1])\n\nif n==1:\n print(k)\nelif n==2:\n print(k*(k-1))\nelse:\n ans = k\n for i in range(n-1):\n ans = ans*(k-1)\n print(ans)", "s = input()", "s", "input()", "input", "s = s.split()", "s", "s.split()", "s.split", "s", "split", "n = int(s[0])", "n", "int(s[0])", "int", "s[0]", "s", "0", "k = int(s[1])", "k", "int(s[1])", "int", "s[1]", "s", "1", "if n==1:\n print(k)\nelif n==2:\n print(k*(k-1))\nelse:\n ans = k\n for i in range(n-1):\n ans = ans*(k-1)\n print(ans)", "n==1", "n", "1", "print(k)", "print", "k", "elif n==2:\n print(k*(k-1))", "n==2", "n", "2", "print(k*(k-1))", "print", "k*(k-1)", "k", "k-1", "k", "1", "ans = k", "ans", "k", "for i in range(n-1):\n ans = ans*(k-1)\n ", "i", "range(n-1)", "range", "n-1", "n", "1", "ans = ans*(k-1)", "ans", "ans*(k-1)", "ans", "k-1", "k", "1", "print(ans)", "print", "ans", "ans = k", "k", "ans", "n = int(s[0])", "int(s[0])", "n", "k = int(s[1])", "int(s[1])", "k", "ans = ans*(k-1)", "ans*(k-1)", "ans", "s = input()", "input()", "s", "s = s.split()", "s.split()", "s" ]

s = input() s = s.split() n = int(s[0]) k = int(s[1]) if n==1: print(k) elif n==2: print(k*(k-1)) else: ans = k for i in range(n-1): ans = ans*(k-1) print(ans)

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 29, 39, 13, 13, 12, 13, 0, 13, 13, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 2, 13, 17, 14, 2, 13, 2, 2, 17, 17, 17, 29, 2, 2, 17, 17, 17, 29, 13, 23, 13, 23, 13, 14, 2, 13, 17, 0, 13, 4, 13, 13, 0, 13, 4, 13, 13, 13, 4, 13, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 22, 21 ], [ 55, 22 ], [ 25, 24 ], [ 53, 28 ], [ 31, 30 ], [ 21, 32 ], [ 30, 32 ], [ 55, 34 ], [ 30, 38 ], [ 21, 38 ], [ 30, 51 ], [ 21, 51 ], [ 53, 53 ], [ 55, 55 ], [ 87, 61 ], [ 76, 63 ], [ 87, 64 ], [ 81, 66 ], [ 79, 68 ], [ 85, 69 ], [ 88, 70 ], [ 82, 73 ], [ 81, 82 ], [ 87, 85 ], [ 87, 88 ] ]

[ "def readinput():\n n,k=map(int,input().split())\n return n,k\n\ndef main(n,k):\n ans=k\n for i in range(1,n):\n ans=ans*(k-1)\n if ans >2**31-1:\n return 2**31-1\n return ans\n\nif __name__=='__main__':\n n,k=readinput()\n ans=main(n,k)\n print(ans)", "def readinput():\n n,k=map(int,input().split())\n return n,k", "readinput", "n,k=map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "return n,k", "return n,k", "n", "k", "def main(n,k):\n ans=k\n for i in range(1,n):\n ans=ans*(k-1)\n if ans >2**31-1:\n return 2**31-1\n return ans", "main", "ans=k", "ans", "k", "for i in range(1,n):\n ans=ans*(k-1)\n if ans >2**31-1:\n return 2**31-1\n ", "i", "range(1,n)", "range", "1", "n", "ans=ans*(k-1)", "ans", "ans*(k-1)", "ans", "k-1", "k", "1", "if ans >2**31-1:\n return 2**31-1\n ", "ans >2**31-1", "ans", "2**31-1", "2**31", "2", "31", "1", "return 2**31-1", "2**31-1", "2**31", "2", "31", "1", "return ans", "ans", "n", "n", "k", "k", "if __name__=='__main__':\n n,k=readinput()\n ans=main(n,k)\n print(ans)", "__name__=='__main__'", "__name__", "'__main__'", "n,k=readinput()", "n", "readinput()", "readinput", "k", "ans=main(n,k)", "ans", "main(n,k)", "main", "n", "k", "print(ans)", "print", "ans", "def readinput():\n n,k=map(int,input().split())\n return n,k", "def readinput():\n n,k=map(int,input().split())\n return n,k", "readinput", "def main(n,k):\n ans=k\n for i in range(1,n):\n ans=ans*(k-1)\n if ans >2**31-1:\n return 2**31-1\n return ans", "def main(n,k):\n ans=k\n for i in range(1,n):\n ans=ans*(k-1)\n if ans >2**31-1:\n return 2**31-1\n return ans", "main", "ans=main(n,k)", "main(n,k)", "ans", "n,k=readinput()", "readinput()", "n", "k=readinput()", "readinput()", "k" ]

def readinput(): n,k=map(int,input().split()) return n,k def main(n,k): ans=k for i in range(1,n): ans=ans*(k-1) if ans >2**31-1: return 2**31-1 return ans if __name__=='__main__': n,k=readinput() ans=main(n,k) print(ans)

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 2, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 42, 2 ], [ 42, 13 ], [ 39, 15 ], [ 34, 16 ], [ 19, 18 ], [ 43, 22 ], [ 36, 25 ], [ 34, 27 ], [ 37, 31 ], [ 40, 31 ], [ 42, 34 ], [ 36, 37 ], [ 34, 39 ], [ 39, 40 ], [ 42, 43 ] ]

[ "a, b = list(map(int, input().split()))\n \nans = b\nfor i in range(a - 1):\n ans *= b - 1\n \nprint(ans)", "a, b = list(map(int, input().split()))", "a", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "b", "ans = b", "ans", "b", "for i in range(a - 1):\n ans *= b - 1\n ", "i", "range(a - 1)", "range", "a - 1", "a", "1", "ans *= b - 1", "ans", "b - 1", "b", "1", "print(ans)", "print", "ans", "b = list(map(int, input().split()))", "list(map(int, input().split()))", "b", "ans *= b - 1", "b - 1", "ans", "ans = b", "b", "ans", "a, b = list(map(int, input().split()))", "list(map(int, input().split()))", "a" ]

a, b = list(map(int, input().split())) ans = b for i in range(a - 1): ans *= b - 1 print(ans)

[ 7, 15, 13, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 4, 13, 2, 13, 4, 18, 13, 13, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 36, 4 ], [ 36, 15 ], [ 37, 21 ], [ 37, 27 ], [ 34, 30 ], [ 36, 34 ], [ 36, 37 ] ]

[ "import math\n\nN, K = list(map(int, input().split()))\nprint(int(K * math.pow(K - 1, N - 1)))", "import math", "math", "N, K = list(map(int, input().split()))", "N", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "print(int(K * math.pow(K - 1, N - 1)))", "print", "int(K * math.pow(K - 1, N - 1))", "int", "K * math.pow(K - 1, N - 1)", "K", "math.pow(K - 1, N - 1)", "math.pow", "math", "pow", "K - 1", "K", "1", "N - 1", "N", "1", "N, K = list(map(int, input().split()))", "list(map(int, input().split()))", "N", "K = list(map(int, input().split()))", "list(map(int, input().split()))", "K" ]

import math N, K = list(map(int, input().split())) print(int(K * math.pow(K - 1, N - 1)))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 27, 2 ], [ 27, 11 ], [ 25, 15 ], [ 25, 18 ], [ 28, 21 ], [ 27, 25 ], [ 27, 28 ] ]

[ "# solution\n\nnim, mike = map(int, input().split())\nprint(mike * (mike - 1) ** (nim - 1))", "nim, mike = map(int, input().split())", "nim", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "mike", "print(mike * (mike - 1) ** (nim - 1))", "print", "mike * (mike - 1) ** (nim - 1)", "mike", "(mike - 1) ** (nim - 1)", "mike - 1", "mike", "1", "nim - 1", "nim", "1", "mike = map(int, input().split())", "map(int, input().split())", "mike", "nim, mike = map(int, input().split())", "map(int, input().split())", "nim" ]

# solution nim, mike = map(int, input().split()) print(mike * (mike - 1) ** (nim - 1))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 33, 2 ], [ 33, 11 ], [ 27, 13 ], [ 34, 15 ], [ 34, 18 ], [ 31, 21 ], [ 28, 25 ], [ 27, 28 ], [ 33, 31 ], [ 33, 34 ] ]

[ "N, K = map(int,input().split())\n\noutput = K * (K -1) ** (N-1)\n\nprint(output)", "N, K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "output = K * (K -1) ** (N-1)", "output", "K * (K -1) ** (N-1)", "K", "(K -1) ** (N-1)", "K -1", "K", "1", "N-1", "N", "1", "print(output)", "print", "output", "output = K * (K -1) ** (N-1)", "K * (K -1) ** (N-1)", "output", "N, K = map(int,input().split())", "map(int,input().split())", "N", "K = map(int,input().split())", "map(int,input().split())", "K" ]

N, K = map(int,input().split()) output = K * (K -1) ** (N-1) print(output)

[ 7, 0, 13, 4, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 30, 2 ], [ 30, 13 ], [ 31, 17 ], [ 31, 21 ], [ 28, 24 ], [ 30, 28 ], [ 30, 31 ] ]

[ "n,m = list(map(int, input().split()))\nprint(m*pow(m-1,n-1))", "n,m = list(map(int, input().split()))", "n", "list(map(int, input().split()))", "list", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "m", "print(m*pow(m-1,n-1))", "print", "m*pow(m-1,n-1)", "m", "pow(m-1,n-1)", "pow", "m-1", "m", "1", "n-1", "n", "1", "n,m = list(map(int, input().split()))", "list(map(int, input().split()))", "n", "m = list(map(int, input().split()))", "list(map(int, input().split()))", "m" ]

n,m = list(map(int, input().split())) print(m*pow(m-1,n-1))

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 37, 2 ], [ 37, 11 ], [ 34, 13 ], [ 38, 14 ], [ 17, 16 ], [ 32, 20 ], [ 40, 23 ], [ 38, 25 ], [ 41, 29 ], [ 35, 29 ], [ 37, 32 ], [ 38, 34 ], [ 34, 35 ], [ 37, 38 ], [ 40, 41 ] ]

[ "n, k = map(int, input().split())\nans = k\nfor _ in range(n-1):\n ans *= (k-1)\nprint(ans)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k", "ans", "k", "for _ in range(n-1):\n ans *= (k-1)", "_", "range(n-1)", "range", "n-1", "n", "1", "ans *= (k-1)", "ans", "k-1", "k", "1", "print(ans)", "print", "ans", "n, k = map(int, input().split())", "map(int, input().split())", "n", "ans = k", "k", "ans", "k = map(int, input().split())", "map(int, input().split())", "k", "ans *= (k-1)", "k-1", "ans" ]

n, k = map(int, input().split()) ans = k for _ in range(n-1): ans *= (k-1) print(ans)

[ 7, 15, 13, 4, 18, 13, 13, 17, 0, 13, 2, 2, 17, 17, 17, 12, 13, 29, 18, 4, 18, 18, 13, 13, 13, 39, 17, 12, 13, 29, 4, 13, 13, 4, 18, 4, 13, 13, 12, 13, 29, 4, 13, 4, 13, 12, 13, 41, 28, 13, 4, 13, 13, 4, 4, 13, 4, 13, 0, 13, 13, 41, 28, 13, 4, 13, 31, 13, 4, 4, 13, 13, 29, 13, 23, 13, 12, 13, 0, 13, 4, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 14, 2, 13, 17, 4, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 12, 13, 10, 2, 13, 10, 12, 13 ]

[ [ 120, 9 ], [ 124, 36 ], [ 124, 44 ], [ 50, 49 ], [ 75, 52 ], [ 118, 57 ], [ 60, 59 ], [ 64, 63 ], [ 59, 67 ], [ 63, 71 ], [ 75, 75 ], [ 80, 79 ], [ 118, 81 ], [ 80, 82 ], [ 85, 84 ], [ 82, 85 ], [ 88, 87 ], [ 79, 91 ], [ 95, 94 ], [ 82, 96 ], [ 94, 100 ], [ 84, 100 ], [ 112, 106 ], [ 120, 121 ] ]

[ "import sys\nsys.setrecursionlimit(500000)\nMOD = 10**9+7\n\ndef input():\n return sys.stdin.readline()[:-1]\n\ndef mi():\n return map(int, input().split())\n\ndef ii():\n return int(input())\n\ndef i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(*tmp)]\n\ndef main():\n N, K = mi()\n ans = K\n for i in range(N-1):\n ans *= K-1\n print(ans)\n\n\nif __name__ == '__main__':\n main()", "import sys", "sys", "sys.setrecursionlimit(500000)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "500000", "MOD = 10**9+7", "MOD", "10**9+7", "10**9", "10", "9", "7", "def input():\n return sys.stdin.readline()[:-1]", "input", "return sys.stdin.readline()[:-1]", "sys.stdin.readline()[:-1]", "sys.stdin.readline()", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", ":-1", "-1", "def mi():\n return map(int, input().split())", "mi", "return map(int, input().split())", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "def ii():\n return int(input())", "ii", "return int(input())", "int(input())", "int", "input()", "input", "def i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(*tmp)]", "i2", "list(mi()) for i in range(n)", "for i in range(n)", "i", "range(n)", "range", "n", "for i in range(n)", "list(mi())", "list", "mi()", "mi", "tmp = [list(mi()) for i in range(n)]", "tmp", "[list(mi()) for i in range(n)]", "list(i) for i in zip(*tmp)", "for i in zip(*tmp)", "i", "zip(*tmp)", "zip", "*tmp", "tmp", "for i in zip(*tmp)", "list(i)", "list", "i", "return [list(i) for i in zip(*tmp)]", "[list(i) for i in zip(*tmp)]", "n", "n", "def main():\n N, K = mi()\n ans = K\n for i in range(N-1):\n ans *= K-1\n print(ans)", "main", "N, K = mi()", "N", "mi()", "mi", "K", "ans = K", "ans", "K", "for i in range(N-1):\n ans *= K-1\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "ans *= K-1", "ans", "K-1", "K", "1", "print(ans)", "print", "ans", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(*tmp)]", "def i2(n):\n tmp = [list(mi()) for i in range(n)]\n return [list(i) for i in zip(*tmp)]", "i2", "def main():\n N, K = mi()\n ans = K\n for i in range(N-1):\n ans *= K-1\n print(ans)", "def main():\n N, K = mi()\n ans = K\n for i in range(N-1):\n ans *= K-1\n print(ans)", "main", "def ii():\n return int(input())", "def ii():\n return int(input())", "ii", "def mi():\n return map(int, input().split())", "def mi():\n return map(int, input().split())", "mi", "MOD = 10**9+7", "10**9+7", "MOD", "def input():\n return sys.stdin.readline()[:-1]", "def input():\n return sys.stdin.readline()[:-1]", "input" ]

import sys sys.setrecursionlimit(500000) MOD = 10**9+7 def input(): return sys.stdin.readline()[:-1] def mi(): return map(int, input().split()) def ii(): return int(input()) def i2(n): tmp = [list(mi()) for i in range(n)] return [list(i) for i in zip(*tmp)] def main(): N, K = mi() ans = K for i in range(N-1): ans *= K-1 print(ans) if __name__ == '__main__': main()

[ 7, 15, 15, 15, 13, 13, 13, 13, 13, 13, 4, 18, 13, 13, 2, 17, 17, 0, 13, 2, 2, 17, 17, 17, 0, 13, 4, 13, 17, 12, 13, 12, 13, 0, 13, 4, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 17, 13, 10, 13, 13, 10, 12, 13, 10, 12, 13, 10, 4, 13, 10, 4, 13, 10, 2, 13 ]

[ [ 86, 18 ], [ 83, 25 ], [ 80, 34 ], [ 78, 36 ], [ 80, 37 ], [ 68, 39 ], [ 43, 42 ], [ 66, 45 ], [ 42, 48 ], [ 71, 51 ], [ 81, 52 ], [ 62, 54 ], [ 81, 56 ], [ 63, 60 ], [ 72, 60 ], [ 69, 60 ], [ 62, 63 ], [ 80, 66 ], [ 68, 69 ], [ 81, 71 ], [ 71, 72 ], [ 80, 81 ], [ 83, 84 ], [ 86, 87 ] ]

[ "from collections import Counter,defaultdict,deque\nfrom heapq import heappop,heappush,heapify\nimport sys,bisect,math,itertools,fractions,pprint\nsys.setrecursionlimit(10**8)\nmod = 10**9+7\nINF = float('inf')\ndef inp(): return int(sys.stdin.readline())\ndef inpl(): return list(map(int, sys.stdin.readline().split()))\n\nn,k = inpl()\nres = 1\nfor i in range(n):\n if i == 0:\n res *= k\n else:\n res *= k-1\nprint(res)", "from collections import Counter,defaultdict,deque", "from heapq import heappop,heappush,heapify", "import sys,bisect,math,itertools,fractions,pprint", "sys", "bisect", "math", "itertools", "fractions", "pprint", "sys.setrecursionlimit(10**8)", "sys.setrecursionlimit", "sys", "setrecursionlimit", "10**8", "10", "8", "mod = 10**9+7", "mod", "10**9+7", "10**9", "10", "9", "7", "INF = float('inf')", "INF", "float('inf')", "float", "'inf'", "def inp(): return int(sys.stdin.readline())", "inp", "def inpl(): return list(map(int, sys.stdin.readline().split()))", "inpl", "n,k = inpl()", "n", "inpl()", "inpl", "k", "res = 1", "res", "1", "for i in range(n):\n if i == 0:\n res *= k\n else:\n res *= k-1", "i", "range(n)", "range", "n", "if i == 0:\n res *= k\n else:\n res *= k-1", "i == 0", "i", "0", "res *= k", "res", "k", "res *= k-1", "res", "k-1", "k", "1", "print(res)", "print", "res", "res *= k-1", "k-1", "res", "n,k = inpl()", "inpl()", "n", "res = 1", "1", "res", "res *= k", "k", "res", "def inp(): return int(sys.stdin.readline())", "def inp(): return int(sys.stdin.readline())", "inp", "def inpl(): return list(map(int, sys.stdin.readline().split()))", "def inpl(): return list(map(int, sys.stdin.readline().split()))", "inpl", "k = inpl()", "inpl()", "k", "INF = float('inf')", "float('inf')", "INF", "mod = 10**9+7", "10**9+7", "mod" ]

from collections import Counter,defaultdict,deque from heapq import heappop,heappush,heapify import sys,bisect,math,itertools,fractions,pprint sys.setrecursionlimit(10**8) mod = 10**9+7 INF = float('inf') def inp(): return int(sys.stdin.readline()) def inpl(): return list(map(int, sys.stdin.readline().split())) n,k = inpl() res = 1 for i in range(n): if i == 0: res *= k else: res *= k-1 print(res)

[ 7, 0, 13, 4, 13, 0, 13, 4, 18, 13, 13, 17, 0, 13, 4, 13, 18, 13, 17, 0, 13, 4, 13, 18, 13, 17, 14, 2, 2, 13, 17, 2, 13, 17, 4, 13, 17, 0, 13, 13, 28, 13, 4, 13, 17, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 55, 2 ], [ 64, 6 ], [ 56, 9 ], [ 61, 13 ], [ 65, 17 ], [ 58, 20 ], [ 65, 24 ], [ 62, 29 ], [ 59, 32 ], [ 67, 38 ], [ 59, 39 ], [ 42, 41 ], [ 62, 45 ], [ 70, 47 ], [ 59, 49 ], [ 71, 53 ], [ 68, 53 ], [ 55, 56 ], [ 58, 59 ], [ 61, 62 ], [ 64, 65 ], [ 59, 67 ], [ 67, 68 ], [ 70, 71 ] ]

[ "sample = input() # two numbers in a string\nnew_sample = sample.split(\" \")\n\nball = int(new_sample[0]) # number of balls\ncolor = int(new_sample[1]) # number of colors\nif ball > 1 and color == 1:\n print(0)\nelse:\n product = color\n for i in range(1, ball):\n product *= (color-1)\n print(product)\n\n \n# 3 balls, 10 colors\n# 1st spot, 10 choices\n# 2nd spot, 9 choices\n# 3rd spot, 9 choices", "sample = input()", "sample", "input()", "input", "new_sample = sample.split(\" \")", "new_sample", "sample.split(\" \")", "sample.split", "sample", "split", "\" \"", "ball = int(new_sample[0])", "ball", "int(new_sample[0])", "int", "new_sample[0]", "new_sample", "0", "color = int(new_sample[1])", "color", "int(new_sample[1])", "int", "new_sample[1]", "new_sample", "1", "if ball > 1 and color == 1:\n print(0)\nelse:\n product = color\n for i in range(1, ball):\n product *= (color-1)\n print(product)\n\n \n# 3 balls, 10 colors\n# 1st spot, 10 choices\n# 2nd spot, 9 choices\n# 3rd spot, 9 choices", "ball > 1 and color == 1", "ball > 1", "ball", "1", "color == 1", "color", "1", "print(0)", "print", "0", "product = color", "product", "color", "for i in range(1, ball):\n product *= (color-1)\n ", "i", "range(1, ball)", "range", "1", "ball", "product *= (color-1)", "product", "color-1", "color", "1", "print(product)", "print", "product", "sample = input()", "input()", "sample", "color = int(new_sample[1])", "int(new_sample[1])", "color", "ball = int(new_sample[0])", "int(new_sample[0])", "ball", "new_sample = sample.split(\" \")", "sample.split(\" \")", "new_sample", "product = color", "color", "product", "product *= (color-1)", "color-1", "product" ]

sample = input() # two numbers in a string new_sample = sample.split(" ") ball = int(new_sample[0]) # number of balls color = int(new_sample[1]) # number of colors if ball > 1 and color == 1: print(0) else: product = color for i in range(1, ball): product *= (color-1) print(product) # 3 balls, 10 colors # 1st spot, 10 choices # 2nd spot, 9 choices # 3rd spot, 9 choices

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 13, 10, 4, 13, 10, 4, 13, 10, 13, 13, 10, 2, 13 ]

[ [ 37, 2 ], [ 37, 11 ], [ 35, 14 ], [ 40, 17 ], [ 38, 18 ], [ 43, 20 ], [ 38, 22 ], [ 38, 25 ], [ 35, 28 ], [ 44, 32 ], [ 41, 32 ], [ 37, 35 ], [ 37, 38 ], [ 38, 40 ], [ 40, 41 ], [ 43, 44 ] ]

[ "N,K = map(int,input().split())\nif N ==1:\n ans=K\nelse:\n ans = K * ((K-1)**(N-1))\n\nprint(ans)", "N,K = map(int,input().split())", "N", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "if N ==1:\n ans=K\nelse:\n ans = K * ((K-1)**(N-1))", "N ==1", "N", "1", "ans=K", "ans", "K", "ans = K * ((K-1)**(N-1))", "ans", "K * ((K-1)**(N-1))", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "print(ans)", "print", "ans", "N,K = map(int,input().split())", "map(int,input().split())", "N", "K = map(int,input().split())", "map(int,input().split())", "K", "ans=K", "K", "ans", "ans = K * ((K-1)**(N-1))", "K * ((K-1)**(N-1))", "ans" ]

N,K = map(int,input().split()) if N ==1: ans=K else: ans = K * ((K-1)**(N-1)) print(ans)

[ 7, 12, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 6, 5 ], [ 5, 14 ], [ 17, 16 ], [ 17, 18 ], [ 18, 22 ], [ 18, 25 ], [ 16, 28 ], [ 38, 35 ] ]

[ "def main():\n N, K = (int(i) for i in input().split())\n print(K*((K-1)**(N-1)))\n\n\nif __name__ == '__main__':\n main()", "def main():\n N, K = (int(i) for i in input().split())\n print(K*((K-1)**(N-1)))", "main", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "N, K = (int(i) for i in input().split())", "N", "(int(i) for i in input().split())", "K", "print(K*((K-1)**(N-1)))", "print", "K*((K-1)**(N-1))", "K", "(K-1)**(N-1)", "K-1", "K", "1", "N-1", "N", "1", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N, K = (int(i) for i in input().split())\n print(K*((K-1)**(N-1)))", "def main():\n N, K = (int(i) for i in input().split())\n print(K*((K-1)**(N-1)))", "main" ]

def main(): N, K = (int(i) for i in input().split()) print(K*((K-1)**(N-1))) if __name__ == '__main__': main()

[ 7, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 13, 13, 10, 13, 13 ]

[ [ 4, 3 ], [ 3, 12 ], [ 32, 14 ], [ 32, 16 ], [ 33, 20 ], [ 33, 23 ], [ 30, 26 ], [ 32, 30 ], [ 32, 33 ] ]

[ "a, b = [int(i) for i in input().split()]\n\nprint(b * (b-1) ** (a - 1))", "int(i) for i in input().split()", "for i in input().split()", "i", "input().split()", "().split", "()", "input", "split", "for i in input().split()", "int(i)", "int", "i", "a, b = [int(i) for i in input().split()]", "a", "[int(i) for i in input().split()]", "b", "print(b * (b-1) ** (a - 1))", "print", "b * (b-1) ** (a - 1)", "b", "(b-1) ** (a - 1)", "b-1", "b", "1", "a - 1", "a", "1", "a, b = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "a", "b = [int(i) for i in input().split()]", "[int(i) for i in input().split()]", "b" ]

a, b = [int(i) for i in input().split()] print(b * (b-1) ** (a - 1))

[ 7, 15, 13, 0, 13, 18, 18, 13, 13, 13, 41, 28, 13, 4, 18, 4, 13, 13, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 10, 13, 13, 10, 18, 13, 10, 13, 13 ]

[ [ 41, 4 ], [ 13, 12 ], [ 42, 16 ], [ 12, 21 ], [ 44, 23 ], [ 44, 25 ], [ 39, 29 ], [ 39, 32 ], [ 45, 35 ], [ 44, 39 ], [ 41, 42 ], [ 44, 45 ] ]

[ "import sys\ninput = sys.stdin.readline\n\nn, k = [int(x) for x in input().split()]\n\nprint(k * (k - 1)**(n - 1))", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "int(x) for x in input().split()", "for x in input().split()", "x", "input().split()", "().split", "()", "input", "split", "for x in input().split()", "int(x)", "int", "x", "n, k = [int(x) for x in input().split()]", "n", "[int(x) for x in input().split()]", "k", "print(k * (k - 1)**(n - 1))", "print", "k * (k - 1)**(n - 1)", "k", "(k - 1)**(n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "k = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "k", "input = sys.stdin.readline", "sys.stdin.readline", "input", "n, k = [int(x) for x in input().split()]", "[int(x) for x in input().split()]", "n" ]

import sys input = sys.stdin.readline n, k = [int(x) for x in input().split()] print(k * (k - 1)**(n - 1))

[ 7, 12, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 5, 13 ], [ 13, 17 ], [ 13, 20 ], [ 4, 23 ], [ 29, 26 ] ]

[ "def resolve():\n N, M = map(int, input().split())\n print(M*(M-1)**(N-1))\nresolve()", "def resolve():\n N, M = map(int, input().split())\n print(M*(M-1)**(N-1))", "resolve", "N, M = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "M", "print(M*(M-1)**(N-1))", "print", "M*(M-1)**(N-1)", "M", "(M-1)**(N-1)", "M-1", "M", "1", "N-1", "N", "1", "resolve()", "resolve", "def resolve():\n N, M = map(int, input().split())\n print(M*(M-1)**(N-1))", "def resolve():\n N, M = map(int, input().split())\n print(M*(M-1)**(N-1))", "resolve" ]

def resolve(): N, M = map(int, input().split()) print(M*(M-1)**(N-1)) resolve()

[ 7, 14, 2, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 4, 13, 2, 13, 4, 13, 2, 13, 17, 2, 13, 17, 10, 4, 13, 10, 4, 13 ]

[ [ 32, 6 ], [ 32, 15 ], [ 30, 19 ], [ 30, 23 ], [ 33, 26 ], [ 32, 30 ], [ 32, 33 ] ]

[ "if __name__ == \"__main__\":\n N, K = map(int, input().split())\n print(K*pow(K-1, N-1))", "if __name__ == \"__main__\":\n N, K = map(int, input().split())\n print(K*pow(K-1, N-1))", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "print(K*pow(K-1, N-1))", "print", "K*pow(K-1, N-1)", "K", "pow(K-1, N-1)", "pow", "K-1", "K", "1", "N-1", "N", "1", "K = map(int, input().split())", "map(int, input().split())", "K", "N, K = map(int, input().split())", "map(int, input().split())", "N" ]

if __name__ == "__main__": N, K = map(int, input().split()) print(K*pow(K-1, N-1))

[ 7, 14, 2, 13, 17, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 17, 28, 13, 4, 13, 13, 14, 2, 13, 17, 0, 13, 13, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 17, 13, 10, 13, 13, 10, 4, 13, 10, 4, 13 ]

[ [ 52, 6 ], [ 52, 15 ], [ 43, 17 ], [ 21, 20 ], [ 50, 23 ], [ 20, 26 ], [ 46, 29 ], [ 53, 30 ], [ 40, 32 ], [ 53, 34 ], [ 41, 38 ], [ 47, 38 ], [ 44, 38 ], [ 40, 41 ], [ 43, 44 ], [ 53, 46 ], [ 46, 47 ], [ 52, 50 ], [ 52, 53 ] ]

[ "if __name__ == \"__main__\":\n n, k = map(int, input().split())\n\n ans = 1\n for i in range(n):\n if i == 0:\n ans *= k\n else:\n ans *= k - 1\n\n print(ans)", "if __name__ == \"__main__\":\n n, k = map(int, input().split())\n\n ans = 1\n for i in range(n):\n if i == 0:\n ans *= k\n else:\n ans *= k - 1\n\n print(ans)", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = 1", "ans", "1", "for i in range(n):\n if i == 0:\n ans *= k\n else:\n ans *= k - 1\n\n ", "i", "range(n)", "range", "n", "if i == 0:\n ans *= k\n else:\n ans *= k - 1\n\n ", "i == 0", "i", "0", "ans *= k", "ans", "k", "ans *= k - 1", "ans", "k - 1", "k", "1", "print(ans)", "print", "ans", "ans *= k - 1", "k - 1", "ans", "ans = 1", "1", "ans", "ans *= k", "k", "ans", "n, k = map(int, input().split())", "map(int, input().split())", "n", "k = map(int, input().split())", "map(int, input().split())", "k" ]

if __name__ == "__main__": n, k = map(int, input().split()) ans = 1 for i in range(n): if i == 0: ans *= k else: ans *= k - 1 print(ans)

[ 7, 12, 13, 15, 13, 0, 13, 18, 18, 13, 13, 13, 41, 28, 13, 4, 18, 4, 18, 4, 13, 13, 13, 17, 4, 4, 13, 13, 0, 13, 13, 13, 4, 13, 2, 13, 2, 2, 13, 17, 2, 13, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 7, 6 ], [ 15, 14 ], [ 6, 20 ], [ 14, 27 ], [ 30, 29 ], [ 30, 31 ], [ 31, 35 ], [ 31, 38 ], [ 29, 41 ], [ 51, 48 ] ]

[ "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, k = [int(x) for x in input().rstrip().split(\" \")]\n\n print(k * ((k - 1) ** (n - 1)))\n\n\nif __name__ == \"__main__\":\n resolve()", "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, k = [int(x) for x in input().rstrip().split(\" \")]\n\n print(k * ((k - 1) ** (n - 1)))", "resolve", "import sys", "sys", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "int(x) for x in input().rstrip().split(\" \")", "for x in input().rstrip().split(\" \")", "x", "input().rstrip().split(\" \")", "().rstrip().split", "().rstrip()", "().rstrip", "()", "input", "rstrip", "split", "\" \"", "for x in input().rstrip().split(\" \")", "int(x)", "int", "x", "n, k = [int(x) for x in input().rstrip().split(\" \")]", "n", "[int(x) for x in input().rstrip().split(\" \")]", "k", "print(k * ((k - 1) ** (n - 1)))", "print", "k * ((k - 1) ** (n - 1))", "k", "(k - 1) ** (n - 1)", "k - 1", "k", "1", "n - 1", "n", "1", "if __name__ == \"__main__\":\n resolve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "resolve()", "resolve", "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, k = [int(x) for x in input().rstrip().split(\" \")]\n\n print(k * ((k - 1) ** (n - 1)))", "def resolve():\n import sys\n input = sys.stdin.readline\n\n n, k = [int(x) for x in input().rstrip().split(\" \")]\n\n print(k * ((k - 1) ** (n - 1)))", "resolve" ]

def resolve(): import sys input = sys.stdin.readline n, k = [int(x) for x in input().rstrip().split(" ")] print(k * ((k - 1) ** (n - 1))) if __name__ == "__main__": resolve()

[ 7, 15, 13, 12, 13, 0, 13, 18, 18, 13, 13, 13, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 2, 13, 17, 4, 13, 13, 29, 17, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 7, 6 ], [ 14, 13 ], [ 6, 20 ], [ 14, 22 ], [ 25, 24 ], [ 22, 25 ], [ 28, 27 ], [ 13, 31 ], [ 24, 35 ], [ 46, 43 ] ]

[ "import sys\n\ndef solve():\n input = sys.stdin.readline\n N, K = map(int, input().split())\n total = K\n for i in range(N-1): total *= (K - 1)\n print(total)\n return 0\n\nif __name__ == \"__main__\":\n solve()", "import sys", "sys", "def solve():\n input = sys.stdin.readline\n N, K = map(int, input().split())\n total = K\n for i in range(N-1): total *= (K - 1)\n print(total)\n return 0", "solve", "input = sys.stdin.readline", "input", "sys.stdin.readline", "sys.stdin", "sys", "stdin", "readline", "N, K = map(int, input().split())", "N", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "K", "total = K", "total", "K", "for i in range(N-1): total *= (K - 1)\n ", "i", "range(N-1)", "range", "N-1", "N", "1", "print(total)", "print", "total", "return 0", "0", "if __name__ == \"__main__\":\n solve()", "__name__ == \"__main__\"", "__name__", "\"__main__\"", "solve()", "solve", "def solve():\n input = sys.stdin.readline\n N, K = map(int, input().split())\n total = K\n for i in range(N-1): total *= (K - 1)\n print(total)\n return 0", "def solve():\n input = sys.stdin.readline\n N, K = map(int, input().split())\n total = K\n for i in range(N-1): total *= (K - 1)\n print(total)\n return 0", "solve" ]

import sys def solve(): input = sys.stdin.readline N, K = map(int, input().split()) total = K for i in range(N-1): total *= (K - 1) print(total) return 0 if __name__ == "__main__": solve()

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 2, 13, 17, 4, 13, 2, 2, 2, 13, 17, 13, 13, 10, 4, 13, 10, 2, 13, 10, 4, 13 ]

[ [ 33, 2 ], [ 33, 11 ], [ 30, 13 ], [ 28, 15 ], [ 34, 22 ], [ 31, 24 ], [ 28, 24 ], [ 34, 25 ], [ 33, 28 ], [ 30, 31 ], [ 33, 34 ] ]

[ "n, k = map(int, input().split())\n\nn = n-1\n\nprint((k-1)**n * k)", "n, k = map(int, input().split())", "n", "map(int, input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "n = n-1", "n", "n-1", "n", "1", "print((k-1)**n * k)", "print", "(k-1)**n * k", "(k-1)**n", "k-1", "k", "1", "n", "k", "n, k = map(int, input().split())", "map(int, input().split())", "n", "n = n-1", "n-1", "n", "k = map(int, input().split())", "map(int, input().split())", "k" ]

n, k = map(int, input().split()) n = n-1 print((k-1)**n * k)

[ 7, 0, 13, 4, 13, 13, 4, 18, 4, 13, 13, 13, 0, 13, 13, 28, 13, 4, 13, 17, 2, 13, 17, 0, 13, 2, 13, 17, 4, 13, 13, 10, 2, 13, 10, 4, 13, 10, 13, 13, 10, 4, 13 ]

[ [ 41, 2 ], [ 41, 11 ], [ 38, 13 ], [ 36, 14 ], [ 17, 16 ], [ 42, 21 ], [ 32, 24 ], [ 36, 26 ], [ 33, 30 ], [ 39, 30 ], [ 32, 33 ], [ 41, 36 ], [ 36, 38 ], [ 38, 39 ], [ 41, 42 ] ]

[ "n,k = map(int,input().split())\n\nans = k\nfor i in range(2,n+1):\n ans *= (k-1)\nprint(ans)", "n,k = map(int,input().split())", "n", "map(int,input().split())", "map", "int", "input().split()", "().split", "()", "input", "split", "k", "ans = k", "ans", "k", "for i in range(2,n+1):\n ans *= (k-1)", "i", "range(2,n+1)", "range", "2", "n+1", "n", "1", "ans *= (k-1)", "ans", "k-1", "k", "1", "print(ans)", "print", "ans", "ans *= (k-1)", "k-1", "ans", "k = map(int,input().split())", "map(int,input().split())", "k", "ans = k", "k", "ans", "n,k = map(int,input().split())", "map(int,input().split())", "n" ]

n,k = map(int,input().split()) ans = k for i in range(2,n+1): ans *= (k-1) print(ans)

[ 7, 12, 13, 0, 13, 4, 13, 4, 13, 41, 28, 13, 4, 13, 13, 4, 13, 0, 13, 13, 0, 13, 18, 13, 17, 13, 28, 13, 4, 13, 17, 13, 0, 13, 18, 13, 13, 13, 14, 40, 2, 13, 13, 17, 0, 13, 2, 13, 2, 13, 13, 14, 2, 2, 2, 13, 13, 13, 13, 14, 40, 2, 13, 13, 17, 0, 13, 2, 13, 2, 13, 13, 0, 13, 2, 2, 13, 13, 13, 0, 13, 2, 2, 13, 13, 13, 4, 13, 2, 13, 13, 29, 14, 2, 13, 17, 4, 13, 10, 12, 13 ]

[ [ 5, 4 ], [ 12, 11 ], [ 4, 14 ], [ 19, 18 ], [ 22, 21 ], [ 18, 23 ], [ 22, 25 ], [ 28, 27 ], [ 4, 31 ], [ 34, 33 ], [ 18, 35 ], [ 27, 36 ], [ 34, 37 ], [ 21, 41 ], [ 73, 41 ], [ 45, 41 ], [ 33, 42 ], [ 46, 45 ], [ 33, 47 ], [ 21, 49 ], [ 73, 49 ], [ 45, 49 ], [ 33, 50 ], [ 37, 55 ], [ 45, 56 ], [ 21, 56 ], [ 73, 56 ], [ 33, 57 ], [ 25, 58 ], [ 80, 58 ], [ 66, 58 ], [ 25, 62 ], [ 80, 62 ], [ 66, 62 ], [ 37, 63 ], [ 67, 66 ], [ 37, 68 ], [ 25, 70 ], [ 80, 70 ], [ 66, 70 ], [ 37, 71 ], [ 74, 73 ], [ 33, 76 ], [ 66, 77 ], [ 25, 77 ], [ 80, 77 ], [ 37, 78 ], [ 81, 80 ], [ 37, 83 ], [ 45, 84 ], [ 21, 84 ], [ 73, 84 ], [ 33, 85 ], [ 73, 89 ], [ 45, 89 ], [ 21, 89 ], [ 80, 90 ], [ 66, 90 ], [ 25, 90 ], [ 100, 97 ] ]

[ "def main():\n N = int(input())\n TA = [[int(_) for _ in input().split()] for __ in range(N)]\n x, y = TA[0] #初期値\n for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n print(x+y)\n return\n\nif __name__ == '__main__':\n main()", "def main():\n N = int(input())\n TA = [[int(_) for _ in input().split()] for __ in range(N)]\n x, y = TA[0] #初期値\n for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n print(x+y)\n return", "main", "N = int(input())", "N", "int(input())", "int", "input()", "input", "[int(_) for _ in input().split()] for __ in range(N)", "for __ in range(N)", "__", "range(N)", "range", "N", "for __ in range(N)", "[int(_) for _ in input().split()]", "TA = [[int(_) for _ in input().split()] for __ in range(N)]", "TA", "[[int(_) for _ in input().split()] for __ in range(N)]", "x, y = TA[0]", "x", "TA[0]", "TA", "0", "y", "for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n ", "i", "range(1, N)", "range", "1", "N", "T, A = TA[i]", "T", "TA[i]", "TA", "i", "A", "if x%T != 0:\n x += T - x%T\n ", "x%T != 0", "x%T", "x", "T", "0", "x += T - x%T", "x", "T - x%T", "T", "x%T", "x", "T", "if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n ", "A * x // T < y", "A * x // T", "A * x", "A", "x", "T", "y", "if y%A != 0:\n y += A - y%A\n ", "y%A != 0", "y%A", "y", "A", "0", "y += A - y%A", "y", "A - y%A", "A", "y%A", "y", "A", "x = T * y // A", "x", "T * y // A", "T * y", "T", "y", "A", "y = A * x // T", "y", "A * x // T", "A * x", "A", "x", "T", "print(x+y)", "print", "x+y", "x", "y", "return", "if __name__ == '__main__':\n main()", "__name__ == '__main__'", "__name__", "'__main__'", "main()", "main", "def main():\n N = int(input())\n TA = [[int(_) for _ in input().split()] for __ in range(N)]\n x, y = TA[0] #初期値\n for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n print(x+y)\n return", "def main():\n N = int(input())\n TA = [[int(_) for _ in input().split()] for __ in range(N)]\n x, y = TA[0] #初期値\n for i in range(1, N):\n T, A = TA[i]\n if x%T != 0:\n x += T - x%T\n if A * x // T < y:\n if y%A != 0:\n y += A - y%A\n x = T * y // A\n else:\n y = A * x // T\n print(x+y)\n return", "main" ]

def main(): N = int(input()) TA = [[int(_) for _ in input().split()] for __ in range(N)] x, y = TA[0] #初期値 for i in range(1, N): T, A = TA[i] if x%T != 0: x += T - x%T if A * x // T < y: if y%A != 0: y += A - y%A x = T * y // A else: y = A * x // T print(x+y) return if __name__ == '__main__': main()