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):
print(48-int(input()))

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

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

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):
h = int(input())
print(48-h)

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

print(24+24-m)

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

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(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):
M = int(input())
print(24 - M + 24)

Solution (Python):

import sys
sys.setrecursionlimit(10**6)

m = int(input())

print(24-m+24)

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

Solution (Python):

M=int(input())
if 1<=M and M<=23:
    result=48-M
    if result>=0:
        print(result)

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

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

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

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

answer = 48 - M
print(answer)

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

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

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):
import sys
print(48-int(sys.stdin.readline().rstrip()))

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):
print(48-int(input()))

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

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


if __name__ == "__main__":
    main()

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

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

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

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

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):
print(48-int(input()))

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

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

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

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

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

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

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-M)+24)

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

Solution (Python):





M = int(input())

print((24 - M) + 24)

Solution (Python):


M = int(input())

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

Solution (Python):







m = int(input())


result = 48 - m
print(result)

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 - m + 24)

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

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

x = 48 - m

print(x)

Solution (Python):

M = int(input())


time_remaining = 48 - M


print(time_remaining)

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


x = 48 - m


print(x)

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

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

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

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

Solution (Python):

M = int(input())


if 1 <= M <=23:
    print(48 - M)

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

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

Solution (Python):
from datetime import datetime, date

dt = datetime(date.today().year, 12, 30, int(input()), 0, 0)
td = abs(dt - datetime(dt.year + 1, 1, 1))
answer = int(td.total_seconds() / (60 * 60))
print(answer)

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

answer = 48 - M

print(answer)

Solution (Python):

M = int(input())


x = 48 - M


print(x)

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


M = int(input())

print(24 + (24 - M))

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

if __name__ == '__main__':
  main()

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

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

x = 24 - M
print(x + 24)

Solution (Python):

M = int(input())
 

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

Solution (Python):

M = int(input())

print(48 - M)

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

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

x=24+(24-M)

print(x)

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

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

day = 24 + (24 - S)
print (day)

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

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

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

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

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






x = 48 - M



answer = x
print(answer)

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

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

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

Solution (Python):

time = int(input())


left_30 = 24 - time
new_year = left_30 + 24

print(new_year)

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

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

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

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

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

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

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

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


left_hour_to_next_year = 48 - day_of_30th_hour
print(left_hour_to_next_year)

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

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

Solution (Python):


m = int(input())

ans = 48 - m

print(ans)

Solution (Python):


m = int(input())

ans = 48 - m

print(ans)

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

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

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

Solution (Python):


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

if __name__ == "__main__":
    main()

Solution (Python):
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))

n = ini()
print(24 + 24 - n)

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

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

Solution (Python):
m = int(input())
print(48-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(48-m)

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

Solution (Python):


import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

M = int(input())

res = 48 - M

print(res)

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

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

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(48-int(input()))

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

Solution (Python):









m = int(input())

print(abs(m-24)+24)

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

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

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

Solution (Python):

def main():
    n = int(input())
    print(24 - n + 24)


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    M = int(readline())
    print(48-M)


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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(48 - int(input()))

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

print(48-M)

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

print(48-M)

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

print(48-M)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    M = int(readline())
    
    print(48 - M)
    
    return


if __name__ == '__main__':
    main()

Solution (Python):
print(eval('48-'+input()))

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

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

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):
N=int(input())
print(48-N)

Solution (Python):
import sys
sys.setrecursionlimit(4100000)
import math
import itertools
INF = float('inf')
from heapq import heapify, heappop, heappush

def main():
    m = int(input())

    print(48-m)


if __name__ == '__main__':
    main()

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

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):
print(48-int(input()))

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

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

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 accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
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()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

print(48 - INT())

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

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

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

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

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



print(24-N+24)

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

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

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):
n = int(input())

print(48-n)

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

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

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

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

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

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

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

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


if __name__ == "__main__":
    solve()

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


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


if __name__ == "__main__":
    main()

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):
m = int(input())
print(24+(24-m))

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):
m = int(input())
print(48-m)

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

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

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

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):
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):
m = int(input())
print(48 - m)

Solution (Python):
import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()


INF = float('inf')


m = I()
ans = 24 + 24 - m
print(ans)

Solution (Python):


import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

m = I()
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(24+24-m)

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

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

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

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

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

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

ans = 24-M+24
print(ans)

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

if __name__ == "__main__":
  resolve()

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

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

print(24+24-n)

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


if __name__ == '__main__':
    main()

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

Solution (Python):


print(48-int(input()))

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

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

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

ans = (24-M)+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
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

print(48-ri())

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):
def main():
    M = int(input())
    print(48 - M)

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):










import sys

def input(): return sys.stdin.readline()
def iIn(): return int(input())
def iInM(): return map(int, input().split())
def iInM1(): return map(int1, input().split())
def iInLH(): return list(map(int, input().split()))
def iInLH1(): return list(map(int1, input().split()))
def iInLV(n): return [iIn() for _ in range(n)]
def iInLV1(n): return [iIn()-1 for _ in range(n)]
def iInLD(n): return [iInLH() for _ in range(n)]
def iInLD1(n): return [iInLH1() for _ in range(n)]
def sInLH(): return list(input().split())
def sInLV(n): return [input().rstrip('\n') for _ in range(n)]
def sInLD(n): return [sInLH() for _ in range(n)]

def OutH(lst, deli=' '): print(deli.join(map(str, lst)))
def OutV(lst): print('\n'.join(map(str, lst)))

sys.setrecursionlimit(10 ** 6)

int1 = lambda x: int(x) - 1

INF = int(1e9)
MOD = 1000000007
dx = (-1, 0, 1, 0)
dy = (0, -1, 0, 1)


M = iIn()

ans = 24 + (24 - M)

print(ans)

Solution (Python):
print(max(0, 48 - int(input())))

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

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

if not ( 1 <= M <= 23):
    sys.exit()

print(24+(24-M))

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

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

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

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

print((24-M)+24)

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

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

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

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

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

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

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

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

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

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

rt30 = 24 - M

x = 24 + rt30

print(x)

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):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7

M = i()
print(48-M)

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

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

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):
x = int(input())
print(48-x)

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

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

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

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

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

    print(24 + (24 - M))

if __name__ == '__main__':
    main()

Solution (Python):

import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial
from bisect import bisect_left 
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')

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):
n = int(input())
print(48-n)

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

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

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    M = int(input())

    ans = (24 - M) + 24

    print(ans)


if __name__ == "__main__":
    main()

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

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

Solution (Python):
def actual(M):
    return (24 - M) + 24

M = int(input())
print(actual(M))

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

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

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


def main():
    m = int(input())
    ans = (24-m)+24
    print(ans)

if __name__=="__main__":
    main()

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



def main():
    M = int(input().strip())
    return (24 - M) + 24


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

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):
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(48 - m)

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

print(48-m)

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

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

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 + (24 - M))

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

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

Solution (Python):
print(24*2-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 = int(input())
m = 24 - m
print(m + 24)

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):
m = int(input())
print(24 + 24 - m)

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

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

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):
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(24 + 24 - int(input()))

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

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

Solution (Python):


import sys






























def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    m = ii()
    print(48 - m)


if __name__ == "__main__":
    main()

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

Solution (Python):

m=int(input())

print(48-m)

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

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

print(48 - m)

Solution (Python):
s = input()
s = int(s)
if s == 23:
    print("25")
elif s == 22:
    print("26")
elif s == 21:
    print("27")
elif s == 20:
     print("28")
elif s == 19:
     print("29")
elif s == 18:
     print("30")
elif s == 17:
     print("31")
elif s == 16:
     print("32")
elif s == 15:
     print("33")
elif s == 14:
     print("34")
elif s == 13:
     print("35")
elif s == 12:
     print("36")
elif s == 11:
     print("37")
elif s == 10:
     print("38")
elif s == 9:
     print("39")
elif s == 8:
     print("40")
elif s == 7:
     print("41")
elif s == 6:
     print("42")
elif s == 5:
     print("43")
elif s == 4:
     print("44")
elif s == 3:
     print("45")
elif s == 2:
     print("46")
else:
     print("47")

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

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

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

Solution (Python):
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

Solution (Python):
print(24 + (24 - 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):
M = int(input())
print(24-M+24)

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

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

print(48 - n)

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

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):
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(48 - M)

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

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

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

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

Solution (Python):
import sys
def ii(): return int(sys.stdin.readline())

M = ii()

print(48-M)

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

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

Solution (Python):
import collections


def inputStrOnebyOne():
    s = list(input())
    return s


def inputOnebyOne_Int():
    a = list(int(x) for x in input().split())
    return a

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

if __name__=='__main__':
    main()

Solution (Python):

print(24 * 2 - int(input()))

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

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

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

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):
import sys
import math
import bisect
 
def main():
    n = int(input())
    print(48 - n)
 
if __name__ == "__main__":
    main()

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

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

print(24+(24-M))

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

ans = 48 - m
print(ans)

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):
A=int(input())
print(48-A)

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

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

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

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

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

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

if __name__ == '__main__':

    ABC_84_A()

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-M+24)

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

if __name__ == '__main__':
    main()

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+(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):
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):
print(48-int(input()))

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

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = 10**20
def I(): return int(input())
def F(): return float(input())
def S(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()

def resolve():
    M = I()

    print((24-M)+24)

if __name__ == '__main__':
    resolve()

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

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