Problem:
 Score : 100 points    Problem Statement How many hours do we have until New Year at M o'clock (24-hour notation) on 30 th, December?      Constraints  1≤M≤23  M is an integer.         Input Input is given from Standard Input in the following format:  M       Output If we have x hours until New Year at M o'clock on 30 th, December, print x .        Sample Input 1 21      Sample Output 1 27  We have 27 hours until New Year at 21 o'clock on 30 th, December.       Sample Input 2 12      Sample Output 2 36

Solution (Python):











import sys
sys.setrecursionlimit(10**6)
input=sys.stdin.readline
from math import floor,ceil,sqrt,factorial,log 
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
inf=float('inf')
mod = 10**9+7
def pprint(*A): 
    for a in A:     print(*a,sep='\n')
def INT_(n): return int(n)-1
def MI(): return map(int,input().split())
def MF(): return map(float, input().split())
def MI_(): return map(INT_,input().split())
def LI(): return list(MI())
def LI_(): return [int(x) - 1 for x in input().split()]
def LF(): return list(MF())
def LIN(n:int): return [I() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
def LLIN_(n: int): return [LI_() for _ in range(n)]
def LLI(): return [list(map(int, l.split() )) for l in input()]
def I(): return int(input())
def F(): return float(input())
def ST(): return input().replace('\n', '')
def main():
    M=I()
    print(24-M+24)
if __name__ == '__main__':
    main()

Solution (Python):
def main():
    M = int(input())
    print(48 - M)


main()

Solution (Python):
m = int(input())
print(24 - m + 24)

Solution (Python):
n=int(input())
print(48-n)

Solution (Python):
M = int(input())
ans = 48 - M

print(ans)

Solution (Python):
a=int(input())
print(int(24+(24-a)))

Solution (Python):
x = int(input())
print(24+24-x)

Solution (Python):
m = int(input())
ans = 24 - m + 24
print (ans)

Solution (Python):
print(24+(24-int(input())))

Solution (Python):

print(24+(24-int(input())))

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
from sys import stdin
from itertools import combinations
from math import factorial
import numpy as np
import math

n = int(stdin.readline().rstrip())

print(24-n+24)

Solution (Python):
def examA():
    N = I()
    ans = 48-N
    print(ans)


import sys,copy,bisect,itertools,heapq,math
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def S(): return sys.stdin.readline().strip()
mod = 10**9 + 7
inf = float('inf')

examA()

Solution (Python):
m = int(input())

print(48 - m)

Solution (Python):
y = int(input())

print(48-y)

Solution (Python):
M = int(input())

print(24 + (24 - M))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
m  = int(input())
print(48 - m)

Solution (Python):
m = int(input())
print(24-m+24)

Solution (Python):
print(48-int(input()))

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
print(48 - int(input()))

Solution (Python):
n=int(input())
print(48-n)

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
input = sys.stdin.readline
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")

def main():
    m=int(input())
    print(48-m)

main()

Solution (Python):
n = int(input())

print(24-n+24)

Solution (Python):
input = int(input())
print(48 - input)

Solution (Python):
print(48 - int(input()))

Solution (Python):

a = int(input())
print(48-a)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
import sys








def main():
    m = int(sys.stdin.readline().rstrip())
    print(48 - m)

if __name__ == "__main__":
    
    main()

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print((24-M)+24)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(24-int(raw_input()) + 24)

Solution (Python):
n=int(input())
print(48-n)

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
m=int(input())

print(48-m)

Solution (Python):

M = int(input())
print(48-M)

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):

m = int(input())
print(24 - m + 24)

Solution (Python):
n = int(input())
print(48-n)

Solution (Python):

n = int(input())
print(48-n)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
m=int(input())

print(24+(24-m))

Solution (Python):
M = int(input())

untill_newyear = 24 + (24-M)
print(untill_newyear)

Solution (Python):
m = int(input())

print(24 + (24 - m))

Solution (Python):
M = int(input())
print(24- M + 24)

Solution (Python):
m = int(input())
print( 48 - m )

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(raw_input())
  
print(24-m + 24)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
print((24 - int(input())) + 24)

Solution (Python):
M = int(input())

print(24-M+24)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
M = int(input())
print(24+(24-M))

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
m=int(input())
n=24-m
print(n+24)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
print(48-int(input()))

Solution (Python):
N = int(input())
print(24+24-N)

Solution (Python):
number = int(input())
h=48-number
print(h)

Solution (Python):
print(48-int(input()))

Solution (Python):
s=int(input());print(48-s)

Solution (Python):
print(48 - int(input()))

Solution (Python):
M = int(input())

print(48-M)

Solution (Python):
print(48-int(input()))

Solution (Python):
m=int(input())
print(24+24-m)

Solution (Python):
print(48 - int(input()))

Solution (Python):
N = int(input())
print(24 - N + 24)

Solution (Python):
print(48 - int(input()) )

Solution (Python):
print(48-int(input()))

Solution (Python):
M=int(input())
print(24-M+24)

Solution (Python):
def new_year(M):
    return 48-M

M=int(input())
print(new_year(M))

Solution (Python):
M=int(input())

def new_year(M):
    return 48-M

print(new_year(M))

Solution (Python):
print(48-int(input()))

Solution (Python):
M=int(input())
print(48-M)

Solution (Python):
M=input()
M=int(M)
ans=48-M
print(ans)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())

print((24-M) + 24)

Solution (Python):
M = int(input())

print(24 + (24 - M))

Solution (Python):
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
    a=INT()
    print(48-a)
if __name__ == '__main__':
    do()

Solution (Python):
M = int(input())

print(48 - M)

Solution (Python):
m = int(input())
print(24-m+24)

Solution (Python):

M = int(open(0).read())
print(48-M)

Solution (Python):
print(48 - int(input()))

Solution (Python):
M = int(input())
ans = 24 + (24-M)
print(ans)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
n = int(input())
print(24+(24-n))

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())

print(24 * 2 - m)

Solution (Python):
def aa084():
    m = int(input()) 
    print(24 - m + 24)

aa084()

Solution (Python):
def slove():
    import sys
    input = sys.stdin.readline
    m = int(input().rstrip('\n'))
    print(24 - m + 24)


if __name__ == '__main__':
    slove()

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    m = int(input())
    print(48 - m)


if __name__ == "__main__":
    main()

Solution (Python):
M=int(input())

print(48-M)

Solution (Python):


import sys

sys.setrecursionlimit(100000)
MOD = 10 ** 9 + 7





M = int(input())
print(48 - M)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print(24 + (24 - m))

Solution (Python):
print(48-int(input()))

Solution (Python):
n = int(input())
print((24-n)+24)

Solution (Python):
M = int(input())
print(24-M+24)

Solution (Python):
i = int(input())
print((24-i)+24)

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
a = int(input())
print(48 - a)

Solution (Python):
a = int(input())
print(48-a)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
M=int(input())

print(48-M)

Solution (Python):
M = int(input())
print(24 + (24 - M))

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
print(24-int(input())+24)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(24 + (24-int(input())))

Solution (Python):
print(48-int(input()))

Solution (Python):
M=int(input())
print(24+(24-M))

Solution (Python):

print(48-int(input()))

Solution (Python):
m = int(input())
ny = 48-m
print(ny)

Solution (Python):
print(48-int(input()))

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
M = int(input())

print(24+(24-M))

Solution (Python):
n = int(input())
print(48-n)

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print(24 + 24 - m)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(24+(24-M))

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
n=int(input())
print(48-n)

Solution (Python):
M = int(input())

print(48 - M)

Solution (Python):
n=int(input())
print(48 - n)

Solution (Python):
print(24*2-int(input()))

Solution (Python):
a = input()
x = int(a)
print(48-x)

Solution (Python):
a = input()
a = int(a)
print(48-a)

Solution (Python):
a = input()
a = int(a)
print(48-a)

Solution (Python):
M=input()
M=int(M)
x=48-M
print(x)

Solution (Python):
a=int(input())
b=24-a
a=b+24
print(a)

Solution (Python):
a=int(input())
b=24-a
a=b+24
print(a)

Solution (Python):
first = input()
m = int(first)
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())

print(48 - m)

Solution (Python):
m = int(input())
print((24 - m) + 24 )

Solution (Python):
n=int(input())
print(48-n)

Solution (Python):
m=int(input())
print(24+(24-m))

Solution (Python):
print(-int(input())+48)

Solution (Python):
print(24*2 - int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print((24 - m) + 24)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input().strip()))

Solution (Python):
N =int(input())
print(48-N)

Solution (Python):
M = int(input())

print(24 * 2 - M)

Solution (Python):

M=int(input())


H=(24-M)+24


print(H)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
M = int(input())

print(24+24-M)

Solution (Python):
M = int(input())

ans = 24 + 24 - M
print(ans)

Solution (Python):
print(48-int(input()))

Solution (Python):
m=int(input())

print(48-m)

Solution (Python):
M = int(input())

print(24-M + 24)

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
m = int(input())
print(24 + (24-m))

Solution (Python):
print(48 - int(input()))

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
import sys

if sys.platform =='ios':
    sys.stdin=open('input_file.txt')
    
    
print(48-int(input()))

Solution (Python):
M=int(input())
print(24+(24-M))

Solution (Python):
M=int(input())
print(24+(24-M))

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
n=int(input())
print(48-n)

Solution (Python):
a=int(input())
b=48-a
print(b)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
import sys
import math
from fractions import gcd





def lcm(a, b):
    return a * b // gcd(a, b)

def combination_count(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

def permutations_count(n, r):
    return math.factorial(n) // math.factorial(n - r)

big_prime = 1000000007

"""


 =  sys.stdin.readline().rstrip()
 =  list(sys.stdin.readline().rstrip())


 =  int(sys.stdin.readline())
 =  map(int, sys.stdin.readline().split())
 =  list(map(int, sys.stdin.readline().split()))
 =  [list(map(int,list(sys.stdin.readline().split()))) for i in range(N)]
"""


N =  int(sys.stdin.readline())
print(24 + (24 - N))

Solution (Python):
print(48-int(input()))

Solution (Python):
a = int(input())
print(48 - a)

Solution (Python):
M = int(input())
X = 24 + (24-M)
print(X)

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    N = int(input())
    print(48 - N)


if __name__ == "__main__":
    main()

Solution (Python):
m = int(input())
print(24 + (24-m))

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48 - int(input()))

Solution (Python):
M = int(input())
print(24 + 24 - M)

Solution (Python):
M =int(input())
print(48-M)

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())

print(48 - m)

Solution (Python):
print(48 - int(input()))

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
m = int(input())
if 1 <= m <= 23:
    print(24 + 24 - m)
else:
    print('hoge!')

Solution (Python):
a = int(input())
print(48 - a)

Solution (Python):
print(24+24-int(input()))

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
print(24+(24-int(input())))

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
import sys
from statistics import *
from collections import *
from operator import itemgetter

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()

m = ni()
print(24 + 24 - m)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(24 * 2 - int(input()))

Solution (Python):
n = int(input())
print((24-n)+24)

Solution (Python):
m = input()

ans = 48-int(m)
print(ans)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
m = int(input())
print(24 + (24 - m))

Solution (Python):
def resolve():
    m = int(input())
    print(48 - m)


if __name__ == "__main__":
    resolve()

Solution (Python):
print(24-int(input())+24)

Solution (Python):
m=int(input())
print(24+24-m)

Solution (Python):
print(48-int(input()))

Solution (Python):


m = int(input())

print(48-m)

Solution (Python):
print(48 - int(input()))

Solution (Python):
a=int(input())
b=24-a
c=24+b
print(c)

Solution (Python):
print(24+24-int(input()))

Solution (Python):
m = int(input())
print(24 + (24-m))

Solution (Python):
M = int(input())
r = 48-M
print(r)

Solution (Python):
if __name__ == '__main__':
  M = int(input())
  print(24-M+24)

Solution (Python):
M = int(input())
answer = abs (24-M) + 24
print(answer)

Solution (Python):
n = int(input())

print(48 - n)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(48 - int(input()))

Solution (Python):
M=int(input())
print(48-M)

Solution (Python):
n=int(input())

print(48-n)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(2 * 24 - int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
x = 48 - m
print(x)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
def main():
    M = int(input())
    return 48 - M

if __name__ == '__main__':
    print(main())

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):


M = int(input())

print(24 + 24 - M)

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
def main():
    m=int(input())
    print(48-m)
main()

Solution (Python):
print(48 - int(input()))

Solution (Python):
a=int(input())
print(48-a)

Solution (Python):
M = int(input())
print(24+(24-M))

Solution (Python):
print(48 - int(input()))

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
M = int(input())
print(24-M+24)

Solution (Python):

m = int(input())
print((24-m) + 24)

Solution (Python):
print(48 - int(input()))

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(24-M+24)

Solution (Python):
M=int(input())
print(48-M)

Solution (Python):
print(48-int(input()))

Solution (Python):
def test():
    m = int(input())
    print(24 + 24 - m)


if __name__ == "__main__":
    test()

Solution (Python):
t = int(input())
print(48 - t)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(48 - int(input()))

Solution (Python):
m=int(input())
print(24-m+24)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print(24 * 2 - m)

Solution (Python):
M = int(input())
print(24 + (24 - M))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(24-int(input())+24)

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
M=int(input())

print(24-M+24)

Solution (Python):
m = int(input())

print(48-m)

Solution (Python):

def main():


    M = int(input())

    print(48-M)



    


if __name__== "__main__":
    main()

Solution (Python):
print(48-int(input()))

Solution (Python):
a = int(input())

print(48-a)

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(48 - int(input()))

Solution (Python):
m = int(input())
print(24-m+24)

Solution (Python):
print(24+24-int(input()))

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
N = int(input())
print(24*2-N)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
m=int(input())
print(24+(24-m))

Solution (Python):
print(24+24-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):

m = int(input())
print(24 + 24-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
print (48 - int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(24-M+24)

Solution (Python):
m = int(input())

print(24+24-m)

Solution (Python):
w=int(input())
print(48-w)

Solution (Python):


m = input()
m = int(m)




x = 48-m
print(x)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):

n = int(input())
print(48-n)

Solution (Python):

print(48 - int(input()))

Solution (Python):
m = int(input())
print(24 + (24 - m))

Solution (Python):


M = int(input())
print(48-M)

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
M = int(input())
year = 24 + (24 - M)
print(year)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
M = int(input())

print(48 - M)

Solution (Python):
M = int(input())
print (24-M+24)

Solution (Python):
print(48 - int(input()))

Solution (Python):
m = int(input())

print(24 + (24 - m))

Solution (Python):
M=int(input())
print(48-M)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
m = int(input())
print(24+24-m)

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print(24+24-m)

Solution (Python):
M = int(input())
print(24-M+24)

Solution (Python):
M = int(input())
print((24 - M) + 24)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
m = int(input())
print(24+(24-m))

Solution (Python):
m=int(input())
print(24-m+24)

Solution (Python):
M = int(input())
print(24-M + 24)

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
m = int(input())
print(24-m+24)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(24+(24-M))

Solution (Python):



M = int(input())


print(48 - M)

Solution (Python):
x = int(input())
print(24+(24-x))

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())

print(str(24+24-M))

Solution (Python):
m = int(input())
print(48 - m)

Solution (Python):
N = int(input())
print(48-N)

Solution (Python):
m = int(input())

print(24 + 24 - m)

Solution (Python):
n = int(input())
print(48 - n)

Solution (Python):
import sys
input = sys.stdin.readline

N = int(input())

print(48 - N)

Solution (Python):
i1 = int(input())
print(24-i1+24)

Solution (Python):
m = int(input())
print(24+24-m)

Solution (Python):
x = int(input())
print(48 - x)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48 - int(input()))

Solution (Python):
M = int(input())
print(24-M+24)

Solution (Python):
print(24+(24-int(input())))

Solution (Python):


m = int(input())
print(48 - m)

Solution (Python):
m = int(input())

print(48-m)

Solution (Python):
print(24+24-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):

N = int(input())

print(24 + (24 - N))

Solution (Python):
a = int(input())
print(24 - a + 24)

Solution (Python):
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

M = INT()
b = 24 - M
ans = 24 + b
print(ans)

Solution (Python):
print( 48 - int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input());
print(48-M);

Solution (Python):
import sys

def input():
    return sys.stdin.readline().rstrip()

if __name__ == "__main__":
    m = int(input())

    print(24 - m + 24)

Solution (Python):
m = int(input())
ans = 24 + 24 -m
print(ans)

Solution (Python):
M=int(input())
print(24*2-M)

Solution (Python):
m = int(input())

print(48 - m)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48 - int(input()))

Solution (Python):
M = int(input())
 
print(24 + 24 - M)

Solution (Python):
M = int(input())

print(24 + 24 - M)

Solution (Python):
a = int(input())
print(48 - a)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):



M = int(input())



print(24 - M + 24)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
a=int(input())
print(48-a)

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):

import sys


def solve(M: int):
    print(48 - M)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    M = int(next(tokens))  
    solve(M)


if __name__ == '__main__':
    main()

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48-int(input()))

Solution (Python):
x=int(input())
print((24-x)+24)

Solution (Python):
n = int(input())
print(48-n)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
n = int(input())

print(48-n)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

M = n()

print(48 - M)

Solution (Python):
print(48-int(input()))

Solution (Python):
m = int(input())
print(24-m+24)

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print((24 - M) + 24)

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
x = int(input())
print(48 - x)

Solution (Python):
m = int(input())
print(24-m+24)

Solution (Python):

import sys


def solve(M: int):
    print(48-M)
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    M = int(next(tokens))  
    solve(M)

if __name__ == '__main__':
    main()

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(24+24-int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
M=int(input())
print(48-M)

Solution (Python):
m = int(input())
print(24 + (24 - m))

Solution (Python):
m=int(input())
print(24-m+24)

Solution (Python):
def abc():
    n = int(input())
    print(48 - n)


abc()

Solution (Python):
X=int(input())
print(48-X)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
M = int(input())
print(24+24-M)

Solution (Python):
from collections import Counter
from collections import deque
from functools import reduce
from pprint import pprint
import bisect
import copy
import fractions
import itertools
import math
import queue
import random
import sys
import time
sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return [int(x) 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 MI(): return map(int, sys.stdin.readline().split())
def II(): return int(sys.stdin.readline())
def IS(): return input()
def C(x): return Counter(x)
def GCD_LIST(numbers): return reduce(fractions.gcd, numbers)
def LCM_LIST(numbers): return reduce(LCM, numbers)
def LCM(m, n): return (m * n // fractions.gcd(m, n))


print(48 - int(input()))

Solution (Python):
print(48-int(input()))

Solution (Python):


m = int(input())

print(48-m)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
n = int(input())
print(24-n+24)

Solution (Python):
M = int(input())
print(24 + (24-M))

Solution (Python):
print(48-int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
n = int(input())
print(int(24+(24-n)))

Solution (Python):
M = int(input())

print(24 - M + 24)

Solution (Python):
print (48-int(input()))

Solution (Python):
s = int(input())

ans = (24-s ) + 24
print(ans)

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())

print(48-M)

Solution (Python):

import sys


def solve(M: int):
    ret = 48 - M
    print(ret)
    return


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    M = int(next(tokens))  
    solve(M)

if __name__ == '__main__':
    main()

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
print(48-int(input()))

Solution (Python):
m=int(input())
print(48-m)

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = input()
M = int(M)

X = 24 - M + 24

print(X)

Solution (Python):




m = int(input())

ans = 48 - m


print(ans)

Solution (Python):
M = int(input())
print(48-M)

Solution (Python):
print(48-int(input()))

Solution (Python):
M=int(input())
print(48-M)

Solution (Python):
print(24 - int(input()) + 24)

Solution (Python):
m = int(input())
print(24-m+24)

Solution (Python):
m=int(input())

answer=(24-m)+24

print(answer)

Solution (Python):
a=int(input())

print(48-a)

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
from functools import reduce
import math

def main():
    
    
    
    

    
    
    
    
    
    

    
    

    
    
    
    
    
    
    
    
    
    INF = float("inf")

    
    MOD = 10**9+7
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    
    
    
    
    a = int(input())
    print((24-a)+24)
    
if __name__ == '__main__':
    main()

Solution (Python):
print(48-int(input()))

Solution (Python):
print(24-int(input())+24)

Solution (Python):
print(48-int(input()))

Solution (Python):
print(abs(24-int(input()))+24)

Solution (Python):
print(48-int(input()))

Solution (Python):
print((24-int(input()))+24)

Solution (Python):

import sys
input = sys.stdin.readline

print(48-int(input()))

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
print(48-int(input()))

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
print(24+24-int(input()))

Solution (Python):
print(48 - int(input()))

Solution (Python):
m = int(input())
print(48-m)

Solution (Python):
M = int(input())
print(48 - M)

Solution (Python):
m = int(input())
print(24 + (24-m))

Solution (Python):
print(24+24-int(input()))

Solution (Python):
print(48-int(input()))