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

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

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

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

if __name__ == "__main__":
    main()

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

Solution (Python):
K = int(input())
a = 0
b = 0
for i in range(1,K+1):
    if i % 2 == 0:
        a += 1
    else:
        b += 1
print(int(a * b))

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

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

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

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())
e = n//2
o = n-e
print(e*o)

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

sum_even = 0
sum_odd = 0
for i in range(K):
    if (i+1) % 2 == 0:
        sum_even += 1
    else :
        sum_odd += 1

print(sum_even*sum_odd)

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

Solution (Python):

"""
A - Pair
https://atcoder.jp/contests/abc108/tasks/abc108_a

"""
import sys


def solve(K):
    even = K // 2
    odd = (K+1) // 2
    return even * odd


def main(args):
    K = int(input())
    ans = solve(K)
    print(ans)


if __name__ == '__main__':
    main(sys.argv[1:])

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

even = k//2
odd = k - k// 2

print(even*odd)

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

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

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

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

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

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

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

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

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

A = int(K/2)
B = K -A

print(A*B)

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

Solution (Python):

K = int(input())

even = K // 2
odd = K - even
print(int(even * odd))

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

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

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

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

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

Solution (Python):
n=int(input())
x=list(range(1,n+1))
A=[]
aa=0
for i in x:
  for j in x:
    if i%2==0 and j%2!=0:
      A.append([i,j])
      aa+=1
print(aa)

Solution (Python):
import sys


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








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

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())
print((n - n // 2) * (n // 2))

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

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

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

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

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

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

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

odd = K//2
even = K - odd

print(odd * even)

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

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

Solution (Python):

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

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(int((k/2)**2))

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

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

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

Solution (Python):
import math

k = int(input())

print(int(k/2) * math.ceil(k/2))

Solution (Python):


from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


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


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    if y > x // 2:
        y = x - y

    ret = 1

    for i in range(0, y):
        j = x - i
        i = i + 1

        ret = ret * j
        ret = ret // i

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance





def main():
    k = intin()

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

    print(odd * even)


if __name__ == '__main__':
    main()

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

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

Solution (Python):
k = int(input())
num_odds = (k - 1) // 2 + 1
num_evens = k // 2

print(num_odds * num_evens)

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

a = int((k+1)/2)
b = int(k/2)

print(a*b)

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

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

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

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

Solution (Python):
k = int(input())
if k % 2 == 0:
    print((k//2)**2)
else:
    print((k//2+1)*(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())
odd = 0
even = 0
if k%2==0:
    odd = k//2
    even = k//2
else:
    odd = k//2+1
    even = k//2
print(odd*even)

Solution (Python):

import math

def solve():
    K = int(input())
    odd = math.ceil(K/2)
    even = math.floor(K/2)

    print(odd*even)

if __name__ == "__main__":
    solve()

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

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

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

lst = [i + 1 for i in range(k)]
odds = len(lst[0::2])
evens = len(lst[1::2])
print(odds*evens)

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

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

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

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

print(math.floor(k) * math.ceil(k))

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

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

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

Solution (Python):
k=int(input())
ls=[i for i in range(1,k+1) if i%2==0]
print(len(ls)*(k-len(ls)))

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 = int(K/2)*int(K/2)
else :
    ans = int(K/2)*(int(K/2)+1)
print(ans)

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

if (k%2) == 0:
    ans = int((k*0.5)**2)
else:
    ans = int((k*0.5-0.5) * (k*0.5+0.5))
print(ans)

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

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

even = len([x for x in range(1,K + 1) if x % 2 == 0])
odd = len([x for x in range(1,K + 1) if x % 2 != 0])

print(even * odd)

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

m=k//2

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

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

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

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

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

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

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

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

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

Solution (Python):

import sys
from math import *
from itertools import *
from collections import *
from functools import *
try:
    from math import gcd
except Exception:
    from fractions import gcd


def solve(K: int):
    return (K // 2) * (K // 2 + (K % 2))


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

if __name__ == '__main__':
    main()

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

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

k = int(input())

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

Solution (Python):
import math

K = int(input())

even = math.floor(K/2)
odd = math.ceil(K/2)

print(even*odd)

Solution (Python):
import math
a = int(input())
if a % 2 == 0:
    print(int((a/2)**2))
else :
    print(math.ceil(a/2)*(a//2))

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

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

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

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

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

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

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

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

Solution (Python):
K = int(input())
count = 0
for i in range(1, K+1):
  for j in range(i+1, K+1, 2):
    count += 1
print(count)

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

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

Solution (Python):

import re

K = int(input())

g = 0
k = 0
for i in range(1,K+1):
    if(i % 2 == 0):
        g += 1
    else:
        k += 1
print(g*k)

Solution (Python):
import bisect
from collections import Counter
def MI(): return map(int, input().split())
def II(): return int(input())
def IS(): return input()
def LI(): return list(map(int, input().split()))

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

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

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

Solution (Python):
import itertools
K = int(input())
K_list = list(range(1, K + 1))
even_list = []
odd_list = []
for i in range(K):
    if K_list[i] % 2 == 0:
        even_list.append(K_list[i])
    elif K_list[i] % 2 == 1:
        odd_list.append(K_list[i])
result = list(itertools.product(even_list, odd_list))
print(len(result))

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

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

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

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

Solution (Python):


def main():
    num = int(input())
    odd_num = (num + 1) // 2
    even_num = num // 2
    print(odd_num * even_num)


if __name__ == '__main__':
    main()

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

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

Solution (Python):
import functools
import math

import os

INF = float('inf')


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


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


def inps():
    return input()


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


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


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


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

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

    return wrapper


k = inp()
print((k // 2) * math.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:
    print(int(k/2)**2)
else:
    print(int((k//2)*(k//2+1)))

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

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

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

Solution (Python):
k=int(input())
o=0
e=0

for i in range(k):
    if (i+1)%2==1:
        o+=1
    else:
        e+=1
print(o*e)

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

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

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

Solution (Python):

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

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

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

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

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

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

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

Solution (Python):

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


def A():
    a,b,c = LI()
    print(9*max(a,b,c)+a+b+c)
    return


def B():
    a,b = LI()
    if a*b %2:
        print("Yes")
    else:
        print("No")
    return


def C():
    k = I()
    print((k//2)*(k//2+k%2))
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


def I_():
    return


def J():
    return


if __name__ == "__main__":
    C()

Solution (Python):
input = input()
list = range(1,int(input)+1)
even = []
odd = []

for fig in list:
    if fig%2 == 0:
        even.append(fig)
    elif fig%2 != 0:
        odd.append(fig)

result = len(even) * len(odd)

print(result)

Solution (Python):
n=int(input())
print(n//2*(n-n//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('{0:.0f}'.format(((k/2)*(k/2))))
else:
    print('{0:.0f}'.format((((k-1)/2)*((k-1)/2)+((k-1)/2))))

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

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

Solution (Python):


K = int(input())

gu = []
ki = []

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

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

Solution (Python):
print(int(input())**2//4)

Solution (Python):
import math
k=int(input())
print(math.floor(k*k/4))

Solution (Python):

import sys


def solve(K: int):
    ret = (K // 2) * ((K + 1) // 2)
    print(ret)
    return


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

if __name__ == '__main__':
    main()

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

Solution (Python):

import sys
import copy
import collections
from bisect import bisect_left
	
def main():
	K = int(input())
	tmp = 0
	tmp2 = K // 2
	if K % 2 == 1:
		tmp = K // 2 + 1
	else:
		tmp = K // 2
	print(tmp * tmp2)
	
if __name__ == "__main__":
	main()

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

if k % 2 == 0:
  print(round(k/2)**2)
else:
  import math
  print(math.ceil(k/2)*math.floor(k/2))

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

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

Solution (Python):

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

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

Solution (Python):
K = int(input())
gu = 0
ki = 0

for i in range(K):
    if i % 2 == 0:
        gu += 1
    else:
        ki += 1

print(ki * gu)

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

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

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

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

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

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

Solution (Python):
k=int(raw_input())
no=k/2+k%2
ne=k/2
print(no*ne)

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

Solution (Python):
import math

K = int(input())

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

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

Solution (Python):
n = int(input())
a = 0
for i in range(2, n+1, 2): a += n-i+1
print(a)

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

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


if __name__ == '__main__':
    main()

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):
import sys
K = int(input()) 

kumi = list(range(0,K+1))
l_even = [i for i in kumi if i % 2 == 0 and i != 0]
l_kisu = [i for i in kumi if i % 2 != 0]

answer = len(l_even) * len(l_kisu)

print(answer)

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):
import numpy as np
import itertools

a = int(input())

odd_list = np.arange(1, a+1, 2)
even_list = np.arange(2, a+1, 2)
count = 0
for odd, even in itertools.product(odd_list, even_list):
    
    count += 1
    
print(count)

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

odd = []
even = []
for i in range (K):
    if i%2 ==0:
        even.append(i)
    else:
        odd.append(i)
print(len(even)*len(odd))

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

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

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

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

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

a, b = K//2, K//2
if K%2 == 1:
    b += 1

print(a*b)

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

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

Solution (Python):


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

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):


K = int(input())

gu = []
ki = []

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

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

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

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

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

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

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

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

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

odd =[i for i in range(1, K + 1) if i % 2 != 0]
even =[i for i in range(1, K + 1) if i % 2 == 0]

ans = len(odd) * len(even) 
print(ans)

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

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

print((n // 2) * (n - n // 2))

Solution (Python):
print(sum([i//2 for i in range(1, int(input())+1)]))

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

ak = 0
for i in range(1, K+1):
  ak += i//2
print(ak)

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

if K%2 == 0:
  ak = K**2//4
else:
  ak = (K**2-1)//4

print(ak)

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

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

print(ans)

Solution (Python):
import math
k=int(input())
if k%2==0:
  print((k//2)**2)
else:
  a=int(math.floor(k/2))
  print(a*(a+1))

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

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

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==0:
    print(int(k*k/4))
else:
    print(int(int(k/2)*((int(k/2))+1)))

Solution (Python):
K=int(input())
if K%2==0:
    print(int((K**2)/4))
else:
    print(int((K**2-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())
if k%2 ==0:
  print((k//2)*(k//2))
else:
  print(((k+1)//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())
odd = 1
even = 0
for i in range(2,K+1):
    if i % 2 == 0:
        even += 1
    else:
        odd += 1
print(even*odd)

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

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

a = (k+1)//2
b = k//2

print(a*b)

Solution (Python):
K = [(i+1)%2 for i in range(int(input()))]
print((len(K)-sum(K))*sum(K))

Solution (Python):
N=int(input())
X=sorted([i%N+1 for i in range(1,N*2+1)])
print(sum(X[:(N-1)]))

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

Solution (Python):
a = int(input())
b = a // 2
c = a - b

print(b * c)

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//2+K%2))

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

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

Solution (Python):
print(int(input())**2//4)

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

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):
from math import ceil
a=int(input())
print((a//2)*ceil(a/2))

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

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

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

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

if(K%2==0):
    even_count = int(K/2)
    odd_count = int(K/2)
else:
    even_count = int(K/2)
    odd_count = int(K/2)+1

print(even_count * odd_count)

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

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

print(ans)

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

Solution (Python):

import math

k = int(input())
g = k / 2

print(math.floor(g) * math.ceil(g))

Solution (Python):
N = int(input())
a = int((N - N % 2) * (N + N % 2)/4)
print(a)

Solution (Python):
'''
A. pair
'''
import math

def main():
    s = int(input().strip())
    c = s/2
    return(math.ceil(c)*math.floor(c))

print(main())

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

Solution (Python):

K = int(input())


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

Solution (Python):
import math

K = int(input())

a = math.ceil(K / 2)
b = math.floor(K / 2)

print(a*b)

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

def calc1(N):
  if N % 2 == 0:
    return int((N/2) ** 2)
  else:
    return int((N//2) *( N//2+1))
  
print(calc1(N))

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):
K = int(input(""))
if K % 2 != 0:
    print("{0}".format(int(K/2)*(int(K/2)+1)))
else:
    print("{0}".format(int(K/2)*int(K/2)))

Solution (Python):




k = int(input())


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


print(even*odd)

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

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

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

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

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

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

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

Solution (Python):

import sys


def solve(K: int):
    even = K//2
    odd = K-even
    print(even*odd)
    return


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


if __name__ == '__main__':
    main()

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

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

print((x//2)*(x- x//2))

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