Problem:
 Score : 100 points    Problem Statement Snuke has a favorite restaurant.  The price of any meal served at the restaurant is 800 yen (the currency of Japan), and each time a customer orders 15 meals, the restaurant pays 200 yen back to the customer.  So far, Snuke has ordered N meals at the restaurant.
Let the amount of money Snuke has paid to the restaurant be x yen, and let the amount of money the restaurant has paid back to Snuke be y yen.
Find x-y .      Constraints  1 ≤ N ≤ 100         Input The input is given from Standard Input in the following format:  N       Output Print the answer.        Sample Input 1 20      Sample Output 1 15800  So far, Snuke has paid 16000 yen, and the restaurant has paid back 200 yen. Thus, the answer is 15800 .       Sample Input 2 60      Sample Output 2 47200  Snuke has paid 48000 yen for 60 meals, and the restaurant has paid back 800 yen.

Solution (Python):











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

Solution (Python):
def resolve():
    n = int( input())
    x= n * 800
    y = (n//15) * 200
    print(x-y)
resolve()

Solution (Python):
def main():
    N = int(input())
    x = 800*N
    y = 200*(N//15)
    print(x-y)


if __name__ == '__main__':
    main()

Solution (Python):
if __name__ == '__main__':
    n = int(input())
    print(n * 800 - n // 15 * 200)

Solution (Python):
n=int(input())
a = 800*n
b = 200*(n//15)
print(a-b)

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

x = 800 * N
y = (N // 15) * 200

print (x - y)

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
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 LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

def solve():
    n = I()
    x = n*800
    y = (n//15)*200
    print(x-y)
    return


if __name__ == "__main__":
    solve()

Solution (Python):
def main():
    n = int(input())
    print(800 * n - 200 * (n // 15))


if __name__ == '__main__':
    main()

Solution (Python):
n=int(input())
print(n*800-200*(n//15))

Solution (Python):
N=int(input())
a=N//15
print(800*N-200*a)

Solution (Python):
a=int(input())
print(a*800-(a//15)*200)

Solution (Python):
N = int(input())
print(N * 800 - (N // 15) * 200)

Solution (Python):
n=int(input())
print(n*800-(n//15*200))

Solution (Python):
n = int(input())
print(800*n - (n//15)*200)

Solution (Python):
n = int(input())
print(n * 800 - n // 15 * 200)

Solution (Python):
N=int(input())
print(800*N-N//15*200)

Solution (Python):
n = int(input())
print(800*n - 200*(n//15))

Solution (Python):
a = int(input())
print(a*800-(a//15)*200)

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

x = N*800 - (N//15)*200
print(x)

Solution (Python):
n = int(input())
x = 800 * n
y = 200 * (n // 15)
print(x - y)

Solution (Python):
N = int(input())
K = N//15
print(800*N-200*K)

Solution (Python):

def resolve():
    N=int(input())
    ans=0
    cnt=0
    for i in range(N):
        ans+=800
        cnt+=1
        if cnt==15:
            ans-=200
            cnt=0
    print(ans)

resolve()

Solution (Python):
n=int(input())
x = 800*n
y = 200*(n//15)
print(x-y)

Solution (Python):
n = int(input())
c = n//15
print(800*n-200*c)

Solution (Python):
n = int(input())
print(800*n-n//15*200)

Solution (Python):
n=int(input())
y=n*800
x=n//15*200
print(y-x)

Solution (Python):

n = int(input())
x = n * 800
y = int(n / 15) * 200
print(x - y)

Solution (Python):
def resolve():
	n = int(input())
	print(n*800 - 200*(n//15))
resolve()

Solution (Python):
N = int(input())
x = 800 * N
y = 200 * (N // 15)
print(x - y)

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

x = 800 * n
y = 200 * (n // 15)
print(x - y)

Solution (Python):
n = int(input())
ret = n//15
ans = n*800 - ret*200
print(ans)

Solution (Python):
N = int(input())
print(800 * N - 200 * (N // 15))

Solution (Python):
N=int(input())
print(800*N-N//15*200)

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

N = int(input())

print(N * 800 - N // 15 * 200)

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

import math

x=N*800
y=N//15*200

print(x-y)

Solution (Python):
n = int(input())
print(800*n-(n//15*200))

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

x = 800 * N
y = 200 * (N // 15)

print(x - y)

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

N = n//15

print(n*800-200*N)

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

x = n * 800
y = n // 15
y = y*200

print(x - y)

Solution (Python):
N=int(input())
x=800*N
y=200*(N//15)
print(x-y)

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

x = n * 800
i = n//15
y = i * 200

print(x-y)

Solution (Python):
import math
n=int(input())
print(800*n-200*math.floor(n/15))

Solution (Python):
N=int(input())
print(N*800-N//15*200)

Solution (Python):
meals = int(input())
price15 = (15*800)-200
print((meals//15)*price15+800*(meals%15))

Solution (Python):
a = int(input())
print(a*800-a//15*200)

Solution (Python):
n = int(input())
print(n*800 - (n//15)*200)

Solution (Python):
n = int(input())
print(n*800-(n//15)*200)

Solution (Python):
def main():
    import sys
    readline = sys.stdin.buffer.readline
    readlines = sys.stdin.buffer.readlines
    
    N = int(input())
    ans = N * 800
    ans -= 200 * (N // 15)
    print(ans)


if __name__ == "__main__":
    main()

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

x = n * 800

y = n//15

print(x-(y*200))

Solution (Python):
n = int(input())
print(n * 800 - n // 15 * 200)

Solution (Python):
i=int(input())
print(800*i-200*(i//15))

Solution (Python):
x=int(input())
y=x//15
print(x*800-y*200)

Solution (Python):
n = int(input())
print(n*800 - (n//15)*200)

Solution (Python):
n = int(input())
print(n*800 - (n//15)*200)

Solution (Python):
n=int(input())
print(800*n-200*int(n/15))

Solution (Python):
n=int(input())
print(n*800-((n//15)*200))

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

x = 800*N
y = N//15*200

print(x-y)

Solution (Python):
n=int(input())
print(800*n-200*(n//15))

Solution (Python):
a = int(input())
print(a*800-(a//15)*200)

Solution (Python):
N = int(input())
x = 800 * N
y = N // 15 * 200
print(x - y)

Solution (Python):
N = int(input())
x = 800 * N
y = 200 * (N //15)
print(x - y)

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


ans = 800 * n - 200 * (n // 15)
print(ans)

Solution (Python):
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
 

def ii(): return int(sys.stdin.readline().rstrip()) 
def mii(): return map(int,sys.stdin.readline().rstrip().split())
def limii(): return list(mii()) 
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]

def ss(): return sys.stdin.readline().rstrip() 
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) 
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]





n=ii()

print(n*800-(n//15)*200)

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

gohan=800*n
if n>=15:
    cnt=n//15
    total=gohan-200*cnt
    print(total)
else:
    print(gohan)

Solution (Python):
icase=0
if icase==0:
    n=int(input())
    print(800*n-200*(n//15))

Solution (Python):
def main():
    N = int(input())
    price = 800
    cashback_unit = 15
    cashbuck_rate = 200

    x = price*N
    y = cashbuck_rate*(N//cashback_unit)

    print(x - y)
main()

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

x = 800 * n
y = 200 * (n // 15)

print(x - y)

Solution (Python):
n = int(input())
print(n * 800 - (n // 15) * 200)

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

print(n*800-n//15*200)

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

print(800*N - 200*(N//15))

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

print(800*n - 200*(n//15))

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

x = 800 * n
y = (n//15) * 200

print(x-y)

Solution (Python):
n = int(input())
print(800*n - 200*(n//15))

Solution (Python):
n = int(input())
ans = n*800 - n//15*200
print(ans)

Solution (Python):
nim = int(input())
print(nim*800 - nim//15*200)

Solution (Python):
n = int(input())
x=n*800
y=(n//15)*200
print(x-y)

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

x = N * 800
y = N // 15 * 200

ans = x-y
print(ans)

Solution (Python):
N = int(input())
print(800*N - 200*(N//15))

Solution (Python):
n = int(input())
print(n * 800 - (n // 15) * 200)

Solution (Python):
N = int(input())
print((N*800)-(N//15*200))

Solution (Python):
N = int(input())
print(N * 800 - (N // 15) * 200)

Solution (Python):
N = int(input())
print(N*800 - (N//15 * 200))

Solution (Python):
n = int(input())
print(n*800 - n//15*200)

Solution (Python):
a = int(input())
print(a*800 - a//15*200)

Solution (Python):
n = int(input())
print(n*800-n//15*200)

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

print(n * 800 - 200 * (n // 15))

Solution (Python):
N = int(input())
print(800*N - 200*(N//15))

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    N = int(input())
    q, r = divmod(N, 15)
    x = 800 * N
    y = 200 * q
    print(x - y)


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
print((n*800)-200*(n//15))

Solution (Python):
N=int(input())
print(N*800-N//15*200)

Solution (Python):
n=int(input())
print(800*n-int(n/15)*200)

Solution (Python):
n = int(input())
print(n * 800 - (n // 15 ) * 200)

Solution (Python):
n = int(input())
k = n//15
x = 800*n
y = 200*k
print(x-y)

Solution (Python):

N = int(input())
ans = 800 * N - (N // 15 * 200)
print(ans)

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

x=800*n
y=200*(n//15)
print(x-y)

Solution (Python):
n = int(input())
x = n * 800
y = int(n / 15)
ans = int(x) - int(y*200)
print(str(ans))

Solution (Python):
N = int(input())
print((N*800)-((N//15)*200))

Solution (Python):
N = int(input())
print(int(800*N-200*(N-N%15)/15))

Solution (Python):
N=int(input())
x=800*N
y=N//15*200
print(x-y)

Solution (Python):
N = int(input())
print( 800*N - 200*(N//15) )

Solution (Python):
n = int(input())
print(n*800+(n//15)*-200)

Solution (Python):
n = int(input())
print(800*n - n//15 * 200)

Solution (Python):
n = int(input())
print(n*800-n//15*200)

Solution (Python):
n = int(input())
x = 800 * n
y = 200 * (n // 15)
print(x - y)

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

print((N*800)-(N//15)*200)

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

print(800*n - 200*(n//15))

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

n = ni()

print(n * 800 - (n // 15) * 200)

Solution (Python):
n = int(input())
print(n*800-(n//15)*200)

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

print(N * 800 - N // 15 * 200)

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

y = N // 15 * 200
x = N * 800

print(x - y)

Solution (Python):
n = int(input())
a = n * 800
b = n //15
print(a - 200 * b)

Solution (Python):
n = int(input())
print(800*n-n//15*200)

Solution (Python):
N=int(input())
print(N*800-N // 15*200)

Solution (Python):
def main():
  n = int(input())
  print(n * 800 - (n//15)*200)
if __name__ == '__main__':
  main()

Solution (Python):


N = int(input())

x = 800 * N
y = (N // 15) * 200

print(x - y)

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

if N < 15:
	answer = 800 * N
elif N >=15: 
	answer = (800 * N) - 200 * (N//15)

print(answer)

Solution (Python):



N = int(input())


x = 800 * N
y = (N//15) * 200
print(x - y)

Solution (Python):
N = int(raw_input())
print 800*N - (N/15)*200

Solution (Python):

import math
n = int(input())
if (n / 15 < 1):
    print(n * 800)
else:
    print(n * 800 - n // 15 * 200)

Solution (Python):
import sys

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

def main():
    x = 800 * n
    y = 200 * (n // 15)
    print(x - y)

if __name__ ==  '__main__':
    main()

Solution (Python):

n = int(input())
print(n * 800 - n // 15 * 200)

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

syou = int(N/15)

print(N *800 - syou * 200)

Solution (Python):
n = int(input())
y = (n // 15) * 200
x = n * 800
print(x - y)

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

print((N*800)-((N//15)*200))

Solution (Python):
n = int(input())
print(800*n-(n//15)*200)

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__':
    a = int(input())
    ans = a*800 - 200*(a//15)
    print(ans)

Solution (Python):
N=int(input())
print(800*N-(int(N/15)*200))

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

th = N // 15

result = N * 800 - th * 200

print(result)

Solution (Python):
N = input()
x = N * 800
y = N/15
print x - y*200

Solution (Python):
N = int(input())
print(N * 800 - (N // 15) * 200)

Solution (Python):

n = int(input())

x = 800*n
y = 200*(int(n/15))

print(x-y)

Solution (Python):
N=int(input());print(200*(4*N-N//15))

Solution (Python):
N = int(input())
print(N*800 - N//15*200)

Solution (Python):
N=int(input())
x=800*N
y=200*(N//15)
print(x-y)

Solution (Python):
N=int(input())
x=800*N
k=N//15
y=200*k
print(x-y)

Solution (Python):
N = int(input())
dis = int(N / 15)
print(N * 800 - dis * 200)

Solution (Python):
import math

a=int(input())
print(800*a - 200*(a//15))

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

print(N*800 - (N//15)*200)

Solution (Python):
N = int(input())
print(N*800 - (N//15)*200)

Solution (Python):
n=int(input())
print(800*n-200*(n//15))

Solution (Python):
N = int(input())
n = N // 15
print(N*800 - n*200)

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

x=N*800
y=200*(N//15)
print(x-y)

Solution (Python):
n = int(input())
print(800*n - 200*(n//15))

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

tmp = n//15 * 200
n = n*800
print(n-tmp)

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

p=800*N
m=200*(N//15)

print(p-m)

Solution (Python):
n=input()
x=800*n
y=200*(n/15)
print x-y

Solution (Python):
n=int(input());print(800*n-200*(n//15))

Solution (Python):
N = int(input())
print(800*N-200*(N//15))

Solution (Python):
n = int(input())
x = (n*800) - ((n//15)*200)
print (x)

Solution (Python):
N = int(input())
print(N*800 - (N//15)*200)

Solution (Python):
import math


N=int(input())

print(N*800-N//15*200)

Solution (Python):
n = int(input())
x = 800*n
y = 200*(n//15)
print(x-y)

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

print((800 * n) - (200 * (n // 15)))

Solution (Python):
N = int(input())
p = 800*N
b = N//15 * 200
print(p-b)

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

print(N*800-N//15*200)

Solution (Python):
N=int(input())
print(800*N-N//15*200)

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

print(n*800-(n//15)*200)

Solution (Python):
n = int(input())
x = 800*n
y = 200*(n//15)
print (x-y)

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

print(N * 800 - (N // 15) * 200)

Solution (Python):
n = int(input())
print(n * 800 - n // 15 * 200)

Solution (Python):

N = int(input())
print(N*800 - N//15*200)

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

print(800*n-(n//15)*200)

Solution (Python):
n=int(input())
x=800*n
y=(n//15)*200
print(x-y)

Solution (Python):
n=int(input())
x=800*n
a=n//15
y=200*a 
print(x-y)

Solution (Python):
N = int(input())
A = (800*N) - 200 * (N//15)
print(A)

Solution (Python):
n = int(input())
print(800*n-(n//15)*200)

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

ans = int(800*N - 200*int((N//15)))
print(ans)

Solution (Python):
n = int(input())
print(800*n - 200*(n//15))

Solution (Python):
n = int(input())
print(n*800-200*(n//15))

Solution (Python):
n = int(input())
print(n * 800 - (n // 15) * 200)

Solution (Python):
N = int(input())
print(N*800-N//15*200)

Solution (Python):

n=int(input())
print(n*800-n//15*200)

Solution (Python):
a = int(input())
ans = a*800 - (a//15)*200
print(ans)

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

x = 800 * n
y = 200 * (n // 15)

print(x - y)

Solution (Python):
from math import floor
n = int(input())
x = (n * 800)
y = (floor(n/15) * 200)
print(x-y)

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

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

def main():
    mod=10**9+7
    N=I()
    print(N*800 -(N//15)*200)

main()

Solution (Python):
import math
n=int(input())
a=0
a=math.floor(n/15)
print(n*800-a*200)

Solution (Python):
n = int(input())
x = n*800
y = (n//15)*200
print(x-y)

Solution (Python):
N=int(input())
x=N*800
y=(N//15)*200
print(x-y)

Solution (Python):
n=int(input())
x=n*800
y=(n//15)*200
print(x-y)

Solution (Python):
N = int(input())
print(800*N-200*(N//15))

Solution (Python):
import sys
import os


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

    N = int(sys.stdin.readline().rstrip())
    m = N // 15
    print(N * 800 - m * 200)


if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
print(N*800-(N//15)*200)

Solution (Python):

n=int(input())
x=800*n
y=(n//15)*200
print(x-y)

Solution (Python):
n=int(input())
x=800*n
y=n//15*200
print(x-y)

Solution (Python):
n=int(input())
print(n*800-n//15*200)

Solution (Python):
N = int(input())
syou, amari = divmod(N,15)
print((800 * N) - (syou * 200))

Solution (Python):
n = int(input())
n1 = n*800
n2 = n//15
print(n1-(n2*200))

Solution (Python):
n = int(input())
value = 800
result = n * value
if n >= 15:
    result = result - (int(n // 15) * 200)

print(result)

Solution (Python):
N = int(input())
print(int(N * 800 - N // 15 * 200))

Solution (Python):
n=int(input())
print(800*n - n//15*200)

Solution (Python):
n=int(input())
print(800*n-n//15*200)

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

x = N * 800

y = 200 * (N//15)

print(x-y)

Solution (Python):
n = int(input())
b = (n // 15) * 200
print(800 * n - b)

Solution (Python):
n=int(input())
print(800*n-n//15*200)

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

x = 800*N
y = 200*(N//15)

print(x-y)

Solution (Python):
N=int(input())
a=N//15
print(800*N-200*a)

Solution (Python):
N = int(input())
print (800*N - 200*(N//15))

Solution (Python):
n = int(input())
print(800*n-200*(n//15))

Solution (Python):
n = int(input())
print(800*n-n//15*200)

Solution (Python):
N = int(input())
print(N*800-(N//15)*200)

Solution (Python):
from itertools import accumulate, permutations, combinations, product, combinations_with_replacement, groupby
from math import floor, ceil, sqrt, factorial, log
from bisect import bisect_left, bisect_right
from collections import Counter, defaultdict
from heapq import heappop, heappush, heappushpop
from itertools import product
import sys
stdin = sys.stdin
mod = 10**9 + 7


def ns(): return stdin.readline().rstrip()


def ni(): return int(ns())


def na(): return list(map(int, stdin.readline().split()))


n = ni()
print(800 * n - 200 * (n // 15))

Solution (Python):
N=int(input())
print(N*800-(N//15)*200)

Solution (Python):
n = int(input())
print(n * 800 - 200 * (n // 15))

Solution (Python):

N = int(input())
x = N*800
y = 200*(N//15)
print(x-y)

Solution (Python):
N=int(input())
t=N//15
print(800*N-200*t)

Solution (Python):
n = int(input())
print(n*800-int(n/15)*200)

Solution (Python):

import sys


def solve(N: int):
    print(N  * 800 - N // 15 * 200)


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


if __name__ == '__main__':
    main()

Solution (Python):
N = int(input())
print(N * 800 - int(N / 15) * 200)

Solution (Python):

n = int(input())

print(n*800 - 200*(n//15))

Solution (Python):

n=int(input())
print(n*800-(n//15)*200)

Solution (Python):
n = int(input())
print((800 * n) - (200 * (n // 15)))

Solution (Python):
n = int(input())
print((800*n)-(200*int(n/15)))

Solution (Python):
n = int(input())
print(800*n-200*(n//15))

Solution (Python):
n=int(input())
print(n*800-(n//15)*200)

Solution (Python):
n = int(input())
print(
    - (n//15) * 200 + 800 * n
)

Solution (Python):
import math
n = int(input())
a = math.floor(n/15)
print(800*n - 200*a)

Solution (Python):
n = int(input())
print(n*800 - n//15*200)

Solution (Python):
n = int(input())
print((n * 800) - (n // 15)*200)

Solution (Python):
n=int(input())
x=n*800
y=(n//15)*200
print(x-y)

Solution (Python):
n=int(input())
print(800*n-(n//15)*200)

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

print(n*800 - n//15*200)

Solution (Python):
def main():
    meals = int(input())
    print(800 * meals - 200 * (meals // 15))


if __name__ == '__main__':
    main()

Solution (Python):


N = int(input().strip())

x = 800*N
y = (N // 15) * 200

print(x-y)

Solution (Python):
N=int(input())
print(N*800-(N//15)*200)

Solution (Python):
n = int(input())
x = 800*n
y = 200*(n//15)
print(x-y)

Solution (Python):
n = int(input())
print(800*n-n//15 *200)

Solution (Python):
n = int(input())
print(800*n-200*(n//15))

Solution (Python):
N = int(input())
print(N * 800 - N // 15 * 200)

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

print(N*800 - N//15*200)

Solution (Python):
N = int(input())
print(800 * N - 200 * (N // 15))

Solution (Python):
N=int(input())
print(int(N*800-(N//15*200)))

Solution (Python):
n = int(input())
 
x = n * 800
y = (n // 15) * 200
 
print(x - y)

Solution (Python):
n = int(input())
print(800*n-n//15*200)

Solution (Python):
n=int(input())
print(n*800-n//15*200)

Solution (Python):
N = int(input())
print(800*N-200*(N//15))

Solution (Python):
import sys

sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]

def main():
    n=II()
    x=800*n
    y=n//15*200
    print(x-y)

main()

Solution (Python):
N = int(input())
print(800*N - 200*(N // 15))

Solution (Python):
N = int(input())
print(800 * N - 200 * (N // 15))

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

x = 800 * n
y = (n //15) * 200

print(x-y)

Solution (Python):
n = int(input())
x=n*800
y=n//15*200
print(x-y)

Solution (Python):
n=int(input())
print(n*800-(n//15)*200)

Solution (Python):
n=int(input())
x=n*800
y=n//15*200
print(x-y)

Solution (Python):
N = int(input())
print(800*N-200*(N//15))

Solution (Python):


N = int(input())

sur = 200 * (N // 15)

print(800 * N - sur)

Solution (Python):
n = int(input())
print(800*n - 200*(n//15))

Solution (Python):


n = int(input())
print(n * 800 - n // 15 * 200)

Solution (Python):
N = int(input())
print((N * 800) - (N//15 *200))

Solution (Python):
n=int(input());print(n*800-n//15*200)

Solution (Python):
N = int(input())
s = 800*N - 200*(N//15)
print(s)

Solution (Python):
n=int(input())
print((n*800)-(n//15)*200)

Solution (Python):
n = int(input())
cost_paid = 800 * n
cost_saved = 200 * (n//15)

print(cost_paid - cost_saved)

Solution (Python):
n = int(input())
print(800*n-200*(n//15))

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

print(N*800-int(N/15)*200)

Solution (Python):
e = int(input())
print(e*800 - (int(e/15)*200))

Solution (Python):
N=int(input())
print(N*800-N//15*200)

Solution (Python):
n = int(input())
print(800*n - (n//15)*200)

Solution (Python):
N=int(input())
x=N*800
y=0
if N>=15:
    y=200*(N//15)
ans=x-y
print(ans)

Solution (Python):
n = int(input())
x = n//15
print(800*n - 200*x)

Solution (Python):
n = int(input())
print(n*800 - 200*(n//15))

Solution (Python):


N = int(input())
Y = 800*N - 200*(N//15)
print(Y)

Solution (Python):
n = int(input())
tmp = n//15

print(800 * n - 200 * tmp)

Solution (Python):
a=int(input())
print(800*a-(a//15*200))

Solution (Python):
n = int(input())
print(n*800 - (n//15) * 200)

Solution (Python):
N = int(input())
a = N//15
Sum = 800*N - 200*a
print(Sum)

Solution (Python):
N = int(input())
p = N // 15
print(N*800 - p*200)

Solution (Python):
n = int(input())
print((n * 800) - ((n // 15) * 200))

Solution (Python):

N = int(input())



x = 800 * N
y = 200 * (N//15)

print(x-y)

Solution (Python):
n = int(input())
print(800*n - 200*(n//15))

Solution (Python):
N=int(input())
print(800*N-int(N/15)*200)

Solution (Python):
N = int(input())
x = N*800
y = (N//15)*200
Ans = x - y
print(Ans)

Solution (Python):
N = int(input())
print(N*800 - (N//15)*200)

Solution (Python):
n=int(input())
print(800*n-200*(n//15))

Solution (Python):
n = int(input())
print(800 * n - 200 * (n//15))

Solution (Python):
N=int(input())
print(N*800-N//15*200)

Solution (Python):
import math
def main(n):
    x = 800 * n
    y = 0
    if n >= 15:
        y = 200 * math.floor(n / 15)
    print(x - y)

main(int(input()))

Solution (Python):

str = input().split()
n = int(str[0])
print(n * 800 - int(n / 15) * 200)

Solution (Python):
def xy(A):
    ans = (A*800) - ((A//15)*200)
    return ans

def main():
    A = int(input())
    print(xy(A))

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
x = n * 800
y = 200 * (n // 15)
print(x - y)

Solution (Python):
N=int(input())
print(800*N-200*(N//15))

Solution (Python):
n = int(input())
print(800*n - 200*(n//15))

Solution (Python):
n=int(input())
ans=int(n*800-200*(n//15))
print(ans)

Solution (Python):




def main():
    N = int(input())
    print(N * 800 - (N // 15 * 200))


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())
print(800 * n - (n//15)*200)

Solution (Python):
n=int(input())
x=n*800
y=(n//15)*200
print(x-y)

Solution (Python):
N = int(input())
print(800 * N - ((N//15) * 200))

Solution (Python):
N = int(input())
print(800*N - (N//15)*200)

Solution (Python):
N = int(input())
print(800*N-N//15*200)

Solution (Python):
n=int(input())
print(n*800-(n//15)*200)

Solution (Python):
"""
author : halo2halo
date : 31, Jan, 2020
"""

import sys




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

N = int(readline())
print(N*800-(N//15)*200)

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


paid = N*800
got = N//15 * 200

print(paid-got)

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

n_fif = N // 15

print(N * 800 - n_fif * 200)

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

x = N * 800
y = int(N / 15) * 200
print(x - y)

Solution (Python):
n = int(input())
N = n//15
print(800*n-200*N)

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

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

N = INT()

print(800*N-N//15*200)

Solution (Python):
N = int(input())
cost = 800 * N
cnt = N // 15 * 200
print(cost - cnt)

Solution (Python):
n = int(input())
print(n*800-200*(n//15))

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

ans = N * 800 - (N // 15) * 200

print(ans)

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

    

    return 800 * N - (N // 15 * 200)


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

Solution (Python):
N=int(input())
print(N*800-N//15*200)

Solution (Python):
n = int(input())
x = 800*n
y = int(n/15)
print (x-200*y)

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

print(n*800-(n //15*200))

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

x = N * 800
y = int(N/15) * 200

print(x-y)

Solution (Python):
n = int(input())
print(n*800-n//15*200)

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

print(n * 800 - n//15 * 200)

Solution (Python):
def main():
    from sys import stdin, setrecursionlimit
    
    n = int(stdin.readline()[:-1])   
    
    
    
    
    
    
    
    
    
    
    

    print(800*n-(n//15)*200)

if __name__ == '__main__':
    main()

Solution (Python):
n = int(input())
print(n*800-(n//15*200))

Solution (Python):
n=int(input())
x=800*n
y=200*(n//15)
print(x-y)

Solution (Python):
n = int(input())
print(800 * n - 200 * (n // 15))

Solution (Python):
n=int(input())
p=int(n/15)

print(int(n*800-p*200))

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

print(N*800-N//15*200)

Solution (Python):
n = int(input())
x = n * 800
y = (n//15) * 200
print(x-y)

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

s = int(800 * n - 200 * (n//15))

print(s)

Solution (Python):
import math
N = int(input())
print(N * 800 - math.floor(N / 15) * 200)

Solution (Python):
import math
N = int(input())
sets = math.floor(N / 15)
discount = sets * 200
cost = N * 800 - discount
print(cost)

Solution (Python):
a=int(input())
b=a//15
c=a*800-b*200
print(c)

Solution (Python):
a=int(input())      
b=a//15
c=a*800-b*200
print(c)

Solution (Python):
n = int(input())
x = n*800
y = int(n/15)*200
print(x-y)

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

print(800*n-200*(n//15))

Solution (Python):
n = int(input())
k = n//15
res = 800*n - 200*k

print(res)

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


















print(n*800-n//15*200)

Solution (Python):
import math
n=int(input())
ans=n*800-(n//15)*200
print(ans)