#include <bits/stdc++.h>
using namespace std;

#define lint int64_t
const lint MOD = 1e9 + 7;

template <typename T, typename U>
T power(T n, U p) {
    /*
     * 累乗 (power)
     *
     * 二つの整数 n, p を受け取り, n の p 乗を O(log p) で返します.
     * 型は揃っている必要はありませんが, p は大小関係と余りが定義されている必要があります.
     * 入力 p < 0 のときは正しく動作しません.
     */
    
    T res = 1;
    while (p > 0) {
        if (p % 2 == 1) {
            res *= n;
        }
        n *= n;
        p /= 2;
    }
    return res;
}

template <int64_t mod>
class ModInt {
    /* 
     *有限体 (mod p での四則演算)
     *
     * 普通の数と同じように入出力や mod p での四則演算ができるクラスです.
     * 法 p はテンプレート引数で受け取ります.
     * 大小関係 (< など) は定義されていないので注意してください.
     */

    int64_t val;

    public:
    // コンストラクタ
    // 引数を指定しない場合は 0, 指定した場合はその数で初期化します.
    ModInt(): val(0) {}
    ModInt(int64_t init_val): val(init_val >= 0? init_val % mod: mod - (-init_val) % mod) {}

    // 入出力
    friend istream& operator >> (istream& is, ModInt& n) {
        int64_t init_val;
        is >> init_val;
        n = ModInt(init_val);
        return is;
    }
    friend ostream& operator << (ostream& os, ModInt n) {
        os << n.val;
        return os;
    }

    // 単項演算子
    // 符号反転 (-), 0 かどうか判定 (!), インクリメント, デクリメント
    ModInt operator -() {
        return ModInt(-val);
    }
    bool operator !() {
        return val == 0;
    }
    ModInt& operator ++() { // 前置インクリメント
        val++;
        if (val >= mod) {
            val -= mod;
        }
        return *this;
    }
    ModInt operator ++(int) { // 後置インクリメント
        ModInt tmp = *this;
        val++;
        if (val >= mod) {
            val -= mod;
        }
        return tmp;
    }
    ModInt& operator --() { // 前置デクリメント
        val--;
        if (val < 0) {
            val += mod;
        }
        return *this;
    }
    ModInt operator --(int) { // 後置デクリメント
        ModInt tmp = *this;
        val--;
        if (val < 0) {
            val += mod;
        }
        return tmp;
    }

    // 二項関係子
    // 等しいか判定 (==), 等しくないか判定 (!=)
    bool operator == (ModInt that) {
        return val == that.val;
    }
    bool operator != (ModInt that) {
        return val != that.val;
    }

    // 四則演算 (+=, -=, *=, /=, +, -, *, /)
    // 除算は mod が素数のときのみ正しく動作し, 計算量は O(log mod) です.
    // 右側の数の型は自動的に ModInt<mod> にキャストされます.
    ModInt& operator += (ModInt that) {
        val += that.val;
        if (val >= mod) {
            val -= mod;
        }
        return *this;
    }
    ModInt& operator -= (ModInt that) {
        val -= that.val;
        if (val < 0) {
            val += mod;
        }
        return *this;
    }
    ModInt& operator *= (ModInt that) {
        val = val * that.val % mod;
        return *this;
    }
    ModInt& operator /= (ModInt that) {
        int64_t res = 1, n = that.val, p = mod - 2;
        while (p > 0) {
            if (p % 2 == 1) {
                res = res * n % mod;
            }
            n = n * n % mod;
            p /= 2;
        }
        val = val * res % mod;
        return *this;
    }
    ModInt operator + (ModInt that) {
        return ModInt(*this) += that;
    }
    ModInt operator - (ModInt that) {
        return ModInt(*this) -= that;
    }
    ModInt operator * (ModInt that) {
        return ModInt(*this) *= that;
    }
    ModInt operator / (ModInt that) {
        return ModInt(*this) /= that;
    }
};

#define mint ModInt<MOD>
// using mint = double; // デバッグ用

int main() {
    mint m;
    int n;
    cin >> m >> n;
    cout << power(m, n) << endl;

    return 0;
}


Measured memory_bytes: 3112