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

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    m = II()
    print(48-m)
    return


def B():
    return


def C():
    return


def D():
    a = II()
    ans = inf
    b = 0
    for k in range(1, 10 ** 5):
        b += a
        ans = min(ans, sum(list(map(int, list(str(b))))))
    print(ans)
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

Solution (Python):

import math

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

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

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

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

Solution (Python):
import math
import sys


def input():
    return sys.stdin.readline()[:-1]








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

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

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

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

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    m = f()[0]
    print(24*2 - m)

solve()

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

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

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

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

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

def read_input():
    m = int(input())
    return m

def submit():
    m = read_input()

    print(24 + 24 - m)

if __name__ == '__main__':
    submit()

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

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

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

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

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

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

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

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

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

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

print(48-m)

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

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

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

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

Solution (Python):


print(48 - int(input()))

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

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

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

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

import os

INF = float('inf')


def inp():
    return int(input())


def inpf():
    return float(input())


def inps():
    return input()


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


def inlf():
    return list(map(float, input().split()))


def inls():
    return input().split()


def inpm(line):
    return [inp() for _ in range(line)]


def inpfm(line):
    return [inpf() for _ in range(line)]


def inpsm(line):
    return [inps() for _ in range(line)]


def inlm(line):
    return [inl() for _ in range(line)]


def inlfm(line):
    return [inlf() for _ in range(line)]


def inlsm(line):
    return [inls() for _ in range(line)]


def debug(fn):
    if not os.getenv('LOCAL'):
        return fn

    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        print('DEBUG: {}({}) -> '.format(
            fn.__name__,
            ', '.join(
                list(map(str, args)) +
                ['{}={}'.format(k, str(v)) for k, v in kwargs.items()]
            )
        ), end='')
        ret = fn(*args, **kwargs)
        print(ret)
        return ret

    return wrapper


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

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

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

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

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

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

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

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

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

print(24 + (24 - h))

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

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

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

print(24+(24-t))

Solution (Python):


a = int(input())

print((24 - a) + 24)

Solution (Python):


a = int(input())

print(24 - a + 24)

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

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

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

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

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

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

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

print(48-M)

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

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

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

Solution (Python):


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

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


main()

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

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

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

Solution (Python):

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

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

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

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

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

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

Solution (Python):

import sys

def main():
	M = int(input())
	
	tmp = 24 - M
	print(24 + tmp)
	
	
if __name__ == "__main__":
	main()

Solution (Python):

import sys
import time
import random

def main():
	M = int(input())
	
	tmp = 24 - M
	print(24 + tmp)
	
	
if __name__ == "__main__":
	main()

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

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

Solution (Python):
k = list(map(int,input().split()))
print(48-k[0])

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

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

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

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

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return list(map(int, sys.stdin.readline().split()))
def I(): return int(sys.stdin.readline())
def LS():return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]
def IR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = I()
    return l
def LIR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = LI()
    return l
def SR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = S()
    return l
def LSR(n):
    l = [None for i in range(n)]
    for i in range(n):l[i] = SR()
    return l
mod = 1000000007


def A():
    m = I()
    print(48-m)
    return


def B():
    return


def C():
    n = I()
    a = LIR(n-1)
    for i in range(n):
        t = 0
        x = i
        while x < n-1:
            if t < a[x][1]:
                t = a[x][1]
            t += (a[x][2]-t)%a[x][2]
            t += a[x][0]
            x += 1
        print(t)


def D():
    def check(n):
        if n == 1:
            return False
        i = 2
        while i*i <= n:
            if n%i == 0:
                return False
            i += 1
        return True
    f = [0 for i in range(100001)]
    for i in range(1,100001):
        f[i] += f[i-1]
        if check(i):
            if check((i+1)//2):
                f[i] += 1
    q = I()
    for i in range(q):
        l,r = LI()
        print(f[r]-f[l-1])


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == "__main__":
    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):
print(48 - 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):
I = int(input())
print(24+24-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):
print(48-int(input()))

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

Solution (Python):
def solve(string):
    return str(48 - int(string))


if __name__ == '__main__':
    print(solve(input()))

Solution (Python):

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

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

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

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

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

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

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

theEndOfYear = 24 + (24 - M)

print(theEndOfYear)

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

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

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

print(24+24-a)

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

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

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


if __name__ == "__main__":
    M = int(input())
    ans = new_year(M)
    print(ans)

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

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

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

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

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

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

Solution (Python):


import itertools
import collections
import bisect

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

if __name__ == '__main__':
    main()

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

Solution (Python):
import sys

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


if __name__ == "__main__":
    main()

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

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

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

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

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

Solution (Python):
from sys import stdin
a=int(stdin.readline().rstrip())
print(48-a)

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

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

ans = 48 - M

print(ans)

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

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

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

ans = (24 - M) + 24

print(ans)
print()

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

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

Solution (Python):
import bisect
import numpy as np
import sys
input = sys.stdin.readline
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

M = I()

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

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

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

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

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

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

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

print(24 + 24 - int_m)

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

Solution (Python):
M = input()

M = 24 - int(M)

print(24 + M)

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

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

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

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

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

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

Solution (Python):


import copy
import numpy as np
import random

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

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

Solution (Python):


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

Solution (Python):
""" AtCoder """

M = int(input())

print(48 - M)

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

Solution (Python):


a = int(input());

print("{}\n".format(24*2-a));

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

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

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

res = 48 -M
print(res)

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

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

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

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

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

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

Solution (Python):



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


if __name__ == '__main__':
    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):
print(24 + 24 - int(input()))

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

Solution (Python):
m = [int(i) for i in input().split()] 
a = 24+(24-m[0])
print(a)

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

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

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

print(24 + 24-n)

Solution (Python):


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

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


abc084_a()

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

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

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

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


if __name__ == '__main__':
    main()

Solution (Python):
print(24+24-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(24 + (24 - n))

Solution (Python):

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

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

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

Solution (Python):



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


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

print(48-a)

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

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

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

Solution (Python):


a=int(input())

s=48-a

print(s)

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

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

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

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

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

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

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

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

print(48-m)

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

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

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

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

Solution (Python):


n  = int( input())

print(24+(24-n))

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

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

print(24+24-n)

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

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

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

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

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

if __name__ == '__main__':
    main()

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

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

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

print(x)

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

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

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

Solution (Python):
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_s(): return list(input().split())

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

Solution (Python):


from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]


def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


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


if __name__ == '__main__':
    main()

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

Solution (Python):



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


if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

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

print(48-a)

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

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

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

print(d)

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

import itertools

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

if __name__ == '__main__':
    main()

Solution (Python):
M = int(input())
x = 48 - M
print("{}".format(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(24+(24-int(input())))

Solution (Python):

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

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

Solution (Python):
print 48 - int(raw_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(48-M)

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

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

Solution (Python):
next_time = 24 - int(input()) + 24

print(next_time)

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

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

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

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

Solution (Python):


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

Solution (Python):


M = int(input())

x = 48 - M

print(x)

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

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

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

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

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

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

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

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

Solution (Python):
print 48-input()

Solution (Python):
print 48-input()

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

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

Solution (Python):

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

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

Solution (Python):
print('{}'.format(48-int(input())))

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