output_description: Print the number of ways modulo $10^9+7$ in a line.
input_description: $n$ $k$
      
  
  The first line will contain two integers $n$ and $k$.
attempt: 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
  
      # m:int MOD
      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))
  
problem_description: 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$.
samples: [{"input": "2 3", "output": "9"}, {"input": "10 5", "output": "9765625"}, {"input": "100 100", "output": "424090053"}]