#include using namespace std; namespace arithmetic { template class Addition { public: template T operator+(const V& v) const { return T(static_cast(*this)) += v; } }; template class Subtraction { public: template T operator-(const V& v) const { return T(static_cast(*this)) -= v; } }; template class Multiplication { public: template T operator*(const V& v) const { return T(static_cast(*this)) *= v; } }; template class Division { public: template T operator/(const V& v) const { return T(static_cast(*this)) /= v; } }; template class Modulus { public: template T operator%(const V& v) const { return T(static_cast(*this)) %= v; } }; } template class IndivisibleArithmetic : public arithmetic::Addition, public arithmetic::Subtraction, public arithmetic::Multiplication {}; template class Arithmetic : public IndivisibleArithmetic, public arithmetic::Division {}; class Inverse { private: long long mod; vector inv; public: Inverse() {} Inverse(long long mod, long long n = 1000000) : mod(mod) { inv = vector(n, 1); for (int i = 2; i < n; ++i) inv[i] = inv[mod % i] * (mod - mod / i) % mod; } long long operator()(long long a) const { if (a < (int)inv.size()) return inv[a]; long long b = mod, x = 1, y = 0; while (b) { long long t = a / b; swap(a -= t * b, b); swap(x -= t * y, y); } return (x %= mod) < 0 ? x + mod : x; } }; class Mint : public Arithmetic { private: static long long mod; static Inverse inverse; long long val; public: Mint() {} Mint(const long long& val) { this->val = val % mod; if (this->val < 0) this->val += mod; } static void setMod(const long long& m) { mod = m; inverse = Inverse(m); } Mint operator+=(const Mint& m) { val += m.val; if (val >= mod) val -= mod; return *this; } Mint operator-=(const Mint& m) { val -= m.val; if (val < 0) val += mod; return *this; } Mint operator*=(const Mint& m) { val *= m.val; val %= mod; return *this; } Mint operator/=(const Mint& m) { val *= inverse(m.val); val %= mod; return *this; } Mint operator++() {return val += 1;} operator long long() { return val; } Mint identity() const { return 1; } }; long long Mint::mod = 1000000007; Inverse Mint::inverse(1000000007); ostream& operator<<(ostream& os, Mint a) { os << (long long)a; return os; } istream& operator>>(istream& is, Mint& a) { long long n; is >> n; a = n; return is; } template T pow(T& m, long long n) { if (n == 0) { return m.identity(); } else if (n < 0) { return m.identity() / pow(m, -n); } T mm = pow(m, n / 2); mm *= mm; if (n % 2) mm *= m; return mm; } template inline T toInteger(const string&); template<> inline int toInteger(const string& s) { return stoi(s); } template<> inline long toInteger(const string& s) { return stol(s); } template<> inline long long toInteger(const string& s) { return stoll(s); } template inline T toInteger(const string& s, int n) { T res = 0; for (char c : s) { if (isdigit(c)) res = res * n + c - '0'; else if (isalpha(c)) res = res * n + tolower(c) - 'a' + 10; } return s[0] == '-' ? -res : res; } int main() { string n, m; cin >> n >> m; m = "00" + m; Mint::setMod(10); Mint nn = toInteger(n.substr(n.size() - 1)); int mm = toInteger(m.substr(m.size() - 3)); cout << pow(nn, mm) << endl; }