Problem:
 Score : 100 points    Problem Statement Find the number of ways to choose a pair of an even number and an odd number from the positive integers between 1 and K (inclusive). The order does not matter.      Constraints  2\leq K\leq 100  K is an integer.         Input Input is given from Standard Input in the following format:  K       Output Print the number of ways to choose a pair of an even number and an odd number from the positive integers between 1 and K (inclusive).        Sample Input 1 3      Sample Output 1 2  Two pairs can be chosen: (2,1) and (2,3) .       Sample Input 2 6      Sample Output 2 9       Sample Input 3 11      Sample Output 3 30       Sample Input 4 50      Sample Output 4 625

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
DP2 = lambda d1, d2: [[INIT_VAL]*d2 for _ in range(d1)]
DP3 = lambda d1, d2, d3: [[[INIT_VAL]*d3 for _ in range(d2)] for _ in range(d1)]

def main():
    k = II()
    print((-(-k//2))*(k//2))
    
        
    
        

if __name__ == '__main__':
    main()

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
DP2 = lambda d1, d2: [[INIT_VAL]*d2 for _ in range(d1)]
DP3 = lambda d1, d2, d3: [[[INIT_VAL]*d3 for _ in range(d2)] for _ in range(d1)]

def main():
    k = II()
    if k%2==0:
        print((k//2)**2)
    else:
        print(((k+1)//2)*(k//2))

if __name__ == '__main__':
    main()

Solution (Python):
k=int(input());print((k//2)**2+(k%2)*(k//2))

Solution (Python):
k=int(input());print((k//2)**2 if k%2==0 else ((k-1)//2)**2+k//2)

Solution (Python):
N = int(input())
 
if N % 2 == 0:
  print(int((N/2)**2))
  
else:
  print(int((N // 2)*((N // 2) + 1)))

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

odd = (k+1)//2
even = k // 2
ans = odd * even
print(ans)

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

if K%2 == 0:
  print( (K//2) ** 2 )
else:
  print( ( (K+1) // 2) * (K//2) )

Solution (Python):
K = int(input())
if K%2 == 0:
  A = K//2
  B = K//2

else:
  A = K//2
  B = K//2 + 1
  
print(int(A*B))

Solution (Python):
k=int(input())
k1=k//2
k2=k-k1
print(k1*k2)

Solution (Python):
K = int(input())
print(K // 2 * (K - K // 2))

Solution (Python):
import math
a=int(input())/2
print(math.floor(a)*math.ceil(a))

Solution (Python):
n=int(input())
e=0
o=0
for i in range(1,n+1):
  if i%2==0:
    e+=1
  else:
    o+=1
print(e*o)

Solution (Python):
K = int(input())
print((K//2)*(K-K//2))

Solution (Python):
n=int(input())
if n%2==0:
  print('{:.0f}'.format((n/2)**2))
else:
  print('{:.0f}'.format((n+1)/2*(n-1)/2))

Solution (Python):
import sys

def main(lines):
  N = int(lines[0])
  print(N // 2*(N - N // 2))

if __name__ == '__main__':
    lines = []
    for l in sys.stdin:
        lines.append(l.rstrip('\r\n'))
    main(lines)

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

Solution (Python):
K = int(input())
L = K // 2
print(L*(K-L))

Solution (Python):
n = int(input())
odd = int(n/2 + 0.5)
even = n//2
print(odd*even)

Solution (Python):
K = int(input())
print((K//2)*(K-(K//2)))

Solution (Python):
icase=0
if icase==0:
    k=int(input())
    k2=k//2
    print(k2*(k-k2))

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

if k % 2 == 0:
    print((k//2)**2)
else:
    print((k//2) * (k//2 + 1))

Solution (Python):
import math
import collections
import sys


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

k=I()
ans=(k//2)*(k-k//2)
print(ans)

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

if k%2 == 1:
    print((k//2)*(k-k//2))
else:
    print((k//2)**2)

Solution (Python):
a = int(input())
if a % 2 == 0:
  print((a//2)*(a//2))
else:
  print((a//2)*((a+1)//2))

Solution (Python):
k = int(input())
if k % 2 == 0:
    print((k // 2) ** 2)
else:
    print(k // 2 * (k // 2 + 1))

Solution (Python):
import math
n=int(input())
print(math.ceil(n/2)*(n//2))

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

even = k//2
odd = k - even
print(odd*even)

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

if a%2 == 1:
    print((a//2+1)*(a//2))
else:
    print((a//2)*(a//2))

Solution (Python):

k = int(input())

if k % 2 == 1:
    a = int(k // 2)
    b = int(k // 2) + 1
    print(a*b)

else:
    a = b =  int(k // 2)
    print(a*b)

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

if k % 2 == 0:
    print(int((k/2)**2))
else:
    print((k//2) * (k//2+1))

Solution (Python):
k=int(input())
p=k//2
if k%2==0:
    print(p**2)
else:
    print(p*(p+1))

Solution (Python):
from math import floor, ceil

n = int(input())
a = n // 2
b = n - a
print(a * b)

Solution (Python):
k=int(input())
print(int(k/2)*int((k+1)/2))

Solution (Python):
def solve():

    K = int(input())
    print(K//2*(K//2+K % 2))


if __name__ == "__main__":
    solve()

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

even = K // 2
odd = K - even

print(even*odd)

Solution (Python):
N = int(input())
print((N//2)*((N-1)//2+1))

Solution (Python):
K=int(input())
if K%2==0:
    print((K//2)**2)
if K%2!=0:
    print(((K-1)//2)*((K+1)//2))

Solution (Python):
k = int(input())
if k%2==0:
    print(k*k//4)
else :
    print((k//2)*(k//2+1))

Solution (Python):
k = int(input())
if k%2==0:
    k = (k/2)*(k/2)
    k = int(k)
    print(k)
else:
    k = (k/2)
    k = int(k)
    k1 = k+1
    k2 = k* k1
    k2 = int(k2)
    print(k2)

Solution (Python):
K = int(input())
print(int((K/2)**2) if K%2==0 else int(((K+1)/2)*((K-1)/2)))

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

guu = k//2

if k%2 == 0:
    ki = k//2
else:
    ki = k//2+1

print(guu*ki)

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

if n%2==0:
  print(int((n/2)*(n/2)))
  
else:
  print(int((n/2+0.5)*(n/2-0.5)))

Solution (Python):
k = int(input())
q_even = k/2 if k%2 == 0 else int(k/2)
q_odd = k/2 if k%2 == 0 else int(k/2)+1
print(int(q_odd*q_even))

Solution (Python):
import itertools
a = int(input())
e = range(1, a + 1, 1)
b = list(itertools.combinations(e, 2))
for i, item in enumerate(b):
    if sum(x % 2 == 0 for x in item) != 1:
        del b[i]
    elif sum(x % 2 != 0 for x in item) != 1:
        del b[i]
print(len(b))

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

par = []
impar = []
for n in range(num):
    if(n%2==0):
        par.append(n)
    else:
        impar.append(n)

print(len(par)*len(impar))

Solution (Python):
import math
def combina(k,p):
    return math.factorial(k)/(math.factorial(k-p)*math.factorial(p))

k = int(input())

if k%2==0:
    print(int((k/2)**2))
else:
    print(int(int(k/2)*((k+1)/2)))

Solution (Python):
k = int(input())
temp = k**2
out = int(temp/4)
print(out)

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

y = x // 2
z = (x - y) * y
print(z)

Solution (Python):
nim = int(input())
print((nim // 2) * ((nim + 1) // 2))

Solution (Python):
def main():
    k = int(input())
    if k % 2 == 0:
        np = k/2
        ni = k/2
        res = np*ni
        print(int(res))
    else:
        np = k//2
        ni = k//2 + 1
        res = np*ni
        print(res)
main()

Solution (Python):
k = int(input())
cont_even = 0
cont_odd = 0
for _ in range(2, k+1, 2):
    cont_even += 1
for _ in range(1, k+1, 2):
    cont_odd += 1
print(cont_even * cont_odd)

Solution (Python):
numero = int(input())
contador = 0
for x in range(1, numero+1):
    for y in range(x, numero+1):
        if(x + y) % 2 == 1:
            contador += 1
print(contador)

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

even = n//2

odd = n-even

print(even*odd)

Solution (Python):
line = input()
num = [int(n) for n in line.split()]
num = num[0]
if num%2 == 0:
    value = round(num/2)**2
else:
    value = round(num/2) * (round(num/2)-1)
print(value)

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

if (N % 2 == 0):
	print(int((N/2)*(N/2)))
else:
	par=int(N/2)
	impar=N-par
	print(int(par*impar))

Solution (Python):
n = int(input())
pares=0
for i in range(1, n):
    for j in range(0, n-i):
        if((i%2==0 and (n-j)%2!=0) or (i%2!=0 and (n-j)%2==0)):
            pares+=1
print(pares)

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

print(K//2*(K-K//2))

Solution (Python):
def main():
  k = int(input())
  
  
  
  
  
  
  
  ans = 0
  count = 0
  lis = []
  
  print((k//2)*((k+1)//2))
  
if __name__ == '__main__':
  main()

Solution (Python):
K=int(input())
if K%2==0:
    print((K//2)**2)
else:
    print((K//2)*(K//2+1))

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

if k % 2 != 0:
    P = (k // 2) * ((k // 2) + 1)
    print(P)
else:
    P = (k // 2)**2
    print(P)

Solution (Python):
k=int(input())
if k%2==0:
    print((k//2)**2)
else:
    print((k//2)*(k//2+1))

Solution (Python):
k=int(input())
if k%2==0:
    print((k//2)**2)
else:
    print((k//2)*(k//2+1))

Solution (Python):
import math

n = int(input())

print(math.floor(n/2) * math.ceil(n/2))

Solution (Python):
a = int(input())
print((a//2) * ((a+1)//2))

Solution (Python):
k=int(input())
if k%2==0:print(int(k**2/4))
else:print(int(k/2)*(int(k/2)+1))

Solution (Python):
K = int(input())
print(K//2 * (K - K//2))

Solution (Python):
K = int(input())
print((K // 2) * ((K + 1) // 2))

Solution (Python):
K = int(input())
print((K//2)*((K+1)//2))

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

if k%2==0:
    print((k//2)**2)
else:
    print((k//2)*(k//2+1))

Solution (Python):
k=int(input())/2
print(int(k ** 2))

Solution (Python):
r, q = divmod(int(input()), 2)
print((r + q) * r)

Solution (Python):
def Pair(k):

    return int((k / 2)**2) if k % 2 == 0 else int((k // 2) * (k // 2 + 1))

def main():
    k = int(input())
    print(Pair(k))

if __name__ == '__main__':
    main()

Solution (Python):
k = int(input())
print(k // 2 * -(-k // 2))

Solution (Python):
s = int(input())
if s%2 == 0:
    print((s//2)**2)
else:
    print((s//2)*(s//2+1))

Solution (Python):

K = int(input())
if K % 2 == 1:
    print(K//2 * (K//2+1))
else:
    print(K//2 * K//2)

Solution (Python):
K = int(input())
print((K-(K//2))*(K//2))

Solution (Python):
k = int(input())
print(k // 2 * (k - k // 2))

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

if K%2==0:
  print(int(K**2/4))
else:
  print(int((K+1)*(K-1)/4))

Solution (Python):

from collections import Counter
def inputlist(): return [int(j) for j in input().split()]

K = int(input())
if K % 2 == 0:
    d = K//2
    print(d**2)
    exit()
else:
    da = (K+1)//2
    db = (K-1)//2
    print(da*db)

Solution (Python):
k=int(input())
k2=k//2
print(k2*(k-k2))

Solution (Python):
import math
k = int(input())

if k % 2 == 0:
  gusu, kisu = k / 2, k / 2
else:
  gusu, kisu = math.floor(k / 2), math.ceil(k / 2)

print(int(gusu*kisu))

Solution (Python):
def main():
    n = int(input())
    if n % 2 == 0:
        print(n//2*n//2)
    else:
        print((n-1)//2*(n-((n-1)//2)))

if __name__ == '__main__':
    main()

Solution (Python):


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

k = I()
a = k // 2
b = (k-1) // 2 + 1
ans = a*b
print(ans)

Solution (Python):
a=int(input())
even_num = 0
odd_num = 0
if a %2==0:
    even_num += a/2
    odd_num +=a/2
else:
    even_num +=(a+1)/2 - 1
    odd_num +=(a+1)/2
print(int(even_num*odd_num))

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

print((K // 2) * ((K+1) // 2))

Solution (Python):
K = int(input())
if K%2 ==0:
    print(int((K/2)*(K/2)))
else:
    print(int(((K-1)/2)*((K+1)/2)))

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


if k%2 ==0:
    print(int((k/2)*(k/2)))
else:
    print(int(((k-1)/2)*((k+1)/2)))

Solution (Python):
from collections import deque
from collections import Counter
from itertools import product, permutations,combinations
from operator import itemgetter
from heapq import heappop, heappush
from bisect import bisect_left, bisect_right, bisect




from fractions import gcd
from math import ceil,floor, sqrt, cos, sin, pi, factorial
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**8)
INF = float('inf')
from datetime import datetime as dt

def main():
  k = int(input())
  if k%2==0:
    print((k//2)**2)
  else:
    print((k//2)*(k//2+1))
  
  
  
if __name__ == '__main__':
  main()

Solution (Python):
k = int(input())
print((k//2)*(k-(k//2)))

Solution (Python):
K=int(input())
if K%2==0:
    print((K//2)*(K//2))
else:
    print((K//2)*(K//2+1))

Solution (Python):
K=int(input())
print((K//2)*((K+1)//2))

Solution (Python):

k = int(input())
print((k // 2) ** 2 if k % 2 == 0 else (k // 2) * (k // 2 + 1))

Solution (Python):
K=int(input())
if(K%2==0):
    num=(K/2)**2
else:
    num=(K-1)/2*(((K-1)/2)+1)
print(int(num))

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

if n%2 == 0:
  print((n//2)*(n//2))
else:
  print((n//2)*(n//2+1))

Solution (Python):
def count_odd_even(N):
    n = N//2
    m = N%2
    c_odd = n+m
    c_even= n
    return c_odd, c_even

N = int(input())
odd, even = count_odd_even(N)
print(odd*even)

Solution (Python):
k = int(input())
if k % 2 != 0:
    print(((k+1)//2)*((k-1)//2))
else:
    print(int((k/2)**2))

Solution (Python):
import sys

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

def main():
    x = k // 2
    y = k - x
    print(x * y)

if __name__ ==  '__main__':
    main()

Solution (Python):
import math
K = int(input())
even = K//2
odd = math.ceil(K/2)
print(even*odd)

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

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

if __name__ == '__main__':
    a = [int(i) for i in input().split()]

    if a[0] %2 ==1:
        print((a[0]//2)*(a[0]//2+1))
    else:
        print((a[0]//2)*(a[0]//2))

Solution (Python):
N = int(input())
if N%2 == 1:
    ans = (N//2)*(N//2 + 1)
    print(ans)
else:
    ans = (N//2)**2
    print(ans)

Solution (Python):
k=int(input())
if k%2==0:
    print((k//2)**2)
else:
    print((k//2)*((k//2)+1))

Solution (Python):
K = int(input())
num_even = K // 2
num_odd = K - num_even
print(num_even * num_odd)

Solution (Python):
k = int(input())
if k&1:
  print(k//2 * (k//2 + 1))
else:
  print((k//2)**2)

Solution (Python):
k = int(input())
l = k // 2
m = (k + 1) // 2
print(l * m)

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

res = 0
for i in range(1, K + 1):
    for j in range(i + 1, K + 1):
        if i % 2 == 1:
            if j % 2 == 0:
                res += 1
        else:
            if j % 2 == 1:
                res += 1

print(res)

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))

k = ii()
even = k//2
if k%2 == 0:
    odd = k//2
else:
    odd = k//2+1

print(even*odd)

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

if K % 2 == 0:
	answer = (K/2) * (K/2)
else:
	answer = (K//2) * ((K//2) + 1) 
print(int(answer))

Solution (Python):

K = int(input())

if K % 2 == 0:
    ans = K // 2 * K // 2
else:
    ans = (K + 1) // 2 * (K - 1) // 2
print(ans)

Solution (Python):
K=int(input())
print((K+1)//2*(K//2))

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

o_, e_ = 0,0

for i in range(1,n + 1):
	if i % 2 == 0:
		e_ += 1
	else:
		o_ += 1
print(e_ * o_)

Solution (Python):
k=int(input())
l=k//2
if k%2==0:print(l*l)
else:print((l+1)*l)

Solution (Python):
k = int(input())
e = k // 2
o = k - e
print(e * o)

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

print( (K//2)*(K - (K//2)))

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

if K%2 == 1:
    ans = ((K+1)//2) * (K//2)
    print(ans)
else:
    ans = (K//2)**2
    print(ans)

Solution (Python):
k=int(input())
if (k%2==0):
  print((k//2)**2)
else:
  print((k//2)*(k//2+1))

Solution (Python):
N = int(input())
if N % 2 == 0:
  print(N//2 * N//2)
else:
  print(N//2 * (N+1)//2)

Solution (Python):
a = int(input())
print((a//2) * ((a+1)//2))

Solution (Python):
K=int(input())
print(int((K/2)**2) if K%2==0 else int(K/2)*(int(K/2)+1))

Solution (Python):

n = int(input())
print(n // 2 * (n - n // 2))

Solution (Python):
K=int(input());print(-(-K//2)*(K//2))

Solution (Python):
K = int(input())
if K%2==1:
  print(int(K//2*(K//2+1)))
else:
  print(int(K//2*K//2))

Solution (Python):
K=int(input())
import math
X=math.ceil(K/2)
print(X*(K-X))

Solution (Python):
K = int(input())
print(K // 2 * ((K + 1) // 2))

Solution (Python):
import math
K = int(input())
a = K // 2
b = math.ceil(K / 2)
print(a * b)

Solution (Python):
k=int(input())
print(k//2*k//2 if k%2==0 else (k//2+1)*(k//2))

Solution (Python):
k = int(input())+1
ans = 0
for i in range(1,k):
    for j in range(i+1,k):
        if i%2==0: ans += 1 if j%2!=0 else 0
        else: ans += 0 if j%2!=0 else 1
print(ans)

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

if k % 2 == 0:
    print((k//2)**2)
else:
    print((k+1)//2*(k//2))

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

even = K//2
odd = K-even

print(even*odd)

Solution (Python):
k=int(input())
if k%2==0:
    print(int((k/2)**2))
else:
    print(int((k//2)*(k//2+1)))

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

if k%2 == 1:
    n = (k//2)*(k//2 + 1)
else:
    n = (k//2)*(k//2)
print(n)

Solution (Python):
n=int(input())
print(n//2*((n+1)//2))

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

odd = (k + 1) // 2
even = k // 2

print(odd * even)

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

if K%2 != 0:
    print((K//2) * (K//2+1))
else:
    print(K//2 * K//2)

Solution (Python):
K = int(input())
print((K//2)*((K+1)//2))

Solution (Python):
k = int(input())
print((k//2) * ((k+1)//2))

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

print(n//2 * (n//2+n%2))

Solution (Python):
n = int(input())
if n % 2 == 0:
  ans = (n // 2) ** 2
else:
  ans = ((n // 2)+ 1) * (n // 2)
print(ans)

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

if k % 2 == 0:
    print(int((k / 2) ** 2))
else:
    print(int(((k - 1) / 2) * (((k - 1) /  2) + 1)))

Solution (Python):
k = int(input())
print((k//2) * ((k+1)//2))

Solution (Python):
from itertools import combinations as comb


def main():
    k = int(input())
    pairs = list(comb(range(1, k+1), 2))

    ans = 0
    for pair in pairs:
        if pair[0] % 2 == 0 and pair[1] % 2 != 0:
            ans += 1
        elif pair[0] % 2 != 0 and pair[1] % 2 == 0:
            ans += 1
    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
k = int(input())
if k%2 == 0:
    print((k//2)**2)
else:
    print(((k+1)//2)*(k//2))

Solution (Python):
k = int(input())
num = k // 2
if k % 2 == 1:
  print(num * (num + 1))
else:
  print(num * num)

Solution (Python):

import math
a = int (input())
print(a // 2 * math . ceil(a / 2))

Solution (Python):
k = int(input())
e = k // 2
o = k - e
print(e * o)

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

numO = K//2
numE = (K+1)//2

print(numO*numE)

Solution (Python):
n = int(input())
print((n//2)*((n+1)//2))

Solution (Python):
K=int(input())
print((K//2)*(K//2+K%2))

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

if k % 2 == 0:
    print((k // 2) ** 2)
else:
    print((k // 2) * (k // 2 + 1))

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

ans=0
for i in range(k):
    for j in range(k):
        if (i%2==0 and j%2==1) or (i%2==1 and j%2==0):
            ans+=1
print(ans//2)

Solution (Python):
a = int(input())
if a %2==0:
  print((a//2)**2)
else:
  print((a//2)*(a//2+1))

Solution (Python):

k=int(input())
ans=0
for i in range(1,k+1):
    for j in range(1,k+1):
        if i%2==0 and j%2==1:
            ans+=1
print(ans)

Solution (Python):
k=int(input())
print((k//2)*(k-(k//2)))

Solution (Python):
def isneg(x):
    if x[0]=="-": return True
    else: return False


def neg(x):
    if isneg(x): return x[1:]
    else: return "-" + x

    
def zerot(x):
    rx = list(x[::-1])
    while rx[-1] == "0":
        rx.pop()
        if len(rx) == 0: 
            rx = ["0"]
            break
    return "".join(rx[::-1])


def zerocut(x):
    if isneg(x):
        ans = neg(zerot(neg(x)))
        if ans == "-0": return "0"
        return ans 
    else:
        return zerot(x)


def bigsmal(x, y):
    if isneg(x) or isneg(y): raise Exception("negative input")
    if len(x) > len(y):
        return x,y
    elif len(x) < len(y):
        return y,x
    else: return tuple(sorted([x, y])[::-1])
    
    
def bigsmall(x, y):
    if (not isneg(x)) and isneg(y):
        return x,y
    elif isneg(x) and (not isneg(y)):
        return y,x
    elif (not isneg(x)) and (not isneg(y)):
        return bigsmal(x, y)
    elif isneg(x) and isneg(y):
        tmp = bigsmal(neg(x), neg(y))[::-1]
        return tuple(neg(i) for i in tmp)
        
    
def ad(x, y):
    if isneg(x) or isneg(y): raise Exception("negative input")
    ra = [0] * (max(len(x), len(y)) + 1)
    rx = [int(i) for i in x][::-1]
    ry = [int(i) for i in y][::-1]
    for i in range(len(rx)): ra[i] += rx[i]
    for i in range(len(ry)): ra[i] += ry[i]
    for i in range(len(ra) - 1):
        ra[i+1] += ra[i] // 10
        ra[i] = ra[i] % 10
    ans = "".join([str(i) for i in ra][::-1])
    return zerocut(ans)


def s_b(x, y):
    if isneg(x) or isneg(y): raise Exception("negative input")
    if bigsmall(x, y) != (x, y): raise Exception("not x>=y error")
    ra = [0] * (max(len(x), len(y)))
    rx = [int(i) for i in x][::-1]
    ry = [int(i) for i in y][::-1]
    for i in range(len(rx)): ra[i] += rx[i]
    for i in range(len(ry)): ra[i] -= ry[i]
    for i in range(len(ra) - 1):
        if ra[i] < 0:
            ra[i] = 10 + ra[i]
            ra[i+1] -= 1
    ans = "".join([str(i) for i in ra][::-1])    
    return zerocut(ans)


def sb(x, y):
    if isneg(x) or isneg(y): raise Exception("negative input")
    if (x, y) == bigsmall(x, y):
        return s_b(x, y)
    else:
        return neg(s_b(y, x))


def add(x, y):
    if isneg(x) and isneg(y):
        return neg(ad(neg(x), neg(y)))
    elif (not isneg(x)) and (not isneg(y)):
        return ad(x, y)
    elif (not isneg(x)) and isneg(y):
        return sb(x, neg(y))
    elif isneg(x) and (not isneg(y)):
        return sb(y, neg(x))
    

def sub(x, y):
    if isneg(x) and isneg(y):
        return sb(neg(y), neg(x))
    elif (not isneg(x)) and (not isneg(y)):
        return sb(x, y)
    elif (not isneg(x)) and isneg(y):
        return ad(x, neg(y))
    elif isneg(x) and (not isneg(y)):
        return neg(ad(neg(x), y))
        

def ml(x, y):
    if isneg(x) or isneg(y): raise Exception("negative input")
    ra = [0] * (len(x) + len(y))
    rx = [int(i) for i in x][::-1]
    ry = [int(i) for i in y][::-1]
    for i in range(len(rx)):
        for j in range(len(ry)):
            ra[i+j] += rx[i] * ry[j]
    for i in range(len(ra) - 1):
        ra[i+1] += ra[i] // 10
        ra[i] = ra[i] % 10
    ans = "".join([str(i) for i in ra][::-1])
    return zerocut(ans)
    

def mul(x, y):
    if isneg(x) and isneg(y):
        return ml(neg(y), neg(x))
    elif (not isneg(x)) and (not isneg(y)):
        return ml(x, y)
    elif (not isneg(x)) and isneg(y):
        return neg(ml(x, neg(y)))
    elif isneg(x) and (not isneg(y)):
        return neg(ml(neg(x), y))
        

def mod2(x):
    return int(x[-1]) % 2


def div2(x):
    if isneg(x): raise Exception("negative input")
    ans = [0] * len(x)
    xs = [int(i) for i in x]
    for i in range(len(x)-1):
        ans[i] += xs[i]
        ans[i+1] += (ans[i]%2) * 10
        ans[i] //= 2
    ans[len(x)-1] = (ans[len(x)-1] + xs[len(x)-1])//2
    ans = "".join([str(i) for i in ans])
    return zerocut(ans)


n = input()
even = div2(n)
odd = sub(n, even)
print(mul(even, odd))

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

a = k // 2
b = k // 2 if k % 2 == 0 else k // 2 + 1
print(a * b)

Solution (Python):
k = int(input())
t = (k/2)**2

if k % 2 == 0:
    print(round(t))
else:
    print(round(t))

Solution (Python):
import sys
import os


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

    K = int(sys.stdin.readline().rstrip())
    e = K // 2
    o = K // 2 if K % 2 == 0 else K // 2 + 1
    print(e * o)


if __name__ == '__main__':
    main()

Solution (Python):
K = int(input())
print(K // 2 * (K - K // 2))

Solution (Python):
k = int(input())
if k%2 == 0:
    print((k//2)**2)
else:
    print((k//2)*(k//2+1))

Solution (Python):
k=int(input())
print((k//2 )* ((k+1)//2))

Solution (Python):

k=int(input())
even=[]
odd=[]
for i in range(1,k+1):
    if (i%2==0):
        even.append(i)
    else:
        odd.append(i)

print(len(even)*len(odd))

Solution (Python):
K=int(input())
if K%2==0:
  e=K//2
  o=K//2
else:
  e=K//2
  o=K//2+1
print(e*o)

Solution (Python):
import numpy as np
import fractions

a=int(input())

print(a//2*((a+1)//2))

Solution (Python):
n = int(input())
if n%2 ==0:
  print(int((n/2)**2))
else:
  print(int((n//2)*((n+1)/2)))

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

Solution (Python):

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

print((N // 2) * ((N + 1) // 2))

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

def main():
    K = int(input())
    k2 = K // 2
    if K % 2 == 1:
        print(k2 * (k2 + 1))
    else:
        print(k2 ** 2)

if __name__ == '__main__':
    main()

Solution (Python):
k=int(input())
if k%2==0:
    print((k//2)**2)
else:
    print((k//2+1)*(k//2))

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

even = n//2

odds = (n+1)//2

print(even * odds)

Solution (Python):
n = int(input())
if n % 2 != 0:
    print(n // 2 * (n // 2 + 1))
else:
    print((n // 2) ** 2)

Solution (Python):
n=int(input())
o=int(n/2)
e=int((n+1)/2)
print(o*e)

Solution (Python):


K = int(input())
odd_list = []
even_list = []

for k in range(1, K+1):
    if k%2==0:
        even_list.append(k)
    else:
        odd_list.append(k)

print(len(odd_list)*len(even_list))

Solution (Python):
n = int(input())
ans = (n // 2) * ((n - 1) // 2 + 1)
print(ans)

Solution (Python):
k = int(input())
print((k//2) * ((k+1)//2))

Solution (Python):
K=int(input())
if K%2==0:
	print((K//2)**2)
else:
	print(K//2*((K//2)+1))

Solution (Python):
k = int(input())
if k%2 == 0:
    print((k//2)**2)
else:
    print(((k+1)//2)*(k//2))

Solution (Python):

K = int(input())
if K % 2 == 0:
    print(int(K/2*K/2))
else:
    print(int((K//2+1)*int(K//2)))

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

E = K // 2

if K % 2 == 0:
  O = E
else:
  O = K // 2 +1

print(E * O)

Solution (Python):




k = int(input())


if k % 2 == 0:
    ans = (k // 2) ** 2
else:
    ans = (k // 2) * ((k // 2) + 1)


print(ans)

Solution (Python):
import itertools
k = int(input())
cnt = 0
lists = list(range(1,k+1))
for i,j in itertools.combinations(lists,2):
    if i % 2 == 1:
        if j % 2 == 0:
            cnt += 1
    elif i % 2 == 0:
        if j % 2 == 1:
            cnt += 1

print(cnt)

Solution (Python):


k = int(input())

even = int(k/2)

odd = even

if k % 2 != 0:
    odd += 1

print(even*odd)

Solution (Python):
K = int(input())
print(((K+1)//2)*(K//2))

Solution (Python):
K=int(input())
print(K//2*(K-K//2))

Solution (Python):

k = int(input())

if k % 2 != 0:
    ans = (k // 2) * (k // 2 + 1)
else:
    ans = (k // 2) ** 2
print(ans)

Solution (Python):
K = int(input())
even = K//2
odd = (K+1)//2
print(even*odd)

Solution (Python):
import math
k = int(input())
even = k // 2
odd = k - even
print(even * odd)

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

from math import ceil

print(ceil(K/2) * ceil((K-1)/2))

Solution (Python):
def main():
    N = int(input())
    odd = (N+1)//2
    even = N//2
    print(odd*even)


if __name__ == '__main__':
    main()

Solution (Python):
import sys
input = sys.stdin.readline
N = int(input())
print((N // 2) * -(-N // 2))

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

print(K//2 * (K//2 + K % 2))

Solution (Python):
K=int(input())
print(K//2*(K-K//2))

Solution (Python):
K = int(input())
print((K//2)*(-(-K//2)))

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

if n%2 == 1:
  print((n//2) * (n//2+1))
else:
  print((n//2) * (n//2))

Solution (Python):
a=int(input())
print(a//2*(-(-a//2)))

Solution (Python):
k = int(input())
print(k//2*(k-k//2))

Solution (Python):
k=int(input())
even=0
odd=0
for i in range(1,k+1):
    if i%2==0:
        even+=1
    else:
        odd+=1
print(even*odd)

Solution (Python):
from math import ceil
k=int(input())
print((k-ceil(k/2))*ceil(k/2))

Solution (Python):
K=int(input())
if K%2==0:
	print((K//2)**2)
else:
	print(K//2*((K//2)+1))

Solution (Python):
K = int(input())
if K % 2==0:
    ans = (K//2) * (K//2)
else:
    ans = (K//2+1) * (K//2)
print(ans)

Solution (Python):
k = int(input())
even = k//2
odd = k-even
ans = even*odd
print(ans)

Solution (Python):
k = int(input())
if k % 2==0:
    print((k//2)*(k//2))
else:
    val1 = k//2
    val2 = k//2 + 1
    print(val1*val2)

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

print((k//2) ** 2 if k % 2 == 0 else ((k//2)+1) * (k//2))

Solution (Python):
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

K = ir()
odd = (K+1) // 2
even = K // 2
print(odd * even)

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

if k % 2 == 0:
  print(k // 2 * k // 2)
else:
  print(k // 2 * (k//2 + 1))

Solution (Python):
n = int(input())
l = [i for i in range(1, n+1)]
print(len(l[::2]) * len(l[1::2]))

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

even = k // 2
odd = k - even
print(even * odd)

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

gu = []

ki = []

for i in range(1,n+1):
    if i%2==1:
        gu.append(i)
    else:
        ki.append(i)

print(len(gu)*len(ki))

Solution (Python):
k=int(input())
if k%2==0:
  print((k//2)**2)
else:
  print((k+1)*(k-1)//4)

Solution (Python):
k = int(input())
if k%2==0:
    print((k//2)**2)
else:
    print((k//2)*(k//2+1))

Solution (Python):
K = int(input())
print(K//2 * ((K+1)//2))

Solution (Python):
n=int(input())
even=n//2
odd=n-even
print(even*odd)

Solution (Python):
k = int(input())
a=k//2
b=k//2+k%2
print(a*b)

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

if k%2 == 0:
    print(int((k**2)/4))

else:
    print(((k//2)*int(k//2+1)))

Solution (Python):
n = int(input())
q, r = divmod(n, 2)
print(q*(q+r))

Solution (Python):
k = int(input())
a = k//2
b = k//2 + k%2
print(a*b)

Solution (Python):


K = int(input().strip())

print( (K//2) * ((K+1)//2) )

Solution (Python):
import math
def comb(n, r):
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

n = int(input())

if n%2 == 0:
    print(comb(n//2, 1)**2)
elif n%2 == 1:
    print(comb(n//2+1, 1)*comb(n//2, 1))

Solution (Python):
N = int(input())
if N % 2 == 0:
    answer = (N // 2)**2
else:
    answer = (N // 2) * (N // 2 + 1) 

print(answer)

Solution (Python):
K = int(input())
even = K//2
odd = (K+1)//2
print(even*odd)

Solution (Python):
K = int(input())
even = K // 2
odd = (K+1) // 2
print(even * odd)

Solution (Python):
N=int(input())
if N%2==1:
    print((N//2+1)*(N//2))
else:
    print((N//2)**2)

Solution (Python):
import sys

input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]

IN=lambda : map(int, input().split())
mod=1000000007



def main():
	a = int(input())
	even=a//2
	odd=(a+1)//2

	print(even*odd)
	
	

isTest=False

def pa(v):
	if isTest:
		print(v)
		
def input_clipboard():
	import clipboard
	input_text=clipboard.get()
	input_l=input_text.splitlines()
	for l in input_l:
		yield l

if __name__ == "__main__":
	if sys.platform =='ios':
		if input_method==input_methods[0]:
			ic=input_clipboard()
			input = lambda : ic.__next__()
		elif input_method==input_methods[1]:
			sys.stdin=open('inputFile.txt')
		else:
			pass
		isTest=True
	else:
		pass
		
			
	ret = main()
	if ret is not None:
		print(ret)