package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	io := NewIo()
	defer io.Flush()
	k := io.NextInt()
	s := io.Next()
	ans := solve(k, s)
	io.Println(ans)
}

const mod = 1e9 + 7

func solve(k int, s string) (ans int) {
	n := len(s)
	cmb := NewModCombination(mod)
	ans = 0
	for i := 0; i <= k; i++ {
		now := cmb.Calc(n-1+i, n-1)
		now = ModMul(now, ModPow(25, i, mod), mod)
		now = ModMul(now, ModPow(26, k-i, mod), mod)
		ans = (ans + now) % mod
	}
	return
}

// Io is I/O object
type Io struct {
	reader    *bufio.Reader
	writer    *bufio.Writer
	tokens    []string
	nextToken int
}

// NewIo returns a new Io instance
func NewIo() *Io {
	return &Io{
		reader: bufio.NewReader(os.Stdin),
		writer: bufio.NewWriter(os.Stdout),
	}
}

// Flush flushes writer
func (io *Io) Flush() {
	err := io.writer.Flush()
	if err != nil {
		panic(err)
	}
}

// NextLine scans a line from stdin
func (io *Io) NextLine() string {
	var buffer []byte
	for {
		line, isPrefix, err := io.reader.ReadLine()
		if err != nil {
			panic(err)
		}
		buffer = append(buffer, line...)
		if !isPrefix {
			break
		}
	}
	return string(buffer)
}

// Next return a word from stdin
func (io *Io) Next() string {
	for io.nextToken >= len(io.tokens) {
		line := io.NextLine()
		io.tokens = strings.Fields(line)
		io.nextToken = 0
	}
	r := io.tokens[io.nextToken]
	io.nextToken++
	return r
}

// NextInt returns an integer from stdin
func (io *Io) NextInt() int {
	i, err := strconv.Atoi(io.Next())
	if err != nil {
		panic(err)
	}
	return i
}

// Println is a wrapper of fmt.Fprintln
func (io *Io) Println(a ...interface{}) {
	fmt.Fprintln(io.writer, a...)
}

// ModMul returns a*b with mod
func ModMul(a, b, mod int) int {
	if b == 0 {
		return 0
	}
	if a*b/b == a {
		return a * b % mod
	}
	panic("overflow")
}

// ModPow returns base^n with mod
func ModPow(base, n, mod int) int {
	ans := 1
	for ; n > 0; n >>= 1 {
		if n&1 == 1 {
			ans = ModMul(ans, base, mod)
		}
		base = ModMul(base, base, mod)
	}
	return ans
}

// ModInv returns inverse value of a with mod
func ModInv(a, mod int) int {
	return ModPow(a, mod-2, mod)
}

// ModFactorial stores factorials with mod
type ModFactorial struct {
	mod    int
	values []int
	invs   []int
}

// NewModFactorial returns new instance of ModFactorial
func NewModFactorial(mod int) *ModFactorial {
	return &ModFactorial{
		mod:    mod,
		values: []int{1},
		invs:   []int{},
	}
}

// Calc returns n!
func (m *ModFactorial) Calc(n int) int {
	l := len(m.values)
	if n < l {
		return m.values[n]
	}
	tmp := make([]int, n+1-l)
	m.values = append(m.values, tmp...)
	for i := l; i <= n; i++ {
		m.values[i] = i * m.values[i-1] % m.mod
	}
	return m.values[n]
}

// CalcInv returns inverse value of n!
func (m *ModFactorial) CalcInv(n int) int {
	l := len(m.invs)
	if n < l {
		return m.invs[n]
	}
	tmp := make([]int, n+1-l)
	m.invs = append(m.invs, tmp...)
	m.invs[n] = ModInv(m.Calc(n), m.mod)
	for i := n - 1; i >= l; i-- {
		m.invs[i] = m.invs[i+1] * (i + 1) % m.mod
	}
	return m.invs[n]

}

// ModCombination returns the number of combinations with mod
type ModCombination struct {
	mod       int
	factorial *ModFactorial
}

// NewModCombination returns new instance of ModCombination
func NewModCombination(mod int) *ModCombination {
	return &ModCombination{
		mod:       mod,
		factorial: NewModFactorial(mod),
	}
}

// Calc returns nCk
func (m *ModCombination) Calc(n, k int) int {
	if n < k || n < 0 || k < 0 {
		return 0
	}
	fn := m.factorial.Calc(n)
	ifk := m.factorial.CalcInv(k)
	ifnk := m.factorial.CalcInv(n - k)
	ans := ModMul(fn, ifk, m.mod)
	ans = ModMul(ans, ifnk, m.mod)
	return ans
}


Measured memory_bytes: 75348