Kyoya Ootori is selling photobooks of the Ouran High School Host Club. He has 26 photos, labeled "a" to "z", and he has compiled them into a photo booklet with some photos in some order (possibly with some photos being duplicated). A photo booklet can be described as a string of lowercase letters, consisting of the photos in the booklet in order. He now wants to sell some "special edition" photobooks, each with one extra photo inserted anywhere in the book. He wants to make as many distinct photobooks as possible, so he can make more money. He asks Haruhi, how many distinct photobooks can he make by inserting one extra photo into the photobook he already has?

Please help Haruhi solve this problem.


-----Input-----

The first line of input will be a single string s (1 ≤ |s| ≤ 20). String s consists only of lowercase English letters. 


-----Output-----

Output a single integer equal to the number of distinct photobooks Kyoya Ootori can make.


-----Examples-----
Input
a

Output
51

Input
hi

Output
76



-----Note-----

In the first case, we can make 'ab','ac',...,'az','ba','ca',...,'za', and 'aa', producing a total of 51 distinct photo booklets.

Difficulty: EASY

Solutions:
s = str(input())
print(25 * len(s) + 26)


print(25 * (len(input()) + 1) + 1)


tam = len(input())
print(26 + tam * 25)


n = len(input())
print(26 * (n + 1) - n)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	s = [c for c in S()]
	r = set()
	l = len(s)
	for i in range(l + 1):
		for c in string.ascii_lowercase:
			r.add(''.join(s[:i] + [c] + s[i:]))
	return len(r)
print(main())


input_letter = input()
length = len(input_letter)
result = 25 * length + 26
print(result)


import itertools as it
import functools
import operator
import collections
import math
import sys

def solve(s):
	letters = set(s)
	letter_count = len(letters)
	size = len(s)
	distinct_count = (26 - letter_count) * (size + 1)
	duplicates = {s[:i] + let + s[i:] for let in letters for i in range(0, size + 1)}
	duplicate_count = len(duplicates)
	return distinct_count + duplicate_count

def print_stderr(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def main():
	s = input().strip()
	result = solve(s)
	print(result)
main()


import string
s = input()
words = set()
for i in range(len(s) + 1):
	for letter in string.ascii_lowercase:
		words.add(s[:i] + letter + s[i:])
print(len(words))


k = len(input())
print(26 * (k + 1) - k)


l = input()
print(51 + 25 * (len(l) - 1))


from string import ascii_lowercase
s = input()
print(len(set((s[:i] + c + s[i:] for i in range(len(s) + 1) for c in ascii_lowercase))))


st = input()
n = len(st)
print(26 + 25 * n)


import sys
from functools import reduce
from collections import Counter
import time
import datetime
from math import sqrt, gcd

def ip():
	return int(sys.stdin.readline())

def sip():
	return sys.stdin.readline()

def mip():
	return map(int, sys.stdin.readline().split())

def mips():
	return map(str, sys.stdin.readline().split())

def lip():
	return list(map(int, sys.stdin.readline().split()))

def matip(n, m):
	lst = []
	for i in range(n):
		arr = lip()
		lst.insert(i, arr)
	return lst

def factors(n):
	return list(set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))))

def minJumps(arr, n):
	jumps = [0 for i in range(n)]
	if n == 0 or arr[0] == 0:
		return float('inf')
	jumps[0] = 0
	for i in range(1, n):
		jumps[i] = float('inf')
		for j in range(i):
			if i <= j + arr[j] and jumps[j] != float('inf'):
				jumps[i] = min(jumps[i], jumps[j] + 1)
				break
	return jumps[n - 1]

def dic(arr):
	return Counter(arr)

def check_prime(n):
	if n < 2:
		return False
	for i in range(2, int(n ** 0.5) + 1, 2):
		if n % i == 0:
			return False
	return True
x = sip()
n = len(x) - 1
print((n + 1) * 26 - n)


def distinctPhotobooks(str_):
	combinations_adding_one_letter = 26 * (len(str_) + 1)
	repeated_words = len(str_)
	return combinations_adding_one_letter - repeated_words
input_ = str(input())
print(distinctPhotobooks(input_))


s = input()
n = len(s)
memo = set()
for i in range(0, n + 1):
	for j in 'abcdefghijklmnopqrstuvwxyz':
		memo.add(s[0:i] + j + s[i:])
print(len(memo))


import sys
import inspect
import re
import math
from pprint import pprint as pp
mod = 998244353
MAX = 10 ** 15

def deb(p):
	for line in inspect.getframeinfo(inspect.currentframe().f_back)[3]:
		m = re.search('\\bdeb\\s*\\(\\s*([A-Za-z_][A-Za-z0-9_]*)\\s*\\)', line)
		print('%s %d' % (m.group(1), p))

def vector(size, val=0):
	vec = [val for i in range(size)]
	return vec

def matrix(rowNum, colNum, val=0):
	mat = []
	for i in range(rowNum):
		collumn = [val for j in range(colNum)]
		mat.append(collumn)
	return mat

def main():
	s = input()
	n = len(s)
	ss = set()
	for i in range(n + 1):
		for j in range(26):
			temp = s[0:i] + str(chr(ord('a') + j)) + s[i:]
			ss.add(temp)
	print(len(ss))
main()


s = input()
l = len(s)
ans = (l + 1) * 26 - l
print(ans)


s = input()
all = set()
for i in range(len(s) + 1):
	for z in range(26):
		c = chr(ord('a') + z)
		all.add(s[:i] + c + s[i:])
print(len(all))


n = list(str(input()))
s = (len(n) + 1) * 26 - len(n)
print(s)


d = len(input())
print((d + 1) * 26 - d)


t = input()
i = len(t)
print(26 * (i + 1) - i)


from string import ascii_lowercase as ascii
s = input()
res = set()
for i in range(len(s) + 1):
	for c in ascii:
		res.add(s[:i] + c + s[i:])
print(len(res))


import os
import sys
from io import BytesIO, IOBase
import heapq as h
from bisect import bisect_left, bisect_right
from types import GeneratorType
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		import os
		self.os = os
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			self.os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from collections import defaultdict as dd, deque as dq
import math, string

def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())
MOD = 10 ** 9 + 7

def solve():
	S = listStr()
	N = len(S)
	ans_set = set()
	lets = string.ascii_lowercase
	for j in range(N + 1):
		for let in lets:
			tmp = S[:]
			tmp.insert(j, let)
			ans_set.add(''.join(tmp))
	return len(ans_set)
print(solve())


a = input()
p = set([])
for i in range(ord('a'), ord('z') + 1):
	for j in range(len(a) + 1):
		x = a[:j] + chr(i) + a[j:]
		p.add(x)
print(len(p))


a = input()
print(26 * (len(a) + 1) - len(a))


a = input()
b = [0] * 26
for i in range(len(a)):
	b[ord(a[i]) - 97] += 1
c = 0
r = 0
for i in range(26):
	if b[i] == 0:
		c += 1
	else:
		r += len(a) + 1 - b[i]
r += c * (len(a) + 1)
print(r)


s = input().strip()
ls = len(s)
insertion_pts = ls + 1
ideal_num = 26 * insertion_pts
ct = 1
for i in range(ls - 1):
	if s[i] == s[i + 1]:
		ct += 1
	else:
		ideal_num -= ct
		ct = 1
ideal_num -= ct
print(ideal_num)


k = 51
s = input()
k += (len(s) - 1) * 25
print(k)


text = input()
length = len(text)
possible = 0
letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
for char in letters:
	if text.count(char) == 0:
		possible += length + 1
	else:
		possible += length + 1 - text.count(char)
print(possible)


import sys
inp = sys.stdin.read().strip().split('\n')
photo = str(inp[0])
leng = len(photo)
res = (leng + 1) * 26 - leng
print(res, end='')


a = input()
if len(a) == 1:
	print(51)
else:
	print(51 + (len(a) - 1) * 25)


import string
base = input().strip()
res = set()
for i in range(len(base) + 1):
	(left, right) = (base[:i], base[i:])
	for photo in string.ascii_lowercase:
		res.add(left + photo + right)
print(len(res))


import sys
istr = sys.stdin.readline().strip()
res = 25 * len(istr) + 26
print(res)


s = input()
x = len(s)
photo = 26
z = x ** x
if x == 1:
	print((26 - x) * 2 + x)
else:
	k = 51
	print(k * x - 26 * (x - 1))


def photobooks(a):
	if a is None or len(a) == 0:
		return 0
	return (len(a) + 1) * 25 + 1
print(photobooks(str(input())))


s = input()
l = len(s)
res = 26 * (l + 1) - l
print(res)


a = len(input()) + 1
print(a * 25 + 1)


booklet = input()
print(25 * len(booklet) + 26)


def photograph(s):
	print((len(s) + 1) * 26 - len(s))
s = input('')
photograph(s)


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect, insort
from time import perf_counter
from fractions import Fraction
import copy
from copy import deepcopy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353

def data():
	return sys.stdin.readline().strip()

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def L():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
try:
	sys.stdin = open('input.txt', 'r')
except:
	pass

def pmat(A):
	for ele in A:
		print(*ele, end='\n')
s = input()
A = set()
for i in range(len(s) + 1):
	start = s[:i]
	end = s[i:]
	for j in range(26):
		A.add(start + chr(ord('a') + j) + end)
print(len(A))
endtime = time.time()


s = input()
l = len(s)
print(26 + 25 * l)


import sys

def main():
	data = sys.stdin.readline().strip()
	s = set()
	for i in range(len(data)):
		for j in range(97, 123):
			s.add(data[:i] + chr(j) + data[i:])
	for j in range(97, 123):
		s.add(data + chr(j))
	print(len(s))
main()


def main():
	s = input()
	n = len(s)
	strings = set()
	chk = ord('a')
	for i in range(n + 1):
		for j in range(26):
			new = s[0:i] + chr(chk + j) + s[i:]
			strings.add(new)
	print(len(strings))
	return
main()


n = input()
a = 26
for i in range(len(n)):
	a += 25
print(a)


st = input()
n = len(st)
print((n + 1) * 25 + 1)


instr = input()
length = len(instr)
print((length + 1) * 26 - length)


str = input()
cnt = 1
ans = 25
length = len(str)
for i in range(1, length):
	if str[i] != str[i - 1]:
		cnt += 1
for i in range(1, length):
	ans += 24
	if str[i] == str[i - 1]:
		ans += 1
ans += 25
print(ans + cnt)


s = input()
l = len(s)
c = (l + 1) * 26 - l
print(c)


s = input()
print((len(s) + 1) * 25 + 1)


s = input()
spaces = len(s) - 1 + 2
ans = 26 * spaces - len(s)
print(ans)


import sys
import math
import bisect
import itertools
import random

def main():
	s = set()
	t = input()
	n = len(t)
	for i in range(n + 1):
		for j in range(26):
			tmp = t[0:i] + chr(ord('a') + j) + t[i:]
			s.add(tmp)
	print(len(s))
main()


print(len(input()) * 25 + 26)


x = input()
print((len(x) + 1) * 26 - len(x))


s = input()
D = set()
ch = 'abcdefghijklmnopqrstuvwxyz'
for i in range(len(s) + 1):
	for j in ch:
		D.add(s[:i] + j + s[i:])
print(len(D))


s = input()
ans = 1
length = len(s)
ans += 50 + 25 * (length - 1)
print(ans)


s = input()
if len(s) == 1:
	print(51)
	quit()
d = set()
counter = 0
extra = 0
for i in range(len(s) - 1):
	if s[i + 1] == s[i]:
		counter += 0
print((len(s) + 1) * 26 - counter - len(s))


from sys import stdin
s = len(stdin.readline())
print(26 * s - (s - 1))


s = list(input())
n = len(s)

def haz(a):
	a = a.copy()
	for i in range(len(a)):
		if a.count(a[i]) > 1:
			a[i] = 0
	return a

def ins(a, b):
	a = a.copy()
	d = a.copy()
	b = h(haz(b))
	b = b.copy()
	f = []
	for i in range(len(a) + 1):
		for l in range(len(b)):
			a = d.copy()
			a.insert(i, b[l])
			f += [a]
	return f

def h(a):
	i = 0
	a = a.copy()
	while 0 in a:
		a.remove(0)
	return a
k = (n + 1) * 26
f = ins(s, s)
b = len(f)
f = h(haz(f))
c = len(f)
k = k - (b - c)
print(k)


s = input()
az = [chr(i) for i in range(ord('a'), ord('z') + 1)]
sets = set()
for i in range(len(s)):
	for c in az:
		sets.add(s[:i] + c + s[i:])
for c in az:
	sets.add(s + c)
print(len(sets))


s = input()
(n, d) = (len(s), dict())
for i in range(n + 1):
	for j in range(26):
		d[s[0:i] + chr(j + 97) + s[i:n]] = 1
print(len(d))


s = input()
a2z = 'qwertyuiopasdfghjklzxcvbnm'
st = set()
for i in range(len(s)):
	first = s[:i]
	second = s[i:]
	for c in a2z:
		st.add(first + c + second)
for c in a2z:
	st.add(s + c)
print(len(st))


LettersString = input('')
Alfabet = 'abcdefghijklmnopqrstuvwxyz'
Combinaties = set()
for x in range(0, len(LettersString) + 1):
	for y in range(0, 26):
		Combinaties.add(LettersString[0:x] + Alfabet[y] + LettersString[x:len(LettersString)])
print(len(Combinaties))


p = input()
l = len(p)
ans = (l + 1) * 26 - l
print(ans)


import unittest
import sys
import re

class Photo:

	def __init__(self, args):
		self.args = args
		self.str = args

	def calculate(self):
		result = 0
		for n in range(len(self.str) + 1):
			if n == 0:
				result += 1
			result += 25
		return result

def decode_inputs(inputs):
	ilist = inputs[0]
	return ilist

def calculate(inputs):
	return Photo(decode_inputs(inputs)).calculate()

def main():
	inputs = [input()]
	print(calculate(inputs))

class unitTests(unittest.TestCase):

	def test_decode_inputs(self):
		self.assertEqual(decode_inputs(['a']), 'a')

	def test_Photo_class__basic_functions(self):
		d = Photo('a')
		self.assertEqual(d.str, 'a')

	def test_calculate(self):
		self.assertEqual(calculate(['a']), 51)
		self.assertEqual(calculate(['hi']), 76)

def __starting_point():
	if sys.argv[-1] == '-ut':
		unittest.main(argv=[' '])
	main()
__starting_point()


import sys
y = sys.stdin.readline().rstrip()
x = len(y)
print((x + 1) * 26 - x)


s = input()
n = len(s)
if n > 1:
	a = 26 * (n + 1) - n
else:
	a = 26 * (n + 1) - n
print(a)


d = {}
s = input()
for i in range(0, len(s) + 1):
	for a in 'abcdefghijklmnopqrstuvwxyz':
		d['%s%s%s' % (s[:i], a, s[i:])] = True
print(len(d))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, copy
from itertools import chain, dropwhile, permutations, combinations
from collections import defaultdict, deque

def VI():
	return list(map(int, input().split()))

def I():
	return int(input())

def LIST(n, m=None):
	return [0] * n if m is None else [[0] * m for i in range(n)]

def ELIST(n):
	return [[] for i in range(n)]

def MI(n=None, m=None):
	if n is None:
		(n, m) = VI()
	arr = LIST(n)
	for i in range(n):
		arr[i] = VI()
	return arr

def MS(n=None, m=None):
	if n is None:
		(n, m) = VI()
	arr = LIST(n)
	for i in range(n):
		arr[i] = input()
	return arr

def MIT(n=None, m=None):
	if n is None:
		(n, m) = VI()
	a = MI(n, m)
	arr = LIST(m, n)
	for (i, l) in enumerate(a):
		for (j, x) in enumerate(l):
			arr[j][i] = x
	return arr

def run(n, x, l, r):
	s = 0
	curr = 1
	for i in range(n):
		skip = (l[i] - curr) // x
		s += r[i] - curr - skip * x + 1
		curr = r[i] + 1
	print(s)

def main(info=0):
	s = input()
	st = set()
	abc = [chr(j) for j in range(97, 97 + 26)]
	for i in range(len(s) + 1):
		st.update([s[:i] + x + s[i:] for x in abc])
	print(len(st))

def __starting_point():
	main()
__starting_point()


st = input()
l = len(st)
print(26 * (l + 1) - l)


firstLine = str(input())
total = 26
for l in firstLine:
	total += 25
print(total)


s = list(input())
a = len(s)
ans = 25 * (a + 1) + 1
print(ans)


string = str(input())
l = len(string)
print(25 * l + 26)


s = input()
alpha = 'abcdefghijklmnopqrstuvwxyz'
possible = []
ans = 0
for letter in alpha:
	for i in range(len(s) + 1):
		seq = [s[:i], letter, s[i:]]
		word = ''.join(seq)
		if word not in possible:
			ans += 1
			possible.append(word)
print(ans)


s = input()
n = len(s)
ss = set()
a = 'abcdefghijklmnopqrstuvwxyz'
for i in range(n + 1):
	for j in range(26):
		ss.add(s[:i] + a[j] + s[i:])
print(len(ss))


import string
s = input().strip()
chars = list(s)
words = set()
for i in range(len(chars) + 1):
	for char in string.ascii_lowercase:
		word = ''.join(chars[:i] + [char] + chars[i:])
		words.add(word)
print(len(words))


s = input()
n = len(s)
ans = (n + 1) * (26 - n)
ans += pow(n, 2)
print(ans)


s = input()
print(sum((len(s) + 1 - s.count(chr(ord('a') + i)) for i in range(26))))


s = input()
a = set()
for i in range(len(s) + 1):
	for x in 'qwertyuiop[lkjhgfdsazxcvbnm':
		y = s[:i] + x + s[i:]
		a.add(y)
print(len(a) - len(s) - 1)


s = input()
print(26 * len(s) + 26 - len(s))


def main():
	s = input()
	distinct = 50
	for i in range(1, len(s)):
		distinct += 24
		if s[i - 1] == s[i]:
			distinct += 1
	same_set = set()
	same_set |= {s[0] + s}
	same_set |= {s + s[len(s) - 1]}
	for i in range(1, len(s)):
		same_set |= {s[:i] + s[i - 1] + s[i:]}
		same_set |= {s[:i] + s[i] + s[i:]}
	distinct += len(same_set)
	print(distinct)
main()


album = input()
tamAlbum = len(album)
resp = 26 * (tamAlbum + 1) - tamAlbum
print(resp)


__author__ = 'Andrey'
s = input()
possibilities = set()
for i in range(97, 97 + 26):
	char = chr(i)
	for j in range(0, len(s) + 1):
		option = s[:j] + char + s[j:]
		possibilities.add(option)
print(len(possibilities))


st = set()
s = input()
for i in range(26):
	for j in range(len(s) + 1):
		temp = s[:j] + chr(i + ord('a')) + s[j:]
		st.add(temp)
print(len(st))


import sys
strInput = sys.stdin.readline().rstrip()
numberOfSpecialPhotos = len(strInput)
print((numberOfSpecialPhotos + 1) * 26 - numberOfSpecialPhotos)


s = input()
l = []
li = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
for c in li:
	for i in range(0, len(s) + 2):
		str = s[0:i] + c + s[i:len(s)]
		if str in l:
			continue
		else:
			l.append(str)
print(len(l))


s = list(input())
if len(s) == 1:
	print(51)
else:
	print(26 * (len(s) + 1) - len(s))


s = input()
n = len(s)
ans = 26 * (n + 1) - n
print(ans)


n = input()
i = (len(n) + 1) * 25
print(i + 1)


s = input()
mest = len(s) + 1
have = []
import string
alphabet = string.ascii_lowercase
for el in alphabet:
	have.append(el + s)
for i in range(1, mest + 1):
	for el in alphabet:
		have.append(s[0:i] + el + s[i:])
print(len(set(have)))


s = input()
a = set(s)
print(25 * len(s) + 26)


import itertools

def main():
	n = input()
	d = n
	if len(d) == 1:
		print(51)
	if len(d) >= 2:
		print((len(d) + 1) * 26 - len(d))
main()


import sys
x = sys.stdin.readline().rstrip()
y = len(x)
if 21 <= y:
	print('Enter a lower number')
elif y == 0:
	print('Enter a higher number')
else:
	print((y + 1) * 26 - y)


import time
s = input()
start = time.time()
ans = 1 + 25 * (len(s) + 1)
print(ans)
finish = time.time()


s = input()
p = 26
p += 25 * len(s)
print(p)


a = input()
print(len(a) * 25 + 26)


a = input()
ans = 0
for i in range(len(a) + 1):
	ans += 26
print(ans - len(a))


i = input()
if len(i) == 1:
	print(51)
else:
	(s, t) = (50, 1)
	for x in range(len(i) - 1):
		s += 25 + t
		t = 0
	print(s)


letra = input()
ans = 26 * (len(letra) + 1) - len(letra)
print(ans)


booklet = input()
alphabet_size = 26
print((len(booklet) + 1) * 26 - len(booklet))


ans = 25
s = input()
for i in range(len(s)):
	if i == len(s) - 1:
		ans += 26
	else:
		ans += 25
print(ans)


photobook = str(input())
print(26 * (len(photobook) + 1) - len(photobook))


letras = len(input())
print(letras * 25 + 26)


def photobooks(letters):
	return (len(letters) + 1) * 26 - len(letters)
letters = input()
print(photobooks(letters))


from sys import stdin, stdout
a = str(stdin.readline())
b = []
c = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
for i in range(len(a)):
	for o in c:
		b.append(a[:i] + o + a[i:])
stdout.write(str(len(set(b))))
stdout.flush()


s = list(input())
a = []

def listmerge(l):
	s = ''
	for el in l:
		s += el
	return s
for i in range(len(s) + 1):
	for j in list('abcdefghijklmnopqrstuvwxyz'):
		S = list(s)
		S.insert(i, j)
		a.append(S)
b = []
for el in a:
	b.append(listmerge(el))
print(len(set(b)))


assd = input()
print((len(assd) + 1) * 26 - len(assd))


s = input()
l = len(s) + 1
ans = l * 25 + 1
print(ans)


ip = str(input())
n = len(ip)
print(26 * (n + 1) - n)


p = input()
print((len(p) + 1) * 26 - len(p))


s = input()

def chrnum(s, a):
	ans = 0
	for i in s:
		if i == a:
			ans += 1
	return ans

def fn(s):
	temp = 'abcdefghijklmnopqrstuvwxyz'
	ans = 0
	for i in temp:
		ans += len(s) + 1 - chrnum(s, i)
	return ans
print(fn(s))


n = list(input())
k = set()
for i in range(len(n) + 2):
	for j in range(26):
		k.add(''.join(str(n[:i] + [chr(j + 97)] + n[i:])))
print(len(k))


a = list(input())
n = len(a)
print((n + 1) * 26 - n)


def photobooks(s):
	return (len(s) + 1) * 26 - len(s)
print(photobooks(input()))


inp = input()
print(26 + len(inp) * 25)


s = input()
print(len({s[:i] + c + s[i:] for i in range(len(s) + 1) for c in 'qwertyuioplkjhgfdsazxcvbnm'}))


b = []
s = input()
b += s
ans = set()
for i in range(len(s) + 1):
	for j in range(26):
		b.insert(i, chr(ord('a') + j))
		now = 0
		y = 37
		for h in range(len(b)):
			now += (ord(b[h]) - ord('a') + 1) * y
			y *= 37
		del b[i]
		ans.add(now)
print(len(ans))


s = input()
se = set()
for j in 'qwertyuiopasdfghjklzxcvbnm':
	for i in range(len(s) + 1):
		se.add(s[:i] + j + s[i:])
print(len(se))


pb = input()
l = len(pb)
rep = [1] * l
for i in range(1, l):
	if pb[i] == pb[i - 1]:
		rep[i] = rep[i - 1] + 1
		rep[i - 1] = 0
print(26 * (l + 1) - sum(rep))


letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
string = input()
result = set()
first = ''
second = ''
for i in range(len(string)):
	first = string[:i]
	second = string[i:]
	for j in range(len(letters)):
		value = letters[j] + first + second
		result.add(value)
		value = first + letters[j] + second
		result.add(value)
		value = first + second + letters[j]
		result.add(value)
print(len(result))


s = input().strip()
ans = 0
d = {}
for x in range(len(s)):
	for c in 'qwertyuiopasdfghjklzxcvbnm':
		a = s[:x] + c + s[x:]
		if a not in d:
			d[a] = True
			ans += 1
for c in 'qwertyuiopasdfghjklzxcvbnm':
	a = s + c
	if a not in d:
		d[a] = True
		ans += 1
print(ans)


from string import ascii_lowercase

def solve(r):
	r = list(r)
	s = 0
	x = set()
	for nl in ascii_lowercase:
		for i in range(len(r) + 1):
			k = r[:i] + [nl] + r[i:]
			x.add(tuple(k))
	return len(x)

def main():
	s = input()
	print(solve(s))
main()


setx = []
x = input()
a = 'abcdefghijklmnopqrstuvwxyz'
t = ''
for i in range(len(x) + 1):
	for j in a:
		t = x[:i] + j + x[i:]
		setx.append(t)
print(len(set(setx)))


s = input()
a = []
for i in s:
	if i not in a:
		a.append(i)
print(len(s) * 25 + 26)


text = len(input())
print((text + 1) * 25 + 1)


s = input()
outList = []
out = 0
alph = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
if len(s) == 1:
	out = 51
else:
	for i in range(len(s) + 1):
		sList = list(s)
		for x in alph:
			if i == len(s):
				sList.append(x)
				sNew = ''
				for e in sList:
					sNew += e
				if not sNew in outList:
					outList.append(sNew)
				sList = list(s)
			else:
				sList.insert(i, x)
				sNew = ''
				for e in sList:
					sNew += e
				if not sNew in outList:
					outList.append(sNew)
				sList = list(s)
	out = len(outList)
print(out)


import itertools
s = input()
n = len(s)
s = ''.join((ch for (ch, _) in itertools.groupby(s)))
print((n + 1) * 26 - len(s) - (n - len(s)))


s = input()
a = list(s)
b = list()
c = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
for i in range(len(s) + 1):
	for j in c:
		a.insert(i, j)
		if ''.join(a) not in b:
			b.append(''.join(a))
		a = list(s)
print(len(b))


book = input()
print(len(book) * 26 + (26 - len(book)))


s = input()
res = set()
for i in range(len(s) + 1):
	for ch in range(ord('a'), ord('z') + 1):
		res.add(s[:i] + chr(ch) + s[i:])
print(len(res))


a = input()
n = len(a)
if n == 1:
	print(51)
else:
	print(26 * (n + 1) - n)


s = input()
n = len(s) + 1
l = n - 1
print(n * 26 - l)


import sys
import math
import collections
from pprint import pprint
s = input()
n = len(s)
ss = set()
for i in range(n + 1):
	for j in range(26):
		temp = s[0:i] + str(chr(ord('a') + j)) + s[i:]
		ss.add(temp)
print(len(ss))


a = 26
for i in input():
	a += 25
print(a)


x = input()
print((len(x) + 1) * 25 + 1)


a = input()
c = 0
for i in range(97, 123):
	x = a.count(chr(i))
	if x > 1:
		c += x - 1
z = 26 * (len(a) + 1) - len(a)
print(z)


s = input() + '1'
arr = []
p = s[0]
c = 1
for i in range(1, len(s)):
	if s[i] == p:
		c += 1
	else:
		arr.append((p, c))
		c = 1
		p = s[i]
c = arr[0][1] * 25 + 1
for i in range(1, len(arr)):
	c += 24 + (arr[i][1] - 1) * 25 + 1
c += 25
print(c)


L = list(input())
S = set(L)
ans = (len(L) + 1) * 26 - len(L)
print(ans)


s = input()
n = len(s)
o = 26 * (n + 1) - n
print(o)


s = input()
result = 26
for l in s:
	result += 25
print(result)


def main():
	s = input()
	ans = 26
	for c in s:
		ans += 25
	print(ans)
main()


print(len(input().strip()) * 25 + 26)


string = str(input())
x = len(string)
print(25 * x + 26)


n = input()
p = len(n)
if len(set(n)) == 1:
	print(25 * (p + 1) + 1)
else:
	print(26 * (p + 1) - len(n))


x = input()
print(26 * len(x) + (26 - len(x)))


from operator import itemgetter
s = input()
print((len(s) + 1) * 25 + 1)


s = input().strip('\n')
n = len(s)
print(26 * (n + 1) - n)


__author__ = 'taras-sereda'

def a():
	s = input()
	return (len(s) + 1) * 26 - len(s)
print(a())


def from_same_letters(word):
	if len(word) == 0:
		return True
	char = word[0]
	for letter in word:
		if letter != char:
			return False
	return True
letters = input()
result = int(51)
for i in range(len(letters) - 1):
	result += 25
	if letters[i + 1] != letters[i]:
		++result
print(result)


s = input('')
b = len(s)
p = 26 * (b + 1) - b
print(p)


def main():
	st = input()
	print(solve(st))

def solve(st):
	return len(st) * 25 + 26
main()


s = input()
d = set()
for i in range(len(s)):
	for a in range(26):
		c = chr(ord('a') + a)
		d.add(s[:i] + c + s[i:])
for a in range(26):
	c = chr(ord('a') + a)
	d.add(s + c)
print(len(d))


import string
s = input().strip()
ens = set()
ls = len(s)
for l in string.ascii_lowercase:
	ens.add(l + s)
	ens.add(s + l)
for i in range(1, ls):
	a = s[:i]
	b = s[i:]
	for l in string.ascii_lowercase:
		ens.add(a + l + b)
print(len(ens))


word = input()
len_word = len(word)
n_possib = len_word * 25 + 26
print(n_possib)


s = input()
a = set()
for c in 'qwertyuiopasdfghjklzxcvbnm':
	for i in range(len(s) + 1):
		a.add(s[:i] + c + s[i:])
print(len(a))


__author__ = 'Adam'
import sys
a_z = [chr(i) for i in range(ord('a'), ord('z') + 1)]
s_in = sys.stdin.readline().replace('\n', '')
a_z1 = []
for i in range(len(s_in)):
	for ch in a_z:
		s_in1 = list(s_in)
		s_in2 = list(s_in)
		s_in1.insert(i, ch)
		s_in2.insert(i + 1, ch)
		a_z1.append(''.join(s_in1))
		a_z1.append(''.join(s_in2))
print(len(set(a_z1)))


alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
string = input()
n = len(string)
letters = list(string)
unique = []
for x in range(n + 1):
	for y in range(26):
		temp = letters[:]
		temp.insert(x, alphabet[y])
		unique.append(''.join(temp))
unique = set(unique)
print(len(unique))


suka = input()
kak = {}
sko = 0
for i in range(0, len(suka) + 1):
	for c in range(ord('a'), ord('z') + 1):
		st = suka[:i] + chr(c) + suka[i:]
		if not st in kak:
			sko += 1
			kak[st] = 1
print(str(sko) + '\n')


import sys
s = input()
booklets = set()
for i in range(0, 1 + len(s)):
	for c in range(ord('a'), ord('z') + 1):
		news = s[0:i] + chr(c) + s[i:]
		booklets.add(news)
print(len(booklets))


q = input()
print(26 * (len(q) + 1) - len(q))


n = input()
print(26 + len(n) + 24 * len(n))


import math
s = list(input())
n = len(s)
ans = (n + 1) * 25 + 1
print(ans)


s = input()
factor = len(s) * 25
shifter = 26
print(shifter + factor)


booklet = str(input())
i = 0
length = len(booklet)
alpha = 'abcdefghijklmnopqrstuvwxyz'
hashset = set()
while i <= length:
	for c in alpha:
		hashset.add(booklet[0:i] + c + booklet[i:])
	i += 1
print(len(hashset))


s = input()
possible = set()
for i in range(len(s) + 1):
	for j in range(26):
		possible.add(s[0:i] + chr(j + ord('a')) + s[i:])
print(len(possible))


n = input()
ans = 26
for i in n:
	ans += 25
print(ans)


Q = set()
T = input()
for P in range(len(T) + 1):
	for L in range(26):
		Q.add(T[:P] + str(chr(L + 97)) + T[P:])
print(len(Q))


l = len(input().strip())
print((l + 1) * 26 - l)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
s = get_string()
l = len(s)
print(26 + l * 25)


s = input()
l = list(s)
a = 'abcdefghijklmnopqrstuvwxyz'
for i in range(len(s) + 1):
	for j in a:
		l.insert(i, j)
print(len(l) - 2 * len(s))