#include <bits/stdc++.h>

using namespace std;

ifstream in("lgput.in");
ofstream out("lgput.out");

namespace Modular {
    template<int MOD>
    struct ModInt {
        long long v;
        ModInt(long long _v = 0) {v = (-MOD < _v && _v < MOD) ? _v : _v % MOD; if (v < 0) v += MOD;}
        ModInt& operator += (const ModInt &other) {v += other.v; if (v >= MOD) v -= MOD; return *this;}
        ModInt& operator -= (const ModInt &other) {v -= other.v; if (v < 0) v += MOD; return *this;}
        ModInt& operator *= (const ModInt &other) {v = v * other.v % MOD; return *this;}
        ModInt& operator /= (const ModInt &other) {return *this *= inverse(other);}
        bool operator == (const ModInt &other) const {return v == other.v;}
        bool operator != (const ModInt &other) const {return v != other.v;}
        friend ModInt operator + (ModInt a, const ModInt &b) {return a += b;}
        friend ModInt operator - (ModInt a, const ModInt &b) {return a -= b;}
        friend ModInt operator * (ModInt a, const ModInt &b) {return a *= b;}
        friend ModInt operator / (ModInt a, const ModInt &b) {return a /= b;}
        friend ModInt operator - (const ModInt &a) {return 0 - a;}
        friend ModInt power(ModInt a, long long b) {ModInt ret(1); while (b > 0) {if (b & 1) ret *= a; a *= a; b >>= 1;} return ret;}
        friend ModInt inverse(ModInt a) {return power(a, MOD - 2);}
        friend ostream& operator << (ostream &os, const ModInt &m) {return os << m.v;}
    };

    const int N = 2e5 + 5; // CHANGE !!!
    const int MOD = 1999999973; // CHANGE !!!
    typedef ModInt<MOD> Mint;

    vector<Mint> fact(N, 0);
    vector<Mint> inv(N, 0);

    void init() {
        fact[0] = 1;
        for (int i = 1; i < N; i++)
            fact[i] = fact[i - 1] * i;
        inv[N - 1] = inverse(fact[N - 1]);
        for (int i = N - 2; i >= 0; i--)
            inv[i] = inv[i + 1] * (i + 1);
    }

    Mint choose(int n, int k) {
        return ((n < k || k < 0) ? 0 : fact[n] * inv[k] * inv[n - k]);
    }
}

int main() {
    long long n, p;
    in >> n >> p;
    out << power(Modular::Mint(n), p);
    return 0;
}