For a positive integer n let's define a function f:

f(n) =  - 1 + 2 - 3 + .. + ( - 1)^{n}n 

Your task is to calculate f(n) for a given integer n.


-----Input-----

The single line contains the positive integer n (1 ≤ n ≤ 10^15).


-----Output-----

Print f(n) in a single line.


-----Examples-----
Input
4

Output
2

Input
5

Output
-3



-----Note-----

f(4) =  - 1 + 2 - 3 + 4 = 2

f(5) =  - 1 + 2 - 3 + 4 - 5 =  - 3

Difficulty: EASY

Solutions:
n = int(input())
pom = round(n // 2)
if n % 2 == 0:
	pom = n - pom
else:
	pom = -1 * (n - pom)
print(pom)


n = int(input())
if n % 2 == 0:
	e = n // 2
	o = n // 2
else:
	e = n // 2
	o = n // 2 + 1
print(e + e * e - o * o)


n = int(input())
if n == 1:
	print('-1')
elif n % 2 == 0:
	print(n // 2)
else:
	print((n + 1) // 2 * -1)


n = int(input())
function = 0
if n % 2 == 0:
	print(int(n / 2))
else:
	print(int(n // 2 - n))


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


def solve():
	n = int(input())
	if n % 2 == 0:
		print(int(n / 2))
	else:
		print(int((n - 1) / 2 - n))
solve()


def f(x):
	if x % 2 == 0:
		return x / 2
	else:
		return f(x - 1) - x
print(int(f(int(input()))))


n = int(input())

def f(n):
	if n % 2 == 0:
		return n // 2
	else:
		return n // 2 - n
print(f(n))


import sys
n = int(sys.stdin.readline())
print(n // 2 - n * (n & 1))


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


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


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


from math import floor

def special_sum(n):
	if n % 2 == 0:
		return 1 * int(n / 2)
	else:
		return 1 * int((n - 1) / 2) - n
number = int(input())
print(special_sum(number))


import math

def solve(n):
	if n % 2 != 0:
		print('-', end='')
	print(math.ceil(n / 2))
n = int(input())
solve(n)


n = int(input())
if n % 2:
	print(-(n + 1) // 2)
else:
	print(n // 2)


a = int(input())
b = a // 2 * (a // 2 + 1)
c = a * (a + 1) // 2
d = c - b
f = b - d
print(f)


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


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


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


import sys, math
num = int(sys.stdin.readline())
count_odd = count_even = 0
if num % 2 == 1:
	ans = int(-1 * ((num + 1) / 2))
else:
	ans = int(num / 2)
print(ans)


n = int(input())
ans = 0
if n % 2 == 0:
	ans = n // 2
else:
	ans = -(n // 2) - 1
print(ans)


x = int(input())
if x % 2 == 0:
	print(int(x / 2))
else:
	print(int(-x / 2 - 1))


from math import *
n = int(input())
s = ceil(n / 2)
if n % 2 == 1:
	s = s * -1
print(int(s))


n = int(input())
if n % 2 == 0:
	res = int(n / 2)
	print(res)
else:
	res = -int(n // 2 + 1)
	print(res)


__author__ = 'JohnHook'
n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print(-(n // 2 + 1))


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


n = int(input())
s1 = 0
print(int(n / 2) if n % 2 == 0 else int(n / 2 * -1) - 1)


import math
n = int(input())
fn = 0
if n % 2 == 0:
	print(int(n / 2))
else:
	half = int(n / 2) + 1
	print(int(-1 * half))


import math
a = int(input())
if a % 2 == 1:
	print(math.floor(-a / 2))
else:
	print(int(a / 2))


n = int(input())
a = 0
if n % 2 == 0:
	a = n // 2
elif n % 2 != 0:
	a = n // 2 - n
print(a)


n = int(input())
f = lambda x: (2 - x % 2 + x) * abs(-x // 2) // 2
print((-1) ** n * (f(n) - f(n - 1)))


n = int(input())
total = n * (n + 1) // 2
half = n // 2 * (2 + (n - n % 2))
print(half - total)


import math
x = int(input())
print(math.floor((-1) ** x * x / 2))


n = int(input())
if n % 2 == 0:
	print(int(n / 2))
else:
	v = (n - 1) / 2
	print(int(v - n))


n = int(input())
(e, o) = (n // 2, n - n // 2)
(se, so) = (e * (4 + (e - 1) * 2) // 2, o * (-2 + (o - 1) * -2) // 2)
print(se + so)


n = int(input())
hasil = 0
if n % 2 == 0:
	hasil = n / 2
elif n % 2 == 1:
	hasil = (n + 1) / 2 * -1
print(int(hasil))


a = int(input())
n = int(a / 2)
ans = -(a * (a + 1)) + 4 * n * (n + 1)
print(int(ans / 2))


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print((-2 * n - 2) // 4)


n = int(input())
Sum = n % 2 + n // 2
if n % 2 != 0:
	Sum = -Sum
print(Sum)


n = int(input())
if n % 2 == 0:
	term = n // 2
	sum1 = term * (2 + n) // 2
	sum2 = term * (1 + n - 1) // 2
else:
	odd_term = (n + 1) // 2
	sum1 = (odd_term - 1) * (2 + n - 1) // 2
	sum2 = odd_term * (1 + n) // 2
print(sum1 - sum2)


i = int(input())
ans = 0
if i % 2 == 0:
	ans = i / 2
else:
	ans = (i - 1) / 2 - i
print(int(ans))


x = int(input())
print((-1) ** x * x // 2)


n = int(input())
n = abs(n)
if n % 2 == 0:
	print(int(n / 2))
else:
	print(int(-(n + 1) / 2))


n = int(input())
sum = 0
if n % 2 == 0:
	sum = n // 2
else:
	sum = -(n + 1) // 2
print(sum)


def calculating_function(a):
	if a % 2 != 0:
		ans = -1 * (a // 2 + 1)
	else:
		ans = a // 2
	return ans
print(calculating_function(int(input())))


n = int(input())
if n % 2 == 0:
	k = int(n / 2)
else:
	k = int(-n // 2)
print(k)


a = int(input())
print(a // 2 - a % 2 * a)


import math
n = int(input())
sum1 = n // 2 * (2 * 2 + (n // 2 - 1) * 2) // 2
n = math.ceil(n / 2)
sum2 = n * (2 + (n - 1) * 2) // 2
print(sum1 - sum2)


n = int(input())
t = n // 2
ev = t * (t + 1)
if n % 2 != 0:
	t = t + 1
od = t * t
print(ev - od)


n = int(input())
res = n // 2
if n % 2 == 1:
	res -= n
print(res)


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


v = int(input())
if v % 2:
	print(v // 2 - v)
else:
	print(v // 2)


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


n = int(input())
a = n // 2
if n % 2 == 0:
	print(a)
else:
	print(a - n)


from math import ceil
n = int(input())
if n % 2 != 0:
	print(-ceil(n / 2))
else:
	print(n // 2)


def Main():
	n = int(input())
	if n % 2 == 0:
		print(n // 2)
	else:
		print(-1 * (n + 1) // 2)
Main()


from math import ceil
n = int(input())
k = n // 2
print(k * (k + 1) - ceil(n / 2) ** 2)


i = int
a = i(input())
b = i(a / 2 + 0.5)
print((-1) ** (a % 2) * b)


user_input = int(input())
if user_input % 2:
	print((user_input + 1) // -2)
else:
	print(user_input // 2)


def solve(n):
	if n % 2 == 0:
		return int(n / 2)
	else:
		result = (n - 1) / 2
		return int(result - n)
print(solve(int(input())))


q = int(input())
e = -1
s = 0
if q % 2 == 0:
	s = q // 2
else:
	s = -(q // 2 + 1)
print(s)


n = int(input())
if n % 2 == 0:
	e = o = n // 2
else:
	o = n // 2 + 1
	e = n // 2
es = e * (e + 1)
os = -(o * o)
print(os + es)


n = int(input())
if n % 2 == 0:
	print(n // 2)
s = '-'
if n % 2 != 0:
	s += str(n // 2 + 1)
	print(s)


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print('-' + str((n + 1) // 2))


import math
n = int(input())
if n % 2 == 0:
	print(math.floor(n / 2))
else:
	print(math.floor(n / 2) - n)


import math, fractions
n = int(input())
print(n // 2 if n % 2 == 0 else -1 * (n + 1) // 2)


n = int(input())
s = 0
negative = True
if n % 2 == 0:
	print(int(n / 2))
else:
	print(int(0 - (n + 1) / 2))


import math
n = int(input())
if n == 1:
	print(-1)
else:
	z = math.ceil(n / 2)
	print((-1) ** n * z)


num = int(input())
if num % 2 == 0:
	ans = int(num / 2)
else:
	ans = int((num - 1) / 2 - num)
print(ans)


s = int(input())
x = s // 2
if s & 1:
	x -= s
print(x)


import math
n = int(input())
if n % 2 != 0:
	x = n // 2
	print(x * (x + 1) - pow(x + 1, 2))
else:
	x = n // 2
	print(x * (x + 1) - pow(x, 2))


n = int(input())
if n % 2 == 0:
	d = int(n / 2)
	print(d)
else:
	i = int(-(n + 1) / 2)
	print(i)


num = int(input())
if num % 2 == 0:
	print(num // 2)
else:
	prev = (num - 1) // 2
	print(prev - num)


n = int(input())
output = 0
if n % 2 == 0:
	output += n // 2
else:
	output += (n - 1) // 2 - n
print(output)


n = int(input())
if n % 2 != 0:
	n = -(n + 1)
print(int(n / 2))


n = int(input())
if n % 2 == 0:
	es = n // 2
	os = n // 2
else:
	es = (n - 1) // 2
	os = (n + 1) // 2
es = es * (es + 1)
os = os * os
print(es - os)


TN = 1

def solution():
	n = int(input())
	print(-(1 + n) * n // 2 + (2 + n // 2 * 2) * (n // 2))
while TN != 0:
	solution()
	TN -= 1


import math
n = int(input())
q = math.ceil(n / 2)
print(-q if n % 2 else q)


entrada = int(input())
if entrada % 2 == 0:
	print(int(entrada / 2))
else:
	print(int(-((entrada + 1) / 2)))


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


test = int(input())
if test % 2 == 0:
	print(int(test / 2))
else:
	print(-int((test + 1) / 2))


n = int(input())
if n % 2 == 0:
	a = n / 2
else:
	a = (n - 1) / 2
	a = a - n
a = round(a)
print(a)


answer = lambda n: n // 2 - n % 2 * n
print(answer(int(input())))


n = int(input())
number = 0
if n % 2 != 0:
	print((n - 1) // 2 - n)
else:
	print(n // 2)


import math
A = int(input())
if A % 2 == 0:
	print(int(A / 2))
else:
	A = math.ceil(A / 2)
	print(-A)


n = int(input())
summ = 0
if n % 2 == 0:
	print(int(n / 2))
else:
	summ = -(n // 2 + 1)
	print(int(summ))


n = int(input())
if n % 2 == 0:
	fun = n / 2
elif n % 2 != 0:
	fun = (n - 1) / 2 - n
print(int(fun))


num = int(input())
if num % 2 != 0:
	print((num + 1) // -2)
elif num % 2 == 0:
	print(num // 2)


t = int(input())
if t % 2 == 0:
	c = int(t / 2)
	print(c)
else:
	f = int((t - 1) / 2)
	print(f - t)


j = int(input())
if j % 2 == 0:
	print(j // 2)
else:
	print((j - 1) // 2 - j)


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


n = int(input())
if n % 2 == 0:
	result = n / 2
	print(int(result))
else:
	result = -(n + 1) / 2
	print(int(result))


n = int(input())

def f(n):
	if n % 2 == 0:
		value = 1 * (n / 2)
	else:
		value = -1 * (n + 1) / 2
	return value
sum = f(n)
print(int(sum))


n = int(input())
t1 = (n + 1) // 2
t2 = n // 2
print(t2 * (t2 + 1) - t1 * t1)


n = int(input())
if n % 2 == 0:
	a = n - 1
	b = n
	an = n // 2
	bn = n // 2
else:
	a = n
	b = n - 1
	an = (n + 1) // 2
	bn = (n - 1) // 2
print(((2 + b) * bn - (1 + a) * an) // 2)


n = int(input())
if n % 2 == 0:
	total = n / 2
else:
	total = (n - 1) / 2 - n
print(int(total))


nums = input().split(' ')
nums = int(nums[0])
if nums % 2 == 0:
	print(nums // 2)
else:
	print(0 - int(nums // 2 + 1))


b = int(input())
print((-1) ** b * b // 2)


def fun(n):
	sum = 0
	if n & 1 == 1:
		no = n // 2 + 1
	else:
		no = n // 2
	osum = no * no
	ne = n // 2
	esum = ne * (ne + 1)
	sum = esum - osum
	return sum
num = int(input())
print(fun(num))


import math
n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print('-' + str(math.ceil(n / 2)))


import math
n = int(input())
f = math.ceil(n / 2) * (-1) ** n
print(f)


x = input()
x = int(x)
if x // 2 == x / 2:
	print(int(x / 2))
else:
	print(int(x // 2 - x))


def func(n):
	x = 1
	sum = 0
	if n % 2 == 0:
		return n / 2
	else:
		return -(n + 1) / 2
n = int(input())
x = int(func(n))
print(x)


number = []
biggest = int(input())
if biggest % 2 == 0:
	print(biggest // 2)
else:
	print(biggest // 2 - biggest)


import math
n = int(input())
result = 0
if n % 2 == 0:
	print(n // 2)
else:
	print(math.ceil(n / 2) * -1)


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


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


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


n = int(input())
sum1 = 0
if n % 2 == 0:
	sum1 = n // 2
else:
	sum1 = (n - 1) // 2 - n
print(sum1)


import sys

def main():
	n = int(input())
	print(-(2 + (n // 2 - 1) * 2) * (n // 2) // 2 + n // 2 * (n // 2 + 1) - (n & 1) * n)
main()


n = int(input(''))
arv = n / 2
if n % 2 == 1:
	arv = -1 * (arv + 0.5)
print('%.0f' % arv)


a = int(input())
if a % 2 == 0:
	b = a
	c = a - 1
	sum = 1 * (b / 2)
else:
	b = a - 1
	c = a
	sum = 1 * (b / 2) - c
print(int(sum))


n = int(input())
even = n // 2
odd = n - even
even = even * (even + 1)
odd = odd ** 2
print(even - odd)


n = int(input())
m = n
s = 0
flag = 0
if n % 2 == 0:
	n -= 1
	flag = 1
temp = n - 1
c1 = temp // 2
if c1 % 2 == 0:
	s += -(n // 2 + 1)
else:
	s += -1 - n
	s += n // 2 + 1
if flag == 1:
	s += m
print(s)


n = int(input())
k = int(n / 2)
p = n - k
c = k * (k + 1) - p * p
print(c)


i = int(input())
import math
if i % 2 == 0:
	print(int(i / 2))
else:
	print(-math.ceil(i / 2))


from math import ceil
a = int(input())
if a % 2 != 0:
	odd_position = int((a + 1) / 2)
	even_position = int((a - 1) / 2)
	print(even_position ** 2 + even_position - odd_position ** 2)
else:
	odd_position = int(ceil((a - 1) / 2))
	even_position = int(a / 2)
	print(even_position ** 2 + even_position - odd_position ** 2)


n = int(input())
evenCount = 0
oddCount = 0
if n % 2 == 0:
	evenCount = n // 2
	oddCount = n // 2
else:
	evenCount = n // 2
	oddCount = n // 2 + 1
evenSum = evenCount * (evenCount + 1)
oddSum = oddCount ** 2
print(evenSum - oddSum)


import math
d = int(input())
if d % 2 == 0:
	print(int(d / 2))
else:
	print(int(math.ceil(d / 2) * -1))


import math
n = int(input())

def f(n):
	if n % 2 == 0:
		return int(n / 2)
	else:
		return -int(math.ceil(n / 2))
print(f(n))


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


x = input()
x = int(x)
add1 = int(x / 2)
add2 = x - add1
add1 = add1 * (add1 + 1)
add2 = add2 ** 2
print(add1 - add2)


def function():
	n = int(input())
	if n % 2 == 0:
		e_o = n // 2
	else:
		e_o = (n + 1) // 2
	sum_ = (-1) ** n * e_o
	return sum_
print(function())


a = int(input())
if a & 1:
	print(-((a >> 1) + 1))
else:
	print(a >> 1)


from sys import stdin
n = int(stdin.readline())
if n % 2 == 0:
	print(int(n / 2))
else:
	print(int(-(n + 1) / 2))


import math
hat = int(input())
if hat % 2 == 0:
	print(int(hat / 2))
else:
	print(-int(math.ceil(hat / 2)))


from sys import stdin
from math import ceil

def readInt():
	return int(stdin.readline())
n = readInt()
if n % 2 == 0:
	print(n // 2)
else:
	print(-ceil(n / 2))


n = int(input())
if n % 2 == 0:
	i0 = 2
	iN = n
	sumi = int(int(int(i0 + iN) / 2) * int(int(int(iN - i0) / 2) + 1))
	k0 = 1
	kN = n - 1
	sumk = int(int(int(k0 + kN) / 2) * int(int(int(kN - k0) / 2) + 1))
	print(sumi - sumk)
else:
	i0 = 1
	iN = n
	sumi = int(int(int(i0 + iN) / 2) * int(int(int(iN - i0) / 2) + 1))
	k0 = 2
	kN = n - 1
	sumk = int(int(int(k0 + kN) / 2) * int(int(int(kN - k0) / 2) + 1))
	print(sumk - sumi)


n = int(input(''))
suma = n * (n + 1) // 2
suma1 = (n // 2 + n % 2) ** 2
print(suma - 2 * suma1)


n = int(input())
if n % 2 == 0:
	r = n // 2
else:
	r = (n - 1) // 2 - n
print(r)


from math import ceil
n = int(input())
print(n // 2 - n % 2 * n)


n = int(input())
e = n // 2
o = n - e
f = e * (e + 1) - o * o
print(f)


n = int(input())
fn = -1
if n < 2:
	print(fn)
else:
	if n % 2 == 0:
		fn = n // 2
	else:
		fn = (n - 1) // 2 - n
	print(fn)


n = int(input())
t = n // 2
if n % 2 == 0:
	s1 = -1 * t ** 2
	s2 = t * (t + 1)
else:
	s1 = -1 * (t + 1) ** 2
	s2 = t * (t + 1)
print(s1 + s2)


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


n = int(input())
if n & 1 == 0:
	k = n // 2
	even = k * (2 + n) // 2
	odd = k * (1 + (n - 1)) // 2
	diff = even - odd
	print(diff)
else:
	k = n // 2
	even = k * (2 + n - 1) // 2
	odd = k * (1 + (n - 2)) // 2
	diff = even - odd - n
	print(diff)


def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

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

def li():
	return list(mi())
import math
n = ii()
if n % 2 == 0:
	ans = n // 2
else:
	ans = math.ceil(n / 2)
	ans *= -1
print(ans)


n = int(input())
nby2 = n // 2
if n % 2 == 1:
	sum_of_evens = nby2 * (nby2 + 1)
	sum_of_odds = (nby2 + 1) ** 2
elif n % 2 == 0:
	sum_of_evens = nby2 * (nby2 + 1)
	sum_of_odds = nby2 ** 2
print(sum_of_evens - sum_of_odds)


loops = int(input())
total = 0
if loops % 2 == 0:
	total = loops // 2
	print(total)
else:
	total = (loops - 1) // 2 - loops
	print(total)


n = int(input())
sum = n // 2 * pow(-1, n % 2) - 1 * (n % 2)
print(sum)


n = int(input())
if n % 2 == 0:
	a = n // 2
	e = a * (2 * 2 + (a - 1) * 2) // 2
	o = a * (2 * 1 + (a - 1) * 2) // 2
	print(e - o)
else:
	a = (n + 1) // 2
	b = a - 1
	e = (2 * 2 + (b - 1) * 2) * b // 2
	o = (2 * 1 + (a - 1) * 2) * a // 2
	print(e - o)


import collections

def getDP(table, *ind):
	for t in ind:
		if t not in table:
			print('non presente')
			return None
		table = table[t]
	return table

def setDP(table, val, *ind):
	for t in ind[0:-1]:
		if t not in table:
			table[t] = {}
		table = table[t]
	table[ind[-1]] = val
n = int(input())
if n % 2:
	print(int(-(n + 1) / 2))
else:
	print(int((n + 1) / 2))


num = int(input())
import math
mult = 1 if num % 2 == 0 else -1
print(math.ceil(num / 2) * mult)


import math
n = int(input())
n1 = math.ceil(n / 2)
n2 = math.floor(n / 2)
print(n2 * (n2 + 1) - n1 ** 2)


import math
n = int(input())
print(pow(-1, n) * ((n + 1) // 2))


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
N = int(input())
na = (N + 1) // 2
nb = N // 2
a = na ** 2
b = nb * (nb + 1)
print(b - a)


n = int(input())
if n % 2 == 0:
	(odd_n, even_n) = (n // 2, n // 2)
else:
	(odd_n, even_n) = (n // 2 + 1, n // 2)
odd_sum = -odd_n ** 2
even_sum = even_n * (even_n + 1)
sum = odd_sum + even_sum
print(int(sum))


n = int(input())
plus_count = minus_count = n // 2
minus_count = minus_count + 1 if n % 2 == 1 else minus_count
minus_summation = (2 * 1 + (minus_count - 1) * 2) * minus_count // 2
plus_summation = plus_count * (2 * 2 + (plus_count - 1) * 2) // 2
print(plus_summation - minus_summation)


b = int(input())
if b % 2 == 0:
	print(b // 2)
else:
	print(-(b + 1) // 2)


n = int(input())
if n & 1 == 0:
	res = n // 2
else:
	res = 0
	odd = -1 * n
	even = n // 2
	res = odd + even
print(int(res))


n = int(input())
if n % 2 == 0:
	m = int(n / 2)
	print(m)
else:
	m = int(-(n + 1) / 2)
	print(m)


k = int(input())
print(k // 2 + (-1) ** (k % 2) * k * (k % 2))


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	even_number = n // 2
	odd_number = n - even_number
	even_res = even_number * even_number + 1 * even_number
	odd_number = odd_number ** 2
	ans = -odd_number + even_res
	print(ans)


n = int(input())
fct = 0
if n % 2 == 0:
	fct = n // 2
else:
	fct = (-n - 1) // 2
print(fct)


n = int(input())
if n % 2 == 0:
	res = n // 2
elif n % 2 != 0:
	res = (n - 1) // 2 - n
print(res)


integer = int(input())
if integer % 2 == 0:
	print(int(integer / 2))
else:
	print(-int((integer + 1) / 2))


def recursSumIt(n):
	result = 0
	m = n
	if n >= 10:
		result = 5 * int(n / 10)
		n = n % 10
		if n > 10:
			result += recursSumIt(n)
		for i in range(m - m % 10 + 1, m + 1):
			result += -i if i & 1 == 1 else i
	else:
		for i in range(n + 1):
			result += -i if i & 1 == 1 else i
	return result
x = int(input())
print(recursSumIt(x))


n = int(input())
od = n - n // 2
e = n // 2
se = e * (2 * 2 + (e - 1) * 2) // 2
so = od * (2 + (od - 1) * 2) // 2
print(se - so)


import math
n = int(input())
n1 = int(n / 2)
n2 = math.ceil(n / 2)
ans = int(n1 * (n1 + 1) - n2 * n2)
print(ans)


n = int(input())
if n % 2 == 0:
	n = int(n) / 2
elif n != 1:
	n = n / 2 - n
	n1 = int(n)
	n2 = float(n)
	if n1 % n2 != 0:
		n = int(n) - 1
else:
	n = n / 2 - n - 1
print(int(n))


import math

def func(num):
	num1 = math.floor(num / 2 + num % 2)
	return num1 * (-1) ** (num % 2)
s = int(input())
print(int(func(s)))


n = int(input())
f = n // 2
if n % 2 == 1:
	f -= n
print(f)


x = int(input())
allsum = 0
allsum = x * (x + 1) // 2
n: int = x // 2
if x % 2 == 0:
	evensum = n * (2 + x) // 2
else:
	evensum = n * (2 + (x - 1)) // 2
oodsum = allsum - evensum
sum = evensum - oodsum
print(sum)


import math
x = int(input())
y = math.ceil(x / 2)
if x % 2:
	print(-y)
else:
	print(y)


def new_calc(n):
	if n % 2 == 0:
		return n // 2
	return -(n // 2 + 1)
print(new_calc(int(input())))


import math
n = int(input())
l = math.ceil(n / 2)
if n % 2 == 1:
	print(-l)
else:
	print(l)


n = int(input())
s = 0
p = 0
if n % 2 == 0:
	n1 = n // 2
	s = (2 + (n1 - 1) * 2) * n1 // 2
	n2 = n // 2
	p = (4 + (n2 - 1) * 2) * n2 // 2
	print(p - s)
else:
	n1 = n // 2 + 1
	s = (2 + (n1 - 1) * 2) * n1 // 2
	n2 = n // 2
	p = (4 + (n2 - 1) * 2) * n2 // 2
	print(p - s)


n = int(input())
neg = 0
poss = 0
if n % 2 == 0:
	print(n // 2)
else:
	print(-(n // 2 + 1))


n = int(input())
if n % 2 == 0:
	odd = n // 2
	even = odd
else:
	odd = (n - 1) // 2 + 1
	even = (n - 1) // 2
n = odd
S_odd = n * (2 + (n - 1) * 2) // 2
n = even
S_even = n * (4 + (n - 1) * 2) // 2
res = -1 * S_odd + S_even
print(int(res))


import math
n = int(input())
odd = math.ceil(n / 2)
even = n - odd
odd_sum = -odd ** 2
even_sum = even * (even + 1)
print(odd_sum + even_sum)


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	pre = (n - 1) / 2
	print(int(pre - n))


from sys import stdin, stdout
n = int(stdin.readline())
if n % 2 == 1:
	stdout.write('-')
	n += 1
stdout.write(str(n // 2) + '\n')


n = int(input())
x = 0
k = n // 2
x = k * (k + 1)
if n % 2 == 0:
	pass
elif n % 2 != 0:
	k = k + 1
x = x - k * k
print(int(x))


number = int(input())
print((-1) ** number * number // 2)


from sys import stdin, maxsize
from math import ceil
(lines, line_index) = (stdin.readlines(), -1)

def get_line():
	global lines, line_index
	line_index += 1
	return lines[line_index]

def even_sum(n):
	if n % 2 != 0:
		n = n - 1
	N = (2 + n) // 2 - 1
	return N * (N + 1)

def odd_sum(n):
	t = ceil(n / 2.0)
	return int(t ** 2)

def main():
	n = int(get_line())
	s1 = even_sum(n)
	s2 = odd_sum(n)
	print(s1 - s2)
main()


n = int(input())
k = n // 2
if n % 2 == 1:
	k -= n
print(k)


def calculatefunction2(n):
	if n % 2 == 0:
		return int(n / 2)
	else:
		prev = (n - 1) / 2
		return int(prev - n)
n = int(input())
print(calculatefunction2(n))


n = int(input())
out = 0
if n % 2:
	out = int(n / 2) - n
else:
	out = n / 2
print(int(out))


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


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


i = 0
sum = 0
n = int(input())
if n % 2 == 0:
	m = int(n / 2)
	o = int(n / 2)
	even = m * (m + 1)
	odd = o * o
	sum = even - odd
else:
	m = int(n / 2)
	o = int(n / 2) + 1
	even = m * (m + 1)
	odd = o * o
	sum = even - odd
print(sum)


angka = int(input())
if angka % 2 == 0:
	print(str(angka // 2))
else:
	print('-' + str((angka + 1) // 2))


def work():
	n = int(input())
	if n & 1 == 0:
		print(n // 2)
	else:
		print(-1 * (n // 2 + 1))
work()


def even(n):
	return n // 2
n = int(input())
if n % 2 == 0:
	print(even(n))
else:
	print(even(n - 1) - n)


n = int(input())
totale = 0
if n % 2 == 0:
	totale = n / 2
else:
	totale = int(-n / 2) - 1
print(int(totale))


n1 = int(input())
e = n1 // 2
if n1 % 2:
	o = n1 // 2 + 1
else:
	o = n1 // 2
print(e * (e + 1) - o ** 2)


import math
n = int(input())
if n % 2 == 0:
	e = n // 2
	o = n // 2
else:
	e = n // 2
	o = n // 2 + 1
sum_even = e * (e + 1)
sum_odd = o * o
print(sum_even - sum_odd)


import math as m
n = int(input())
if n % 2 == 0:
	print(int(n / 2))
else:
	print(m.floor(-n / 2))


n = int(input())
summe = 0
if n % 2 == 0:
	summe = n / 2
else:
	zwischen_summe = (n - 1) / 2
	summe = zwischen_summe - n
print(int(summe))


end = int(input())
(div, mod) = divmod(end, 2)
print(div + mod * -1 * end)


n = int(input())
x = n // 2
e = x * (x + 1)
o = x * x
if n % 2 == 0:
	t = 0
else:
	t = n
print(e - o - t)


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


n = int(input())
t = n // 2
if n % 2 == 0:
	answer = t
else:
	answer = t - n
print(answer)


n = int(input().strip())
if n % 2 == 0:
	print(n // 2)
elif n % 2 != 0:
	print((n + 1) // 2 * -1)


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


n = int(input())
evenNum = int(n / 2)
oddNum = n - int(n / 2)
sumEven = evenNum * (evenNum + 1)
sumOdd = oddNum * oddNum * -1
print(sumEven + sumOdd)


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


import math
n = int(input())
e = math.floor(n / 2)
o = math.ceil(n / 2)
print(e * (e + 1) - o * o)


import math
num1 = int(input())
if num1 % 2 == 0:
	nume = num1 // 2
	numo = num1 // 2
else:
	nume = num1 // 2
	numo = num1 // 2 + 1
even = nume * (nume + 1)
odd = numo ** 2
print(even - odd)


(in0, in1) = (int(input()), 0)
if in0 % 2 == 0:
	in1 = in0 // 2
else:
	in1 = -1 * (in0 + 1) // 2
print(in1)


s = int(input())
if s % 2 == 0:
	print(s // 2)
else:
	print('-' + str(int(s // 2 + 1)))


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


import math
n = int(input())
if n % 2 == 0:
	print(math.ceil(n / 2))
elif n % 2 == 1:
	a = math.ceil(n / 2)
	print(-a)


n1 = int(input())
if n1 % 2 == 0:
	print(int(n1 / 2))
else:
	print(-1 * (n1 - int((n1 - 1) / 2)))


n = int(input())
s = n // 2 * 1
if n % 2 == 1:
	s -= n
print(s)


import math
n = input()
n = int(n)
print(1 * math.floor(n / 2) - (n - math.floor(n / 2) * 2) * n)


n = int(input())
s = n * (n + 1) // 2
n //= 2
s1 = n * (4 + (n - 1) * 2) // 2
Ans = -s + 2 * s1
print(Ans)


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


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print('-', n // 2 + 1, sep='')


n = int(input())
if n % 2 == 0 and n != 1:
	print(int(n / 2))
else:
	print(int(-(n + 1) / 2))


def func(n):
	if n % 2 == 0:
		print(n // 2)
	else:
		print(-(n + 1) // 2)
func(int(input()))


import math
n = int(input())
if n % 2 == 1:
	print(-(n + 1) // 2)
else:
	print(n // 2)


x = int(input())
suma = 0
if x % 2 == 0:
	suma = x // 2
else:
	suma = x // 2 - x
print(suma)


import math

def func(n):
	res = 0
	if n % 2 == 0:
		odd = -(n // 2) ** 2
		even = (n // 2) ** 2 + n // 2
		res = even + odd
	else:
		odd = -math.ceil(n / 2) ** 2
		even = (n // 2) ** 2 + n // 2
		res = even + odd
	return res
print(func(int(input())))


import math
n = int(input())
if n % 2 == 0:
	k1 = n // 2
else:
	k1 = math.ceil(n / 2)
k2 = n - k1
res = k2 * (k2 + 1) - k1 ** 2
print(res)


n = int(input())
if n % 2 == 0:
	odd = n // 2
else:
	odd = n // 2 + 1
p = n * (n + 1) // 2
q = 2 * odd + 4 * ((odd - 1) * odd // 2)
print(p - q)


def calculate_function(a):
	if a % 2 == 0:
		return a // 2
	else:
		return a // 2 - a
n = int(input())
ans = calculate_function(n)
print(ans)


x = int(input())
if x % 2 == 0:
	s = x // 2
	print(s)
else:
	print(-x // 2)


import math
import os
import random
import re
import sys
from itertools import permutations
n = int(input())
(even, odd, s) = (0, 0, 0)
if n % 2 == 0:
	even = odd = n // 2
	s1 = even * (2 + n) // 2
	s2 = odd * (-1 - (n - 1)) // 2
	s = s1 + s2
else:
	even = n // 2
	odd = (n + 1) // 2
	s1 = even * (2 + (n - 1)) // 2
	s2 = odd * (-1 - n) // 2
	s = s1 + s2
print(s)


n = int(input())
if n % 2 == 1:
	p1 = (1 + n) * (n // 2 + 1) // 2
	p2 = (1 + n) * (n // 2) // 2
else:
	p2 = (2 + n) * (n // 2) // 2
	p1 = n * (n // 2) // 2
print(p2 - p1)


input_n = int(input())
input_n == 100

def f(n):
	if n % 2 == 0:
		jumlah = n // 2
	elif n % 2 == 1:
		jumlah = (n - 1) // 2 - n
	return jumlah
print(f(input_n))


n = int(input())
ans = n // 2
if n % 2:
	ans += -1 ** n * n
print(ans)


a = int(input())
b = 0
if a % 2 == 0:
	print(int(a / 2))
else:
	print(int(a / 2) - a)


s = input()
s = int(s)
if s % 2 == 0:
	ans = s // 2
else:
	ans = s // 2 - s
print(ans)


from math import sqrt, ceil

def ii():
	return int(input())

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

def li():
	return list(mi())

def si():
	return input()
t = ii()
n1 = ceil(t / 2)
n2 = t - n1
s = (n2 + 1) * n2 - n1 ** 2
print(s)


try:
	n = int(input())
	if n % 2 == 0:
		r = n // 2
	else:
		n = n + 1
		n = n - 2 * n
		r = n // 2
	print(r)
except:
	pass


n = int(input())
if n % 2 == 1:
	k = n // 2 + 1
	k1 = n // 2
else:
	k = n // 2
	k1 = n // 2
neg = k * k
pos = k1 * k1 + k1
print(pos - neg)


import math
n = int(input())
if n % 2 != 0:
	n = -1 * (n + 1)
r = math.floor(n / 2)
print(r)


n = int(input())
if n % 2:
	p = n // 2 + 1
else:
	p = n // 2
n = n // 2
sum = n * (n + 1) - p * p
print(sum)


import math as m
n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print(-1 * m.ceil(n / 2))


from sys import stdin
x = int(stdin.readline().rstrip())
print(x // 2 * (1 + x // 2) - (x // 2 + x % 2) ** 2)


i = int(input())
li = 0
if i % 2 == 0:
	li = int(i // 2)
if i % 2 == 1:
	li = int(i - 1) // 2 - i
print(li)


def fun(n):
	if n % 2 == 0:
		return int(n / 2)
	else:
		return int(n / 2) - n
n = int(input())
print(fun(n))


def calculating_func(n):
	import math
	ceil = math.ceil(n / 2) if n % 2 != 0 else n // 2
	odd = ceil ** 2
	even = n // 2 * (n // 2 + 1)
	print(even - odd)
calculating_func(int(input().strip(' ')))


n = int(input())
z = n // 2
if n % 2:
	z -= n
print(z)


from sys import stdin

def sums(l, r):
	terms = (r - l) // 2 + 1
	return terms * (r + l) // 2
n = int(stdin.readline())
sum1 = 0
if n % 2 == 0:
	sum1 += sums(2, n)
	sum1 -= sums(1, n - 1)
else:
	sum1 += sums(2, n - 1)
	sum1 -= sums(1, n)
print(sum1)


inpt = int(input())
ans = 0
if inpt % 2 == 0:
	ans = int(inpt / 2)
else:
	ans = int(-(inpt + 1) / 2)
print(ans)


from sys import stdin as cin
n = int(cin.readline().strip())
if n % 2 == 0:
	print(n // 2)
else:
	print(-n // 2)


ii = lambda : int(input())
n = ii()
if n % 2 == 0:
	a = -(n // 2) ** 2
	b = n // 2 * (n // 2 + 1)
else:
	a = -(n // 2 + 1) ** 2
	b = n // 2 * (n // 2 + 1)
print(a + b)


n = int(input())
answer = 0

def function(n):
	if n % 2 == 0:
		answer = n // 2
		print(answer)
	else:
		answer = -(n // 2 + 1)
		print(answer)
function(n)


n = int(input())
r2 = 0
if n == 1:
	print(-1)
elif n == 2:
	print(1)
elif n == 3:
	print(-2)
else:
	if n % 2 == 0:
		r2 += n // 2 * (2 + (n // 2 - 1))
		r2 -= n // 2 * (1 + (n // 2 - 1))
	else:
		r2 += n // 2 * (2 + (n // 2 - 1))
		r2 -= (n // 2 + 1) * (1 + n // 2)
	print(r2)


def fun():
	n = int(input())
	odd = 0
	even = 0
	if n % 2 == 0:
		odd = n // 2
		even = n - odd
	else:
		odd = n // 2 + 1
		even = n - odd
	sumofodd = odd * (2 * 1 + (odd - 1) * 2) // 2
	sumofeven = even * (2 * 2 + (even - 1) * 2) // 2
	print(int(sumofeven - sumofodd))
fun()


c = int(input())
sum = 0
if c % 2 == 0:
	print(int(c / 2))
else:
	print(int(c / 2) - c)


inp = int(input())
print(inp // 2 - inp % 2 * inp)


def answer():
	a = int(input())
	x = 1
	if a % 2:
		x = -1
	return (int(a / 2) + a % 2) * x
print(answer())


variable_n = int(input())
if variable_n % 2 == 0:
	print(variable_n // 2)
else:
	print(variable_n // 2 - variable_n)


input_s = int(input())
if input_s % 2 > 0:
	print(int(-(input_s // 2 + 1)))
else:
	print(int(input_s / 2))


n = int(input())
sum = 0
sum = -1 * (n * (n + 1)) // 2
if 1 == 1:
	posvsum = 0
	c = n // 2
	if n % 2 == 0:
		posvsum = c * (c + 1)
	elif n % 2 == 1:
		posvsum = c * (c + 1)
	else:
		print('error')
total = sum + 2 * posvsum
print(total)


import math
from fractions import Fraction as frac
MOD = 1000000000.0 + 7

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)

def no():
	print('NO')
	return

def yes():
	print('YES')
	return

def solve(case_no):
	n = int(input())
	ans = 0
	if n % 2 == 1:
		ans = -n
		n -= 1
	ans += n // 2
	print(ans)
t = 1
for i in range(1, t + 1):
	solve(i)


import math
n = int(input())
add = n // 2 * (n // 2 + 1)
sub = math.ceil(n / 2) * math.ceil(n / 2)
print(add - sub)


n = int(input())
if n % 10 % 2 == 1:
	n += 1
	n *= -1
print(n // 2)


n = int(input())
if n % 2 == 1:
	s1 = (n + 1) ** 2 // 4
	s2 = (n ** 2 - 1) // 4
else:
	s1 = n ** 2 // 4
	s2 = (n + 2) * n // 4
print(-s1 + s2)


import math
n = int(input())
q = math.ceil(n / 2)
p = n - q
res = -q ** 2 + p * (p + 1)
print(res)


x = int(input())
n1 = x // 2 + x % 2
n2 = x // 2
odd = n1 ** 2
even = n2 ** 2 + n2
print(even - odd)


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


def fim(x):
	if x % 2 == 0:
		return int(n / 2)
	else:
		return int((n - 1) / 2 - n)
n = int(input())
print(fim(n))


len = int(input())
res = 0
if len % 2 == 0:
	res = len / 2
else:
	res = len // 2 - len
print(int(res))


import sys
import math
import bisect

def solve(n):
	ans = n * (n + 1) // 2
	if n % 2 == 1:
		tmp = n
	else:
		tmp = n - 1
	ans -= (tmp + 1) * ((tmp - 1) // 2 + 1) // 2
	ans -= (tmp + 1) * ((tmp - 1) // 2 + 1) // 2
	return ans

def main():
	n = int(input())
	ans = solve(n)
	print(ans)
main()


n = int(input())
ev = n // 2
od = n - ev
ev_s = ev * (ev + 1)
od_s = -(od * od)
total = ev_s + od_s
print(total)


n = int(input())
s = (-1 + (-1) ** n) / 4 + (-1) ** n * n / 2
print(int(s))


n = int(input())
even = n // 2
odd = n - even
sum_odd = odd ** 2
sum_total = n * (n + 1) // 2
print(sum_total - 2 * sum_odd)


n = int(input())
e = n // 2
odd = n - n // 2
so = -1 * odd ** 2
se = e * (e + 1)
print(so + se)


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


from math import ceil
data = int(input())
print(ceil(data / 2) * int((-1) ** data))


n = int(input())
half = n // 2
if n % 2 == 0:
	print(half)
else:
	print(-half - 1)


n = input('')
n = int(n)
s = n // 2
if n % 2:
	print((n - s - 1) * (n - s) - pow(s + 1, 2))
else:
	print((n - s) * (n - s + 1) - pow(s, 2))


x = int(input())
if x % 2 == 0:
	print(x // 2)
elif x % 2 == 1:
	print((x - 1) // 2 - x)


n = int(input())
a = n // 2
b = n % 2
if b == 0:
	print(a)
if b == 1:
	print(a - n)


n = int(input())
ans = 0
ans2 = 0
if n % 2 == 0:
	print(n // 2)
elif n % 2 == 1:
	print(n // 2 - n)


def f(n):
	if n % 2 == 0:
		return n / 2
	else:
		return (n - 1) // 2 - n
num = int(input())
print(int(f(num)))


def main(n):
	res = 0
	if n % 2 != 0:
		res = 0 - (n + 1) / 2
	else:
		res = n / 2
	return int(res)
n = int(input())
print(main(n))


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


no = int(input())
if no % 2 == 0:
	n = no // 2
	sm = 0
	od = n * n
	ev = n * (n + 1)
	print(ev - od)
else:
	n = no // 2 + 1
	sm = 0
	od = n * n
	n = no // 2
	ev = n * (n + 1)
	print(ev - od)


a = int(input())
if a % 2 == 0:
	m = a / 2
else:
	m = a // 2 - a
print(int(m))


n = int(input())
s = 0
if n % 2 == 0:
	print(int(n / 2))
elif n % 2 != 0:
	print(-(int(n / 2) + 1))


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


from sys import stdin, stdout

def main():
	line = stdin.readline()
	parts = line.split()
	n = int(parts[0])
	ans = 0
	if n % 2 == 0:
		ans = int(n / 2)
	else:
		ans = -int(n / 2) - 1
	stdout.write(str(ans))
main()


n = int(input())
f_n = None
if n % 2 == 0:
	f_n = n / 2 * (n / 2 + 1 - n / 2)
else:
	f_n = (n - 1) / 2 * ((n - 1) / 2 + 1 - (n - 1) / 2) - n
print(int(f_n))


n = int(input())
print(int((-1) ** n * (n + 0.5) // 2))


n = int(input())
if n % 2 == 0:
	f = (2 + n) * n // 4 - (1 + n - 1) * n // 4
if n % 2 == 1:
	f = (2 + n - 1) * (n // 2) // 2 - (1 + n) * (n // 2 + 1) // 2
print(f)


import math
n = int(input())
z = math.ceil(n / 2)
if n % 2 == 0:
	print(z)
else:
	print(-z)


def num():
	n = int(input())
	l1 = 0
	l2 = 0
	if n % 2 == 0:
		l1 = n
		l2 = n - 1
	else:
		l1 = n - 1
		l2 = n
	c1 = (l1 - 2) // 2 + 1
	c2 = (l2 - 1) // 2 + 1
	s1 = c1 * (2 + l1) // 2
	s2 = c2 * (1 + l2) // 2
	print(int(s1 - s2))
num()


def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def solve():
	N = getInt()
	if N % 2 == 0:
		return N // 2
	return -(N + 1) // 2
ans = solve()
print(ans)


s = int(input())
n1 = int(s / 2)
n2 = s - n1
ev = n1 * (4 + (n1 - 1) * 2)
od = -n2 * (2 + (n2 - 1) * 2)
sum = (ev + od) / 2
print(int(sum))


import math
n = int(input())
if not n & 1:
	print(n // 2)
else:
	print(-1 * math.ceil(n / 2))


(n, b) = (int(input()), 0)
if n % 2 == 0:
	n = n // 2
	sgen = n * (n + 1)
	sgan = n ** 2
else:
	n = n // 2
	sgen = n * (n + 1)
	a = n + 1
	sgan = a ** 2
print(sgen - sgan)


n = int(input())
a = (-1) ** (n - 1)
b = 2 * n + 1
x = (a * b + 1) // 4
print(-1 * x)


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	prev = (n - 1) // 2
	print(prev - n)


s = int(input())
if s % 2 == 0:
	print(int(s / 2))
if s % 2 != 0:
	x = (s - 1) / 2 - s
	import math
	print(math.floor(x))


def function(n):
	k = int(n / 2)
	p = int((n + 1) / 2)
	return k * (k + 1) - p * p
n = int(input())
print(function(n))


import math
total = 0
n = int(input())

def func(n):
	if n % 2 == 0:
		return n / 2
	else:
		return (n - 1) / 2 - n
print(int(func(n)))


n = int(input())
(even, odd) = (n // 2, n - n // 2)
(s1, s2) = (even * (4 + (even - 1) * 2) // 2, odd * (-2 + (odd - 1) * -2) // 2)
print(s1 + s2)


from sys import stdin, stdout

def fun():
	n = stdin.readline()
	if int(n) % 2 == 0:
		sum = int(int(n) / 2)
	else:
		sum = int(-1 * ((int(n) + 1) / 2))
	stdout.write(str(sum))
fun()


n = int(input())
print(int(0.25 * (2 * n * (-1) ** n + (-1) ** n - 1)))


n = int(input())
ne = n // 2
s1 = ne * (ne + 1)
no = n - ne
s2 = no ** 2
print(int(s1) - int(s2))


n = int(input())
if n % 2 == 0:
	k1 = k2 = n // 2
	an1 = -(n - 1)
	an2 = n
else:
	k1 = n // 2 + 1
	k2 = n // 2
	an1 = -n
	an2 = n - 1
s1 = (-1 + an1) // 2 * k1
s2 = (2 + an2) // 2 * k2
print(s1 + s2)


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


n = int(input())
if n & 1:
	print(end='-')
print(n + 1 >> 1)


def seperateints(x):
	k = ''
	l = []
	for i in x:
		if i == ' ':
			l.append(int(k))
			k = ''
			continue
		k = k + i
	l.append(int(k))
	return l

def luckynum(x):
	for i in x:
		if i != '4' and i != '7':
			return False
	return True
n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print(-(n // 2 + 1))


def contFun(x):
	if x % 2 == 0:
		totalNum = int(x / 2)
	else:
		totalNum = int((x + 1) / 2 * -1)
	print(totalNum)
userIn = int(input())
contFun(userIn)


import math
n = int(input())
s = 0
e = n // 2
d = math.ceil(n / 2)
e = e * (e + 1)
d = d * d
print(e - d)


n = int(input())
count = 0
if n % 2 == 0:
	count = n / 2
else:
	count = (-n - 1) / 2
print(int(count))


n = int(input())
s = n * (n + 1) // 2
k = n // 2
if n & 1:
	k += 1
s1 = k * (2 + (k - 1) * 2)
print(s - s1)


import sys
from sys import setrecursionlimit
from bisect import bisect_left, bisect_right, insort
from collections import deque, Counter
from math import gcd, sqrt, factorial, ceil, log10, log2
from itertools import permutations
from heapq import heappush, heappop, heapify
inf = float('inf')
mod = 1000000007
mini = 1000000007
setrecursionlimit(10 ** 5)

def ncr(n, r):
	d = 10 ** 9 + 7
	num = fact(n)
	den = fact(r) * fact(n - r) % d
	den = pow(den, d - 2, d)
	return num * den % d

def sieve(n):
	prime = [True for i in range(n + 1)]
	lst = []
	p = 2
	while p * p <= n:
		if prime[p]:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p = p + 1
	for i in range(2, n + 1):
		if prime[i]:
			lst.append(i)
	return lst

def binary(number):
	result = 0
	while number:
		result = result + 1
		number = number & number - 1
	return result

def calculate_factors(n):
	hh = [1] * (n + 1)
	p = 2
	while p * p < n:
		if hh[p] == 1:
			for i in range(p * 2, n, p):
				hh[i] = 0
		p += 1
	total = 1
	for p in range(2, n + 1):
		if hh[p] == 1:
			count = 0
			if n % p == 0:
				while n % p == 0:
					n = int(n / p)
					count += 1
				total *= count + 1
	return total

def prime_factors(n):
	i = 2
	factors = set()
	while i * i <= n:
		if n % i:
			i += 1
		else:
			factors.add(n // i)
			n = n // i
			factors.add(i)
	if n > 1:
		factors.add(n)
	return factors

def isPrime(n):
	if n == 2 or n == 3:
		return True
	if n % 2 == 0 or n < 2:
		return False
	for i in range(3, int(n ** 0.5) + 1, 2):
		if n % i == 0:
			return False
	return True

def even(n):
	return n * (n + 1)

def odd(n):
	return -1 * n * n

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
n = int(input())
if n & 1:
	nod = n // 2 + 1
	noe = n // 2
	print(odd(nod) + even(noe))
else:
	nod = n // 2
	noe = n // 2
	print(odd(nod) + even(noe))


import math
n = int(input())
x = math.ceil(n / 2)
print(x if n % 2 == 0 else -x)


import sys
n = int(input())
if n % 2 == 0:
	n = n // 2
	odd = n * n
	even = n * (n + 1)
	print(-odd + even)
else:
	n = n // 2 + 1
	odd = n * n
	even = n * (n + 1) - 2 * n
	print(-odd + even)


import math
n = int(input())
r = math.ceil(n / 2)
print(r if n % 2 == 0 else -r)


n = int(input())
if n % 2 == 0:
	summ = n / 2
elif abs(n) % 2 == 1:
	summ = -(n + 1) / 2
print(int(summ))


n = int(input())
p = 0
q = 0
if n % 2 == 0:
	p = n // 2
	q = n // 2
else:
	p = n // 2
	q = n // 2 + 1
m = 2 + (p - 1) * 2
k = 1 + (q - 1) * 2
a = p * (2 + m)
a = a // 2
b = q * (1 + k)
b = b // 2
print(a - b)


n = int(input())
n_l = n % 2
if n_l == 0:
	n_ = n // 2
else:
	n_ = int(n // 2 + (-1) ** n * n)
print(n_)


def myFunc(n):
	if n % 2 == 0:
		return n // 2
	return -(n + 1) // 2
n = int(input())
print(myFunc(n))


n = int(input())
r = 0
if n % 2 == 0:
	print(int(n / 2))
else:
	r = 0 - n / 2 - 0.5
	print(int(r))


n = int(input())
print(n // 2 - [n, 0][n % 2 == 0])


n = int(input())
f = 0
x = n % 2
print(int(n / 2 + x) - (n + 1) * x)


def f(arg):
	sign = -1 if arg % 2 == 1 else 1
	return sign * (arg + 1) // 2
x = int(input())
print(f(x))


a = int(input())
res = a // 2
if a % 2 != 0:
	res -= a
print(res)


import math
a = int(input())
s = 0
if a % 10 == 0:
	print(int(a / 2))
else:
	b = math.floor(a / 10) * 10
	s += b / 2
	for i in range(b + 1, a + 1):
		if i % 2 == 0:
			s += i
		else:
			s -= i
	print(int(s))


hoop = int(input())
if hoop % 2 == 0:
	print(hoop // 2)
else:
	print(-(hoop + 1) // 2)


num = int(input())
n = num
x = (1 - (-1) ** n) / 4
a = (-1) ** (n + 1)
y = (n - 1) * a / 2
z = 1 / 2
ans = -(x + y + z)
if n % 2 != 0:
	print(int(ans))
else:
	print(int(ans) + 1)


n = int(input())
r = int(n / 4)
ans = r * 2
for i in range(r * 4 + 1, n + 1):
	if i % 2 == 0:
		ans += i
	else:
		ans -= i
print(ans)


from sys import stdin

def main():
	inp = stdin
	num = int(inp.readline().strip())
	if num == 1:
		print(-1)
	elif num % 2 == 0:
		print(num // 2)
	else:
		print(-1 * (num + 1) // 2)
main()


n = int(input())
sum_of_fun = n / 2
if int(sum_of_fun) < sum_of_fun:
	sum_of_fun = int(sum_of_fun) + 1
else:
	sum_of_fun = int(sum_of_fun)
if n % 2 != 0:
	sum_of_fun *= -1
print(sum_of_fun)


n = int(input())
m = n // 2
even = m ** 2 + m
total = (n ** 2 + n) // 2
print(2 * even - total)


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


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


num = int(input())
odd = 0
even = 0

def Sum(a, step):
	sum = step * (2 * a + (step - 1) * 2)
	return int(sum // 2)
if num % 2 == 0:
	odd = Sum(1, num // 2)
	even = Sum(2, num // 2)
else:
	even = Sum(2, num // 2)
	odd = Sum(1, num // 2 + 1)
print(even - odd)


n = int(input())
if n % 2 == 0:
	x = (n + 1) * (n // 2)
	x1 = (x - n // 2) // 2
	x2 = x1 + n // 2
else:
	m = n - 1
	x = (m + 1) * (m // 2)
	x1 = (x - m // 2) // 2 + n
	x2 = x1 - n + m // 2
print(int(x2) - int(x1))


n = int(input())
if n % 2 == 0:
	no_of_even = int(n / 2)
	no_of_odd = int(n / 2)
else:
	no_of_even = (n - 1) // 2
	no_of_odd = n - no_of_even
print(no_of_even * (no_of_even + 1) - no_of_odd * no_of_odd)


import math as mt
import sys as sy

class abc:

	def mkl(self):
		n = int(input())
		if n % 2 == 0:
			print(n // 2)
		else:
			print('-' + str(int(n // 2) + 1))
b = abc()
b.mkl()


a = int(input())
print(a // 2 - (a & 1) * a)


nStr = input()
n = int(nStr)
ans = 0
if n % 2 == 0:
	ans = n // 2
else:
	ans = n // 2 - n
print(ans)


try:
	k = int(input())
	if k % 2 != 0:
		print(-(k // 2 + 1))
	else:
		print(k // 2)
except:
	pass


x = int(input())
i = 1
s = 0
if x % 2 == 0:
	n = x // 2
else:
	n = -(x + 1) // 2
print(n)


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


a = int(input())
res = a // 2 - a % 2 * a
print(res)


n = int(input())
s = (-1) ** (n % 2)
f = (n + 1) // 2
print(s * f)


n = int(input())
positive_sum = n // 2 * (4 + (n // 2 - 1) * 2) // 2
negative_sum = n // 2 * (2 + (n // 2 - 1) * 2) // 2
if n % 2 == 1:
	negative_sum += n
print(positive_sum - negative_sum)


def f(num):
	if num % 2 == 0:
		sum = num / 2
	else:
		sum = -num // 2
	print(int(sum))
num = int(input())
f(num)


n = int(input())
ans = 0
le = 2
lo = 1
xx = []
if n % 2 == 0:
	x = n // 2
	xx = [x, x]
	le = n
	lo = n - 1
else:
	lo = n
	le = n - 1
	x = n // 2
	xx = [x, x + 1]
se = xx[0] * (2 + le) // 2
so = xx[1] * (1 + lo) // 2
print(se - so)


def calc_fun(x):
	if x % 2 == 0:
		return '%.0f' % (x / 2)
	else:
		return '%.0f' % ((x / 2 + 0.5) * -1)

def main():
	print(calc_fun(int(input())))
main()


n = int(input())
if n % 2 == 0:
	a1 = 2
	d = 2
	index = (n - a1) / d + 1
	a1 = 1
	d = 1
	result = int(a1 + (index - 1) * d)
else:
	a1 = 1
	d = 2
	index = (n - a1) / d + 1
	a1 = -1
	d = -1
	result = int(a1 + (index - 1) * d)
print(result)


n = int(input())
s = n // 2
if n % 2 != 0:
	s -= n
print(s)


n = int(input())
if n % 2 == 0:
	k = n // 2
	ans1 = 4 + (k - 1) * 2
	ans2 = 2 + (k - 1) * 2
	ans1 = ans1 * k // 2
	ans2 = ans2 * k // 2
	print(ans1 - ans2)
else:
	k = n // 2
	ans1 = 4 + (k - 1) * 2
	ans2 = 2 + k * 2
	ans1 = ans1 * k // 2
	ans2 = ans2 * (k + 1) // 2
	print(ans1 - ans2)


a = int(input())
s = 0
if a % 2 == 0:
	print(int(a / 2))
else:
	print(int(a // 2 - a))


x = int(input())
z = x // 2 - x * (x % 2)
print(int(z))


n = int(input())
if n & 1:
	c = n // 2
	sumOfOdds = -c ** 2
	sumOfEvens = c * (c + 1) - n
	print(sumOfOdds + sumOfEvens)
else:
	c = n // 2
	sumOfOdds = -c ** 2
	sumOfEvens = c * (c + 1)
	print(sumOfOdds + sumOfEvens)


from math import floor

def f(n):
	if n % 2 == 0:
		return n // 2
	return floor(n // 2) - n

def main():
	n = int(input())
	print(f(n))
main()


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


from heapq import heappush, heappop
import queue
import re
import math
import functools

def int_raw():
	return int(input())

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

def ints_raw():
	return list(map(int, ss_raw()))
INF = 1 << 29

def make1d_arr(n, val=INF):
	return [val for i in range(n)]

def make2d_arr(h, w, val=INF):
	return [[val for i in range(w)] for i in range(h)]

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
N = int_raw()

def main():
	return N // 2 + (-N if N % 2 == 1 else 0)
print(main())


from sys import stdout
num = int(input())
isEven = num % 2 == 0
stdout.write(str(int(num / 2) if isEven else int((num + 1) / -2)))


import sys

class Scanner:

	def __init__(self):
		self.current_tokens = []

	def remaining_tokens(self):
		return len(self.current_tokens)

	def nextline(self):
		assert self.remaining_tokens() == 0, 'Reading next line with remaining tokens'
		return input()

	def nexttokens(self):
		return self.nextline().split()

	def nexttoken(self):
		if len(self.current_tokens) == 0:
			self.current_tokens = self.nexttokens()
		assert self.remaining_tokens() > 0, 'Not enough tokens to parse.'
		return self.current_tokens.pop(0)

	def nextints(self, n=-1):
		if n == -1:
			return list(map(int, self.nexttokens()))
		else:
			return (self.nextint() for i in range(n))

	def nextint(self):
		return int(self.nexttoken())

def quit():
	sys.exit(0)
stdin = Scanner()
nextint = stdin.nextint
nextints = stdin.nextints
nextline = stdin.nextline
n = nextint()
if n % 2 == 0:
	print(n // 2)
else:
	print(n // 2 - n)


n = int(input())
summation = 0
if n % 2:
	summation -= n
	n = n - 1
number_of_term = n // 2
summation = summation + number_of_term * (number_of_term + 1) - number_of_term ** 2
print(int(summation))


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	h = (n - 1) // 2
	print(h - n)


n = int(input())
n1 = int(n / 2)
n2 = int((n + 1) / 2)
print(n1 * (n1 + 1) - n2 ** 2)


import math
n = int(input())
even = n // 2
odd = n - even
sum_even = even * (even + 1)
sum_odd = odd * (2 + (odd - 1 * 2))
print(sum_even - sum_odd)


def f(l, r):
	ans = 0
	n = abs(r) - abs(l) + 1
	if l % 2 != 0 and l > 0:
		l = -l
	if r % 2 != 0 and r > 0:
		r = -r
	if n == 1:
		return r
	if n % 2 != 0:
		return (l + r) / 2
	elif l < 0 and r > 0:
		return l + f(-l + 1, r)
	elif l > 0 and r < 0:
		return l + f(-l - 1, r)
for i in range(1):
	nn = int(input())
	print(int(f(1, nn)))


n = int(input())
e = n // 2
o = e + n % 2
e1 = e * (e + 1)
o1 = o ** 2
print(e1 - o1)


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


def r(n):
	e = n // 2
	e = e * (e + 1)
	o = n - n // 2
	o = o ** 2
	return e - o
n = int(input())
print(r(n))


def calculateFunc(n):
	if n % 2 == 0:
		return n // 2
	return -(n // 2) - 1
n = int(input())
print(calculateFunc(n))


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import bisect as bi
import heapq

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

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

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

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

def main():
	try:
		n = I()
		if n & 1 == 1:
			t1 = math.ceil(n / 2) ** 2 - n // 2 * (n // 2 + 1)
			print(-t1)
		else:
			t1 = math.ceil(n / 2) ** 2 - n // 2 * (n // 2 + 1)
			print(abs(t1))
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


import math
i = int(input())
p = 0
if i % 2 == 0:
	p = 2
else:
	p = 1
print(math.ceil(i * 1.0 / 2.0) * pow(-1, p))


inp = int(input())

def mf(num):
	if num % 2 == 0:
		return int(num / 2)
	else:
		return -int((num + 1) / 2)
print(mf(inp))


n = int(input())
if n % 2 == 0:
	a = n // 2
	print(a)
else:
	b = n // 2
	ans = b - n
	print(ans)


x = int(input())
res = 0
e = x // 2
res1 = e * (e + 1)
o = (x + 1) // 2
res2 = o * o
print(res1 - res2)


import math
n = int(input())
s = 0
if n % 2 == 0:
	print(math.floor(n / 2))
else:
	p = math.floor(n / 2) + 1
	print(-1 * p)


def f_de_n(n):
	if n % 2 == 0:
		return n / 2
	else:
		fn = (n - 1) / 2
		return fn - n
n = int(input())
(aux, fn) = (1, 0)
print(int(f_de_n(n)))


from math import floor
n = int(input())
odd = ((n + 1) // 2) ** 2 * -1
eve = floor(n / 2) * (floor(n / 2) + 1)
print(odd + eve)


n = int(input())
if n % 2 == 0:
	Fn = int(n / 2)
else:
	Fn = int(-n / 2 - 0.5)
print(Fn)


import sys
local_launch = False
try:
	open('LOCAL').read()
	local_launch = True
except:
	pass
input_data = open('INPUT.txt').read() if local_launch else sys.stdin.read()
done = {'i': 0}
tokens = input_data.split()

def next_token():
	result = tokens[done['i']]
	done['i'] += 1
	return result

def next_int():
	return int(next_token())

def next_str():
	return next_token()
n = next_int()
if n % 2 == 0:
	print(n // 2)
else:
	print(-(n // 2) - 1)


def solution(n):
	if n % 2 == 0:
		return n // 2
	else:
		return (n - 1) // 2 - n
print(solution(int(input())))


n = int(input())
if n % 2 == 0:
	output = n // 2
elif n % 2 == 1:
	output = -(n + 1) // 2
print(output)


final = int(input())
result = 0
if final % 2 == 0:
	result = int(final / 2)
else:
	result = int(-0.5 * (final + 1))
print(result)


t = int(input())
(ans, count1, count2, full) = (0, 0, 0, 0)
full = t * (t + 1) // 2
n = (t + 1) // 2
count1 = n * (2 + (n - 1) * 2) // 2
count2 = full - count1
ans = count2 - count1
print(ans)


integer_n = int(input())
if integer_n % 2 == 0:
	print(integer_n // 2)
else:
	print(f'-{integer_n // 2 + 1}')


n = int(input())
a = n // 2
b = n - a
odd = b * b
even = a * (a + 1)
print(even - odd)


x = int(input())
i = 0
j = 2
k = -1
vsota = 0
if x % 2 == 0:
	print(x // 2)
else:
	print((x - 1) // 2 - x)


__author__ = 'curiousfool'
n = int(input())
if n % 2 == 1:
	sum = -1 * (n // 2 + 1)
else:
	sum = n / 2
print(int(sum))


n = int(input())
s = 0
if n % 2 == 0:
	k2 = (2 + n) * (n // 2) // 2
	k1 = (1 + (n - 1)) * (n // 2) // 2
	print(k2 - k1)
else:
	k2 = (2 + (n - 1)) * ((n - 1) // 2) // 2
	k1 = (1 + n) * (n + 1) // 2 // 2
	print(k2 - k1)


def sumat_alt(num):
	if num % 2 != 0:
		return int(num / 2) - num
	else:
		return int(num / 2)
num = int(input())
print(sumat_alt(num))


n = int(input())
i = n // 2
j = n - i
sum = i * (i + 1) - j ** 2
print(sum)


a = int(input())
if a % 2 == 0:
	print(int(a / 2))
else:
	print(int(-2 - (a - 3) / 2))


import math

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

def rotate(my_list, num):
	return my_list[num:] + my_list[:num]

def main():
	num = int(input())
	if num % 2:
		print(int(-(num + 1) / 2))
	else:
		print(int(num / 2))
main()


def sum(x):
	if x % 2 == 0:
		return int(x / 2)
	elif x % 2 == 1:
		return int((x - 1) / 2 - x)
ans = int(input())
print(sum(ans))


def calculatingFunction():
	n = int(input())
	if n % 2 == 0:
		print(int(n / 2))
	else:
		previous = int((n - 1) / 2)
		print(previous - n)
calculatingFunction()


i = int(input())
print([i // 2, i // 2 - i][i % 2])


import math
x = int(input())
if x % 2 == 0:
	print(int(x - x / 2))
else:
	print(int(-x + math.floor(x / 2)))


print((lambda n: int(n / 2) if n % 2 == 0 else n // 2 - n)(int(input())))


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


def samantor_dhara(i, n):
	return int((i + n) / 2) * (int((n - i) / 2) + 1)
n = int(input())
if n % 2 == 0:
	print(samantor_dhara(2, n) - samantor_dhara(1, n - 1))
else:
	print(samantor_dhara(2, n - 1) - samantor_dhara(1, n))


n = int(input())
h = n >> 1
if n & 1:
	print(-(h + 1))
else:
	print(h)


i = int(input())

def recursive(a):
	a /= 2
	return int(a)
print(recursive(i) if i % 2 == 0 else recursive(i - 1) - i)


n = int(input())
if n % 2 == 0:
	x = n / 2
	x = int(x)
	print(x)
else:
	x = -(n / 2)
	y = x - 0.5
	y = int(y)
	print(y)


n = int(input(), base=10)
print(n // 2 - n % 2 * n)


def main():
	n = int(input())
	ans = (n + 1) // 2
	print(ans if n % 2 == 0 else -ans)
main()


CALC_INPUT = int(input())
CALC_TMP = CALC_INPUT / 2.0
if int(CALC_TMP) == CALC_TMP:
	print(int(CALC_TMP))
else:
	print(0 - (CALC_INPUT - int(CALC_TMP)))


def rex():
	n = int(input())
	if n % 2 == 0:
		ret = n // 2
	else:
		ret = -(n + 1) // 2
	return ret
print(rex())


import sys
input = sys.stdin.readline
n = int(input().strip())
if n % 2:
	print(-1 * (n // 2 + 1))
else:
	print(n // 2)


b = int(input())
s = 0
if b & 1 == 0:
	s = b // 2
else:
	q = (b - 1) // 2
	s = q - b
print(s)


def mod(a, b):
	r = 0
	for i in range(len(a)):
		r = (r * 10 + int(a[i])) % b
	return r
n = input()
if mod(n, 2) == 0:
	print(1 * int(n) // 2)
else:
	print(1 * int(n) // 2 - int(n))


n = int(input())
sum = 0
if n % 2 != 0:
	odd = n // 2 + 1
else:
	odd = n // 2
even = n // 2
sum = even * (even + 1) - odd * odd
print(sum)


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


from sys import stdin, stdout
from math import ceil
inp = stdin.readline
out = stdout.write
n = int(inp().strip())
s = ceil(n / 2)
if n % 2 == 0:
	out(str(s))
else:
	out(str(-1 * s))


n = int(input()) / 2
pos_sum = int(n) * (int(n) + 1)
neg_sum = int(n + 0.5) * int(n + 0.5)
print(pos_sum - neg_sum)


a = int(input())
if a % 2 == 0:
	print(round(a / 2))
else:
	print(round(a // 2 - a))


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


n = int(input())
if n % 2 == 0:
	l = n // 2
	a = n - l
	x = l * (l + 1)
	y = a * a
	print(x - y)
else:
	l = (n + 1) // 2
	a = n - l
	x = a * (a + 1)
	y = l * l
	print(x - y)


import math

def f(n):
	if n % 2 == 0:
		return n // 2
	if n % 2 == 1:
		i = -math.ceil(n / 2)
		return i
print(f(int(input())))


import math
n = int(input())
s = n * (n + 1) // 2
ans = s - 2 * pow(math.ceil(n / 2), 2)
print(ans)


x = input()
y = int(x)
if y % 2 == 0:
	output = y // 2
else:
	output = (y - 1) // 2 - y
print(output)


import math
n = int(input())
a = (-1) ** n
res = a * n // 2
print(res)


def f(n):
	if n % 2 == 0:
		return n // 2
	return -n + n // 2

def main():
	n = int(input())
	print(f(n))
main()


from math import ceil
N = int(input())
total = 0
if N & 1 == 1:
	total = -ceil(N / 2)
else:
	total = int(N / 2)
print(total)


from math import ceil
n = int(input())
p = 1 - 2 * (n % 2)
print(p * ceil(n / 2))


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


def main():
	n = int(input())
	if n % 2 == 0:
		ultimo_par = n
		ultimo_impar = n - 1
		soma_impar = (1 + ultimo_impar) * (n // 2) // 2
		soma_par = (2 + ultimo_par) * (n // 2) // 2
	else:
		ultimo_par = n - 1
		ultimo_impar = n
		soma_impar = (1 + ultimo_impar) * (n // 2 + 1) // 2
		soma_par = (2 + ultimo_par) * (n // 2) // 2
	f = soma_par - soma_impar
	print(f)
main()


from math import ceil

def func(n):
	even = n // 2
	odd = ceil(n / 2)
	e_sum = even * (even + 1)
	o_sum = -odd ** 2
	main_sum = e_sum + o_sum
	print(main_sum)
n = int(input())
func(n)


def main():
	n = int(input())
	if n % 2 == 0:
		k = (n - 2) // 2 + 1
		c = k * (2 + n) // 2
		d = k * (1 + n - 1) // 2
	else:
		k = (n - 1 - 2) // 2 + 1
		c = k * (2 + n - 1) // 2
		d = (k + 1) * (1 + n) // 2
	print(c - d)
main()


from sys import stdin
inp = int(str(stdin.readline()).replace('\n', ''))
if inp % 2 == 0:
	print(inp // 2)
else:
	print((inp // 2 + 1) * -1)


n = int(input())
if n % 2 == 0:
	print(int(n / 2))
else:
	print('-', end='')
	print(int(n / 2) + 1)


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


import math
x = int(input())
if x % 2 == 0:
	y = x / 2
if x % 2 == 1:
	y = -(x + 1) / 2
f = math.trunc(y)
print(f)


a = int(input())

def f(n):
	if n % 2 == 0:
		return n / 2
	elif n % 2 == 1:
		return -(n + 1) / 2
print(int(f(a)))


def funct(n):
	if n % 2 == 0:
		return int(n / 2)
	else:
		return int(-n / 2 - 1)
reda = int(input())
print(funct(reda))


n = int(input())
temp = (n + 1) // 2
result = -temp if n % 2 == 1 else temp
print(result)


import math
n = int(input())
i = 1
x = 0
y = -1
if n % 2 == 0:
	print(int(n / 2))
else:
	print(math.ceil(n / 2) * -1)


num = int(input())
even = odd = 0
if num & 1:
	odd = num
else:
	even = num
odd = odd if odd else num - 1
even = even if even else num - 1
n1 = (odd - 1) // 2 + 1
n2 = (even - 2) // 2 + 1
sum1 = -n1 * (1 + odd) // 2
sum2 = n2 * (2 + even) // 2
print(sum1 + sum2)


n = int(input())

def F(N):
	if N % 2 == 0:
		return N // 2
	return -((N + 1) // 2)
print(F(n))


inp1 = input()
inp1 = int(inp1)
if inp1 % 2 == 0:
	print(int(inp1 / 2))
else:
	print(-(int(inp1 / 2) + 1))


def calculate(number):
	if number % 2 == 1:
		return -(number + 1) // 2
	else:
		return number // 2
number = int(input())
print(calculate(number))


a = int(input())
print(round(a / 2 + 0.4) * (-1) ** (a % 2))


n = int(input())
if n % 2 == 0:
	w = n // 2
else:
	w = (n - 1) // 2 - n
print(w)


import sys
import math
from os import path
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print(-1 * ((n + 1) // 2))


from sys import stdin
_input = stdin.readline
_int = int

def solution():
	n = _int(_input())
	if n == 1:
		print(-1)
	elif n % 2 == 0:
		print(n // 2)
	else:
		print(n // 2 - n)
solution()


n = int(input())
if n % 2 == 0:
	sumo = n * n // 4
else:
	sumo = (n + 1) // 2 * (n + 1) // 2
sume = n // 2 * (n // 2 + 1)
sum = sume - sumo
print(sum)


from math import ceil
n = int(input())
ans = ceil(n // 2)
if n % 2 == 1:
	ans = -ans - 1
print(ans)


n = int(input())
if n % 2 == 0:
	v = n // 2
	a = v * (2 + n)
	a //= 2
	b = v * n
	b //= 2
	sum = a - b
else:
	v = (n - 1) // 2
	a = v * (n + 1)
	a //= 2
	b = (v + 1) * (n + 1)
	b //= 2
	sum = a - b
print(int(sum))


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


from math import ceil
num = int(input())
print(pow(-1, num) * ceil(num / 2))


import math

def main():
	n = int(input())
	if n % 2 == 0:
		sign = 1
	else:
		sign = -1
	print(math.ceil(n / 2) * sign)
main()


n = int(input())
num = 0
if n % 2 != 0:
	n = n + 1
	x = n / 2
	p = -1 * x
	print(int(p))
elif n % 2 == 0:
	p = n / 2
	print(int(p))


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


n = int(input())

def fun(x):
	return (-1) ** x / 4 - (-1) ** x * x / 2
print(int(fun(n + 1) - fun(1)))


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


n = int(input())
a = int(n / 2)
b = n - a
p = b * b
q = a * (a + 1)
print(q - p)


c = int(input())
if c % 2 == 0:
	c = c / 2
	c = int(c)
	print(c)
else:
	d = -(c + 1) / 2
	d = int(d)
	print(d)


from fractions import Fraction
n = Fraction(input())
if n % 2 == 0:
	odd = (n / 2) ** 2
	even = n / 2 * (n / 2 + 1)
else:
	odd = ((n + 1) / 2) ** 2
	even = (n - 1) / 2 * ((n - 1) / 2 + 1)
sum = even - odd
print(int(sum))


n = int(input())
even = n // 2
odd = n // 2 if n % 2 == 0 else n // 2 + 1
sum_even = even * (even + 1)
sum_odd = odd ** 2
print(sum_even - sum_odd)


def f(n):
	(n_even, a_1, a_n) = (n // 2, 2, n if n % 2 == 0 else n - 1)
	even_sum = n_even * ((a_1 + a_n) // 2)
	(n_odd, a_1, a_n) = (n - n // 2, 1, n if n % 2 != 0 else n - 1)
	odd_sum = n_odd * ((a_1 + a_n) // 2)
	print(even_sum - odd_sum)
f(int(input()))


import time
import random
from math import *
from collections import defaultdict
from itertools import *
import re

def solve(n):
	n = int(n)
	return n // 2 if n % 2 == 0 else -n // 2
print(solve(input()))


x = int(input())
lyst = []
if x % 2 == 1:
	result1 = int(-x / 2 - 0.5)
	print(int(result1))
else:
	result2 = x / 2
	print(int(result2))


def main():
	from sys import stdout
	n = int(input())
	if n % 2 == 0:
		res = int(n / 2)
	else:
		res = int(-(n + 1) / 2)
	stdout.write(str(res))
main()


n = int(input())
if n % 2 == 0:
	t = n // 2
	s1 = -1 * t ** 2
	s2 = t * (t + 1)
elif n % 2 != 0:
	t = n // 2
	s1 = -1 * (t + 1) ** 2
	s2 = t * (t + 1)
print(s1 + s2)


n = int(input())
print(n // 2 if not n % 2 else n // 2 - n)


import math
t = int(input())
if t % 2 == 0:
	print(int(t / 2))
else:
	print(0 - (int(t / 2) + 1))


n = int(input())
x = 0
if n % 2 == 0:
	print(n // 2)
else:
	print(n // 2 - n)


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


import math
n = int(input())
if n % 2 == 0:
	print('{0:.0f}'.format(n / 2))
else:
	print('{0:.0f}'.format(-math.ceil(n / 2)))


n = int(input())
if n == 1:
	print(-1)
	exit(0)
if n % 2 == 0:
	print(n // 2)
else:
	print(-(n // 2 + 1))


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


n = int(input())
if n % 2 == 0:
	half = int(n / 2)
	even = half * (half + 1)
	odd = half * half
	print(even - odd)
else:
	half = int(n / 2)
	even = half * (half + 1)
	odd = half * half + n
	print(even - odd)


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


import math
s = int(input())
num = 0
if s % 2 == 0:
	num = s // 2
	print(num)
else:
	num = math.ceil(s / 2)
	print(-num)


def cal(n):
	if n % 2 == 0:
		return n // 2
	else:
		return (n - 1) // 2 - n
n = int(input())
print(cal(n))


total = int(input())
if total % 2 == 0:
	(n1, n2) = (total // 2, total // 2)
	sumeven = n1 * (n1 + 1)
	sumodd = n2 ** 2
	print(sumeven - sumodd)
else:
	n1 = total // 2 + 1
	n2 = total // 2
	sumeven = n2 * (n2 + 1)
	sumodd = n1 ** 2
	print(sumeven - sumodd)


Inpt = int(input())
if Inpt % 2 == 0:
	print(Inpt // 2)
else:
	print(Inpt // 2 - Inpt)


b = int(input())
if b % 2 == 0:
	print(b // 2)
else:
	b = b + 1
	print('-', end=str(b // 2))


p = int(input())
number = int(p / 2)
if p % 2 == 0:
	print(int(number))
else:
	print(int(number - p))


n = int(input())
sm = (-1) ** n * n
print(int(sm / 2) if n % 2 == 0 else int((sm - 1) / 2))


import math
n = int(input())
(o, e) = (math.ceil(n / 2), n // 2)
print(-o ** 2 + e ** 2 + e)


n = int(input())

def answer_(n):
	first_el = -1
	last_el = -1 ** n * n
	answer = 0
	if last_el % 2 != 0:
		answer = (first_el + last_el) // 2
	else:
		answer = -(last_el // 2)
	return answer
print(answer_(n))


def main():
	size = int(input()) + 1
	if size % 2:
		print(size // 2)
	else:
		print(-(size // 2))
main()


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


n = int(input())
x = n // 2
even_sum = x * (x + 1)
total_sum = n * (n + 1) // 2
odd_sum = total_sum - even_sum
print(even_sum - odd_sum)


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


n = int(input())
no = n // 2
seve = no * (4 + (no - 1) * 2) // 2
if n == 1:
	print(-1)
elif n & 1:
	sodd = (no + 1) * (2 + no * 2) // 2
	print(-sodd + seve)
else:
	sodd = no * (2 + (no - 1) * 2) // 2
	print(seve - sodd)


import math
n = int(input())
i = 1
if n % 2:
	i = -1
print(i * math.ceil(n / 2))


import math
num = int(input())
res = math.ceil(num / 2)
if num % 2 == 0:
	print(str(res))
else:
	print(str(res * -1))


def func(num):
	if num % 2 == 0:
		return num / 2
	else:
		return (num - 1) / 2 - num
print(int(func(int(input()))))


t = int(input())
if t % 2:
	sum = t // 2 - t
else:
	sum = t - t // 2
print(sum)


i = int(input())
a = (-1) ** i
b = a * i
print('%d' % (1 / 4 * (2 * b + a - 1)))


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


n = int(input())
a = n if n % 2 == 1 else n - 1
b = n if n % 2 == 0 else n - 1
ans = b // 2 * (2 + b) // 2 - (a + 1) // 2 * (1 + a) // 2
print(f'{ans}')


def f(n):
	res = 1
	if n % 2:
		res = -1
		n += 1
	return res * (n // 2)
n = int(input())
print(f(n))


from sys import stdin
input = stdin.readline
print((lambda n: (n + 1 >> 1) * [1, -1][n & 1])(int(input())))


n = int(input())
if n % 2 != 0:
	(n1, n2) = (n // 2 + 1, n // 2)
else:
	n1 = n2 = n // 2
res1 = n1 * (2 + (n1 - 1) * 2) // 2
res2 = n2 * (4 + (n2 - 1) * 2) // 2
print(res2 - res1)


n = int(input())
if n % 2 == 0:
	n1 = n2 = n // 2
	print(n1)
else:
	n1 = n // 2
	n2 = n // 2 + 1
	print(n1 ** 2 + n1 - n2 ** 2)


def cal_function(n):
	return n // 2 if n % 2 == 0 else -(n + 1) // 2
n = int(input())
print(cal_function(n))


from collections import deque, Counter, OrderedDict
from heapq import nsmallest, nlargest
from math import ceil, floor, log, log2, sqrt

def binNumber(n, size=1):
	return bin(n)[2:].zfill(size)

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

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

def ini():
	return int(input())

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

def sti():
	return str(input())
n = ini()
n2 = n // 2
s = 0
s += n2 * (n2 + 1)
n2 = n - n2
s -= n2 * n2
print(s)


n = int(input())
if n % 2 == 0:
	cPares = n // 2
	cImpares = cPares - 1
else:
	cPares = n // 2
	cImpares = cPares
suma = cPares * (cPares + 1) - (cImpares * (cImpares + 1) + cImpares + 1)
print(suma)


n = int(input())
f = 0
if n % 2 == 0:
	f = n / 2
else:
	f = -n / 2 - 0.5
print(int(f))


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


cislo = int(input())
sucet = (-1) ** (cislo % 2) * (cislo + 1) // 2
print(sucet)


def f(n):
	i = k = n // 2
	if n % 2:
		k += 1
	return i * (i + 1) - k * k
print(f(int(input())))


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


def calculating_function(n):
	if n % 2:
		return int(n / 2) - n
	else:
		return int(n / 2)
n = int(input())
print(calculating_function(n))


n = int(input())
if n % 2 == 0:
	e = n // 2
	o = n // 2
else:
	e = (n - 1) // 2
	o = (n + 1) // 2
add = e * (e + 1)
sub = o ** 2
print(add - sub)


from math import ceil
X = int(input())
print(X * (X + 1) // 2 - 2 * ceil(X / 2) ** 2)


def check(n):
	if n % 2 == 0:
		return int(n / 2)
	return -(int(n / 2) + 1)

def main():
	n = int(input())
	ans = check(n)
	print(ans)
main()


n = int(input())
s = 0
p = 0
c = 0
if n % 2 == 0:
	p = n // 2
	print(p)
else:
	c = -1 + -(n // 2)
	print(c)


n = int(input())
a = []
i = 0
if n % 2 == 0:
	print(n // 2)
elif n % 2 != 0:
	print(-(n + 1) // 2)


def ceil(a, b):
	if a % b == 0:
		return a / b
	return int(a / b) + 1
n = int(input())
print(int((-1) ** n * ceil(n, 2)))


def calculate(num):
	if num % 2 == 0:
		return int(num / 2)
	else:
		return int(-((num + 1) / 2))
number = int(input())
print(calculate(number))


n = int(input())
result = n / 2
if n % 2 == 1:
	result = -(result + 0.5)
print(int(result))


n = int(input())
x = n // 2
y = x + n % 2
x = 2 * (x * (x + 1) // 2)
y = y ** 2
print(x - y)


n = int(input())
e = n // 2
od = n - e
s1 = 0
s1 = e * (e + 1) - od * od
print(s1)


import math
n = int(input())
if n % 2 == 0:
	n1 = n2 = n // 2
else:
	n1 = math.floor(n / 2)
	n2 = math.ceil(n / 2)
a1 = n1 * (n1 + 1)
a2 = n2 ** 2
print(a1 - a2)


a = int(input().strip())
if a % 2 == 1:
	print(-a // 2)
else:
	print(a // 2)


n = int(input())
s = 0
s1 = 0
if n % 2 == 0:
	k = n // 2
else:
	k = n // 2 + 1
t = n - k
s = t * (t + 1)
m = k * k
print(-m + s)


import math
n = int(input())
no = math.ceil(n / 2)
ne = n // 2
ans = ne * (ne + 1) - no ** 2
print(ans)


n = int(input())
sign = (-1) ** (n % 2)
ans = n // 2 + n % 2
print(ans * sign)


def f(n):
	odd = 0
	even = 0
	all = n * (n + 1) // 2
	if n % 2 == 0:
		even = (2 + n) // 2 * (n // 2)
		odd = all - even
		odd = -odd
		return odd + even
	else:
		even = (2 + n - 1) // 2 * (n // 2)
		odd = all - even
		odd = -odd
		return odd + even
n = int(input())
print(f(n))


r = int(input())
a = r % 2
if a == 0:
	b = r / 2
	print(int(b))
else:
	c = -(r / 2 + 0.5)
	print(int(c))


import math
n = int(input())
result = math.ceil(n / 2) * (-1) ** n
print(result)


def solve_bruteforce(n):
	return sum(((-1) ** i * i for i in range(1, n + 1)))

def solve(n):
	k = n // 2
	if n % 2 == 0:
		return k
	else:
		return k - n

def test():
	import random
	for _ in range(100):
		k = random.randint(1, 100000)
		assert solve(k) == solve_bruteforce(k)

def main():
	n = int(input())
	result = solve(n)
	print(result)
main()


n = int(input())
fn = 0
if n == 1:
	print('-', 1, sep='')
elif n == 2:
	print(1)
elif n % 2 == 0:
	print(n // 2)
else:
	print('-', n // 2 + 1, sep='')


from math import ceil

def f(n):
	ne = n // 2
	no = ceil(n / 2)
	return ne * (ne + 1) - no * no
n = int(input())
print(f(n))


n = int(input())
if n % 2 == 0:
	print(n // 2)
elif n % 2 != 0:
	print(f'-{n // 2 + 1}')


import math
n = int(input())
if n & 1:
	temp = n - 1
else:
	temp = n
t = (2 + temp) // 2 - 1
se = t * (t + 1)
so = math.ceil(n / 2) ** 2
print(se - so)


def f(n):
	summa = (-1) ** n * n // 2
	print(summa)
n = int(input())
f(n)


n = int(input())
tot = 0
if n % 2 == 0:
	tot = int(n / 2)
	print(tot)
else:
	tot = int((n - 1) / 2)
	print(tot - n)


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


def F(n):
	return n // 2 - n % 2 * n
n = int(input())
print(F(n))


def _486A(number):
	if number % 2 == 0:
		return number / 2
	else:
		return -((number + 1) / 2)
print(int(_486A(int(input()))))


x = int(input())
z = 0
if x % 2 != 0:
	z = -x
z = z + x // 2
print(z)


n = int(input())
v = (n + 1) // 2
if n % 2 == 1:
	v *= -1
print(v)


from math import ceil

def s(n):
	return n * (n + 1) // 2
n = int(input())
even = 2 * s(n // 2)
odd = ceil(n / 2) + 2 * s(n // 2 + (0 if n % 2 else -1))
print(even - odd)


k = int(input())
print(k // 2 - k % 2 * k)


n = int(input())
print(str((-1) ** n * [n // 2, n // 2 + 1][n % 2 != 0]))


def F(x):
	if x % 2:
		return int(-(x + 1) / 2)
	return int(x / 2)
A = int(input())
print(F(A))


n = int(input())
num_odds = n
if n % 2 != 0:
	num_odds += 1
num_odds = num_odds // 2
num_evens = n - num_odds
sum_odds = -(num_odds * num_odds)
sum_even = num_evens * (num_evens + 1)
ans = sum_odds + sum_even
print(ans)


import sys

def x(y):
	return (2 + y) * (y // 2) // 2

def a(y):
	return (1 + y) * ((y + 1) // 2) // 2
n = int(input())
if n % 2 == 0:
	print(x(n) - a(n - 1))
else:
	print(-a(n) + x(n - 1))


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


def r(t=int):
	return list(map(t, input().split()))

def ri(t=int):
	return t(input())

def cd(it):
	ret_val = dict()
	for v in it:
		ret_val[v] = ret_val.get(v, 0) + 1
	return ret_val
n = ri()
print((n + 1) // 2 * (-1) ** (n % 2))


n = int(input())
op = -1
output = 0
if n == 1:
	print(-1)
elif n % 2 == 0:
	print(n // 2)
else:
	print((n // 2 + 1) * -1)


n = int(input())
p = int(n / 2)
i = int((n + 1) / 2)
ans = p * (p + 1) - i * i
print(ans)


def f(n):
	if n % 2 == 0:
		return n // 2
	return -1 * (n // 2 + 1)
n = int(input())
print(f(n))


from math import *
from collections import deque
from copy import deepcopy
import sys

def inp():
	return sys.stdin.readline().rstrip('\r\n')

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

def lis():
	return list(map(int, inp().split()))

def out(var):
	sys.stdout.write(str(var))

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True
n = int(inp())
if not n % 2:
	print(n // 2)
else:
	print(-(n + 1) // 2)


p = int(input())
if p % 2 == 0:
	print(p // 2)
else:
	print('-' + str((p + 1) // 2))


import sys
import math
input = sys.stdin.readline

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

def str_array():
	return input().strip().split()

def lower_letters():
	lowercase = []
	for i in range(97, 97 + 26):
		lowercase.append(chr(i))
	return lowercase

def upper_letters():
	uppercase = []
	for i in range(65, 65 + 26):
		uppercase.append(chr(i))
	return uppercase
n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print(-(n + 1) // 2)


n = int(input())
t = n * (n + 1) // 2
p = n // 2
pm = p * (p + 1) // 2
print(4 * pm - t)


def sum_of_all(n):
	return n * (n + 1) // 2

def sum_of_odd(n):
	if n % 2 == 1:
		return (n // 2 + 1) ** 2
	else:
		return (n // 2) ** 2
x = int(input())
print(sum_of_all(x) - 2 * sum_of_odd(x))


N = int(input())
p = N // 2
z = int(p * (p + 1))
tot = int(N * (N + 1) // 2)
odd = int(tot - z)
odd *= -1
print(int(odd + z))


import math
input = int(input())
output = math.pow(-1, input) * ((input + 1) // 2)
output = int(output)
print(output)


n = int(input())
x = n // 2
y = n - x
sum_p = x * (x + 1)
sum_n = y ** 2
print(sum_p - sum_n)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	if n % 2 == 0:
		return n // 2
	return -(n // 2 + 1)
print(main())


import math
n = int(input())

def f(n):
	a = math.ceil(n / 2)
	if n / 2 != n // 2:
		a *= -1
	return a
print(f(n))


from math import ceil
n = int(input())
os = ceil(n / 2) ** 2
es = int(n / 2) * (int(n / 2) + 1)
print(es - os)


def evenSum(n):
	n = n // 2
	return n * (n + 1)

def oddSum(n):
	n = n // 2 + 1
	return n * n
n = int(input())
if n % 2 == 0:
	print(evenSum(n) - oddSum(n - 1))
else:
	print(evenSum(n - 1) - oddSum(n))


inp = int(input())
evenSum = inp // 2 * (inp // 2 + 1)
oddSum = (inp // 2 + (inp % 2 != 0)) ** 2
print(evenSum - oddSum)


try:
	n = int(input())
	sum_ = 0
	if n % 2 == 0:
		sum_ = n / 2
	else:
		sum_ = (n - 1) / 2 - n
	print(int(sum_))
except EOFError:
	pass


number_of_input = int(input())
if number_of_input % 2 == 0:
	print(number_of_input // 2)
else:
	print('-{value}'.format(value=str(number_of_input // 2 + number_of_input % 2)))


x = int(input())
if x % 2 == 0:
	a = x - 1
	n = x // 2
	a1 = x
	n1 = n
else:
	a = x
	n = x // 2 + 1
	a1 = x - 1
	n1 = x - n
print(-(n * (1 + a) // 2) + n1 * (2 + a1) // 2)


a = int(input())
g = a // 2
if a % 2 == 1:
	g = g - a
print(g)


n = int(input())
sum = n * (n + 1) // 2
x = n // 2
se = x * (x + 1)
ans = se - (sum - se)
print(ans)


def calFunc(n: int) -> int:
	if n % 2 == 0:
		return n // 2
	return -((n + 1) // 2)

def main():
	integer = int(input().strip())
	print(calFunc(integer))
main()


def calFun(num):
	if num % 2 == 0:
		return int(num / 2)
	return int((num - 1) / 2 - num)
print(calFun(int(input())))


n = int(input())
N = (n + 2) // 2 - 1
s1 = N * (N + 1)
s2 = -(n * (n + 1) // 2) + s1
r = s1 + s2
print(r)


def odd_sum(r):
	return r ** 2

def even_sum(s):
	return s * (s + 1)
n = int(input())
if int(n % 2) == 0:
	print(even_sum(n // 2) - odd_sum(n // 2))
else:
	print(even_sum(n // 2) - odd_sum(n // 2 + 1))


from sys import stdin
N = int(stdin.readline())
if N % 2 == 0:
	print(N // 2)
else:
	print(-N // 2)


f = int(input())
a = (f + 1) // 2
if f % 2 > 0:
	a = -a
print(a)


n = int(input())
a = n // 2
x = n * (n + 1) // 2
print(x - 2 * (x - a * (a + 1)))


n = int(input())
eve = n // 2
od = n - eve
print(-1 * (od * od) + eve * (eve + 1))


import math
import os
import sys
import re
import itertools
import functools
import operator
n = int(input())
print(n // 2 if n % 2 == 0 else -n // 2)


def solve(n):
	x = n - 1 if n % 2 == 0 else n
	mn = -((1 + x) * ((x - 1) // 2 + 1) // 2)
	x = n - 1 if n % 2 == 1 else n
	mx = (2 + x) * ((x - 1) // 2 + 1) // 2
	return mn + mx
n = int(input())
print(solve(n))


n = int(input())
whole = n // 2
part = n % 2
if part == 0:
	print(whole)
else:
	print((whole + 1) * -1)


n = int(input())
if n % 2 == 0:
	print(int(n / 2))
elif n % 2 == 1:
	g = n - 1
	g = g / 2
	print(int(g - n))


i = input
n = int(i())
Even = n // 2
if n % 2 != 0:
	Even -= n
print(Even)


n = int(input())
n1 = (n + 1) // 2
n2 = n // 2
n1n = -1 - 2 * (n1 - 1)
n2n = 2 + 2 * (n2 - 1)
print((n1 * (-1 + n1n) + n2 * (2 + n2n)) // 2)


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


m = int(input())
sum = 0
sum1 = 0
if m % 2 == 0:
	n = m // 2
else:
	n = m // 2 + 1
sum = n * n
sum1 = m * (m + 1) // 2
sum1 = sum1 - sum - sum
print(sum1)


from math import ceil

def fun(num, a, d):
	n = ceil(num / 2)
	v = (2 * a + (n - 1) * d) * n // 2
	return v
n = int(input())
su = 0
if n % 2 == 0:
	vo = fun(n - 1, -1, -2)
	ve = fun(n, 2, 2)
	su = vo + ve
else:
	vo = fun(n, -1, -2)
	ve = fun(n - 1, 2, 2)
	su = vo + ve
print(su)


n = int(input())
ans = 0
i = 2
j = 1
ans += int(n / 2) * int(n / 2 + 1)
ans -= int(((n + 1) // 2) ** 2)
print(ans)


n = int(input())
x1 = 0
x2 = 0
if n % 2 == 0:
	x1 = n // 2
	x2 = n // 2
elif n % 2 == 1:
	x1 = n // 2
	x2 = (n + 1) // 2
print(int(x1 * (x1 + 1) - x2 * x2))


n = int(input())
if n % 2 == 0:
	m1 = n // 2
	a = m1 * (2 + n) // 2
	b = m1 * n // 2
	s = a - b
else:
	m1 = n // 2
	m2 = n // 2 + 1
	a = m1 * (1 + n) // 2
	b = m2 * (1 + n) // 2
	s = a - b
print(s)


n = int(input())
if n % 2 == 0:
	numb = n // 2
	print(numb)
else:
	numb = n // 2 + 1
	print(-numb)


from sys import stdin
arr = [int(x) for x in stdin.readline().rstrip().split()]
num = arr[0]

def compEven(num):
	a1 = 2
	an = num
	n = num // 2
	Sn_even = n * (a1 + an) // 2
	a1 = 1
	an = num - 1
	n = num // 2
	Sn_odd = n * (a1 + an) // 2
	return Sn_even - Sn_odd

def comp(num):
	if num == 1:
		print('-1')
		return
	if num % 2 == 1:
		print(-1 * num + compEven(num - 1))
	else:
		print(compEven(num))
comp(num)


n = int(input().strip())
pos = n // 2 if n % 2 == 0 else (n - 1) // 2
neg = n if n % 2 == 1 else n - 1
pos = pos * (pos + 1)
neg = ((neg + 1) // 2) ** 2
print(pos - neg)


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	temp = (n - 1) // 2
	print(temp - n)


n = int(input())
k = n // 2
l = k + n % 2
e = k * (k + 1)
o = -l ** 2
print(o + e)


m = int(input())
print(m // 2 - m % 2 * m)


import math
number = int(input())
if number % 2 == 0:
	print(math.ceil(number / 2))
else:
	print(-1 * math.ceil(number / 2))


def solve():
	n = int(input())
	if n % 2 == 0:
		print(n // 2)
		return
	print((n - 1) // 2 - n)
solve()


def get_value():
	nth = int(input())
	if nth % 2 == 0:
		return nth // 2
	else:
		return -(nth // 2 + 1)
print(get_value())


n = int(input())
p = n
i = n - 1
if n % 2 != 0:
	p = n - 1
	i = n
p = p // 2
s = p * (p + 1)
i = (i + 1) // 2
s -= i * i
print(s)


T = int(input())
if T % 2 == 0:
	print(int(T / 2))
else:
	print(-int(T / 2) - 1)


x = int(input())
if x % 2 == 0:
	p = x // 2
	q = x // 2
else:
	p = x // 2
	q = x // 2 + 1
m = q * q
n = p * (p + 1)
print(n - m)


n = int(input())
eve = int(n / 2)
odd = n - eve
res1 = int(eve * (eve + 1))
res2 = int(odd * odd)
print(res1 - res2)


from sys import stdin
x = stdin.readline().rstrip().split()[0]
x = int(x)
nr_even = x // 2
nr_odd = x - nr_even
positive_sum = nr_even * (nr_even + 1)
negative_sum = nr_odd ** 2
print(positive_sum - negative_sum)


import math
n = int(input())
sum = 0
if n % 2 == 0:
	print(int(n / 2))
else:
	print(-math.ceil(n / 2))


i = int(input())
if i % 2 == 0:
	eve = True
	odd = True
	if eve == True:
		n = i // 2
		ao = 2
		d = 2
		se = n * (2 * ao + (n - 1) * d) // 2
	if odd == True:
		n = i // 2
		ao = 1
		d = 2
		so = n * (2 * ao + (n - 1) * d) // 2
elif i % 2 != 0:
	eve = True
	odd = True
	if eve == True:
		n = (i - 1) // 2
		ao = 2
		d = 2
		se = n * (2 * ao + (n - 1) * d) // 2
	if odd == True:
		n = (i + 1) // 2
		ao = 1
		d = 2
		so = n * (2 * ao + (n - 1) * d) // 2
print(se + so * -1)


n = int(input())
if n % 2 == 0:
	x = n // 2
	s = x * (x + 1) - x ** 2
if n % 2 == 1:
	x = n // 2
	s = x * (x + 1) - (x + 1) ** 2
print(s)


d = int(input())
if d % 2 == 0:
	x = 2 * d / 4
else:
	x = 2 * (d - 1) / 4 - d
print(int(x))


number = int(input())
outcome = 0
if number % 2 == 0:
	print(int(number / 2))
else:
	print(int((number - 1) / 2 - number))


try:
	x = int(input())
	if x % 2 == 0:
		print(int(x / 2))
	else:
		print(int(-1 * (x // 2 + 1)))
except:
	pass


def prob486a(x):
	if x % 2 == 0:
		n = x
		k = x
	else:
		n = x + 1
		k = x - 1
	sum_odd_num = (n // 2) ** 2
	if x >= 2:
		magic_number = (2 + k) // 2 - 1
		sum_even_num = magic_number * (magic_number + 1)
	else:
		sum_even_num = 0
	return sum_even_num - sum_odd_num
x = int(input())
print(prob486a(x))


i = int(input())
answer = 0
if i % 2 == 0:
	answer = 1 * (i // 2)
else:
	answer = 1 * (i // 2) - i
print(str(answer))


import sys
input = sys.stdin.readline

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

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = int(input())
if n & 1:
	ans = -1 * (n // 2 + 1)
else:
	ans = n // 2
print(ans)


num = int(input())
result = num // 2 if num % 2 == 0 else -(num + 1) // 2
print(result)


n = int(input())
if n % 2 == 0:
	e = n
	o = n - 1
else:
	e = n - 1
	o = n
e = int(e / 2)
sum_e = e * (e + 1)
o = int(o / 2)
sum_o = o + 1 + o * (o + 1)
print(sum_e - sum_o)


def function(n):
	if n % 2:
		return (n // 2 + 1) * -1
	else:
		return n // 2
print(function(int(input())))


a = int(input())
print(a // 2 if not a % 2 else -(a + 1) // 2)


from math import ceil
t = int(input())
(p, q) = (0, 0)
m = ceil(t / 2)
n = t // 2
p = n * (n + 1)
q = -(m * m)
print(p + q)


import math

def calc(a, b):
	totaln = math.ceil(b / 2)
	return (totaln * a + totaln * b) // 2
n = int(input())
ans = calc(2, n) - calc(1, n - 1) if n % 2 == 0 else calc(2, n - 1) - calc(1, n)
print(ans)


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	k = n // 2
	add = k + 1
	str_ = str(add)
	print('-' + str_)


__author__ = 'Utena'
n = int(input())
if n % 2 == 0:
	print(int(n / 2))
else:
	print(int(n / 2) - n)


number = int(input())
number_nieparzysty = number / 2 + 0.5
number_razy_dwa = number_nieparzysty * 2
wynik = number_nieparzysty - number_razy_dwa
if number % 2 == 0:
	print(int(number / 2))
elif number % 2 == 1:
	print(int(wynik))


n = int(input())
if n % 2 == 0:
	even_n = n
	odd_n = n - 1
else:
	even_n = n - 1
	odd_n = n
last_even = int(even_n / 2)
last_odd = int((odd_n + 1) / 2)
sum_even = last_even * (last_even + 1)
sum_odd = last_odd ** 2
print(sum_even - sum_odd)


x = int(input())
y = int(pow(-1, x % 2) * (x / 2 + x % 2))
print(y)


withFile = 0
if withFile == 1:
	fin = open('input.txt', 'r')
	fout = open('output.txt', 'w')

def getl():
	if withFile == 0:
		return input()
	else:
		return fin.readline()

def printl(s):
	if withFile == 0:
		print(s)
	else:
		fout.write(str(s))

def get_arr():
	x = getl().split(' ')
	if x[-1] == '':
		x = x[:-1]
	return list(map(int, x))
n = get_arr()[0]
if n % 2:
	print(int(int(n - 1) / 2) - n)
else:
	printl(int(n / 2))
if withFile == 1:
	fin.close()
	fout.close()


def main():
	n = int(input())
	if n % 2 == 0:
		e = n // 2
		o = n // 2
	else:
		e = n // 2
		o = n // 2 + 1
	esum = e * (e + 1)
	osum = o * o
	print(osum * -1 + esum)
main()


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


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


def tot(n):
	if n % 2 == 0:
		return n // 2
	else:
		previous = (n - 1) // 2
		return previous - n
n = int(input())
print(tot(n))


import math
n = int(input(''))
if n == 1:
	print('-1')
else:
	minus = 1
	if n % 2 != 0:
		minus *= -1
	ans = math.ceil(n / 2)
	print(ans * minus)


from math import ceil
n = int(input())
f = ceil(n / 2)
if n % 2 == 1:
	f *= -1
print(f)


sr = int(input())
print(sr // 2 - sr % 2 * sr)


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


import math
a = int(input())
if a % 2 != 0:
	sum = int(a / 2) - a
else:
	sum = a / 2
print(int(sum))


n = int(input())
a = n // 2
r = a
if n % 2 != 0:
	r = a + 1
s = a * (a + 1) - r * r
print(s)


num = int(input())
if num % 2 == 0:
	print(num // 2)
else:
	a = num // 2
	print(a - num)


from math import ceil
x = int(input())
if x % 2 != 0:
	x = ceil(x / 2) * -1
else:
	x //= 2
print(x)


def f(n):
	if n % 2 == 0:
		k1 = int(n / 2)
		return k1 * (k1 + 1) - k1 * k1
	else:
		k2 = int((n + 1) / 2)
		return -(k2 * k2) + k2 * (k2 - 1)
n = int(input())
print(f(n))


import sys

def get():
	return int(sys.stdin.readline().strip())
n = get()
if n % 2:
	print(-(n + 1) // 2)
else:
	print(n // 2)


try:
	n = int(input())
	func = 0
	if n % 2 == 0:
		func = n // 2
	else:
		func = -n + n // 2
	print(func)
except:
	pass


n = int(input())
r = n // 2
if n % 2 != 0:
	r += -n
print(r)


from sys import stdin

def main():
	val = int(stdin.readline())
	if val % 2 == 0:
		print(int(val / 2))
	else:
		print(int(-(val + 1) / 2))
main()


n = int(input())
if n == 1:
	print(-1)
else:
	if n % 2 == 0:
		od = n // 2
		ev = n // 2
	else:
		od = n // 2 + 1
		ev = n // 2
	smo = od * (-2 - (od - 1) * 2) // 2
	sme = ev * (4 + (ev - 1) * 2) // 2
	sm = smo + sme
	print(sm)


x = int(input())
y = x / 2
z = x % 2
if z != 0:
	y = int(-1 * (y + 1))
	print(y)
if z == 0:
	y = int(y)
	print(y)


x = input()
n = int(x)
if n % 2 == 0:
	print(int(n / 2))
else:
	y = int(n / 2) + 1
	z = f'-{y}'
	print(z)


def main():
	n = int(input())
	print((2 * (-1) ** n * n + (-1) ** n - 1) // 4)
main()


f = int(input())
if f % 2 == 0:
	f = f // 2
	print(f)
else:
	f = f // 2 - f
	print(f)


n = int(input())
if n % 2 == 0:
	x = int(n / 2)
	z = x * (x + 1)
	o = n - 1
	y = int(o // 2 + 1)
	m = y * y
	print(z - m)
elif n % 2 == 1:
	j = int(n // 2 + 1)
	k = j * j
	h = n - 1
	l = int(h / 2)
	q = l * (l + 1)
	print(q - k)


n = int(input())
if n % 2 != 0:
	odd_1 = -(1 + n) * (n + 1) // 4
	even_1 = (1 + n) * (n - 1) // 4
	print(odd_1 + even_1)
else:
	odd_2 = -(1 + n) * (n - 1) // 4
	even_2 = (1 + n) * (n + 1) // 4
	print(odd_2 + even_2)


n = int(input())
ans = 0
if n == 1 or n == 0:
	ans = -n
elif n % 2 == 0 and n != 0:
	ans = n / 2
else:
	ans = -(n + 1) / 2
retans = int(ans)
print(retans)


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


def calcfun(n):
	if n % 2 == 0:
		return n / 2
	else:
		p = (n - 1) / 2
		return p - n
n = int(input())
print(int(calcfun(n)))


x = int(input())
if x % 2 == 0:
	a = x / 2
else:
	a = x // 2 - x
print(int(a))


def main(n):
	if n % 2 == 0:
		a = n // 2 * (2 + n) // 2
		b = n // 2 * (-1 + (-n + 1)) // 2
	else:
		a = n // 2 * (2 + (n - 1)) // 2
		b = (n // 2 + 1) * (-1 + -n) // 2
	return a + b
print(main(int(input())))


from sys import stdin

def readint():
	return int(stdin.readline())

def main():
	n = readint()
	print((-1 if n % 2 else 1) * int((n + 1) / 2))
main()


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


n = int(input())
r = n % 2
if r == 1:
	o = (1 + n) * (n + 1) // 4
	e = (2 + n - 1) * (n - 1) // 4
else:
	o = n * n // 4
	e = (2 + n) * n // 4
print(e - o)


n = int(input())
summ = -(1 - pow(-1, n)) / 4 - n * pow(-1, n + 1) / 2
print(int(summ))


import math
st = ''

def func(n):
	if n % 2:
		return n // 2 - n
	return n // 2
for _ in range(1):
	n = int(input())
	st += str(func(n)) + '\n'
print(st)


def cal_fun(n):
	if n % 2 == 0:
		return n / 2
	else:
		s = (n - 1) / 2
		return s - n
n = int(input())
print(int(cal_fun(n)))


def f(a):
	halb = a // 2
	plus = halb * (halb + 1)
	if a % 2 == 0:
		half = halb
	else:
		half = (a + 1) // 2
	minus = half ** 2
	return plus - minus
inp = int(input())
print(f(inp))


m = int(input())
o = m // 2 + m % 2
e = m - o
s = e * (e + 1) - o * o
print(s)


import math
n = input()
n = int(n)
impar = math.ceil(n / 2)
par = math.floor(n / 2)
print((par + 1) ** 2 - (par + 1) - impar ** 2)


import sys
import math
s = int(input())
if s % 2 == 0:
	print(int(s / 2))
else:
	print(int(s / 2) + -1 * s)


import sys

def ceiling(a):
	if a > int(a):
		return int(a + 1)
	return int(a)
n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print(-ceiling(n / 2))


from math import ceil
n = int(input())
a = ceil(n / 2)
if n & 1:
	print(-a)
else:
	print(a)


import math
n = int(input())
if n % 2 == 0:
	en = on = int(n / 2)
else:
	on = int(math.ceil(n / 2))
	en = n - on
tot = en * (en + 1) - on * on
print(tot)


n = int(input())
soma = 0
if n % 2 == 0:
	soma = n // 2
else:
	soma = -(n + 1) // 2
print(soma)


f = lambda n: -f(n + 1) if n % 2 else n // 2
print(f(int(input())))


n = int(input())
if n % 2 == 0:
	x = n / 2
else:
	l = (n + 1) / 2
	x = 0 - l
print(int(x))


import sys
n = 0
for line in sys.stdin:
	n = int(line)
result = 0
if n % 2 == 0:
	result = n / 2
else:
	result = -(n + 1) / 2
print(int(result))


n = int(input())
if n % 2:
	c = n // 2 + 1
	d = n // 2
	e = -c ** 2
	f = d * (d + 1)
	print(e + f)
else:
	y = n // 2
	m = -y ** 2
	h = y * (y + 1)
	print(m + h)


def f(n):
	if n % 2 == 0:
		ans = n // 2
	else:
		ans = -(n // 2 + 1)
	print(ans)
n = int(input())
f(n)


def calculatingFunction():
	n = int(input())
	i = 1
	add = n // 2 - n % 2 * n
	print(add)
calculatingFunction()


n = int(input())
no_of_odds = n // 2 + (1 if n % 2 != 0 else 0)
sum_of_odd = -1 * no_of_odds ** 2
n -= no_of_odds
sum_of_even = n * (n + 1)
print(sum_of_even + sum_of_odd)


import math
n = int(input())
p = n * (n + 1) // 2
k = math.ceil(n / 2)
q = 2 * k ** 2
print(p - q)


n = int(input())
if n % 2 == 0:
	odd = (n // 2) ** 2
	even = n // 2 * (n // 2 + 1)
	print(even - odd)
else:
	temp = n // 2 + 1
	odd = temp ** 2
	even = n // 2 * (n // 2 + 1)
	print(even - odd)


count = int(input())
res = int(count / 2)
if count % 2 == 1:
	res -= count
print(res)


number = int(input())
sum = 1
sum = int(sum * number / 2)
if number % 2 == 0:
	print(sum)
else:
	print(sum * -1 - 1)


p = int(input())
print(p // 2 - p % 2 * p)


n = int(input())
chet = (2 + n - n % 2) * (n // 2) // 2
nechet = (1 + (n - 1 + n % 2)) * (n // 2 + n % 2) // 2
print(chet - nechet)


def main():
	n = int(input())
	if n == 1:
		print(-1)
		return
	if n == 2:
		print(1)
		return
	if n % 2:
		sum_odds = (n // 2 + 1) ** 2
	else:
		sum_odds = (n // 2) ** 2
	print(2 * sum_cons(n // 2) - sum_odds)

def sum_cons(n):
	return n * (n + 1) // 2
main()


import sys
n = int(sys.stdin.readline().rstrip())
if n % 2 == 0:
	print(n // 2)
else:
	print(n // 2 - n)


n = int(input())
evens = (n - n % 2) * (2 + (n - n % 2)) // 4
if n % 2 == 0:
	n = n - 1
odds = -(pow(1 + n, 2) // 4)
print(evens + odds)


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


n = int(input())
count = (0 - (-1) ** (n + 1) * n + (n - 1) % 2 - 1) / 2
print(int(count))


n = int(input())
a = 0
if n % 2 == 0:
	print(n // 2)
elif n == 3:
	print(-2)
else:
	a = n // 2
	print('-' + str(n - a))


def main():

	def parser():
		while 1:
			data = list(input().split(' '))
			for number in data:
				if len(number) > 0:
					yield number
	input_parser = parser()
	gets = lambda : next(input_parser)

	def getNum():
		data = gets()
		try:
			return int(data)
		except ValueError:
			return float(data)
	n = getNum()
	print(n // 2 - (n if n & 1 > 0 else 0))
main()


n = int(input())
(o, e) = (n // 2, n // 2)
(se, so) = (0, 0)
if n & 1:
	o += 1
	se = e * (2 + n - 1) // 2
	so = o * (1 + n) // 2
else:
	se = e * (2 + n) // 2
	so = o * n // 2
print(se - so)


i = int(input())
if i % 2 == 0:
	x = i // 2
	y = i // 2
else:
	x = i // 2
	y = i - x
sum = x * (x + 1) - y ** 2
print(sum)


sumodd = 0
n = int(input())
sumeven = 2 * n // 2 * (n // 2 + 1) // 2
if n % 2 != 0:
	extra = (n + 1) / 2
else:
	extra = -(n / 2)
print(sumeven - (sumeven + int(extra)))


n = int(input())
p = int(n // 2)
sum = n * (n + 1) // 2
tot = sum
odd = tot - 2 * (p * (p + 1) // 2)
sum = int(sum)
odd = int(2 * odd)
print(sum - odd)


from math import ceil
n = int(input())
sign = (-1) ** n
print(sign * ceil(n / 2))


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


y = int(input(''))
if y % 2 == 0:
	print(int(y / 2))
else:
	print(int((y - 1) / 2 - y))


__author__ = 'Rakshak.R.Hegde'

def AP(a, n, d):
	return n * (2 * a + (n - 1) * d) >> 1
n = int(input())
ans = AP(2, n >> 1, 2) - AP(1, n + 1 >> 1, 2)
print(ans)


ahmedahmed = int(input())
print(ahmedahmed // 2 - ahmedahmed % 2 * ahmedahmed)


n = int(input())
a = int((n + 1) / 2)
if n % 2:
	a *= -1
print(a)


n = int(input())
resO = 0
resE = 0
if n % 2 == 0:
	n = n // 2
	resO += n ** 2
	resE += n * (n + 1)
else:
	n = n // 2
	resO += (n + 1) ** 2
	resE += n * (n + 1)
print(resE - resO)


import math
i = int(input())
if i % 2 == 0:
	print(int(i / 2))
else:
	print(math.floor(-i / 2))


n = int(input())
temp1 = n // 2 + n % 2
temp2 = n - temp1
ans1 = temp1 ** 2
ans2 = temp2 * (temp2 + 1)
print(ans2 - ans1)


n = int(input())
m = int(n / 2)
k = m * (m + 1)
if n % 2 == 1:
	d = int(n / 2) + 1
else:
	d = int(n / 2)
s = d * d
print(int(k - s))


import math
a = int(input())

def my_function(a):
	if a % 2 == 0:
		print(a // 2)
	else:
		print(-math.ceil(a / 2))
my_function(a)


def getnumber(n):
	if n % 2 == 0:
		return n / 2
	else:
		return (n - 1) / 2 - n
print(int(getnumber(int(input()))))


import math
n = int(input())
d = math.ceil(n / 2)
if n % 2 == 0:
	print(d)
else:
	print(-d)


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


foo = int(input())
if foo % 2 == 0:
	print(int(foo / 2))
else:
	print(int(-(foo + 1) / 2))


n = int(input())
l = []
d = -(n - 1) / 2
if n % 2 == 0:
	print(int(n / 2))
else:
	print(int(-1 + d))


N = int(input())
even = lambda n: n * (n + 1)
odd = lambda n: n ** 2
O = odd((N + 1) // 2)
E = even(N // 2)
print(E - O)


n = int(input())
t = 0
r = n // 2
if n % 2 == 0:
	t = r
else:
	t = r - n
print(t)


n = int(input())
z = -1 if n % 2 == 1 else 1
print((n * 2 * z + z - 1) // 4)


data = int(input())
print(-data // 2 if data % 2 == 1 else data // 2)


num = int(input())
print(num // 2 - num % 2 * num)


import math
m = int(input())
result = m / 2
if m % 2 == 0:
	print(math.ceil(result))
else:
	print(math.floor(-result))


n = int(input())
f = 0
if n % 2 == 0:
	f = n / 2
else:
	f = (n - 1) / 2 - n
z = str(f)
print(z[:-2])


aaa = int(input())
print(aaa // 2 - aaa % 2 * aaa)


def function(n):
	mid = n // 2
	even_sum = (2 + n) // 2 * mid
	if n % 2 == 1:
		mid += 1
	odd_sum = (1 + n) // 2 * mid
	print(even_sum - odd_sum)
n = int(input())
function(n)


til = int(input())
if til % 2 == 0:
	n = int(til / 2)
	odd = n * n
	even = n * (n + 1)
	print(even - odd)
else:
	n = til // 2 + 1
	odd = n * n
	even = (n - 1) * n
	print(even - odd)


def f(n):
	if n % 2 == 0:
		return n // 2
	else:
		return -(n // 2 + 1)
	return s
a = int(input())
print(f(a))


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


a = int(input())
if a % 2 == 0:
	print('%d' % (a / 2))
else:
	print(a // 2 - a)


a = int(input())
aa = a // 2
bb = -aa - 1
if a % 2 == 0:
	print(aa)
else:
	print(bb)


n = int(input())
resultat = 0
if n % 2 == 0:
	resultat = int(n / 2)
else:
	resultat = -int(n / 2) - 1
print(resultat)


n = int(input())
z = -1
ans = z * ((1 - (n + 1) * z ** n + n * z ** (n + 1)) / (1 - z) ** 2)
print(int(ans))


N = int(input())
x = N // 2
evens = x * (x + 1)
n = (N + 1) // 2
odds = n + n * (n - 1)
ans = evens - odds
print(ans)


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


import math
a = int(input())
if a % 2 == 0:
	a /= 2
	print('%.0f' % a)
else:
	print(-1 * math.ceil(a / 2))


n = int(input())
sign = -1 if n % 2 != 0 else 1
print(sign * ((n + 1) // 2))


def summ(n):
	if n % 2 == 0:
		return n / 2
	else:
		return (n + 1) / 2 * -1
print(int(summ(int(input()))))


n = int(input())
if n == 1:
	print(-1)
else:
	if n % 2 == 1:
		(no, ne) = (n, n - 1)
	else:
		(ne, no) = (n, n - 1)
	s1 = (1 + no) * ((no - 1) // 2 + 1) // 2
	s2 = (2 + ne) * ((ne - 2) // 2 + 1) // 2
	print(s2 - s1)


import math
n = int(input())
res = int(math.ceil(n / 2))
if n % 2 == 1:
	res *= -1
print(res)


n = int(input())
even_start = 2
odd_start = 1
if n % 2 == 0:
	even_end = n
	odd_end = n - 1
else:
	even_end = n - 1
	odd_end = n
sum_of_even = ((even_end - even_start) // 2 + 1) * (even_start + even_end) // 2
sum_of_odd = ((odd_end - odd_start) // 2 + 1) * (odd_start + odd_end) // 2
print(sum_of_even - sum_of_odd)


n = int(input())
c = 0
if n % 2 == 0:
	l = n // 2
	e = n // 2
	e = e * (e + 1)
else:
	l = (n + 1) // 2
	e = (n - 1) // 2
	e = e * (e + 1)
so = l ** 2
c = e - so
print(c)


def f(n):
	sum1 = int(n / 2)
	if n % 2 != 0:
		sum1 -= n
	return sum1
print(f(int(input())))


def foo(num):
	if num % 2 == 1:
		return int(-num + (num - 1) / 2)
	else:
		return int(num / 2)
x = int(input())
print(foo(x))


value_of_n = int(input())
if int(value_of_n) % 2 == 0:
	even_sum = int(value_of_n / 2) * (int(value_of_n / 2) + 1)
	odd_sum = pow(int((value_of_n + 1) / 2), 2)
else:
	even_sum = int(value_of_n / 2) * (int(value_of_n / 2) + 1)
	odd_sum = pow(int((value_of_n + 1) / 2), 2)
total_sum = even_sum - odd_sum
print(int(total_sum))


n = int(input())
from math import ceil
a = ceil(n / 2)
b = n // 2
s = b * (b + 1) - a * a
print(s)


n = int(input())
a = -1
d = -1
r = -1
s = (a - (a + (n - 1) * d) * r ** n) / (1 - r) + d * r * (1 - r ** (n - 1)) / (1 - r) ** 2
print(int(s))


n = int(input())
if n % 2 == 0:
	odd = n // 2
else:
	odd = n // 2 + 1
final = n * (n + 1) // 2 - 2 * odd * odd
print(final)


n = int(input())
m = n - 1
if n % 2 == 0:
	a = n // 2 * (m + 2) // 2
	b = n // 2 * (1 + m) // 2
	s = n // 2 * (n + 2) // 2 - n // 2 * (1 + m) // 2
	print(s)
else:
	s = (n - 1) // 2 * (2 + m) // 2 - (n + 1) // 2 * (1 + n) // 2
	print(s)


from math import ceil, floor
n = int(input())
if n % 2 == 0:
	print(int(n / 2))
if n % 2 != 0:
	o = int(n / 2) + 1
	e = floor(n / 2)
	print(int(e ** 2 + e - o * o))


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


n = int(input())
terms_even = 0
terms_odd = 0
if n % 2 == 0:
	terms_even = n // 2
	terms_odd = n // 2
else:
	terms_even = (n - 1) // 2
	terms_odd = (n + 1) // 2
print(terms_even * (4 + (terms_even - 1) * 2) // 2 - terms_odd * (2 + (terms_odd - 1) * 2) // 2)


n = int(input())
t = n // 2
m = n - t
even = t * (t + 1)
odd = m ** 2
print(int(even - odd))


def main():
	n = int(input())
	x = n // 2
	ret = x
	if n % 2 == 1:
		ret += -n
	print(ret)
main()


n = int(input())
total_sum = n * (n + 1) // 2
if n % 2 == 1:
	n = n // 2 + 1
else:
	n = n // 2
odd_sum = n * (2 * n) // 2
print(total_sum - 2 * odd_sum)


n = int(input())
positive = n // 2
negative = n - positive
sum_p = (2 * 2 + 2 * (positive - 1)) * positive // 2
sum_n = (2 + 2 * (negative - 1)) * negative // 2
print(sum_p - sum_n)


def main():
	from sys import stdin, stdout
	from math import ceil
	n = int(stdin.readline())
	result = ceil(n / 2)
	n //= 2
	stdout.write(str(n * (n + 1) - result * result))
main()


repetition = int(input())
number = (repetition + 1) // 2
output = 0
if repetition % 2 == 1:
	output = output - number
	print(output)
else:
	output = output + number
	print(output)


from math import *
n = int(input())
ans = abs(n) // 2 + abs(n) % 2
if n % 2 == 1:
	ans = -ans
print(ans)


n = int(input())
e = n // 2
o = n - e
even = e * (e + 1)
odd = o ** 2
print(even - odd)


x = int(input())
if x % 2 == 0:
	n = x // 2
	y = n * (n + 1) - n ** 2
elif x % 2 != 0:
	n = x // 2
	y = n * (n + 1) - (n + 1) ** 2
print(y)


x = int(input())

def f(x):
	if x % 2 == 0:
		return x / 2
	elif x < 10 ** 7:
		s = 0
		signe = -1
		for i in range(1, x + 1):
			s = s + signe * i
			signe = signe * -1
		return s
	else:
		return ((x - 1) / 2 + 1) * -1
print(int(f(x)))


import sys
for line in sys.stdin:
	n = int(line.strip())
	total = (n // 2) ** 2 + n // 2
	total -= (n // 2 + n % 2) ** 2
	print(total)


_1 = '236a'
_2 = '339a'
_3 = '266a'
_4 = '96a'
_5 = '236a'
_6 = '281a'
_7 = '546a'
_8 = '116a'
_9 = '977a'
_10 = '266b'
_11 = '110a'
_12 = '41a'
_13 = '734a'
_14 = '133a'
_15 = '467a'
_16 = '158a'
_17 = '677a'
_18 = '580a'
_19 = '344a'
_20 = '1030a'
_21 = '705a'
_22 = '318a'
_23 = '479a'
_24 = '486a'
n = int(input())
if n % 2 == 0:
	print(int(n / 2))
else:
	print(round((n + 1) / 2) * -1)


lookup_pow = int(input())
print(int(lookup_pow / 2) * (-1 if lookup_pow % 2 else 1) - (1 if lookup_pow % 2 else 0))


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


def arithmetic(n):
	if n % 2 != 0:
		even = n // 2
		odd = even + 1
	else:
		odd = even = n // 2
	neg_sum = odd * (-2 + (odd - 1) * -2) // 2
	pos_sum = even * (4 + (even - 1) * 2) // 2
	return neg_sum + pos_sum
n = int(input())
print(arithmetic(n))


def f(n):
	odd_n = (n + 1) // 2
	even_n = n // 2
	if n % 2 == 0:
		odd_last = n - 1
		even_last = n
	else:
		odd_last = n
		even_last = n - 1
	return (2 + even_last) * even_n // 2 - (1 + odd_last) * odd_n // 2
print(f(int(input())))


n = int(input())
if n % 2 == 0:
	print(n // 2)
elif n % 2 != 0:
	p = str(n // 2 + 1)
	print('-' + p)


from math import ceil
num = int(input())
div2 = ceil(num / 2)
print(div2 if num % 2 == 0 else -div2)


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


import math as m
n = int(input())
h = m.ceil(n / 2)
print((n - h) * (n - h + 1) - h ** 2)


t = int(input())
s = 0
if t % 2 == 0:
	print(t // 2)
else:
	t = -1 * (t // 2) - 1
	print(t)


s = int(input())
p = s // 2
if s % 2 != 0:
	a = (p + 1) * (p + 1)
	b = p * (p + 1)
	print(-a + b)
else:
	a = p * p
	b = p * (p + 1)
	print(b - a)


def calcular(n):
	if n % 2 == 0:
		n //= 2
	else:
		n //= -2
	return n
print(calcular(int(input())))


n = input()
n = int(n)
x = 0
if n % 2 == 0:
	n = n // 2
	print(n)
	exit()
else:
	n = float(n)
	x = n / 2.0
	n = int(x + 0.5)
	n = -1 * n
print(n)


import math
n = int(input())
even = math.floor(n / 2.0) * (math.floor(n / 2.0) + 1)
odd = math.ceil(n / 2.0) * math.ceil(n / 2.0)
print(even - odd)


n = int(input())
e = int(n / 2)
evens = e * (e + 1)
odds = int((n + 1) / 2) ** 2
print(evens - odds)


__author__ = 'myduomilia'
n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	print(-(n + 1) // 2)


def cFun(n):
	if n % 2 == 0:
		return n // 2
	return -(n // 2 + 1)
n = int(input())
print(cFun(n))


n = int(input())
if n % 2 == 0:
	a = n // 2 * (n // 2 + 1)
	b = n * n // 4
	print(a - b)
else:
	t = (n - 1) // 2
	c = t * (t + 1)
	d = ((n + 1) // 2) ** 2
	print(c - d)


import math
n = int(input())
s = math.ceil(n / 2)
if n % 2 == 1:
	print(-s)
else:
	print(s)


from math import ceil

def solve(n):
	n_even = n % 2 == 0
	return n // 2 if n_even else (n - 1) // 2 - n

def main():
	n = int(input())
	print(solve(n))
main()


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


n = int(input())
if n % 2 == 0:
	lastEven = n
	lastOdd = -(n - 1)
else:
	lastEven = n - 1
	lastOdd = -n
numOdd = lastOdd // 2
numEven = abs(lastEven // 2)
sumEven = numEven * (2 + lastEven) // 2
sumOdd = numOdd * (-1 + lastOdd) // 2
print(sumEven - sumOdd)


n = int(input())
sign = 1
if n % 2:
	sign = -1
n = int(n / 2 + 0.5) * sign
print(n)


def solve():
	n = int(input())
	ret = n // 2
	if n % 2 == 1:
		ret -= n
	print(ret)
solve()


def fd70000000():
	n = int(input())
	if n % 2:
		return print(-(n // 2 + 1))
	else:
		return print(n // 2)
fd70000000()


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


n = int(input())
le = n
if n % 2 == 1:
	le -= 1
lo = n
if n % 2 == 0:
	lo -= 1

def f(fir, las):
	fir = int(fir)
	las = int(las)
	return (fir + las) * ((las - fir) // 2 + 1) // 2
print(f(2, le) - f(1, lo))


n = int(input())
x = n // 2
if n % 2 == 1:
	x -= n
print(x)


yy = int(input())
if yy % 2 == 0:
	print(yy // 2)
else:
	print(-((yy + 1) // 2))


s = int(input())
if s == 0:
	print('0')
elif s % 2 == 0:
	print(s // 2)
else:
	print(-(s + 1) // 2)


n = int(input())
len1 = n // 2
len2 = n - len1
ls1 = 0
ls2 = 0
if n % 2 == 0:
	ls1 = n
	ls2 = n - 1
else:
	ls1 = n - 1
	ls2 = n
s1 = (2 + ls1) * len1 // 2
s2 = (1 + ls2) * len2 // 2
print(s1 - s2)


num = int(input())
tot = 0
tot += num // 2
if num % 2 == 1:
	tot -= num
print(tot)


n = int(input())
final_answer = 0
if n % 2 == 0:
	final_answer = n / 2
else:
	final_answer = -(n // 2) - 1
print(int(final_answer))


n = int(input())
fun = 0
if n % 2 == 0:
	fun = int(n / 2)
else:
	fun = int(n / 2) - n
print(fun)


n = int(input())
c = n - int(n / 2)
if n % 2 == 1:
	c = -c
print(c)


number = int(input())
if number % 2 == 1:
	print(-abs(number - number // 2))
elif number % 2 == 0:
	print(number - number // 2)


n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	a = n // 2
	e = n % 2
	ok = a + e
	print(-ok)


n = int(input())
npar = n // 2
nimpar = n - npar
resp = -1 * nimpar * nimpar + npar * (npar + 1)
print(resp)


def get():
	return [int(x) for x in input().split()]
(n,) = get()
print(-(n // 2 + 1) if n % 2 else n // 2)


def calcfunc(n):
	if n % 2 == 0:
		print(int(n / 2))
	else:
		print(int(-(n + 1) / 2))
n = int(input())
calcfunc(n)


from sys import stdin, stdout
import math
n = int(stdin.readline())
print(n // 2 * (n // 2 + 1) - math.ceil(n / 2) ** 2)


a = int(input())
print([a // 2 - a, a // 2][a % 2 == 0])


from math import ceil

def calc():
	n = int(input())
	ans = 0
	if n % 2 == 0:
		ans = n // 2
	else:
		ans = -ceil(n / 2)
	print(ans)
calc()


n = int(input())
k = n // 2
j = k * (k + 1)
l = n - k
q = l ** 2
print(j - q)


a = int(input())
if a % 2 == 0:
	print(int(a / 2))
if a % 2 != 0:
	a = a / 2 * -1 - 0.5
	a = int(a)
	print(a)


import math
x = int(input())
print('-' if x % 2 else '', str(int(math.ceil(x / 2))), sep='')


a = int(input())
if a % 2 == 0:
	print(a // 2)
elif a % 2 != 0:
	print((a - 1) // 2 - a)