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
Tags: Mathematics

Implementation

Starter code:

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)


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


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)


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


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)


n = int(input())
if n >= 1 and n <= 10 ** 15:
	if n % 2 == 0:
		print(n // 2)
	else:
		print(n // 2 - 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)


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


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
a = eval(input())
if a % 2 == 0:
	print(int(a / 2))
elif a % 2 != 0:
	print(-int(math.ceil(a / 2)))


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)


n = eval(input())
if n % 2:
	print(-n // 2)
else:
	print(n // 2)


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)


while True:
	n = int(input())
	if n >= 1 and n <= 10 ** 15:
		break
if n % 2 == 0:
	print(int(n / 2))
else:
	print(-int((n + 1) / 2))


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


import math

def BuubleSort(n):
	if n == 1:
		return -1
	if n == 2:
		return 1
	if n == 3:
		return 2
	if n == 4:
		return 2
	no = math.ceil(n / 2)
	ne = n - no
	so = no ** 2
	se = ne * (ne + 1)
	return se - so

def main():
	n = int(input())
	a = BuubleSort(n)
	print(a)
main()


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


def main():
	n = int(input())
	if 1 <= n <= pow(10, 15):
		if n % 2 == 0:
			print(int(n / 2))
		else:
			print(int((n + 1) / 2 * -1))
main()


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)


n = eval(input())
c = n // 4
if n % 4 == 0:
	f = c * 2
elif n % 4 == 1:
	f = c * 2 - n
elif n % 4 == 2:
	f = c * 2 + 1
elif n % 4 == 3:
	f = c * 2 - n + 1
print(f)


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)


n = int(input())
if n > 1000000000 and n % 2 == 0:
	print(int(n / 2))
elif n % 2 == 0:
	x_odd = n / 2
	x_even = n - x_odd
	print(int(-1 * (x_odd * x_odd) + x_even * (x_even + 1)))
else:
	x_odd = int(n / 2) + 1
	x_even = n - x_odd
	print(int(-1 * (x_odd * x_odd) + x_even * (x_even + 1)))


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


def mCheckInputs(inputList):
	input1 = inputList[0]
	if input1.isdigit() and 1 <= int(input1) <= pow(10, 15):
		pass
	else:
		exit(1)

def mHandleInputs(inputList):
	x = input()
	inputList.append(x)
	mCheckInputs(inputList)

def mDoWork(inputList, outputList):
	n = int(inputList.pop())
	result = 0
	result = n // 2 if n % 2 == 0 else -(n + 1) // 2
	outputList.append(result)

def mFormatResult(outputList):
	print(outputList[0])

def main():
	inputList = []
	mHandleInputs(inputList)
	outputList = []
	mDoWork(inputList, outputList)
	mFormatResult(outputList)
main()


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 = eval(input())
if n % 2 == 0:
	print(int(n / 2))
else:
	print(int((-n - 1) / 2))


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


n = int(input())

def f(x):
	if x % 4 == 0:
		return x // 2
	elif x % 4 == 3:
		return -f(x + 1)
	elif x % 4 == 1:
		return -(f(x - 1) + 1)
	elif x % 4 == 2:
		return -f(x - 1)
print(f(n))


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


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


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


def cf(n):
	if n >= 1 and n <= 10 ** 15:
		c = 0
		if n % 2 == 0:
			c = int(n / 2)
		else:
			c = int(n / 2) - n
		return c
try:
	print(cf(int(input())))
except:
	pass


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)


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


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


x = eval(input())
i = 1
s = 0
if x <= 8:
	while i <= x:
		s += (-1) ** i * i
		i += 1
elif x % 2 == 0:
	s = int(x / 2)
else:
	s = int(-(x + 1) / 2)
print(s)


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
import os
import random
import re
import sys
total = 0
n = int(input())
if n % 2 == 0:
	print(n // 2)
else:
	n = n + 1
	n = n // 2
	print(-n)


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


inp = input().split(' ')
k = 0
l = []
a = int(inp[0])
n = (-1) ** a * a
if n % 2 == 0:
	k = n / 2
else:
	k = n // 2
print(int(k))


k = int(input())
p = k // 2
n = p * (p + 1)
o = k - k // 2
print(n - o ** 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))


b = list(map(int, input().split()))
if b[0] % 2 == 0:
	c = int(b[0] / 2)
else:
	c = int(b[0] / 2) + 1
d = b[0] - c
print(-(c * c) + (d * d + d))


from math import ceil

def f(x):
	minuse = x % 2 != 0
	x = ceil(x / 2)
	if not minuse:
		return x
	return -x
print(f(int(input())))


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)


x = int(input())
if x >= 1 and x <= 10 ** 15:
	if x % 2 == 0:
		print(int(x / 2))
	else:
		print(int((x + 1) / 2 * -1))


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)


import math
from bisect import bisect_right as br
import sys
input = sys.stdin.readline
n = int(input())
x = n // 2
y = n - x
print(x * (x + 1) - y * y)


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


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)


additions = []
a = 0
n = int(input())
if n > 100 and n % 2 == 0:
	print(int(n / 2))
if n > 100 and n % 2 != 0:
	print(-(int(n / 2) + 1))
if n < 100 or n == 100:
	for i in range(1, n + 1):
		if i % 2 == 0:
			additions.append(i)
			a = sum(additions)
		else:
			additions.append(-i)
			a = sum(additions)
		if i == n:
			break
	print(a)


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)


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


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


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


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


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


n = int(input())
import math

def O(p):
	return p * p

def E(p):
	return p * p + p
if n == 1:
	print(-1)
	exit()
l = n // 2
if n % l:
	l += 1
print(-O(l) + E(n // 2))


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


t = int(input())
if t % 2 == 0:
	print('%d' % (t // 2))
else:
	print('%d' % (t // 2 - t))


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)


num = int(input())
func = 0
flag = False
if num % 2 == 0:
	flag = True
else:
	num += 1
if flag:
	func = num // 2
else:
	func = -1 * num // 2
print(func)


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


from sys import stdin
from math import ceil
n = int(stdin.readline().strip())
result = ceil(n / 2)
if n % 2 != 0:
	result *= -1
print(result)


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)


from math import *
n = int(input())
if n > 0 and n <= 1000000000000000:
	print(ceil(n / 2) * (-1) ** n)


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


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)


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


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 solve(N):
	if N % 2 == 0:
		return int(N / 2)
	else:
		prev = (N - 1) / 2
		return int(prev - N)
print(solve(int(input())))


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


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


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


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


n = int(input())
n_b = n // 2
n_a = n - n_b
a1 = -1
b1 = 2
d = 2
an = a1 - d * (n_a - 1)
bn = b1 + d * (n_b - 1)
sa = (a1 + an) * n_a // 2
sb = (b1 + bn) * n_b // 2
print(sa + sb)


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

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

def nCr(n, k):
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i

def factoriazation(x):
	ret = {}
	while x != 1:
		ret[spf[x]] = ret.get(spf[x], 0) + 1
		x = x // spf[x]
	return ret

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

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

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math

def solve():
	n = int(input())
	if n % 2 == 1:
		print(-math.ceil(n / 2))
	else:
		print(n // 2)
for _ in range(1):
	solve()


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)


import math
n = int(input())
sum_1 = (2 + 2 * (math.ceil(n / 2) - 1)) * math.ceil(n / 2)
sum_2 = (4 + 2 * (math.ceil(n / 2) - 1)) * math.ceil(n / 2)
print(int(math.pow(-1, n) * int((sum_2 - sum_1) / 2)))


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


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)


import sys
input = sys.stdin.readline

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


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


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


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())
sum1 = n * (2 * 1 + (n - 1)) // 2
if n % 2 == 0:
	k = n // 2
else:
	k = n // 2 + 1
sum2 = k * k
print(sum1 - sum2 * 2)


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)


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


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())
net = 0
if n % 2 == 0:
	print(n // 2)
else:
	print(-(n + 1) // 2)


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 = eval(input())
f = n // 2 - n % 2 * n
print(f)


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


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


n = int(input())
s = 0
if n >= 1 and n <= 10 ** 15:
	if n % 2 == 0:
		print(n // 2)
	elif n % 2 == 1:
		s = n // 2
		print(s - n)


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)


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


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


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


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


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


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


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


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


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


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


from sys import stdin, stdout
import sys
import math

def get_int():
	return int(stdin.readline().strip())

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

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

def get_string():
	return stdin.readline().strip()

def op(c):
	return stdout.write(c)
n = get_int()
if n % 2 == 0:
	print(n // 2)
else:
	print(-(n + 1) // 2)


n = int(input())
if n & 1 == 0:
	print(n >> 1)
else:
	print(~(n >> 1))


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


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


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


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


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


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


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


def fn1(n):
	if n ^ 1 == n + 1:
		return n >> 1
	return ~(n >> 1)
print(fn1(int(input())))


import sys

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


import math

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


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


from math import ceil

def solve(n):
	if n == 1:
		return -1
	l_odd = n if n & 1 else n - 1
	x = -((1 + l_odd) * ceil(l_odd / 2)) // 2
	l_even = n if n % 2 == 0 else n - 1
	y = (2 + l_even) * ceil(l_even / 2) // 2
	return x + y

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


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


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


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


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


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


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


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


n = int(input())
p = n * (n + 1)
p = p // 2
d = 2 * pow(n - n // 2, 2)
print(p - d)


import math
n = int(input())
v = math.ceil(n / 2) * [1, -1][n % 2]
print(v)


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


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)


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


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


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


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
sys.setrecursionlimit(100000000)
ii = lambda : int(input())
si = lambda : input()
jn = lambda x, l: x.join(map(str, l))
sl = lambda : list(map(str, input().strip()))
mi = lambda : map(int, input().split())
mif = lambda : map(float, input().split())
lii = lambda : list(map(int, input().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
mod = 1000000007
n = ii()
print(n // 2 - n % 2 * n)


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


import os
import sys
from io import BytesIO, IOBase
import math

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

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


n = int(input())
if n % 2 == 0:
	v = n // 2
	print(v)
else:
	g = pow(-1, n) * (n // 2 + 1)
	print(g)


n = int(input())
l = []
if n % 2 == 0:
	div = (n - 1) // 2
	rem = (n - 1) % 2
	print(n - (div + rem))
else:
	div = (n - 1) // 2
	print(-n + div)


g = lambda : map(int, input().split())
n = int(input())
print((-1) ** (n % 2) * ((n - 1) // 2 + 1))


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


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


n = int(input())
if n % 2 == 1:
	even = 2
	nth = n // 2
	x = nth * (even + n - 1) // 2
	odd = 1
	nt = n // 2 + 1
	y = nt * (odd + n) // 2
	print(x - y)
else:
	even = 2
	nth = n // 2
	x = nth * (even + n) // 2
	odd = 1
	nt = n // 2
	y = nt * (odd + n - 1) // 2
	print(x - y)


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)


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


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


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


import sys
from random import choice, randint
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 MI():
	return map(int, sys.stdin.readline().strip().split())

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

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

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

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

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

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

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

def S():
	return sys.stdin.readline().strip()

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

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))
inp = sys.stdin.readline
out = sys.stdout.write

def main():
	from math import ceil
	n = I()
	if n % 2 == 0:
		pf(ceil(n / 2))
	else:
		pf(-ceil(n / 2))
main()


n = int(input())
sum1 = 0
sum2 = 0
k = n // 2
j = k * (k + 1)
l = n - k
q = l ** 2
print(j - q)


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())
from math import ceil as c
print(n * (n + 1) // 2 - 2 * c(n / 2) ** 2)


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


n = int(input())

def f(a):
	if a % 2 == 0:
		s1 = (2 + a) // 2 * ((a - 2) // 2 + 1)
		s2 = (1 + a - 1) // 2 * (a // 2)
		s1 -= s2
		return s1
	else:
		s1 = (2 + a - 1) // 2 * (a // 2)
		s2 = (1 + a) // 2 * ((a + 2) // 2)
		s1 -= s2
		return s1
print(f(n))


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


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


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


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


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


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)


N = int(input())
even = N // 2
odd = N - even

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

def arithSumOdd(n):
	arithSumOdd = n * (2 * 1 + (n - 1) * 2) // 2
	return arithSumOdd
print(arithSumEven(even) - arithSumOdd(odd))


def function(n):
	sum1 = 0
	sum2 = 0
	if n % 2 == 0:
		temp = int(n / 2)
		sum1 = temp * (temp + 1)
		sum2 = temp ** 2
	else:
		temp = n // 2 + 1
		sum1 = temp * (temp - 1)
		sum2 = temp ** 2
	print(sum1 - sum2)
n = int(input(''))
function(n)


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


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


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)