Problem:
Balls and Boxes 1  Balls Boxes Any way At most one ball At least one ball  Distinguishable Distinguishable 1 2 3  Indistinguishable Distinguishable 4 5 6  Distinguishable Indistinguishable 7 8 9  Indistinguishable Indistinguishable 10 11 12  Problem You have $n$ balls and $k$ boxes. You want to put these balls into the boxes. Find the number of ways to put the balls under the following conditions:  Each ball is distinguished from the other.  Each box is distinguished from the other.  Each ball can go into only one box and no one remains outside of the boxes.  Each box can contain an arbitrary number of balls (including zero).  Note that you must print this count modulo $10^9+7$. Input $n$ $k$ The first line will contain two integers $n$ and $k$. Output Print the number of ways modulo $10^9+7$ in a line. Constraints  $1 \le n \le 1000$  $1 \le k \le 1000$  Sample Input 1 2 3 Sample Output 1 9 Sample Input 2 10 5 Sample Output 2 9765625 Sample Input 3 100 100 Sample Output 3 424090053

Solution (Python):
MOD = 1000000007

def main():
	n,k = map(int, input().split())
	print(k**n % MOD)
	return

main()

Solution (Python):
class Twelvefold(): 
    def __init__(self, n, mod):
        self.mod = mod
        self.fct = [0 for _ in range(n + 1)]
        self.inv = [0 for _ in range(n + 1)]
        self.stl = [[0 for j in range(n + 1)] for i in range(n + 1)]
        self.bel = [[0 for j in range(n + 1)] for i in range(n + 1)]
        self.prt = [[0 for j in range(n + 1)] for i in range(n + 1)]
        self.fct[0] = 1
        self.inv[0] = 1
        self.stl[0][0] = 1
        self.bel[0][0] = 1
        for i in range(n):
            self.fct[i + 1] = self.fct[i] * (i + 1) % mod
        self.inv[n] = pow(self.fct[n], mod - 2, mod)
        for i in range(n)[::-1]:
            self.inv[i] = self.inv[i + 1] * (i + 1) % mod
        for i in range(n):
            for j in range(n):
                self.stl[i + 1][j + 1] = self.stl[i][j] + (j + 1) * self.stl[i][j + 1]
                self.stl[i + 1][j + 1] %= mod
        for i in range(n):
            for j in range(n):
                self.bel[i + 1][j + 1] = self.bel[i + 1][j] + self.stl[i + 1][j + 1] % mod
                self.bel[i + 1][j + 1] %= mod
        for j in range(n):
            self.prt[0][j] = 1
        for i in range(n):
            for j in range(n):
                if i - j >= 0:
                    self.prt[i + 1][j + 1] = self.prt[i + 1][j] + self.prt[i - j][j + 1]
                else:
                    self.prt[i + 1][j + 1] = self.prt[i + 1][j]
                self.prt[i + 1][j + 1] %= mod

    def solve(self, element, subset, equate_element=False, equate_subset=False, less_than_1=False, more_than_1=False):
        assert not less_than_1 or not more_than_1
        n = element
        k = subset
        a = equate_element
        b = equate_subset
        c = less_than_1
        d = more_than_1
        id = a * 3 + b * 6 + c + d * 2
        tw = [self.tw1, self.tw2, self.tw3, self.tw4, self.tw5, self.tw6, self.tw7, self.tw8, self.tw9, self.tw10, self.tw11, self.tw12]
        return tw[id](n, k)

    def tw1(self, n, k):
        return pow(k, n, self.mod)

    def tw2(self, n, k):
        if k - n < 0: return 0
        return self.fct[k] * self.inv[k - n] % self.mod

    def tw3(self, n, k):
        return self.stl[n][k] * self.fct[k] % self.mod

    def tw4(self, n, k):
        if k == 0: return 0
        return self.fct[n + k - 1] * self.inv[n] * self.inv[k - 1] % self.mod

    def tw5(self, n, k):
        if k - n < 0: return 0
        return self.fct[k] * self.inv[n] * self.inv[k - n] % self.mod

    def tw6(self, n, k):
        if n - k < 0 or k == 0: return 0
        return self.fct[n - 1] * self.inv[k - 1] * self.inv[n - k]

    def tw7(self, n, k):
        return self.bel[n][k]

    def tw8(self, n, k):
        if k - n < 0: return 0
        return 1

    def tw9(self, n, k):
        return self.stl[n][k]

    def tw10(self, n, k):
        return self.prt[n][k]

    def tw11(self, n, k):
        if k - n < 0: return 0
        return 1

    def tw12(self, n, k):
        if n - k < 0: return 0
        return self.prt[n - k][k]

n, k = map(int, input().split())
t = Twelvefold(1000, 10**9 + 7)
print(t.solve(n, k, 0, 0, 0, 0))

Solution (Python):
import sys

import math
import collections

import bisect
import itertools
import fractions

import copy

import decimal

import queue



sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7


ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))




def main():
    n, k = ns()
    print(pow(k, n, MOD))


if __name__ == '__main__':
    main()

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10**9 + 7
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    n, k = LI()

    ans = pow(k, n, MOD)

    print(ans)

if __name__ == '__main__':
    resolve()

Solution (Python):
a,b=map(int,input().split())
print(pow(b,a,10**9+7))

Solution (Python):
n, k = map(int,input().split())
"""
それぞれのボールがkつの箱にいく選択肢がある。
k^n
"""
print(pow(k, n, 10**9+7))

Solution (Python):
N, K = map(int, input().split())
MOD = 10 ** 9 + 7
print(pow(K, N, MOD))

Solution (Python):
n, k = map(int, input().split())
print(pow(k, n, 10 ** 9 + 7))

Solution (Python):
import sys

def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
EPS = 10 ** -10

N, K = MAP()

ans = K**N % MOD
print(ans)

Solution (Python):
N, K = map(int,input().split())
print(pow(K, N, 10**9+7))

Solution (Python):
def way1(ball, box):
    """ball: True / box: True / constraints: None
    -> ans = box ** ball
    """
    ans = pow(box, ball, MOD)
    return ans


n, k = map(int, input().split())
MOD = 10 ** 9 + 7

print(way1(n, k))

Solution (Python):
MOD = 1000000007
class ModInt:
    def __init__(self, x):
        self.x = x % MOD

    def __str__(self):
        return str(self.x)
    def __int__(self):
        return self.x

    __repr__ = __str__

    def __add__(self, other):
        return (
            ModInt(self.x + other.x) if isinstance(other, ModInt) else
            ModInt(self.x + other)
        )

    def __sub__(self, other):
        return (
            ModInt(self.x - other.x) if isinstance(other, ModInt) else
            ModInt(self.x - other)
        )

    def __mul__(self, other):
        return (
            ModInt(self.x * other.x) if isinstance(other, ModInt) else
            ModInt(self.x * other)
        )

    def __truediv__(self, other):
        return (
            ModInt(
                self.x * pow(other.x, MOD - 2, MOD)
            ) if isinstance(other, ModInt) else
            ModInt(self.x * pow(other, MOD - 2, MOD))
        )

    def __mod__(self, other):
        return (
            ModInt(
                other.x
            ) if isinstance(other, ModInt) else
            self.x
        )

    def __pow__(self, other):
        return (
            ModInt(pow(self.x, other.x, MOD)) if isinstance(other, ModInt) else
            ModInt(pow(self.x, other, MOD))
        )

    __radd__ = __add__

    def __rsub__(self, other):
        return (
            ModInt(other.x - self.x) if isinstance(other, ModInt) else
            ModInt(other - self.x)
        )

    __rmul__ = __mul__

    def __rtruediv__(self, other):
        return (
            ModInt(
                other.x * pow(self.x, MOD - 2, MOD)
            ) if isinstance(other, ModInt) else
            ModInt(other * pow(self.x, MOD - 2, MOD))
        )

    def __rpow__(self, other):
        return (
            ModInt(pow(other.x, self.x, MOD)) if isinstance(other, ModInt) else
            ModInt(pow(other, self.x, MOD))
        )
    
    def __iadd__(self,other):
        self.x += other.x if isinstance(other, ModInt) else other
        self.x %= MOD
        return self

    def __isub__(self,other):
        self.x += ModInt(MOD - other.x) if isinstance(other, ModInt) else ModInt(MOD - other)
        return self

    def __imul__(self, other):
        self.x *= other.x if isinstance(other, ModInt) else other
        self.x %= MOD
        return self
    
    def factorical(self,n):
        tmp = ModInt(1)
        for i in range(n):
            tmp *= (i+1)
        return tmp
    
    
    def modinv(self,a,m=MOD):
        b = m
        u = 1
        v = 0
        while(b):
            t = a//b
            a -= t * b
            a,b = b,a
            u -= t * v
            u,v = v,u
        return ModInt(u)

    def comb(self,n,r):
        n = int(n)
        r = int(r)
        if r > n or n < 0 or r < 0:
            return 0
        m = n+1
        nterms = min(r, n-r)
        numerator = ModInt(1)
        denominator = ModInt(1)
        for j in range(1, nterms + 1):
            numerator *= m - j
            denominator *= j
        return numerator * self.modinv(denominator.x)
        
if __name__ == "__main__":
    a,b = map(int, input().split())
    n = ModInt(a)
    k = ModInt(b)
    print(pow(k,n))

Solution (Python):


iim = lambda: map(int, input().rstrip().split())

def resolve():
    N, K = iim()
    mod = 10**9 + 7

    print(pow(K, N, mod))

if __name__ == "__main__":
    resolve()

Solution (Python):
from functools import lru_cache
mod=1000000007

n,k=[int(i) for i in input().split(" ")]

@lru_cache()
def power(m,n,mod):
    if n==0:
        return 1
    elif n==1:
        return m
    elif n%2==0:
        return ((power(m,n//2,mod)%mod) * (power(m,n//2,mod)%mod))%mod
    else:
        return (power(m,n-1,mod)*m)%mod

print(power(k,n,mod))

Solution (Python):
n,k = map(int,input().split())
print(pow(k,n,1000000007))

Solution (Python):
n, k = list(map(int,input().split()))

mod = int(1e9+7)
ans = 1
while (n > 0):
    if (n % 2 == 1):
        ans = (ans * k) % mod
    k = (k * k) % mod
    n = n // 2
print(ans)

Solution (Python):
n,k = map(int,input().split())
ans = 1
MOD = 10**9+7
for _ in range(n):
    ans *= k
    ans %= MOD
print(ans)

Solution (Python):

"""
Balls and Boxes 1
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=DPL_5_A&lang=ja

"""
import sys


def solve(n, k):
    ans = 1
    for _ in range(n):
        ans = (ans * k) % (10**9 + 7)
    return ans


def main(args):
    n, k = map(int, input().split())
    ans = solve(n, k)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

Solution (Python):
mod = 10**9+7
n, k = map(int, input().split())
print(pow(k, n, mod))

Solution (Python):
if __name__ == "__main__":
    n, k = map(lambda x: int(x), input().split())
    ans = k ** n % (10 ** 9 + 7)
    print(ans)

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

Solution (Python):
n,k=map(int,input().split())
print((k**n)%1000000007)

Solution (Python):
n,k = map(int, input().split())
print(k ** n % (10**9+7))

Solution (Python):
n,k = map(int,input().split())
print(pow(k,n,1000000007))

Solution (Python):
N, K = map(int, input().split())
MOD = 10**9 + 7
 
print(pow(K, N, MOD))

Solution (Python):
n, k = map(int, input().split())
MOD = 10**9 + 7
ans = pow(k, n, MOD)
print(ans)

Solution (Python):
n,k=map(int,input().split())
print(pow(k,n,1000000007))

Solution (Python):
from math import factorial
def P(n,r):
    return factorial(n)//factorial(n-r)
def C(n,r):
    return P(n,r)//factorial(r)

n, k = map(int, input().split())

print((k**n)%(pow(10,9)+7))

Solution (Python):
n,k=map(int,input().split())
print(pow(k,n,10**9+7))

Solution (Python):
n,k = map(int,input().split())
print(pow(k,n,1000000007))

Solution (Python):
n,m = map(int,input().split())
mod = 1000000007
print(pow(m,n,mod))

Solution (Python):
N, K = map(int, input().split())
MOD = 10**9 + 7

print(pow(K, N, MOD))

Solution (Python):
n,k = map(int, input().split())
ans = k
for i in range(n-1):
    ans *= k
    ans %= 1000000007
print(ans)

Solution (Python):
n,k=map(int,input().split(" "))
print(pow(k,n,10**9+7))

Solution (Python):


import sys
import math
import itertools as it
from collections import deque

sys.setrecursionlimit(10000000)

MOD = 10 ** 9 + 7

n, k = map(int, raw_input().split())

print k ** n % MOD