#include <bits/stdc++.h>
using namespace std;
#define CPP_CAT(x,y) CPP_CAT_I(x,y)
#define CPP_CAT_I(x,y) x ## y

using i8  = int8_t;
using u8  = uint8_t;
using i16 = int16_t;
using u16 = uint16_t;
using i32 = int32_t;
using u32 = uint32_t;
using i64 = int64_t;
using u64 = uint64_t;
using f32 = float;
using f64 = double;
using ll = long long;
constexpr i64 INF = 1010000000000000017LL;
constexpr i64 MOD = 1000000007LL;
constexpr f64 EPS = 1e-12;
constexpr f64 PI = 3.14159265358979323846;
#define FOR(i, start, end) for(i64 i = (start), CPP_CAT(i,xxxx_end)=(end); i < CPP_CAT(i,xxxx_end); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(f,c,...) (([&](decltype((c)) cccc) { return (f)(std::begin(cccc), std::end(cccc), ## __VA_ARGS__); })(c))
template<typename T, typename U, typename Comp=less<>>
bool chmax(T& xmax, const U& x, Comp comp={}) {
    if(comp(xmax, x)) {
        xmax = x; 
        return true;
    }
    return false;
}
template<typename T, typename U, typename Comp=less<>>
bool chmin(T& xmin, const U& x, Comp comp={}) {
    if(comp(x, xmin)) {
        xmin = x; 
        return true;
    }
    return false;
}
template<typename Val>
bool bitcheck(Val bit, size_t idx) {
    return bit & (1 << idx);
}
struct ProconInit {
    static constexpr int IOS_PREC = 15;
    static constexpr bool AUTOFLUSH = false;
    ProconInit() {
        cin.tie(nullptr); ios::sync_with_stdio(false);
        cout << fixed << setprecision(IOS_PREC);
        if(AUTOFLUSH) cout << unitbuf;
    }
} PROCON_INIT;

template<int MOD_> struct Fp {
    ll val;
    constexpr Fp(ll v = 0) noexcept
    :val(v % MOD_)
    {
        if (val < 0) v += MOD_;
    }
    constexpr ll get_mod() {return MOD_;}
    constexpr Fp operator- () const noexcept {
        return val ? MOD_ - val : 0;
    }
    constexpr Fp operator+ (const Fp& r) const noexcept {return Fp(*this) += r;}
    constexpr Fp operator- (const Fp& r) const noexcept {return Fp(*this) -= r;}
    constexpr Fp operator* (const Fp& r) const noexcept {return Fp(*this) *= r;}
    constexpr Fp operator/ (const Fp& r) const noexcept {return Fp(*this) /= r;}
    constexpr Fp& operator+= (const Fp& r) noexcept {
        val += r.val;
        if (val >= MOD_) val -= MOD_;
        return *this;
    }
    constexpr Fp& operator-= (const Fp& r) noexcept {
        val -= r.val;
        if (val < 0) val += MOD_;
        return *this;
    }
    constexpr Fp& operator*= (const Fp& r) noexcept {
        val = val * r.val % MOD_;
        return *this;
    }
    constexpr Fp& operator/= (const Fp& r) noexcept {
        ll a = r.val, b = MOD_, u = 1, v = 0;
        while (b) {
            ll t = a / b;
            a -= t * b; swap(a, b);
            u -= t * v; swap(u, v);
        }
        val = val * u % MOD_;
        if (val < 0) val += MOD_;
        return *this;
    }

    constexpr bool operator== (const Fp& r) const noexcept {
        return this->val == r.val;
    }
    constexpr bool operator!= (const Fp& r) const noexcept {
        return this->val != r.val;
    }
    friend constexpr ostream& operator<< (ostream& outS, const Fp<MOD_>& x) noexcept {
        return outS << x.val;
    }
    friend constexpr istream& operator>> (istream& inS, Fp<MOD_>& x) noexcept {
        return inS >> x.val;
    }
    friend constexpr Fp<MOD_> modpow(const Fp<MOD_>& a, ll n) noexcept {
        if (n == 0) return 1;
        auto t = modpow(a, n/2);
        t *= t;
        if (n&1) t *= a;
        return t;
    }
};

template <typename TYPE, TYPE Mod>
struct Combination_template
{
    size_t size;
    std::vector<TYPE> fc, inv_fc;
    Combination_template(int N)
    :size(N+1), fc(size), inv_fc(size)
    {
        fc[0] = 1;
        for (int i = 1; i <= N; ++i) { fc[i] = fc[i - 1] * i % Mod; }
        inv_fc[N] = inv(fc[N]);
        for (int i = N - 1; i >= 0; --i) { inv_fc[i] = inv_fc[i + 1] * (i+1) % Mod; }
    }
    TYPE fact(TYPE n) const { return fc[n]; }
    TYPE inv_fact(TYPE n) const { return inv_fc[n]; }
    static TYPE inv(TYPE n) { return power(n, Mod - 2); }
    static TYPE power(TYPE n, TYPE pow) {
        TYPE res = 1;
        TYPE exp = n;
        for (; pow; pow /= 2) {
            if (pow & 1) res = res * exp % Mod;
            exp = exp * exp % Mod;
        }
        return res;
    }
    TYPE perm(TYPE n, TYPE r) const {
        if (r < 0 || n < r) return 0;
        return fc[n] * inv_fc[n-r] % Mod;
    }
    TYPE binom(TYPE n, TYPE r) const {
        if (n < 0 || r < 0 || n < r) return 0;
        return fc[n] * inv_fc[r] % Mod * inv_fc[n-r] % Mod;
    }
    TYPE homo(TYPE n, TYPE r) const {
        if (n < 0 || r < 0) return 0;
        return r == 0 ? 1 : binom(n + r - 1, r);
    }
};
using Combination = Combination_template<long long, MOD>;

using mint = Fp<MOD>;

void solve() {
    int k; cin >> k;
    string s; cin >> s;
    int n = s.size();

    Combination comb(2100000);
    mint ans = 0;
    FOR(i, 0, k+1) {
        ans += mint(comb.binom(n + k - i - 1, n - 1)) 
        * modpow(mint(26), i) * modpow(mint(25), k - i);
    }
    cout << ans << endl;
}

signed main() {
    solve();
    return 0;
}

Measured memory_bytes: 37260