import core.bitop, std.bitmanip;
import core.checkedint;
import std.algorithm, std.functional, std.meta;
import std.array, std.container;
import std.bigint;
import std.conv;
import std.math, std.numeric;
import std.range, std.range.interfaces;
import std.stdio, std.string;
import std.ascii, std.typecons;

void main()
{
    int k;
    readf("%s", &k);
    readln;
    
    string s = readln.chomp;

    class mod {
        static:
        const int MD = 10 ^^ 9 + 7;
    
        int mul(int a, int b) {
            return a.to!long * b % MD;
        }
        
        int add (int a, int b) {
            return (a.to!long + b) % MD;
        }
        
        int fstpw(int a, int p) {
            if (p == 0) { return 1; }
            if (p == 1) { return a; }

            int odd = p % 2 == 1 ? a : 1;

            int sub = fstpw(a, p / 2);

            return sub.to!long * sub % MD * odd % MD;
        }
        
        int invf(int x) {
            return fstpw(x, MD - 2);
        }
    }
  
    auto slen = s.length.to!int;
    auto totlen = slen + k;
    
    auto fact = new int[] (totlen + 1);
    fact[0] = 1;
    foreach (i; 1 .. totlen + 1) { fact[i] = mod.mul(fact[i-1], i); }
    
    auto inv = new int[] (totlen + 1);
    inv[totlen] = mod.invf(fact[totlen]);
    foreach_reverse (i; 0 .. totlen) { inv[i] = mod.mul(inv[i+1], i+1); }
    
    auto nCk = new int[] (totlen + 1);
    nCk[slen-1] = 1;
    foreach (i; slen .. totlen + 1) {
        nCk[i] = mod.mul(fact[i], mod.mul(inv[i - (slen-1)], inv[slen-1]));
    }
    
    auto invAlpha = mod.invf('z' - 'a' + 1);
    auto inBetween = 1;
    auto rightSide = mod.fstpw('z' - 'a' + 1, k);
    
    auto ans = 0;
    foreach (clen; slen .. totlen + 1) {
        auto cur = mod.mul(nCk[clen-1], mod.mul(inBetween, rightSide));
        ans = mod.add(ans, cur);
        
        inBetween = mod.mul(inBetween, 'z' - 'a' + 1 - 1);
        rightSide = mod.mul(rightSide, invAlpha);
    }
    
    ans.writeln;
}