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

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

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

print(ans)

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

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

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):
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop

import collections

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

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

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

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

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

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, groupby
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
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

M = INT()
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):
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-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 = input()
M = int(M)
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):
s = int(input())
def year(m):
    return 48 - m;

print(year(s))

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

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

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

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

Solution (Python):
from sys import stdin

def main():
    d = int(stdin.readline())
    ny = 48 - d

    print(ny)

if __name__ == '__main__':
    main()

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

Solution (Python):
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [LI()for i in range(n)]
inf = 10**17
mod = 10**9 + 7

m=I()
print(48-m)

Solution (Python):
import sys

IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
MIIZ = lambda: list(map(lambda x: x-1, MII()))

INIT_VAL = 0
MD2 = lambda d1,d2: [[INIT_VAL]*d2 for _ in range(d1)]
MD3 = lambda d1,d2,d3: [MD2(d2,d3) for _ in range(d1)]

DIVC = lambda x,y: -(-x//y)
DIVF = lambda x,y: x//y

def main():
    m = II()
    print(48-m)

if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

Solution (Python):

import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1

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

if __name__ == '__main__':
    main()

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

print(48 - x)

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

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

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

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

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

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

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

print(48-M)

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

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

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

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

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

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

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

print(48-n)

Solution (Python):

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


if '__main__' == __name__:
    resolve()

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

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

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

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

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

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

print(24 + (24 - m))

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

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

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

Solution (Python):
import sys
import heapq, math
from itertools import zip_longest, permutations, combinations, combinations_with_replacement
from itertools import accumulate, dropwhile, takewhile, groupby
from functools import lru_cache
from copy import deepcopy

M = int(input())

print(24 - M + 24)

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

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

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

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

Solution (Python):

import sys


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


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

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

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

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

print(24+24-m)

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

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

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

import sys
input = sys.stdin.readline











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

Solution (Python):


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

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

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

answer = 24 - M + 24 

print(answer)

Solution (Python):
import sys

m = int(sys.stdin.readline().rstrip())

def main():
    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):
import sys
import copy
import math
import bisect
import pprint
import bisect
from functools import reduce
from copy import deepcopy
from collections import deque

if __name__ == '__main__':
    s=int(input())
    s= 24+ (24-s)

    print(s)

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

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

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

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

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


if __name__ == "__main__":
    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):
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())
print(48-a)

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

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

print(x)

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

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

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

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

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):
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
 
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
 
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()

M = ni()

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

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

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):
import sys
import os


def main():
    if os.getenv("LOCAL"):
        sys.stdin = open("input.txt", "r")

    M = int(sys.stdin.readline().rstrip())
    print(24+(24-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):
m=int(input())

print(48-m)

Solution (Python):









import sys



ipti = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)

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

if __name__ == '__main__':
    main()

Solution (Python):
from sys import stdin

m = int(stdin.readline().rstrip())
print(48-m)

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

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

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

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

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

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

Solution (Python):
import math
import itertools
import statistics


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

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

Solution (Python):

def New_Year(m):

    return  24 + (24 - m)

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

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
import math
import string


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


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


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

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

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

print((24-M) + 24)

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

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

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

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

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

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

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



print(24+24-n)

Solution (Python):



M = int(input().strip())


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

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

print(24+(24-m))

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

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

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

print(48 - M)

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

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

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

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

print(48 - M)

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

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

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

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

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

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

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


if __name__ == '__main__':
    main()

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

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

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

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

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

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

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

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

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

N=24-M

print(N+24)

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

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

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

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

Solution (Python):
str = input().split()
m = int(str[0])
print(48 - m)

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

Solution (Python):




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


if __name__ == "__main__":
    main()

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

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

print(48-m)

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

Solution (Python):
m = int(input())
print(24+(24-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):
"""
author : halo2halo
date : 24, Jan, 2020
"""

import sys
import itertools



read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

N = int(readline())

print(48-N)

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

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

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

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

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

Solution (Python):

import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(input())
print(48-n)

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

ans = 48 - M

print(ans)

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


print(48-n)

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

Solution (Python):


import sys
input = sys.stdin.readline


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


if __name__ == "__main__":
    main()

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

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

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

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

Solution (Python):

from itertools import product, permutations, combinations
from bisect import bisect_right,bisect_left
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):
def main():
    m = int(input())

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

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

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

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
print(24 + (24 - N))

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

print(24+24-m)

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

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

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

Solution (Python):


M = int(input())

H = 24 - M + 24

print(H)

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

Solution (Python):
import sys
input = sys.stdin.readline
M = int(input())
print(48-M)

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

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

Solution (Python):
def read_values():
    return map(int, input().split())


def read_list():
    return list(read_values())


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


if __name__ == "__main__":
    main()

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

print(48-m)

Solution (Python):
def read_values():
    return map(int, input().split())


def read_list():
    return list(read_values())


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

Solution (Python):

M = int(input())

hours_on_31 = 24

print(24 - M + hours_on_31)

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

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

Solution (Python):



def main():
    
    hour = int(input())
    
    print(24 - hour + 24)
    
    return 0
    
    
if __name__ == '__main__':
    main()

Solution (Python):



def main():
    n = int(input())
    
    print(48 - n)
    
    return 0
    
    
if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline
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(24+(24-M))

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):
print(list(range(48, 24, -1))[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):
N = int(input())
print(48-N)

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

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

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

Solution (Python):
import sys

m = int(sys.stdin.readline().rstrip())

def main():
    return 48 - m

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

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

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

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

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

print(48-m)

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

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

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

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

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

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

print(48 - m)

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

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

ans = 48- m
print(ans)

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

Solution (Python):

from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations
import sys
import bisect
import string
import math
import time
from fractions import gcd



def I(): return int(input())


def MI(): return map(int, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


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


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YN = ['Yes', 'No']
MOD = 10**9+7
inf = float('inf')
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)


show_flg = False



def main():
    M = I()

    print(48 - M)


if __name__ == '__main__':
    main()

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

Solution (Python):
import datetime

M = int(input())
today = datetime.datetime(2019, 12, 30, M)
new_year = datetime.datetime(2020, 1, 1, 0)
td = new_year - today

print(td.days * 24 + td.seconds // 3600)

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

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

print(48-time)

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

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

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

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

print((24-h)+24)

Solution (Python):
n = int(input().split()[0])
ans = 24 - n + 24
print(ans)

Solution (Python):
def two_int():
    N, K = map(int, input().split())
    return N,K

def one_int():
    return int(input())

def one_str():
    return input()

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

M=one_int()

print(24+24-M)

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

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

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

Solution (Python):

import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)

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

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

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

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

Solution (Python):

import math


M = int(input())


print (24-M+24)

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

print(48-M)

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