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: interview

Starter code:

Solutions:
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2015 missingdays <missingdays@missingdays>
#
# Distributed under terms of the MIT license.

"""

"""

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


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))

from string import ascii_lowercase as letters

s = input()
books = set()

for i in range(len(s) + 1):
    for l in letters:
        books.add(s[:i] + l + s[i:])

print(len(books))


# I know it's messy

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))


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


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


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))


s = input()
print(26 + 25 * len(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 = input()
b = len(a)
print(26 + 25 * b)

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()


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

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

# Guide:
#   1. construct complex data types while reading (e.g. graph adj list)
#   2. avoid any non-necessary time/memory usage
#   3. avoid templates and write more from scratch
#   4. switch to "flat" implementations

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): # input matrix of integers
    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): # input matrix of strings
    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): # input transposed matrix/array of integers
    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()

string = len(input())+1

print(string*26-string+1)

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

n = len(input())+1

print(n*26-n+1)

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


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



s = list(input())

perms = (26 * (len(s)+1)) - len(s)

print(perms)
# 26*3-2


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


s = input()

print((len(s) + 1) * 26 - len(s))


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

s = input()
x = len(s)

print((26 * (x + 1)) - x)



#!/usr/bin/env python
# 554A_photo.py - Codeforces.com 554A Photo quiz
#
# Copyright (C) 2015 Sergey
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#       http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
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.

"""

# Standard libraries
import unittest
import sys
import re

# Additional libraries


###############################################################################
# Photo Class
###############################################################################


class Photo:
    """ Photo representation """

    def __init__(self, args):
        """ Default constructor """

        self.args = args
        self.str = args

    def calculate(self):
        """ Main calcualtion function of the class """

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

        return result

###############################################################################
# Executable code
###############################################################################


def decode_inputs(inputs):
    """ Decoding input string list into base class args list """

    # Decoding input into a string
    ilist = inputs[0]

    return ilist


def calculate(inputs):
    """ Base class calculate method wrapper """
    return Photo(decode_inputs(inputs)).calculate()


def main():
    """ Main function. Not called by unit tests """

    # Read test input string list
    inputs = [input()]

    # Print the result
    print(calculate(inputs))

###############################################################################
# Unit Tests
###############################################################################


class unitTests(unittest.TestCase):

    def test_decode_inputs(self):
        """ Input string decoding testing """
        self.assertEqual(decode_inputs(["a"]), "a")

    def test_Photo_class__basic_functions(self):
        """ Photo class basic functions testing """
        d = Photo("a")
        self.assertEqual(d.str, "a")

    def test_calculate(self):
        """ Main calculation function """

        # Sample tests
        self.assertEqual(calculate(["a"]), 51)
        self.assertEqual(calculate(["hi"]), 76)

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

__starting_point()