Anonymous

import time,sys

#T(a, 0) = 1
#T(0, b) = T(1, b-1)
#T(24, b) = T(23, b)
#T(a, b) = T(a-1, b-1) + T(a+1, b-1)

retType = lambda a:ModInt(a, 10)

def T(a, b):
    global retType
    if b==1 or b==0: return retType(1)
    if a==0: return retType(T(1, b-1))
    if a==25: return retType(T(24, b-1))
    return retType(T(a-1, b-1) + T(a+1, b-1))

def triv(n):
    if n==0:return 1
    else:return triv(n-1)+triv(n-1)

class ModInt:
    def __init__(self, n, m):
        self.n = int(n)%m
        self.m = m
    def __add__(self, n):
        return ModInt(self.n + int(n), self.m)
    def __radd__(self, n):
        return ModInt(int(n) + self.n, self.m)
    def __sub__(self, n):
        return ModInt(self.n - int(n), self.m)
    def __rsub__(self, n):
        return ModInt(int(n) - self.n, self.m)
    def __mul__(self, n):
        return ModInt(self.n * int(n), self.m)
    def __rmul__(self, n):
        return ModInt(int(n) * self.n, self.m)
    def __div__(self, n):
        return ModInt(self.n / int(n), self.m)
    def __rdiv__(self, n):
        return ModInt(int(n) / self.n, self.m)
    def __int__(self):
        return self.n
    def __repr__(self):
        return str(self.n)
    def __str__(self):
        return str(self.n)
    def __eq__(self, n):
        return self.n==int(n)

def memoizate(f):
    class F:
        def __init__(self, f):
            self.f=f
            self.m={}
        def call(self, *args):
            targs=tuple(args)
            try:
                return self.m[targs]
            except:
                res=self.f(*args)
                self.m[targs]=res
                return res
    _f=F(f)
    return lambda *a:_f.call(*a)

sys.setrecursionlimit(20000)

T=memoizate(T)

def get_uohg(a):
    return sum([T(i, a) for i in range(26)])

#print get_uohg(100)

for arg in sys.argv:
    try:
        uohg = get_uohg(int(arg))
        print arg, uohg
    except:
        pass