package main

import (
	"bufio"
	"fmt"
	"os"
)

const MOD int64 = 998244353
const ROOT int64 = 3

func powMod(a, e int64) int64 {
	res := int64(1)
	for e > 0 {
		if e&1 == 1 {
			res = res * a % MOD
		}
		a = a * a % MOD
		e >>= 1
	}
	return res
}

func ntt(a []int64, invert bool) {
	n := len(a)
	for i, j := 1, 0; i < n; i++ {
		bit := n >> 1
		for ; j&bit != 0; bit >>= 1 {
			j ^= bit
		}
		j ^= bit
		if i < j {
			a[i], a[j] = a[j], a[i]
		}
	}
	for length := 2; length <= n; length <<= 1 {
		wlen := powMod(ROOT, (MOD-1)/int64(length))
		if invert {
			wlen = powMod(wlen, MOD-2)
		}
		half := length >> 1
		for i := 0; i < n; i += length {
			w := int64(1)
			for j := 0; j < half; j++ {
				u := a[i+j]
				v := a[i+j+half] * w % MOD
				a[i+j] = u + v
				if a[i+j] >= MOD {
					a[i+j] -= MOD
				}
				a[i+j+half] = u - v
				if a[i+j+half] < 0 {
					a[i+j+half] += MOD
				}
				w = w * wlen % MOD
			}
		}
	}
	if invert {
		nInv := powMod(int64(n), MOD-2)
		for i := 0; i < n; i++ {
			a[i] = a[i] * nInv % MOD
		}
	}
}

func convolution(a, b []int64) []int64 {
	need := len(a) + len(b) - 1
	n := 1
	for n < need {
		n <<= 1
	}
	fa := make([]int64, n)
	fb := make([]int64, n)
	copy(fa, a)
	copy(fb, b)
	ntt(fa, false)
	ntt(fb, false)
	for i := 0; i < n; i++ {
		fa[i] = fa[i] * fb[i] % MOD
	}
	ntt(fa, true)
	return fa[:need]
}

func countSubseq(m, base int) []int64 {
	if m == 0 {
		return []int64{1}
	}
	L := m*base + m + 1
	A := make([]int64, L)
	B := make([]int64, L)
	O := make([]int64, L)
	nA := make([]int64, L)
	nB := make([]int64, L)
	nO := make([]int64, L)

	A[base] = 1
	B[1] = 1
	O[0] = 24

	for l := 1; l < m; l++ {
		for i := 0; i < L; i++ {
			nA[i] = 0
			nB[i] = 0
			nO[i] = 0
		}
		for x := 0; x <= l; x++ {
			start := x * base
			maxY := l - x
			for y := 0; y <= maxY; y++ {
				i := start + y
				va := A[i]
				if va != 0 {
					nB[i+1] += va
					nO[i] += va * 24
				}
				vb := B[i]
				if vb != 0 {
					nA[i+base] += vb
					nO[i] += vb * 24
				}
				vo := O[i]
				if vo != 0 {
					nA[i+base] += vo
					nB[i+1] += vo
					nO[i] += vo * 23
				}
			}
		}
		for i := 0; i < L; i++ {
			if nA[i] >= MOD {
				nA[i] -= MOD
			}
			if nB[i] >= MOD {
				nB[i] -= MOD
			}
			if nO[i] >= MOD {
				nO[i] %= MOD
			}
		}
		A, nA = nA, A
		B, nB = nB, B
		O, nO = nO, O
	}

	res := make([]int64, L)
	for i := 0; i < L; i++ {
		v := A[i] + B[i]
		if v >= MOD {
			v -= MOD
		}
		v += O[i]
		if v >= MOD {
			v -= MOD
		}
		res[i] = v
	}
	return res
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	var n int
	fmt.Fscan(in, &n)
	c := make([]int, 26)
	for i := 0; i < 26; i++ {
		fmt.Fscan(in, &c[i])
	}

	base := n + 1
	odd := (n + 1) / 2
	even := n / 2

	po := countSubseq(odd, base)
	var pe []int64
	if even == odd {
		pe = po
	} else {
		pe = countSubseq(even, base)
	}

	conv := convolution(po, pe)

	W := n + 2
	suf := make([]int64, W*W)

	for x := 0; x <= n; x++ {
		row := x * W
		start := x * base
		maxY := n - x
		for y := 0; y <= maxY; y++ {
			idx := start + y
			if idx < len(conv) {
				suf[row+y] = conv[idx]
			}
		}
	}

	for x := n; x >= 0; x-- {
		row := x * W
		nextRow := row + W
		for y := n; y >= 0; y-- {
			v := suf[row+y] + suf[nextRow+y] + suf[row+y+1] - suf[nextRow+y+1]
			v %= MOD
			if v < 0 {
				v += MOD
			}
			suf[row+y] = v
		}
	}

	ans := suf[0]
	for i := 0; i < 26; i++ {
		v := suf[(c[i]+1)*W]
		ans -= v
		if ans < 0 {
			ans += MOD
		}
	}
	for i := 0; i < 26; i++ {
		for j := i + 1; j < 26; j++ {
			v := suf[(c[i]+1)*W+(c[j]+1)]
			ans += v
			if ans >= MOD {
				ans -= MOD
			}
		}
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprint(out, ans)
	out.Flush()
}