Manao is trying to open a rather challenging lock. The lock has n buttons on it and to open it, you should press the buttons in a certain order to open the lock. When you push some button, it either stays pressed into the lock (that means that you've guessed correctly and pushed the button that goes next in the sequence), or all pressed buttons return to the initial position. When all buttons are pressed into the lock at once, the lock opens.

Consider an example with three buttons. Let's say that the opening sequence is: {2, 3, 1}. If you first press buttons 1 or 3, the buttons unpress immediately. If you first press button 2, it stays pressed. If you press 1 after 2, all buttons unpress. If you press 3 after 2, buttons 3 and 2 stay pressed. As soon as you've got two pressed buttons, you only need to press button 1 to open the lock.

Manao doesn't know the opening sequence. But he is really smart and he is going to act in the optimal way. Calculate the number of times he's got to push a button in order to open the lock in the worst-case scenario.


-----Input-----

A single line contains integer n (1 ≤ n ≤ 2000) — the number of buttons the lock has.


-----Output-----

In a single line print the number of times Manao has to push a button in the worst-case scenario.


-----Examples-----
Input
2

Output
3

Input
3

Output
7



-----Note-----

Consider the first test sample. Manao can fail his first push and push the wrong button. In this case he will already be able to guess the right one with his second push. And his third push will push the second right button. Thus, in the worst-case scenario he will only need 3 pushes.

Difficulty: EASY
Tags: Mathematics

Implementation

Starter code:

Solutions:
n = int(input())
ans = 0
for i in range(1, n):
	ans += i * (n - i)
ans += n
print(ans)


from sys import stdin
i = int(stdin.readline().rstrip())
if i == 1:
	clicks = 1
else:
	clicks = 1
	current_error = 0
	for x in range(2, i + 1):
		clicks += x
		clicks += current_error
		current_error += x - 1
print(clicks)


def main():
	n = int(input())
	if n == 1:
		s = 1
	else:
		s = n + 1
	for i in range(2, n):
		s += (n - i) * i + 1
	print(s)
main()


import math
from collections import defaultdict, Counter, deque
INF = float('inf')

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def isPrime(n):
	if n <= 1:
		return False
	i = 2
	while i ** 2 <= n:
		if n % i == 0:
			return False
		i += 1
	return True

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

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

def main():
	n = int(input())
	pressed = 0
	ans = 0
	while n > 0:
		ans += n * (pressed + 1) - pressed
		pressed += 1
		n -= 1
	print(ans)
t = 1
for _ in range(t):
	main()


n = int(input())
print(n * (n * n + 5) // 6)


a = int(input())
print(((a + 1) * a * (a - 1) // 6 + a) // 1)


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


n = int(input())
s = 0
j = 0
for i in range(n):
	s += (n - i) * (i + 1) - i
print(s)


num = int(input())
correctnum = 1
uncorrectnum = num - 1
sum = num
for i in range(2, num + 1):
	sum = sum + correctnum * (uncorrectnum - 1) + uncorrectnum
	correctnum = i
	uncorrectnum = num - correctnum
print(sum)


x = int(input())
sum = 0
for i in range(0, x):
	sum += (i + 1) * (x - i) - i
print(sum)


n = int(input())
c = 0
k = 0
for i in range(n, 0, -1):
	c += i + (i - 1) * k
	k += 1
print(c)


n = int(input())
if n >= 2:
	v = 1
	x = n
	f = 0
	while x >= 2:
		if x == n:
			f = f + (x * v + 1)
		else:
			f = f + ((x - 1) * v + 1)
		v = v + 1
		x = x - 1
	print(f)
else:
	print(n)


n = int(input())
result = 0
i = 0
while n != 0:
	result += n + (n - 1) * i
	n -= 1
	i += 1
print(result)


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


count = int(input())
answer = 0
for i in range(0, count):
	answer += (i + 1) * (count - i) - i
print(answer)


n = int(input())
arr = []
result = 0
local = 0
for i in range(1, n + 1):
	arr.append(i)
arr1 = []
for k in arr:
	local += k
	arr1.append(local)
for l in range(len(arr1) - 1):
	result += arr1[l]
print(result + n)


x = int(input())
n = x
for i in range(x - 1, 0, -1):
	n = n + (i - 1) * (x - i + 1) + 1
print(n)


n = int(input())
buttonsPressed = 0
for i in range(1, n + 1):
	buttonsPressed += (n - i) * i
buttonsPressed += n
print(buttonsPressed)


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


n = int(input())
res = 0
for i in range(1, n):
	res += i * (n - i)
res += n
print(res)


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


n = int(input())
sum = n
for i in range(2, n + 1):
	sum += 1
	sum += i * max(0, n - i)
print(sum)


n = int(input())
c = n
for i in range(n):
	c += (n - i) * i
print(c)


n = int(input())
add = 2
output = 1
for i in range(2, n + 1):
	output += add
	add += i
print(output)


n = int(input())
c = 0
i = 0
while i < n:
	c += 1 + i * (n - i)
	i += 1
print(c)


def stepCalculator(buttons):
	step = 2
	totalSteps = buttons
	buttons -= 1
	while buttons > 0:
		totalSteps += (buttons - 1) * step + 1
		step += 1
		buttons -= 1
	return totalSteps

def main():
	buttons = int(input())
	step = 0
	print(stepCalculator(buttons))
	return ()
main()


def count_presses(n):
	series_sum = sum(list((x ** 2 for x in range(1, n))))
	return (2 * n + n * (n - 2)) * (n - 1) // 2 + n - series_sum

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


x = int(input())
(a, b) = (1, 0)
for i in range(x):
	a += i
	b += a
print(b)


n = int(input())
result = 0
for i in range(1, n + 1):
	result += i * (n - i) + 1
print(result)


n = int(input())
counter = n
for i in range(1, n + 1):
	counter += i * (n - i)
print(counter)


n = int(input())
x = [0 for i in range(n + 1)]
x[1] = n
for i in range(2, n + 1):
	x[i] = x[i - 1] + 1 + (n - i) * i
print(x[n])
lol = 1


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


n = int(input())
jieguo = 0
for i in range(1, n - 1):
	jieguo = jieguo + (n - i) * i
jieguo = jieguo + n - 1 + n
print(jieguo)


t = int(input())
sum = 0
for i in range(1, t + 1):
	sum += (t - i) * i
print(sum + t)


n = int(input())
count = n
n -= 1
i = 2
while n:
	count += (n - 1) * i + 1
	n -= 1
	i += 1
print(count)


n = int(input())
i = 1
k = 0
while n != 0:
	k += i * (n - 1)
	if n == 1:
		k += i
	i += 1
	n -= 1
print(k)


x = int(input())
a = x
s = 0
s = x
if x == 1:
	print(1)
	quit()
for i in range(1, x - 1):
	a = a - 1
	s += 1 + i * a
print(s + 1)


n = int(input())
print(sum([i * (n - i) for i in range(n)]) + n)


N = int(input())
k = 0
ans = 0
SUM = int(N * (N + 1) / 2)
for i in range(1, N + 1):
	ans = ans + k * (N - i)
	k += 1
print(ans + SUM)


init = int(input())
N = init
res = 1
while N > 1:
	res = res + N + (N - 1) * (init - N)
	N = N - 1
print(res)


n = int(input())
totaal = 0
for i in range(0, n):
	totaal = totaal + 1 + (n - i) * i
print(totaal)


n = int(input())
Sum = n
for i in range(1, n):
	Sum += i * (n - i)
print(Sum)


class CodeforcesTask268BSolution:

	def __init__(self):
		self.result = ''
		self.n = 0

	def read_input(self):
		self.n = int(input())

	def process_task(self):
		cost = self.n
		base_cost = 1
		unknown = self.n
		for layer in range(1, self.n):
			cost += base_cost * (unknown - 1)
			base_cost += 1
			unknown -= 1
		self.result = str(cost)

	def get_result(self):
		return self.result
Solution = CodeforcesTask268BSolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


isDebug = False
n = int(input())
t = 0
for i in range(1, n):
	t = t + (n - i) * i
print(f't={t}') if isDebug else ''
print(f'{t + n}')


n = int(input())
s = 0
t = 0
while s < n:
	f = n - s - 1
	t += s * f + f
	s += 1
print(t + n)


t = int(input())
k = 0
k = t * t * (t + 1) / 2 - (t + 1) * t * (2 * t + 1) / 6
k = t ** 3 / 6 - t / 6
print(int(k + t))


import math
import sys

def buttons():
	n = int(input())
	rightbuttons = n
	wrongbuttons = (1 + n) * (n / 2) - n
	j = 1
	for i in range(n - 2, 0, -1):
		rightbuttons += j * i
		j += 1
	print(int(rightbuttons + wrongbuttons))
buttons()


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


a = int(input())
print(a * (a * a + 5) // 6)


n = int(input())
if 1 <= n <= 2000:
	s = int(n * (n * n - 1) / 6 + n)
	print(s)


n = eval(input())
i = 1
summ = 0
while i <= n:
	summ += (n - i) * i
	i += 1
print(summ + n)


n = int(input())
s = 1
for i in range(1, n):
	s += 1 + i * (i + 1) // 2
print(s)


n = int(input())
temp = n * (n + 1) // 2
ex = 0
if n > 2:
	for i in range(1, n - 1):
		ex += i * (n - (i + 1))
print(temp + ex)


n = int(input())
i = n
j = 1
k = 0
while i > 1:
	k += j * (n - j)
	i -= 1
	j += 1
k += n
print(k)


numberOfButtons = int(input())
print(numberOfButtons + sum([count * (numberOfButtons - count) for count in range(1, numberOfButtons)]))


import sys
n = int(sys.stdin.readline().strip())
print(int((n * n + 5) * n / 6))


n = int(input())
c = n
r = 1
if n == 1:
	print(n)
else:
	for i in range(n - 1, 1, -1):
		c += i
		c += r * (i - 1)
		r += 1
	print(c + 1)


n = int(input())
i = 1
r = 0
for j in range(1, n + 1)[::-1]:
	r += (j - 1) * i
	i += 1
print(r + n)


inp = int(input(''))
print(int((inp - 1) * inp * (inp + 1) / 6 + inp))


n = int(input())
ans = 0
i = 0
while i < n:
	ans += (i + 1) * (n - i) - i
	i += 1
print(ans)


from sys import stdin, stderr

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

def print_err(*args, **kwargs):
	print(*args, file=stderr, **kwargs)

def solve(n):
	remain = n - 1
	pushed = n
	down = 1
	while down < n:
		pushed += remain * (down + 1) - down
		down += 1
		remain -= 1
	return pushed

def run():
	(n,) = readInts()
	print(solve(n))
run()


N = int(input())
s = 0
for i in range(1, N):
	s = s + (N - i) * i
print(s + N)


n = int(input())
times = 0
correct = 0
while correct < n:
	times += n - correct + (n - correct - 1) * correct
	correct += 1
print(times)


n = int(input())
tot = n
for i in range(1, n):
	tot += i * (n - i)
print(tot)


n = int(input())
s = 0
i = 0
while n > 0:
	s += n + i * (n - 1)
	i += 1
	n -= 1
print(s)


n = int(input())
k = 1
tries = 0
while n:
	tries += (n - 1) * k + 1
	k += 1
	n -= 1
print(tries)


n = int(input())
if n == 1:
	print(1)
else:
	ans = n
	for t in range(1, n):
		ans += (n - t) * t
	print(ans)


n_button = int(input())
tentativas = 0
for i in range(n_button):
	tentativas += (i + 1) * (n_button - i - 1)
tentativas += n_button
print(tentativas)


x = int(input())
y = x
s = x * (x + 1) / 2
x = x - 2
for i in range(y - 2):
	t = x - 1 * i
	s += t * (t + 1) / 2
print(int(s))


n = int(input())
t = 0
for i in range(n):
	t += 1 + (n - i - 1) * (i + 1)
print(t)


def main():
	num_buttons = int(input())
	print(num_buttons + num_buttons ** 2 * (num_buttons + 1) // 2 - num_buttons * (num_buttons + 1) * (2 * num_buttons + 1) // 6)
main()


import copy
n = int(input())
if n == 1:
	print(1)
else:
	max_pushes = n + 1
	l = copy.copy(n - 2)
	for i in range(2, n):
		max_pushes += i * l + 1
		l -= 1
	print(max_pushes)


n = int(input())
c = n * (n + 1) // 2
i = 1
for j in range(n - 2, 0, -1):
	c += j * i
	i += 1
print(c)


n = int(input())
value = n
for i in range(1, n):
	value += i * (n - i)
print(value)


import math
a = input()
b = math.ceil(int(a))
c = math.ceil((b * b * b + 5 * b) / 6)
print(c)


n = int(input())
summ = n
for i in range(n):
	stayHalat = n - i
	summ += stayHalat * i
print(summ)


n = int(input())
b = 0
for i in range(n):
	b += i * (n - i)
print(b + n)


n = int(input())
sum = 0
for i in range(n):
	sum += (n - i - 1) * (i + 1) + 1
print(sum)


n = int(input())
g = 0
for i in range(n):
	g = g + i * (n - i)
print(g + n)


n = int(input())
if n == 2:
	print(3)
if n == 1:
	print(1)
if n > 2:
	i = 2
	x = 0
	y = 0
	while i > 1:
		x = x + i * (n - i)
		y += 1
		if n - i == 1:
			break
		i += 1
	print(y + n + 1 + x)


n = int(input())
ret = n
for i in range(1, n):
	ret += i * (n - i)
print(ret)


n = eval(input())
ans = n
for i in range(1, n):
	ans += i * (n - i)
print(ans)


n = int(input())
c = n - 2
s = n
i = 1
while c > 0:
	s = s + c + c * i + 1
	c = c - 1
	i = i + 1
if n > 1:
	print(s + 1)
else:
	print(s)


n = int(input())
q = 0
q = q + n
for i in range(1, n):
	q = q + i * (n - i)
print(q)


n = int(input())
num = 0
t = 0
while t < n:
	num = num + n - t
	num = num + (n - t - 1) * t
	t = t + 1
print(num)


def buttons(n):
	return int(n * n * (n - 1) / 2 + n - (n - 1) * n * (2 * n - 1) / 6 if n > 0 else 0)
print(buttons(int(input())))


n = int(input())
i = 0
m = 0
while i < n - 1:
	m += (n - i) * (i + 1) - i
	i += 1
	if i == n - 1:
		break
print(m + 1)


n = int(input())
count = 0
for i in range(1, n):
	count += (n - i) * i
print(count + n)


n = int(input())
button_presses = 0
for i in range(1, n + 1):
	button_presses += (n - i) * i + 1
print(button_presses)


keys = int(input())
sum = 0
for i in range(keys):
	sum += i * (keys - i)
print(sum + keys)


n = int(input())
soma = n
for i in range(n - 1):
	soma += (i + 1) * (n - i - 1)
print(soma)


x = int(input())
total = 0
for i in range(1, x + 1):
	total += (x - i) * i
print(total + x)


n = int(input())
k = 0
if n == 1:
	print(1)
elif n == 2:
	print(3)
else:
	for i in range(1, n - 1):
		k += (n - i) * i
	k += 2 * n - 1
	print(k)


def buttons(n):
	if n == 1:
		return 1
	if n == 2:
		return 3
	i = 2
	tot = n
	while i < n:
		tot += (n - i) * i + 1
		i += 1
	return tot + 1

def main():
	n = int(input())
	print(str(buttons(n)))
main()


b = int(input())
s = b
for i in range(1, b):
	s = s + (b - i) * i
print(s)


n = int(input())
s = 2 * n - 1
k = 1
while k <= n - 2:
	s += (n - k) * k
	k += 1
print(s)


import math
n = int(input())
cnt = 0
for i in range(0, n):
	cnt += 1 + (i + 1) * (n - i - 1)
print(cnt)


l1 = input()
l1 = int(l1)
movements = 0
for i in range(l1):
	movements += (i + 1) * (l1 - i) - i
print(movements)


n = int(input())
t = n
c = 1
r = 0
while n > 0:
	r += (n - 1) * c
	c += 1
	n -= 1
print(r + t)


import math
import sys
import cmath
import string
import bisect
from itertools import combinations, permutations
from queue import Queue, LifoQueue, PriorityQueue
from collections import deque, Counter
n = int(input())
sum = 0
for i in range(1, n + 1):
	sum += 1 + (n - i) * i
print(sum)


n = eval(input())
summ = 0
for i in range(1, n):
	summ += i * (n - i)
print(summ + n)


n = int(input())
m = 0
for i in range(1, n):
	m += (n - i) * i
m += n
print(m)


n = int(input())
answer = 0
for i in range(1, n + 1):
	answer += i * (n - i + 1) - (i - 1)
print(answer)


def but_count(n=1):
	count = 0
	for i in range(1, n + 1):
		count += i * (n - i + 1)
	count -= int(n * (n - 1) / 2)
	return count
print(but_count(int(input())))


n = int(input())
summ = 0
for i in range(1, n + 1):
	summ += i
	summ += (i - 1) * (n - i)
print(summ)


locks = int(input())
stack = 0
n = locks
iteration = 1
for _ in range(locks):
	stack += iteration * (n - iteration) + 1
	iteration += 1
print(stack)


n = int(input())
ans = 0
i = 1
while n > 0:
	wrong = n - 1
	push = i * wrong
	i += 1
	push += 1
	ans += push
	n -= 1
print(ans)


n = int(input())
cnt = 0
k = 1
cnt += n * k + (n - 1) * k
k += 1
n -= 2
while n > 0:
	cnt += n * k
	k += 1
	n -= 1
print(cnt)


t = int(input(''))
s = 0
for i in range(1, t):
	s += i * (t - i)
print(s + t)


n = int(input())
clicks = 0
for i in range(n):
	clicks += n - i
	clicks += i * (n - i - 1)
print(clicks)


a = int(input())
sum = 0
for i in range(1, a):
	sum = sum + i * (a - i)
print(sum + a)


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


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


n = int(input())
tedad = n
for i in range(1, n + 1):
	tedad += i * (n - i)
print(tedad)


bottons = int(input())
botton_begin = bottons - 1
botton_level = 1
push = 0
if bottons == 1:
	push = 1
else:
	while botton_level <= bottons:
		push += botton_begin * botton_level
		botton_begin -= 1
		if botton_begin == 0:
			botton_begin = 1
		botton_level += 1
print(push)


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())
	summ = 0
	for x in range(1, n):
		summ += (n - x) * x
	print(summ + n)
for _ in range(1):
	solve()


n = int(input())
res = sum(((n - 1 - i) * (i + 1) + 1 for i in range(n - 1)))
print(res + 1)


n = int(input())
ans = 0
k = 1
while n != 0:
	n -= 1
	ans += k * n
	k += 1
ans += k
print(ans - 1)


n = int(input())
cnt = n
for i in range(1, n):
	cnt += i * (n - i)
print(cnt)


n = int(input())
sum1 = 0
for i in range(1, n + 1):
	x = n - i
	if x == 0:
		x = 1
	sum1 += i * x
print(sum1)


n = int(input())
i = 1
b = 0
while i < n:
	b = b + i * (n - i)
	i = i + 1
else:
	print(b + n)


s = 0
n = int(input())
for x in range(n):
	k = (n - x) * x + 1
	s += k
print(s)


n = int(input())
i = 1
sum = 0
while i < n:
	sum += (n - i) * i
	i += 1
print(sum + n)


__author__ = 'Utena'
n = int(input())
t = 0
for i in range(1, n):
	t += (n - i) * i
t += n
print(t)


n = int(input().strip())
if n == 1:
	print(1)
else:
	ans = n * 1
	st = 2
	n -= 2
	while n > 0:
		ans += n * st + 1
		n -= 1
		st += 1
	print(ans + 1)


k = int(input())
r = 0
for i in range(k - 1):
	r += (k - i) * (i + 1) - i
print(r + 1)


n = int(input())
sol = 0
for i in range(1, n + 1):
	sol += (n - i) * i
print(sol + n)


n = int(input())
s = 0
for i in range(1, n + 1):
	if i == 1:
		s += n
	elif i == n:
		s += 1
	else:
		s += (n - i) * i + 1
print(s)


n = int(input())
push = 0
for i in range(n):
	if i + 1 != n:
		push += (n - (i + 1)) * (i + 1)
	else:
		push += n
print(push)


buttons = int(input())
moves = 0
for x in range(1, buttons):
	moves += (buttons - x) * x
print(moves + buttons)


def pushes_count(buttons):
	pushes_list = list(range(1, buttons))
	pushes_list.sort(reverse=True)
	counter = 0
	for i in pushes_list:
		pushes_list[counter] += i * counter
		counter += 1
	print(buttons + sum(pushes_list))
pushes_count(int(input()))


n = int(input())
s = n
for i in range(n + 1):
	s += sum(range(i))
print(s)


n = int(input())
if n == 1:
	print('1')
else:
	tot = n + 1
	k = 2
	while k != n:
		tot += k * (n - k) + 1
		k += 1
	print(tot)


n = int(input())
ttl = n
for i in range(1, n):
	t = (n - i) * i
	ttl += t
print(ttl)


N = int(input())
if N == 1:
	print('1')
	exit()
counter = N
for i in range(1, N + 1):
	counter += (N - i) * i
print(counter)


import sys
inf = float('inf')
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
(mod, MOD) = (1000000007, 998244353)
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

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()
ans = 0
n = int(input())
t = n
while t > 2:
	ans += (t - 2) * (t - 1) // 2
	t -= 1
ans += n * (n + 1) // 2
print(ans)


n = int(input().strip())
res = 0
for k in range(1, n):
	res += k * (n - k)
res += n
print(res)


k = 0
t = int(input())
for i in range(1, t + 1):
	k += i * (t - i)
print(k + t)


n = int(input())
ans = n * (n ** 2 + 5) // 6
print(ans)


n = int(input())
number = n
for i in range(1, n):
	number += i * (n - i)
print(number)


n = int(input())
sum = 2 * n - 1
i = 1
while n - i >= 2:
	sum = sum + i * (n - i)
	i += 1
print(sum)


n = int(input())
cont = 0
numConhecidos = 0
while numConhecidos < n:
	cont += (n - numConhecidos - 1) * (numConhecidos + 1) + 1
	numConhecidos += 1
print(cont)


n = int(input())
retries = 0
for i in range(n):
	retries += i * (n - i - 1)
worst = n * (n + 1) / 2 + retries
print(int(worst))


import os
import sys

def log(*args, **kwargs):
	if os.environ.get('CODEFR'):
		print(*args, **kwargs)
n = int(input())
r = n
for i in range(1, n):
	r += 1 + (n - i - 1) * (i + 1)
print(r)


n = int(input())
line1 = list(range(1, n + 1))
line2 = list(range(1, n))
line2.sort(reverse=True)
line2.append(1)
num = 0
for i in range(n):
	num += line1[i] * line2[i]
print(num)


import math
from collections import defaultdict
ml = lambda : map(int, input().split())
ll = lambda : list(map(int, input().split()))
ii = lambda : int(input())
ip = lambda : input()
t = ii()
ans = t * (t + 1) // 2
t -= 2
while t > 0:
	ans += t * (t + 1) // 2
	t -= 1
print(ans)


n = int(input())
ans = 0
for i in reversed(range(n)):
	ans += i * (n - i)
print(ans + n)


n = int(input())
initial_n = n
sum = n
if n == 1:
	print(1)
else:
	n = n - 1
	while n != 1:
		sum += 1 + (n - 1) * (initial_n - n + 1)
		n -= 1
	sum += 1
	print(sum)


n = int(input())
s1 = n * (n + 1) * n // 2
s2 = n * (n + 1) * (2 * n + 1) // 6
ans = s1 - s2 + n
print(ans)


import math
n = int(input())
ans = 0
for x in range(1, n):
	ans += x * (n - x)
ans += n
print(ans)


n = int(input())
result = 0
k = 0
while k < n:
	result += (k + 1) * (n - k) - k
	k += 1
print(result)


a = int(input())
total = a
for i in range(1, a + 1):
	total = total + (a - i) * i
print(total)


__author__ = 'Bian'
n = int(input())
o = n
for i in range(1, n):
	o += i * (n - i)
print(o)


R = lambda : map(int, input().split())
n = int(input())
b = n * (n + 1) // 2
k = 1
for i in range(n - 1, 1, -1):
	b += max(0, (i - 1) * k)
	k += 1
print(b)


n = int(input())
c = 0
x = 0
while n > 0:
	c += n + (n - 1) * x
	n -= 1
	x += 1
print(c)


n = int(input())
sum_n = 0
for m in range(0, n):
	sum_n += (n - m) * (1 + m) - m
print(sum_n)


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

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

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

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

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

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

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

def S():
	return input()

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

def main():
	n = I()
	r = 0
	for i in range(n, 0, -1):
		r += (i - 1) * (n - i + 1)
	return r + n
print(main())


def buttons(num):
	if num == 1:
		return 1
	total = num - 1
	stuff = num
	for x in range(1, stuff):
		total += (num - 1) * (x + 1)
		if x + 1 != stuff:
			total -= x + 1
		num = num - 1
	return total
print(buttons(int(input(''))))


inp = int(input())
m = 0
for i in range(inp):
	m += (inp - i) * i
if inp > 1:
	print(m + inp)
else:
	print(inp)


import sys
N = int(sys.stdin.readline())
result = 0
for i in range(1, N):
	result += (N - i) * i
print(result + N)


n = int(input())
if n == 1:
	print(1)
	exit()
sum = n
for i in range(1, n - 1):
	sum += (n - i - 1) * (i + 1) + 1
sum += 1
print(sum)


a = int(input())
s = 0
for i in range(0, a):
	s += (i + 1) * (a - i) - i
print(s)


def buttons(x):
	s = x
	for i in range(1, x):
		s += i * (x - i)
	return s
x = int(input())
print(buttons(x))


n = int(input())
(res, x) = (n, n - 2)
for i in range(2, n + 1):
	res = res + i * x + 1
	x -= 1
print(res)


z = int(input())
print(int(z * (z * z + 5) / 6))


a = int(input())
answer = 0
for i in range(1, a + 1):
	answer = answer + i * (a - i)
answer = answer + a
print(answer)


from sys import stdin, stdout

def main():
	n = int(stdin.readline())
	count = 0
	for i in range(0, n):
		count += n - i + (n - i - 1) * i
	stdout.write(str(count) + '\n')
main()


i = 0
g = 1
sg = 1
tg = 0
a = 0
n = int(input())
while i != n:
	a = a + sg
	i += 1
	tg += 1
	sg += tg
	g += sg
print(a)


def B268():
	n = int(input())
	i = 1
	k = 0
	while i != n:
		k += i * (n - i)
		i += 1
	print(n + k)
B268()


n = int(input())
ans = 2 * n - 1
for i in range(2, n):
	ans += i * (n - i)
print(ans)


import array
n = int(input())
res = int(n * (n + 1) / 2)
for i in range(1, n):
	res = res + i * (n - (i + 1))
print(res)


n = int(input())
ans = 0
for i in range(0, n):
	if i != 0:
		ans = ans + (n - i) * i
	else:
		ans = ans + (n - i)
print(ans)


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin1(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = k ** mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin1(mid + 1, r, k, t, b, val, ans)
		else:
			return bin1(l, mid - 1, k, t, b, val, ans)

def bin2(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = t * k ** mid + b * mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin2(l, mid - 1, k, t, b, val, ans)
		else:
			return bin2(mid + 1, r, k, t, b, val, ans)

def SieveOfEratosthenes(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
	l = []
	for i in range(2, n + 1):
		if prime[i]:
			l.append(i)
	return l

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if val >= ll[mid][0] and val <= ll[mid][1]:
			return mid
		elif val < ll[mid][0]:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def deci(n):
	s = ''
	while n != 0:
		if n % 2 == 0:
			n = n // 2
			s = '0' + s
		else:
			n = n // 2
			s = '1' + s
	return s

def diff(s1, s2):
	if len(s1) < len(s2):
		v = len(s1)
		while v != len(s2):
			s1 = '0' + s1
			v = v + 1
	else:
		v = len(s2)
		while v != len(s1):
			s2 = '0' + s2
			v = v + 1
	c = 0
	for i in range(len(s1)):
		if s1[i:i + 1] != s2[i:i + 1]:
			c = c + 1
	return c
from sys import stdin, stdout

def fac(a, b):
	v = a
	while a != b:
		v *= a - 1
		a = a - 1
	return v

def bino(l, r, n):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		val1 = math.log(n / mid + 1, 2)
		val2 = int(val1)
		if val1 == val2:
			return val1
		elif val1 < 1.0:
			return bino(l, mid - 1, n)
		else:
			return bino(mid + 1, r, n)

def binary(l, r, ll, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		if ll[mid] == val:
			return ll[mid]
		elif ll[mid] < val:
			ans = ll[mid]
			return binary(mid + 1, r, ll, val, ans)
		else:
			return binary(l, mid - 1, ll, val, ans)

def check(n):
	v = 1
	while n != 0:
		if n % 10 == 0 or n % 10 == 1:
			n = n // 10
		else:
			v = 0
			break
	return v

def stairs(n, m, val, c, l):
	if val > n:
		return 100000
	elif val == n:
		if l[val] != -1:
			return l[val]
		elif c % m == 0:
			l[val] = c
			return l[val]
		else:
			l[val] = 100000
			return l[val]
	else:
		l[val] = min(stairs(n, m, val + 1, c + 1, l), stairs(n, m, val + 2, c + 1, l))
		return l[val]
n = int(input())
l = []
l.append(0)
for i in range(1, 2001):
	l.append(i + (i - 1) * (i - 2) // 2 + l[i - 1])
print(l[n])


n = int(input())
times = 0
for i in range(n):
	times = times + i * (n - i)
times += n
print(times)


n = int(input())
result = n * (n + 1) / 2
while n != 1:
	n = n - 1
	result = result + n * (n - 1) / 2
print(int(result))


def parse_input() -> int:
	return int(input())

def solve(n: int) -> int:
	if n == 1:
		return 1
	k = 1
	g = 0
	while k <= n:
		g += (n - k) * k
		k += 1
	return g + n
print(solve(parse_input()))


n = int(input())
if 1 <= n <= 2000:
	print(int(n * (n * n + 5) / 6))


num = int(input().strip())
print(sum((x * (num - x) for x in range(num))) + num)


N = int(input())
print(sum([i * (N - i) for i in range(1, N)]) + N)


n = int(input())
output = 0
for i in range(1, n + 1):
	output = output + i * (n - i) + 1
print(output)


n = int(input())
(i, out) = (n, 0)
while i > 1:
	out += (i - 1) * (n - i + 1)
	i -= 1
print(out + n)


n = int(input())
for i in range(n, 0, -1):
	if i == n:
		summ = n
		continue
	summ += 1 + (n - i + 1) * (i - 1)
print(summ)


def f(n):
	return (n ** 3 + 5 * n) // 6
print(f(int(input())))


n = int(input())
print(sum([x * (n - x) for x in range(1, n + 1)]) + n)


n = int(input())
time = 0
known = 0
unknown = n
while unknown:
	time += 1
	for i in range(unknown - 1):
		time += known + 1
	known += 1
	unknown -= 1
print(time)


n = int(input())
pushes = 0
for i in range(n):
	pushes += (i + 1) * (n - i) - i
print(pushes)


n = int(input())
sum = 0
c = 0
while n > 0:
	c += 1
	sum += c * (n - 1) + 1
	n -= 1
print(sum)


n = int(input())
res = n * (n + 1) // 2
for i in range(2, n):
	j = n - i
	res += j * (j + 1) // 2
print(res)


n = int(input())
p = 0
if n < 3:
	print([0, 1, 3][n])
else:
	for i in range(2, n):
		p = p + (n - i) * i
	print(2 * n - 1 + p)


n = int(input())
an = 0
ct = 1
lp = 0
while n > 0:
	an += n * ct - lp
	ct += 1
	n -= 1
	lp += 1
print(an)


n = int(input())
sum1 = n
for i in range(1, n):
	sum1 += (n - i) * i
print(sum1)


from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

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

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

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
n = read_int()
print((n * n + 5) * n // 6)


n = int(input())
ways = 0
i = 1
while n - i >= 1:
	ways += (n - i) * i
	i += 1
print(ways + n)


import math
n = int(input())
x = n
for i in range(1, n):
	x += (n - i) * i
print(x)


def Buttons():
	n = int(input())
	ans = 0
	for i in range(1, n):
		ans += (n - i) * i
	ans += n
	print(ans)

def main():
	Buttons()
main()


t = 1
while t > 0:
	t -= 1
	n = int(input())
	sum = 0
	for i in range(1, n + 1):
		sum += (n - i) * i
	print(sum + n)


n = int(input())
presses_count = 0
prev = 0
for left in reversed(range(1, n + 1)):
	worst_case_presses = left * (prev + 1) - prev
	presses_count += worst_case_presses
	prev += 1
print(presses_count)


n = int(input())
ans = n
if n == 1:
	print(1)
	exit()
else:
	for i in range(2, n + 1):
		ans += (n - i) * i + 1
		if not n - i:
			break
	print(ans)


n = int(input())
sum = n
i = 2
n = n - 1
while n > 0:
	n = n - 1
	sum = sum + max(0, n) * i + 1
	i = i + 1
print(sum)


n = int(input())
print(sum(((n - k) * k + 1 for k in range(1, n + 1))))


from collections import Counter
from collections import defaultdict as dfd
from bisect import bisect, bisect_left
from math import sqrt, gcd, ceil, factorial
from heapq import heapify, heappush, heappop
MOD = 998244353
inf = float('inf')
ans_ = []

def nin():
	return int(input())

def ninf():
	return int(file.readline())

def st():
	return input().strip()

def stf():
	return file.readline().strip()

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

def readf():
	return list(map(int, file.readline().strip().split()))

def solve():
	n = nin()
	ans = n
	for i in range(1, n):
		ans += (n - i) * i
	ans_.append(ans)
solve()
for i in ans_:
	print(i)


n = int(input())
i = 1
j = n - 1
times = 0
while i < n and j > 0:
	times += i * j
	i += 1
	j -= 1
print(times + n)


n = int(input())
s = 1
k = 0
b = 0
while s < n + 1:
	k = s * (n - s)
	b = b + k
	s = s + 1
print(b + n)


n = int(input())
res = n
for pressed in range(n):
	res += (n - pressed - 1) * (pressed + 1)
print(res)


n = int(input())
dp = [0] * 2010
dp[1] = 1
for i in range(2, 2002):
	dp[i] = dp[i - 1] + i - 1
ans = 0
for i in range(1, n + 1):
	ans += dp[i]
print(ans)


def function1(n):
	times = 0
	for i in range(1, n + 1):
		times += i * (n - i)
	return times + n

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


n = int(input())
(ans, i) = (n + 1, 2)
if n == 1:
	print(1)
	exit()
for _ in range(n - 2):
	ans += 1 + i * (n - i)
	i += 1
print(ans)


n = int(input())
steps = 0
for i in range(n):
	steps += (i + 1) * (n - i - 1)
steps += n
print(steps)


n = int(input())
total = n
for layer in range(n - 1):
	total += (n - 2 - layer) * (layer + 2)
	total += 1
print(total)


m = int(input())
k = 1
s = 0
for i in range(m, 0, -1):
	s += k * i - k + 1
	k += 1
print(s)


n = int(input())
ans = n
j = 2
count = 0
while n - j >= 0:
	ans += j * (n - j)
	count += 1
	j += 1
print(ans + count)


n = int(input())
known = 1
push = 0
i = 1
while i < n:
	push += (n - i) * known
	known += 1
	i += 1
push += n
print(push)


n = int(input())
t = n
p = 2
while p <= t:
	z = p * (t - p) + 1
	n += z
	p += 1
print(n)


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

def ss():
	return [x for x in input()]

def si():
	return [int(x) for x in input().split()]

def mi():
	return map(int, input().split())
a = ii()
ans = a
for i in range(1, a):
	ans += i * (a - i)
print(ans)


n = int(input())
push = n
for i in range(1, n):
	push += (n - i) * i
print(push)


n = int(input())
presses = 0
for i in range(1, n + 1):
	presses += (n - i) * i
print(presses + n)


z = int(input())
i = 1
t = 0
sub = 0
while z > 1:
	t += z * i - sub
	sub += 1
	i += 1
	z -= 1
print(t + 1)


n = int(input())
r = sum(((n - i - 1) * (i + 1) + 1 for i in range(n)))
print(r)


n = int(input())
rs = 3
start = 4
skip = 3
if n == 1:
	print(1)
	exit()
for i in range(2, n):
	rs += start
	start += skip
	skip += 1
print(rs)


n = int(input())
k = n * (n + 1) // 2
for i in range(n, 1, -1):
	k += (n - i) * (i - 1)
print(k)


n = int(input())
k = 1
r = n
sum = 0
for i in range(r):
	sum += k * (n - 1) + 1
	n -= 1
	k += 1
print(sum)


from sys import stdin
n = int(stdin.readline())
sum = 0
for i in range(n):
	sum += (n - i) * i
print(sum + n)


a = int(input())
summ = a
for i in range(a - 1, 0, -1):
	summ += (a - i) * (i - 1) + i
print(summ)


N = int(input())
SUM = N
count = 1
for i in range(N - 1, 0, -1):
	SUM += (i - 1) * (count + 1) + 1
	count += 1
print(SUM)


n = int(input())
m = 1
value = 0
while n > m:
	value += (n - m) * m
	m += 1
value += n
print(value)


n = int(input())
dp = [0] * 3000
dp[1] = 1
dp[2] = 3
for i in range(3, 3000):
	dp[i] = dp[i - 1] - dp[i - 2] + i - 1 + dp[i - 1]
print(dp[n])


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


n = int(input())
Ans = n
c = n - 1
for val in range(1, n):
	Ans += c * val
	c -= 1
print(Ans)


n = int(input())
i = 1
j = n - 1
total = n
while j != 0:
	total = total + i * j
	j = j - 1
	i = i + 1
print(total)


def Main():
	n = int(input())
	ans = 1
	coef = 2
	inc = 2
	for i in range(2, n + 1):
		ans += coef
		coef += inc
		inc += 1
	print(ans)
Main()


n = int(input())
su = n
for i in range(n):
	su = su + (n - i) * i
print(su)


n = int(input())
count = 1
total = 0
while n > 1:
	total += count * (n - 1)
	total += 1
	count += 1
	n -= 1
print(total + 1)


def find_total(length):
	wrong_starts = length - 1
	counter = 2
	initial = length
	result = initial + wrong_starts
	for i in range(2, length + 1):
		result += i * (length - counter)
		counter += 1
	return result
num = int(input())
print(find_total(num))


n = int(input())
p = 0
for i in range(n):
	p += n - i
	p += i * (n - i - 1)
print(p)


n = int(input())
times = n
for i in range(1, n):
	times = times + (n - i) * i
print(times)


import sys
n = int(sys.stdin.readline())
count = n
temp = n - 1
for i in range(1, n):
	count += i * temp
	temp -= 1
print(count)


n = int(input())
ans = 0
for x in range(1, n):
	ans += (n - x) * x
print(ans + n)


n = int(input())
s = 0
for i in range(n):
	s += (n - i) * i
print(s + n)


n = int(input())
ans = n - 1
i = 2
while i <= n:
	ans += i * (n - i)
	i += 1
ans += n
print(ans)


from sys import stdin, stdout
n = int(input())
num = n
for i in range(n):
	num += i * (n - i)
print(num)


n = int(input())
print(int((pow(n, 3) + 5 * n) / 6))


n = int(input())
m = (n ** 2 + 5) * n / 6
print(int(m))


n = int(input())
x = n * (n + 1)
x_ = x // 2
if n == 1:
	print(1)
else:
	i = 1
	c = 0
	while i != n - 1:
		c += (n - (i + 1)) * i
		i += 1
	print(c + x_)


n = int(input())
total = n
i = 2
while n - 2 >= 0:
	total += i * (n - 2) + 1
	n -= 1
	i += 1
print(total)


n = int(input())
d = n
for i in range(1, n + 1):
	d += i * (n - i)
print(d)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
N = int(input())
ans = 0
for i in range(1, N):
	ans += i * (N - i)
ans += N
print(ans)


from sys import stdin, stdout
from math import gcd, ceil, sqrt
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
n = ii1()
res = 0
for i in range(n):
	res += n - i + (n - i - 1) * i
print(res)


n = int(input())
end = n - 1
total = n
for i in range(1, end + 1):
	total += i * (n - i)
print(total)


import sys

def main():
	line = input()
	n = int(line)
	res = 0
	for i in range(1, n):
		res += (n - i) * i
	res += n
	print(res)
main()


n = int(input())
depth = 0
result = 0
while depth < n:
	tmp = n - depth
	result += tmp
	result += depth * (tmp - 1)
	depth += 1
print(result)


n = int(input())
num = 0
for i in range(1, n + 1):
	num += (n - i) * i
num += n
print(num)


from sys import stdin
input = lambda : stdin.readline().strip()
n = int(input())
o = 0
i = 0
sum1 = 0
k = n
while i < n:
	sum1 += k - 1 + (k - 1) * o + 1
	o += 1
	i += 1
	k -= 1
print(sum1)


n = int(input())
c = 0
for i in range(n):
	if i == n - 1:
		c += 1
		break
	if i == 0:
		c += n
	else:
		c += n - i + (n - i - 1) * i
print(c)


def button(n):
	l = 0
	for i in range(1, n):
		l += (n - i) * i
	l += n
	return l
n = int(input())
print(button(n))


import sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush, nlargest, nsmallest, _heapify_max, _heapreplace_max
from math import ceil, floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque, Counter as c
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from fractions import Fraction
mod = pow(10, 9) + 7
mod2 = 998244353

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

def out(*var, end='\n'):
	sys.stdout.write(' '.join(map(str, var)) + end)

def l():
	return list(sp())

def sl():
	return list(ssp())

def sp():
	return map(int, data().split())

def ssp():
	return map(str, data().split())

def l1d(n, val=0):
	return [val for i in range(n)]

def l2d(n, m, val=0):
	return [l1d(n, val) for j in range(m)]
n = int(data())
answer = n + (n - 1)
j = 2
for i in range(n - 2, 0, -1):
	answer += i * j
	j += 1
out(answer)


a = int(input())
b = a - 1
c = 1
sum = 0
if a == 2:
	print(3)
elif a == 1:
	print(1)
else:
	while b > -1:
		sum += c * b
		b -= 1
		c += 1
	print(sum + a)


def buttonPressIter(n, numSolved):
	timesPushed = 0
	while n > 0:
		timesPushed += n + numSolved * (n - 1)
		numSolved += 1
		n -= 1
	return timesPushed
print(buttonPressIter(int(input()), 0))


def main():
	(r, a, k) = (int(input()), 0, 0)
	while r >= 1:
		k += 1 + (a + 1) * (r - 1)
		a += 1
		r -= 1
	print(k)
main()


l = [2, 4, 7, 11, 16, 22, 29, 37, 46, 56, 67, 79, 92, 106, 121, 137, 154, 172, 191, 211, 232, 254, 277, 301, 326, 352, 379, 407, 436, 466, 497, 529, 562, 596, 631, 667, 704, 742, 781, 821, 862, 904, 947, 991, 1036, 1082, 1129, 1177, 1226, 1276, 1327, 1379, 1432, 1486, 1541, 1597, 1654, 1712, 1771, 1831, 1892, 1954, 2017, 2081, 2146, 2212, 2279, 2347, 2416, 2486, 2557, 2629, 2702, 2776, 2851, 2927, 3004, 3082, 3161, 3241, 3322, 3404, 3487, 3571, 3656, 3742, 3829, 3917, 4006, 4096, 4187, 4279, 4372, 4466, 4561, 4657, 4754, 4852, 4951, 5051, 5152, 5254, 5357, 5461, 5566, 5672, 5779, 5887, 5996, 6106, 6217, 6329, 6442, 6556, 6671, 6787, 6904, 7022, 7141, 7261, 7382, 7504, 7627, 7751, 7876, 8002, 8129, 8257, 8386, 8516, 8647, 8779, 8912, 9046, 9181, 9317, 9454, 9592, 9731, 9871, 10012, 10154, 10297, 10441, 10586, 10732, 10879, 11027, 11176, 11326, 11477, 11629, 11782, 11936, 12091, 12247, 12404, 12562, 12721, 12881, 13042, 13204, 13367, 13531, 13696, 13862, 14029, 14197, 14366, 14536, 14707, 14879, 15052, 15226, 15401, 15577, 15754, 15932, 16111, 16291, 16472, 16654, 16837, 17021, 17206, 17392, 17579, 17767, 17956, 18146, 18337, 18529, 18722, 18916, 19111, 19307, 19504, 19702, 19901, 20101, 20302, 20504, 20707, 20911, 21116, 21322, 21529, 21737, 21946, 22156, 22367, 22579, 22792, 23006, 23221, 23437, 23654, 23872, 24091, 24311, 24532, 24754, 24977, 25201, 25426, 25652, 25879, 26107, 26336, 26566, 26797, 27029, 27262, 27496, 27731, 27967, 28204, 28442, 28681, 28921, 29162, 29404, 29647, 29891, 30136, 30382, 30629, 30877, 31126, 31376, 31627, 31879, 32132, 32386, 32641, 32897, 33154, 33412, 33671, 33931, 34192, 34454, 34717, 34981, 35246, 35512, 35779, 36047, 36316, 36586, 36857, 37129, 37402, 37676, 37951, 38227, 38504, 38782, 39061, 39341, 39622, 39904, 40187, 40471, 40756, 41042, 41329, 41617, 41906, 42196, 42487, 42779, 43072, 43366, 43661, 43957, 44254, 44552, 44851, 45151, 45452, 45754, 46057, 46361, 46666, 46972, 47279, 47587, 47896, 48206, 48517, 48829, 49142, 49456, 49771, 50087, 50404, 50722, 51041, 51361, 51682, 52004, 52327, 52651, 52976, 53302, 53629, 53957, 54286, 54616, 54947, 55279, 55612, 55946, 56281, 56617, 56954, 57292, 57631, 57971, 58312, 58654, 58997, 59341, 59686, 60032, 60379, 60727, 61076, 61426, 61777, 62129, 62482, 62836, 63191, 63547, 63904, 64262, 64621, 64981, 65342, 65704, 66067, 66431, 66796, 67162, 67529, 67897, 68266, 68636, 69007, 69379, 69752, 70126, 70501, 70877, 71254, 71632, 72011, 72391, 72772, 73154, 73537, 73921, 74306, 74692, 75079, 75467, 75856, 76246, 76637, 77029, 77422, 77816, 78211, 78607, 79004, 79402, 79801, 80201, 80602, 81004, 81407, 81811, 82216, 82622, 83029, 83437, 83846, 84256, 84667, 85079, 85492, 85906, 86321, 86737, 87154, 87572, 87991, 88411, 88832, 89254, 89677, 90101, 90526, 90952, 91379, 91807, 92236, 92666, 93097, 93529, 93962, 94396, 94831, 95267, 95704, 96142, 96581, 97021, 97462, 97904, 98347, 98791, 99236, 99682, 100129, 100577, 101026, 101476, 101927, 102379, 102832, 103286, 103741, 104197, 104654, 105112, 105571, 106031, 106492, 106954, 107417, 107881, 108346, 108812, 109279, 109747, 110216, 110686, 111157, 111629, 112102, 112576, 113051, 113527, 114004, 114482, 114961, 115441, 115922, 116404, 116887, 117371, 117856, 118342, 118829, 119317, 119806, 120296, 120787, 121279, 121772, 122266, 122761, 123257, 123754, 124252, 124751, 125251, 125752, 126254, 126757, 127261, 127766, 128272, 128779, 129287, 129796, 130306, 130817, 131329, 131842, 132356, 132871, 133387, 133904, 134422, 134941, 135461, 135982, 136504, 137027, 137551, 138076, 138602, 139129, 139657, 140186, 140716, 141247, 141779, 142312, 142846, 143381, 143917, 144454, 144992, 145531, 146071, 146612, 147154, 147697, 148241, 148786, 149332, 149879, 150427, 150976, 151526, 152077, 152629, 153182, 153736, 154291, 154847, 155404, 155962, 156521, 157081, 157642, 158204, 158767, 159331, 159896, 160462, 161029, 161597, 162166, 162736, 163307, 163879, 164452, 165026, 165601, 166177, 166754, 167332, 167911, 168491, 169072, 169654, 170237, 170821, 171406, 171992, 172579, 173167, 173756, 174346, 174937, 175529, 176122, 176716, 177311, 177907, 178504, 179102, 179701, 180301, 180902, 181504, 182107, 182711, 183316, 183922, 184529, 185137, 185746, 186356, 186967, 187579, 188192, 188806, 189421, 190037, 190654, 191272, 191891, 192511, 193132, 193754, 194377, 195001, 195626, 196252, 196879, 197507, 198136, 198766, 199397, 200029, 200662, 201296, 201931, 202567, 203204, 203842, 204481, 205121, 205762, 206404, 207047, 207691, 208336, 208982, 209629, 210277, 210926, 211576, 212227, 212879, 213532, 214186, 214841, 215497, 216154, 216812, 217471, 218131, 218792, 219454, 220117, 220781, 221446, 222112, 222779, 223447, 224116, 224786, 225457, 226129, 226802, 227476, 228151, 228827, 229504, 230182, 230861, 231541, 232222, 232904, 233587, 234271, 234956, 235642, 236329, 237017, 237706, 238396, 239087, 239779, 240472, 241166, 241861, 242557, 243254, 243952, 244651, 245351, 246052, 246754, 247457, 248161, 248866, 249572, 250279, 250987, 251696, 252406, 253117, 253829, 254542, 255256, 255971, 256687, 257404, 258122, 258841, 259561, 260282, 261004, 261727, 262451, 263176, 263902, 264629, 265357, 266086, 266816, 267547, 268279, 269012, 269746, 270481, 271217, 271954, 272692, 273431, 274171, 274912, 275654, 276397, 277141, 277886, 278632, 279379, 280127, 280876, 281626, 282377, 283129, 283882, 284636, 285391, 286147, 286904, 287662, 288421, 289181, 289942, 290704, 291467, 292231, 292996, 293762, 294529, 295297, 296066, 296836, 297607, 298379, 299152, 299926, 300701, 301477, 302254, 303032, 303811, 304591, 305372, 306154, 306937, 307721, 308506, 309292, 310079, 310867, 311656, 312446, 313237, 314029, 314822, 315616, 316411, 317207, 318004, 318802, 319601, 320401, 321202, 322004, 322807, 323611, 324416, 325222, 326029, 326837, 327646, 328456, 329267, 330079, 330892, 331706, 332521, 333337, 334154, 334972, 335791, 336611, 337432, 338254, 339077, 339901, 340726, 341552, 342379, 343207, 344036, 344866, 345697, 346529, 347362, 348196, 349031, 349867, 350704, 351542, 352381, 353221, 354062, 354904, 355747, 356591, 357436, 358282, 359129, 359977, 360826, 361676, 362527, 363379, 364232, 365086, 365941, 366797, 367654, 368512, 369371, 370231, 371092, 371954, 372817, 373681, 374546, 375412, 376279, 377147, 378016, 378886, 379757, 380629, 381502, 382376, 383251, 384127, 385004, 385882, 386761, 387641, 388522, 389404, 390287, 391171, 392056, 392942, 393829, 394717, 395606, 396496, 397387, 398279, 399172, 400066, 400961, 401857, 402754, 403652, 404551, 405451, 406352, 407254, 408157, 409061, 409966, 410872, 411779, 412687, 413596, 414506, 415417, 416329, 417242, 418156, 419071, 419987, 420904, 421822, 422741, 423661, 424582, 425504, 426427, 427351, 428276, 429202, 430129, 431057, 431986, 432916, 433847, 434779, 435712, 436646, 437581, 438517, 439454, 440392, 441331, 442271, 443212, 444154, 445097, 446041, 446986, 447932, 448879, 449827, 450776, 451726, 452677, 453629, 454582, 455536, 456491, 457447, 458404, 459362, 460321, 461281, 462242, 463204, 464167, 465131, 466096, 467062, 468029, 468997, 469966, 470936, 471907, 472879, 473852, 474826, 475801, 476777, 477754, 478732, 479711, 480691, 481672, 482654, 483637, 484621, 485606, 486592, 487579, 488567, 489556, 490546, 491537, 492529, 493522, 494516, 495511, 496507, 497504, 498502, 499501, 500501, 501502, 502504, 503507, 504511, 505516, 506522, 507529, 508537, 509546, 510556, 511567, 512579, 513592, 514606, 515621, 516637, 517654, 518672, 519691, 520711, 521732, 522754, 523777, 524801, 525826, 526852, 527879, 528907, 529936, 530966, 531997, 533029, 534062, 535096, 536131, 537167, 538204, 539242, 540281, 541321, 542362, 543404, 544447, 545491, 546536, 547582, 548629, 549677, 550726, 551776, 552827, 553879, 554932, 555986, 557041, 558097, 559154, 560212, 561271, 562331, 563392, 564454, 565517, 566581, 567646, 568712, 569779, 570847, 571916, 572986, 574057, 575129, 576202, 577276, 578351, 579427, 580504, 581582, 582661, 583741, 584822, 585904, 586987, 588071, 589156, 590242, 591329, 592417, 593506, 594596, 595687, 596779, 597872, 598966, 600061, 601157, 602254, 603352, 604451, 605551, 606652, 607754, 608857, 609961, 611066, 612172, 613279, 614387, 615496, 616606, 617717, 618829, 619942, 621056, 622171, 623287, 624404, 625522, 626641, 627761, 628882, 630004, 631127, 632251, 633376, 634502, 635629, 636757, 637886, 639016, 640147, 641279, 642412, 643546, 644681, 645817, 646954, 648092, 649231, 650371, 651512, 652654, 653797, 654941, 656086, 657232, 658379, 659527, 660676, 661826, 662977, 664129, 665282, 666436, 667591, 668747, 669904, 671062, 672221, 673381, 674542, 675704, 676867, 678031, 679196, 680362, 681529, 682697, 683866, 685036, 686207, 687379, 688552, 689726, 690901, 692077, 693254, 694432, 695611, 696791, 697972, 699154, 700337, 701521, 702706, 703892, 705079, 706267, 707456, 708646, 709837, 711029, 712222, 713416, 714611, 715807, 717004, 718202, 719401, 720601, 721802, 723004, 724207, 725411, 726616, 727822, 729029, 730237, 731446, 732656, 733867, 735079, 736292, 737506, 738721, 739937, 741154, 742372, 743591, 744811, 746032, 747254, 748477, 749701, 750926, 752152, 753379, 754607, 755836, 757066, 758297, 759529, 760762, 761996, 763231, 764467, 765704, 766942, 768181, 769421, 770662, 771904, 773147, 774391, 775636, 776882, 778129, 779377, 780626, 781876, 783127, 784379, 785632, 786886, 788141, 789397, 790654, 791912, 793171, 794431, 795692, 796954, 798217, 799481, 800746, 802012, 803279, 804547, 805816, 807086, 808357, 809629, 810902, 812176, 813451, 814727, 816004, 817282, 818561, 819841, 821122, 822404, 823687, 824971, 826256, 827542, 828829, 830117, 831406, 832696, 833987, 835279, 836572, 837866, 839161, 840457, 841754, 843052, 844351, 845651, 846952, 848254, 849557, 850861, 852166, 853472, 854779, 856087, 857396, 858706, 860017, 861329, 862642, 863956, 865271, 866587, 867904, 869222, 870541, 871861, 873182, 874504, 875827, 877151, 878476, 879802, 881129, 882457, 883786, 885116, 886447, 887779, 889112, 890446, 891781, 893117, 894454, 895792, 897131, 898471, 899812, 901154, 902497, 903841, 905186, 906532, 907879, 909227, 910576, 911926, 913277, 914629, 915982, 917336, 918691, 920047, 921404, 922762, 924121, 925481, 926842, 928204, 929567, 930931, 932296, 933662, 935029, 936397, 937766, 939136, 940507, 941879, 943252, 944626, 946001, 947377, 948754, 950132, 951511, 952891, 954272, 955654, 957037, 958421, 959806, 961192, 962579, 963967, 965356, 966746, 968137, 969529, 970922, 972316, 973711, 975107, 976504, 977902, 979301, 980701, 982102, 983504, 984907, 986311, 987716, 989122, 990529, 991937, 993346, 994756, 996167, 997579, 998992, 1000406, 1001821, 1003237, 1004654, 1006072, 1007491, 1008911, 1010332, 1011754, 1013177, 1014601, 1016026, 1017452, 1018879, 1020307, 1021736, 1023166, 1024597, 1026029, 1027462, 1028896, 1030331, 1031767, 1033204, 1034642, 1036081, 1037521, 1038962, 1040404, 1041847, 1043291, 1044736, 1046182, 1047629, 1049077, 1050526, 1051976, 1053427, 1054879, 1056332, 1057786, 1059241, 1060697, 1062154, 1063612, 1065071, 1066531, 1067992, 1069454, 1070917, 1072381, 1073846, 1075312, 1076779, 1078247, 1079716, 1081186, 1082657, 1084129, 1085602, 1087076, 1088551, 1090027, 1091504, 1092982, 1094461, 1095941, 1097422, 1098904, 1100387, 1101871, 1103356, 1104842, 1106329, 1107817, 1109306, 1110796, 1112287, 1113779, 1115272, 1116766, 1118261, 1119757, 1121254, 1122752, 1124251, 1125751, 1127252, 1128754, 1130257, 1131761, 1133266, 1134772, 1136279, 1137787, 1139296, 1140806, 1142317, 1143829, 1145342, 1146856, 1148371, 1149887, 1151404, 1152922, 1154441, 1155961, 1157482, 1159004, 1160527, 1162051, 1163576, 1165102, 1166629, 1168157, 1169686, 1171216, 1172747, 1174279, 1175812, 1177346, 1178881, 1180417, 1181954, 1183492, 1185031, 1186571, 1188112, 1189654, 1191197, 1192741, 1194286, 1195832, 1197379, 1198927, 1200476, 1202026, 1203577, 1205129, 1206682, 1208236, 1209791, 1211347, 1212904, 1214462, 1216021, 1217581, 1219142, 1220704, 1222267, 1223831, 1225396, 1226962, 1228529, 1230097, 1231666, 1233236, 1234807, 1236379, 1237952, 1239526, 1241101, 1242677, 1244254, 1245832, 1247411, 1248991, 1250572, 1252154, 1253737, 1255321, 1256906, 1258492, 1260079, 1261667, 1263256, 1264846, 1266437, 1268029, 1269622, 1271216, 1272811, 1274407, 1276004, 1277602, 1279201, 1280801, 1282402, 1284004, 1285607, 1287211, 1288816, 1290422, 1292029, 1293637, 1295246, 1296856, 1298467, 1300079, 1301692, 1303306, 1304921, 1306537, 1308154, 1309772, 1311391, 1313011, 1314632, 1316254, 1317877, 1319501, 1321126, 1322752, 1324379, 1326007, 1327636, 1329266, 1330897, 1332529, 1334162, 1335796, 1337431, 1339067, 1340704, 1342342, 1343981, 1345621, 1347262, 1348904, 1350547, 1352191, 1353836, 1355482, 1357129, 1358777, 1360426, 1362076, 1363727, 1365379, 1367032, 1368686, 1370341, 1371997, 1373654, 1375312, 1376971, 1378631, 1380292, 1381954, 1383617, 1385281, 1386946, 1388612, 1390279, 1391947, 1393616, 1395286, 1396957, 1398629, 1400302, 1401976, 1403651, 1405327, 1407004, 1408682, 1410361, 1412041, 1413722, 1415404, 1417087, 1418771, 1420456, 1422142, 1423829, 1425517, 1427206, 1428896, 1430587, 1432279, 1433972, 1435666, 1437361, 1439057, 1440754, 1442452, 1444151, 1445851, 1447552, 1449254, 1450957, 1452661, 1454366, 1456072, 1457779, 1459487, 1461196, 1462906, 1464617, 1466329, 1468042, 1469756, 1471471, 1473187, 1474904, 1476622, 1478341, 1480061, 1481782, 1483504, 1485227, 1486951, 1488676, 1490402, 1492129, 1493857, 1495586, 1497316, 1499047, 1500779, 1502512, 1504246, 1505981, 1507717, 1509454, 1511192, 1512931, 1514671, 1516412, 1518154, 1519897, 1521641, 1523386, 1525132, 1526879, 1528627, 1530376, 1532126, 1533877, 1535629, 1537382, 1539136, 1540891, 1542647, 1544404, 1546162, 1547921, 1549681, 1551442, 1553204, 1554967, 1556731, 1558496, 1560262, 1562029, 1563797, 1565566, 1567336, 1569107, 1570879, 1572652, 1574426, 1576201, 1577977, 1579754, 1581532, 1583311, 1585091, 1586872, 1588654, 1590437, 1592221, 1594006, 1595792, 1597579, 1599367, 1601156, 1602946, 1604737, 1606529, 1608322, 1610116, 1611911, 1613707, 1615504, 1617302, 1619101, 1620901, 1622702, 1624504, 1626307, 1628111, 1629916, 1631722, 1633529, 1635337, 1637146, 1638956, 1640767, 1642579, 1644392, 1646206, 1648021, 1649837, 1651654, 1653472, 1655291, 1657111, 1658932, 1660754, 1662577, 1664401, 1666226, 1668052, 1669879, 1671707, 1673536, 1675366, 1677197, 1679029, 1680862, 1682696, 1684531, 1686367, 1688204, 1690042, 1691881, 1693721, 1695562, 1697404, 1699247, 1701091, 1702936, 1704782, 1706629, 1708477, 1710326, 1712176, 1714027, 1715879, 1717732, 1719586, 1721441, 1723297, 1725154, 1727012, 1728871, 1730731, 1732592, 1734454, 1736317, 1738181, 1740046, 1741912, 1743779, 1745647, 1747516, 1749386, 1751257, 1753129, 1755002, 1756876, 1758751, 1760627, 1762504, 1764382, 1766261, 1768141, 1770022, 1771904, 1773787, 1775671, 1777556, 1779442, 1781329, 1783217, 1785106, 1786996, 1788887, 1790779, 1792672, 1794566, 1796461, 1798357, 1800254, 1802152, 1804051, 1805951, 1807852, 1809754, 1811657, 1813561, 1815466, 1817372, 1819279, 1821187, 1823096, 1825006, 1826917, 1828829, 1830742, 1832656, 1834571, 1836487, 1838404, 1840322, 1842241, 1844161, 1846082, 1848004, 1849927, 1851851, 1853776, 1855702, 1857629, 1859557, 1861486, 1863416, 1865347, 1867279, 1869212, 1871146, 1873081, 1875017, 1876954, 1878892, 1880831, 1882771, 1884712, 1886654, 1888597, 1890541, 1892486, 1894432, 1896379, 1898327, 1900276, 1902226, 1904177, 1906129, 1908082, 1910036, 1911991, 1913947, 1915904, 1917862, 1919821, 1921781, 1923742, 1925704, 1927667, 1929631, 1931596, 1933562, 1935529, 1937497, 1939466, 1941436, 1943407, 1945379, 1947352, 1949326, 1951301, 1953277, 1955254, 1957232, 1959211, 1961191, 1963172, 1965154, 1967137, 1969121, 1971106, 1973092, 1975079, 1977067, 1979056, 1981046, 1983037, 1985029, 1987022, 1989016, 1991011, 1993007, 1995004, 1997002, 1999001, 2001001]
n = int(input())
print(1 + sum(l[:n - 1]))


n = int(input())
print(sum((n * (i + 1) - i * (i + 2) for i in range(n))))


co = n = int(input())
slon = 0
for i in range(1, co + 1):
	slon += n * i - (co - n)
	n -= 1
print(slon)


(j, ans) = (1, 0)
for i in range(int(input()), 0, -1):
	ans += (i - 1) * j + 1
	j += 1
print(ans)


n = int(input())
v = n
t = 1
n = n - t
while n > 0:
	v = v + t * n
	t += 1
	n = n - 1
print(v)


import sys
sys.setrecursionlimit(3000)

def sigma(i, n):
	if i == 1:
		return n - 1
	else:
		return i * (n - i) + sigma(i - 1, n)
n = int(input())
ans = sigma(n, n) + n
print(ans)


a = int(input())
sum1 = 0
for i in range(1, a):
	sum1 += (a - i) * i + 1
print(sum1 + 1)


el = int(input())
ans = 0
kn = 0
for i in range(el):
	ans += el - i
	ans += kn * (el - i)
	kn += 1
	ans -= el - i - 1
print(ans)


n = int(input())
if n == 1:
	print(1)
else:
	accumulator = n + 1
	for i in range(2, n):
		accumulator += i * (n - i) + 1
	print(accumulator)


n = int(input())
(c, s) = (1, 0)
for i in range(n):
	s += n * c - (c - 1)
	n -= 1
	c += 1
print(s)


n = int(input())
k = 1
s = n
for i in range(n - 1, 0, -1):
	s += k * i
	k += 1
print(s)


n = int(input())
total = 0
for i in range(1, n + 1, 1):
	total += 1 + (i - 1) * (n - (i - 1))
print(total)


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


buttons = int(input())
inner = buttons - 1
sum = 0
for x in range(1, buttons + 1):
	sum += x + (x - 1) * inner
	inner -= 1
print(sum)


n = int(input())
sums = 0
for i in range(1, n):
	sums += (n - i) * i
print(sums + n)


n = int(input())
total = n * (n ** 2 + 5) / 6
print(int(total))


from functools import reduce
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import *
from io import BytesIO, IOBase
input = lambda : sys.stdin.readline().rstrip('\r\n')

def value():
	return tuple(map(int, input().split()))

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

def sarr():
	return [int(i) for i in input()]

def inn():
	return int(input())
mo = 1000000007
n = inn()
ans = n
j = 1
for i in range(n - 1, 0, -1):
	ans += j * i
	j += 1
print(ans)


n = int(input())
p = 1
s = 2
k = 0
for i in range(1, n + 1):
	k = k + i
	if i > 2:
		k = k + p
		p = p + s
		s = s + 1
print(k)


x = int(input())
a = 0
for q in range(0, x):
	a += (x - q) * q + 1
print(a)


n = int(input())
if n == 1:
	print(n)
else:
	taps = n + 1
	k = 2
	while n - k > 0:
		taps += 1 + (n - k) * k
		k += 1
	print(taps)


n = int(input())
newN = n - 1
res = n
while newN >= 1:
	if newN == 1:
		res = res + 1
		newN = newN - 1
	else:
		res = res + (newN * (n - newN + 1) - (n - newN))
		newN = newN - 1
print(res)


n = int(input())
if n == 1:
	print('1')
else:
	i = 1
	num = n + 1
	while n - i > 1:
		num += (n - i) * (i + 1) - i
		i += 1
	print(num)


n = int(input())
data = [n]
for i in range(n - 1, 0, -1):
	data.append(1 + (i - 1) * (n - i + 1))
print(sum(data))


__author__ = 'myduomilia'
n = int(input())
arr = [0 for i in range(n)]
for i in range(n):
	arr[i] = n
	j = i - 1
	while j >= 0:
		arr[j] += n - 1
		j -= 1
	n -= 1
print(sum(arr))


n = int(input())
worst_case = 0
for i in range(1, n + 1):
	worst_case += 1 + (n - i) * i
print(worst_case)


n = int(input())
m = 0
p = 2
if n == 1:
	print(1)
elif n == 2:
	print(3)
elif n > 2:
	for i in range(n - 2, 0, -1):
		m += i * p + 1
		p += 1
	print(n + m + 1)


n = int(input())
tries = n
for i in range(1, n):
	tries += i * (n - i)
print(int(tries))


n = int(input())
tries = 0
correct = 0
for i in range(1, n):
	tries += (n - i) * correct + (n - i)
	correct += 1
tries += n
print(tries)


x = int(input())
counter = x
for i in range(1, x + 1):
	counter += i * (x - i)
print(counter)


def solve(n):
	x = 0
	t = 0
	while x < n:
		t += n - x + x * (n - 1 - x)
		x += 1
	return t

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


n = int(input())
op = []
for i in range(1, n + 1):
	op.append(i)
op.sort(reverse=True)
ans = sum(op)
for i in range(0, len(op)):
	ans += i * (op[i] - 1)
print(ans)


import math
n = int(input())
k = n
i = 0
while i <= n:
	k = k + i * (n - i)
	i = i + 1
print(k)


def main():
	x = int(input())
	e = x - 1
	s = 0
	l = []
	for num in range(1, x + 1):
		s = s + num
		l.append(num - 1)
	xl = l[::-1]
	sumlists = []
	i = 0
	for num in l:
		sumlists.append(num * xl[i])
		i += 1
	print(sum(sumlists) + s)
main()


pressButton = int(input())
print(pressButton * (pressButton ** 2 + 5) // 6)


n = int(input())
s = 0
k = 1
while n > 0:
	t = k * (n - 1) + 1
	s += t
	k += 1
	n -= 1
print(s)


n = int(input())
count = n
i = 1
while n != 0:
	for ii in range(n - 1):
		count += i
	i += 1
	n -= 1
print(count)


n = int(input())
sum = 0
for x in range(1, n - 1):
	sum = sum + x * (n - 1 - x)
print(n * (n + 1) // 2 + sum)


bNum = int(input())
time = bNum
i = bNum
while i >= 1:
	time += (i - 1) * (bNum - i + 1)
	i -= 1
print(time)


n = int(input())
if n == 1:
	print(n)
else:
	sum = n
	n = n - 1
	i = 2
	while n > 1:
		sum = sum + i * n - (i - 1)
		i = i + 1
		n = n - 1
	sum = sum + 1
	print(sum)


n = int(input())
ans = 0
for t in range(1, n + 1):
	ans += t
	ans += (n - t) * (n - (n - t + 1))
print(ans)


a = int(input())
print(a + (a ** 3 - a) // 6)


def d(x):
	if x == 1:
		return 1
	elif x == 2:
		return 3
	else:
		return x + (x - 2) * (x - 1) // 2 + d(x - 1)
n = int(input())
print(d(n))


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


a = int(input())
k = a
for i in range(1, a):
	k = k + i * (a - i)
print(k)


n = int(input()) - 1
if n == 0:
	print(1)
	exit()
total = n + 1
i = 2
while n > 1:
	total += 1 + i * (n - 1)
	n -= 1
	i += 1
print(total + 1)


(a, t, d) = (int(input()), 0, 1)
for i in range(a):
	t += d * (a - i) - i
	d += 1
print(t)


a = int(input())
j = 0
k = a
count = a
while j < a:
	k -= 1
	j += 1
	count += j * k
print(count)


n = int(input())
q = n
for i in range(n):
	q += i * (n - i)
print(q)


n = int(input().strip())
print((n - 1) * n * (n + 1) // 6 + n)


number_of_buttons = input()
n = int(number_of_buttons)
click = 0
for i in range(1, n, 1):
	click = (n - i) * i + click
total_click = click + n
print(total_click)


N = int(input())
Suma = 0
K = 1
while K < N:
	Suma = Suma + (N - K) * K
	K = K + 1
print(Suma + N)


def get_button_presses(n):
	s1 = n
	s2 = n * (n - 1) * n // 2
	s3 = (n - 1) * n * (2 * n - 1) // 6
	return s1 + s2 - s3
n = int(input())
print(get_button_presses(n))


n = int(input(''))
sum = n
m = n - 1
for i in range(1, n):
	sum = sum + m * i
	m = m - 1
print(sum)


n = int(input())
l = 0
for i in range(1, n):
	l += i * (n - i)
print(l + n)


a = int(input())
t = a + a - 1
a -= 2
c = 2
while a > 0:
	t += a * c
	c += 1
	a -= 1
print(t)


def main():
	n = int(input())
	result = n
	if n > 1:
		n -= 1
		mult = 2
		while n > 1:
			result += (n - 1) * mult + 1
			mult += 1
			n -= 1
		result += 1
	print(result)
main()


import math
import os
import sys
import re
import string
import itertools
import functools
import operator

def seq(n):
	(idx, k) = (n - 1, 1)
	yield n
	while idx > 0:
		yield (k * idx)
		idx = idx - 1
		k = k + 1
print(sum(seq(int(input()))))


def my_input():
	return int(input())

def locker(n):
	result = (n + 1) * n / 2
	for k in range(2, n):
		result += (n - k) * (k - 1)
	return int(result)

def main():
	x = my_input()
	print(locker(x))
main()


try:
	n = int(input())
	ans = 0
	i = 1
	while n - i >= 1:
		ans += (n - i) * i
		i += 1
	print(ans + n)
except EOFError:
	pass


answ = 0
n = int(input())
for i in range(1, n):
	answ += (n - i) * i
print(answ + n)


n = int(input())
out = 0
for i in range(1, n + 1):
	out += (n - i) * i
print(out + n)


n = int(input())
if n == 1:
	print(1)
	exit()
cnt = n
p = 2
for i in range(n - 2, 0, -1):
	cnt += i * p + 1
	p += 1
print(cnt + 1)


n = int(input())
but = 0
for i in range(n):
	but = but + (n - i) * (i + 1) - i
if n == 1:
	print(but)
elif n == 2:
	print(but)
else:
	print(but)


def main():
	number_of_buttons = int(input())
	path_len = 0
	for i in range(1, number_of_buttons):
		path_len += (number_of_buttons - i) * i
	path_len += number_of_buttons
	print(path_len)
main()


def knopki(number):
	return number * (number ** 2 + 5) // 6
print(knopki(int(input())))


btn_amount = int(input())
presses = btn_amount
known_code_len = 0
while known_code_len < btn_amount:
	max_stage_clicks = btn_amount - known_code_len
	presses += (max_stage_clicks - 1) * (known_code_len + 1)
	known_code_len += 1
print(presses)


n = int(input())
j = 1
s = n
while j < n:
	s += (n - j) * j
	j += 1
print(str(s))


n = int(input())
s = 2 * n - 1
t = n - 2
if n > 2:
	for i in range(2, n):
		s += i * t
		t -= 1
print(s)


n = int(input())
z = 0
for i in range(n):
	z += (i + 1) * (n - i) - i
print(z)


n = int(input())
sum = 0
if n == 2:
	print(3)
elif n == 3:
	print(7)
else:
	for i in range(1, n + 1):
		sum += i * (n - i)
	print(sum + n)


n = int(input())
_ = 0
for i in range(1, n + 1):
	_ += i * (n - i)
print(_ + n)


Inpt = int(input())
print(int(Inpt * (Inpt ** 2 + 5) / 6))


n = int(input())
i = 1
j = n - 1
x = 0
if n == 1 or n == 2:
	if n == 1:
		print(1)
	else:
		print(3)
else:
	while j > 0:
		x = x + i * j
		i = i + 1
		j = j - 1
	print(x + n)


buttons = int(input())
result = (buttons ** 3 + 5 * buttons) / 6
print(str(int(result)))


import math
n = int(input())
ans = 0
j = 1
for i in range(n, 0, -1):
	ans += (i - 1) * j + 1
	j += 1
print(ans)


n = int(input())
x = 1 / 6 * (n - 1) * n * (n + 1) + n
print(int(round(x, 3)))


n = int(input())
a = n
x = 0
while n != 0:
	x = x + n + (n - 1) * (a - n)
	n -= 1
print(x)


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


from sys import stdin, stdout
import bisect

def st():
	return list(stdin.readline())

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

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

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

def pr(n):
	stdout.write(str(n) + '\n')

def soe(limit):
	l = [1] * (limit + 1)
	prime = []
	for i in range(2, limit + 1):
		if l[i]:
			for j in range(i * i, limit + 1, i):
				l[j] = 0
	for i in range(2, limit + 1):
		if l[i]:
			prime.append(i)
	return prime

def segsoe(low, high):
	limit = int(high ** 0.5) + 1
	prime = soe(limit)
	n = high - low + 1
	l = [0] * (n + 1)
	for i in range(len(prime)):
		lowlimit = low // prime[i] * prime[i]
		if lowlimit < low:
			lowlimit += prime[i]
		if lowlimit == prime[i]:
			lowlimit += prime[i]
		for j in range(lowlimit, high + 1, prime[i]):
			l[j - low] = 1
	for i in range(low, high + 1):
		if not l[i - low]:
			if i != 1:
				print(i)

def power(a, n):
	r = 1
	while n:
		if n & 1:
			r = r * a
			n = n - 1
		else:
			a = a * a
			n = n >> 1
	return r

def solve():
	n = inp()
	s = n * (n + 1) // 2
	x = 0
	for i in range(n, 0, -1):
		attempt = i - 1
		s += attempt * x
		x += 1
	pr(s)
solve()


n = int(input())
print(round(n ** 3 / 6 + 5 * n / 6))


def main():
	from math import ceil
	n = int(input())
	pushes = 0
	for i in range(1, ceil(n / 2)):
		pushes += i * (n - i)
	pushes *= 2
	if n % 2 == 0:
		pushes += (n // 2) ** 2
	pushes += n
	print(pushes)
main()


n = int(input())
s = n
for x in range(2, n + 1):
	s += 1 + (n - x) * x
print(s)


number = input()
number = int(number)
ans = 0
for x in range(number):
	ans += x * (number - x)
ans += number
print(ans)


def main():
	n = int(input())
	print(n * (n ** 2 + 5) // 6)

def __starting_point():
	main()
__starting_point()


a = int(input())
z = 0
for i in range(1, a):
	z += i * (a - i)
z += a
print(z)


n = int(input())
res = 0
(j, k) = (1, 0)
for i in range(n, 0, -1):
	res += i * j - k
	j += 1
	k += 1
print(res)


import sys
input = sys.stdin.readline

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

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

def primefs(n):
	primes = {}
	while n % 2 == 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:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

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

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

def union(x, y, size, link):
	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(1000000.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().split()))
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
n = int(input())
ans = n * (n + 1) // 2
x = 1
for i in range(n - 1, 0, -1):
	ans += x * (i - 1)
	x += 1
print(ans)


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()
ans = n * (n - 1) * (n - 5) // 6 + n ** 2
print(ans)


n = int(input())
k = 1
total = 0
while n - k > 0:
	total = total + k * (n - k)
	k = k + 1
total = total + n
print(total)


x = int(input())
print((x ** 3 + 5 * x) // 6)


from math import factorial
n = int(input())
square = n ** 2
print(n * (square - 1) // 6 + n)


t = int(input())
sum = 0
for _ in range(t):
	sum += (t - (_ + 1)) * (_ + 1)
sum += t
print(sum)


n = int(input(''))
a = 1
p = 0
x = 1
while x == 1:
	if n - (a - 1) == 0:
		break
	p = p + a * (n - (a - 1)) - (a - 1)
	a = a + 1
print(p)


n = int(input())
if n == 1:
	print(1)
else:
	(f, s) = (0, 0)
	n -= 1
	while n >= 0:
		s += n + (n - 1) * f + (f + 1)
		n -= 1
		f += 1
	print(s)


import sys, os
from collections import Counter
import heapq
import math
from io import BytesIO, IOBase
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')
import os.path
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

def listt():
	return [int(i) for i in input().split()]
n = int(input())
ans = n
for i in range(1, n):
	ans += (n - i) * i
print(ans)


buttons = int(input())
res = buttons
for i in range(1, buttons):
	res += (buttons - i) * i
print(res)


def pklk(n):
	s = n
	if n == 1:
		return n
	if n == 2:
		return 3
	for i in range(2, n):
		s += 1 + i * (n - i)
	return s + 1
n = int(input())
print(pklk(n))


n = int(input())
c = 0
for i in range(n):
	c += n + (n - i - 2) * i
print(c)


a = int(input())
g = 1
res = 0
for i in range(a):
	if i == a - 1:
		break
	for j in range(a - i - 1):
		res += g
	res += 1
	g += 1
print(res + 1)


n = int(input())
times = 1
moves = 0
while n > 0:
	moves += (n - 1) * times + 1
	times += 1
	n -= 1
print(moves)


n = int(input())
count = 0
summ = 0
boole = False
while n >= 1:
	if boole == False:
		summ += n
		boole = True
	else:
		summ += n + n * count - count
		boole = True
	n -= 1
	count += 1
print(summ)


a = int(input())
ans = 0
for n in range(a):
	ans += (a - n - 1) * (n + 1)
ans += a
print(ans)


num = int(input())
total = 0
mult = 1
for n in range(1, num):
	total += (num - n) * mult
	mult += 1
print(total + num)


n = int(input())
ans = 0

def f(x):
	return x * (x + 1) // 2
for i in range(n):
	ans += n - i
	ans += f(max(0, n - i - 2))
print(ans)


__author__ = 'runekri3'
n = int(input())
total = n
for i in range(1, n):
	total += i * (n - i)
print(total)


n = int(input())
a = n
total = 0
while True:
	if a == 1:
		total += n
		break
	else:
		a -= 1
		total += a * (n - a)
print(total)


import math
n = int(input())
print(int(n * (n - 1) * (1 + n) / 6 + n))


buttons = int(input())
push = buttons
for i in range(1, buttons):
	push += i * (buttons - i)
print(push)


n = int(input())
t = 0
for k in range(n):
	t += (n - k - 1) * (k + 1) + 1
print(t)


buttons_count = int(input())
touches = 0
for i in range(0, buttons_count):
	touches += (buttons_count - i) * i + 1
print(touches)


n = int(input())
ans = n
for i in range(n):
	ans += (n - i) * i
print(ans)


n = int(input())
b = n
c = n - 2
i = 2
while c >= 0:
	b += c * i + 1
	c -= 1
	i += 1
print(b)


import math
n = int(input())
n = int(n)
others = n
correct = 0
step = 0
while correct < n:
	step += others + correct * (others - 1)
	correct += 1
	others -= 1
print(step)


n = int(input())
ct = 0
for i in range(1, n + 1):
	ct += (n - i) * i + 1
print(ct)


N = int(input())
if N == 1:
	print(1)
	exit()
if N == 2:
	print(3)
	exit()
ans = [(N - i - 1) * (i + 1) for i in range(N)]
ans[-1] = N
print(sum(ans))


import sys
n = int(input())
ans = 0
for i in range(n):
	ans += 1 + (i + 1) * (n - i - 1)
print(ans)


a = int(input())
s = 0
for i in range(a):
	s += i * (a - 1 - i)
d = int((a + a * a) / 2)
print(s + d)


n = int(input())
a = 1
res = n
while n > 1:
	res += n - 1 + (n - 2) * a
	n -= 1
	a += 1
print(res)


n = int(input())
s = 0
n1 = n
while n != 0:
	s = s + n + (n - 1) * (n1 - n)
	n -= 1
print(s)


def func(n):
	s = 0
	for i in range(0, n):
		s += (n - i) * i
	print(s + n)
n = int(input())
func(n)


n = int(input())
sum = 0
i = 2
while n - i > 0:
	sum += (n - i) * i + 1
	i += 1
sum += n + 1
if n == 1:
	sum = 1
print(sum)


b = int(input())
a = b
ans = 0
x = 1
while a > 2:
	ans += (a - 2) * x + (a - 1)
	x += 1
	a -= 1
if b == 1:
	print('1')
else:
	print(ans + b + 1)


x = int(input())
(moves, ret) = (0, 0)
for i in range(0, x):
	ret += (moves + 1) * (x - i - 1) + 1
	moves += 1
print(ret)


n = int(input())
count = n
n -= 1
i = 1
while n != 0:
	count += n
	count += (n - 1) * i
	i += 1
	n -= 1
print(count)


n = int(input())
x = 0
for j in range(2, n):
	x = x + (n - j) * j
print(x + n - 1 + n)


n = int(input())
s = 0
for i in range(n):
	error = n - i - 1
	rep = i + 1
	s += error * rep
print(s + n)


n = int(input())

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

def m(n):
	x = 0
	for i in range(0, n):
		x += t(i) + i + 1
	return x
print(int(m(n)))


N = int(input())
countCount = 2
ap = 2
array = [0, 1]
for i in range(N - 1):
	array.append(array[-1] + ap)
	ap += countCount
	countCount += 1
print(array[-1])


n = int(input())
m = n
c = 1
ans = 0
for f1 in range(1, n):
	for f2 in range(1, m):
		ans += c
	c += 1
	m -= 1
print(ans + n)


n = int(input())
k = n * (n ** 2 + 5) / 6
print(int(k))


n = int(input(''))
cont = 1
j = 1
d = {1: 1}
for k in range(n - 1):
	cont += 1
	d[j + d[j]] = cont
	j = j + d[j]
print(sum(d.keys()))


n = int(input())
if n == 1:
	print(1)
else:
	num = n
	for i in range(1, n):
		num += (i + 1) * (n - i) - i
	print(num)


buttons = int(input())
press = 0
i = 1
while buttons > 0:
	press += buttons * i - i + 1
	buttons -= 1
	i += 1
print(press)


def main():
	n = int(input())
	s = 0
	for x in range(n):
		s += (n - x) * x
	print(s + n)
main()


n = int(input())

def soma_fodase(n):
	return sum((x * (n - x) for x in range(1, n)))
print(n + soma_fodase(n))


def parse_input() -> int:
	return int(input())

def solve(n: int) -> int:
	return (n ** 3 + 5 * n) // 6
print(solve(parse_input()))


n = int(input())
s = 0
a = 2
if n == 1:
	m = 1
else:
	for i in range(n):
		p = a * (n - a) + 1
		a += 1
		if n - a < 0:
			break
		else:
			s += p
	m = n + s + 1
print(m)


import sys
import math
a = int(input())
b = 1
c = 0
d = b
e = []
for i in range(a):
	d = b
	b += i
	e.append(b)
print(sum(e[:a]))


n = int(input())
k = 4
res = 3
i = 2
if n == 1:
	print(1)
else:
	while i < n:
		res += k
		i += 1
		k += i
	print(res)


n = int(input())
y = 0
c = 0
while n > 0:
	c += n + (n - 1) * y
	n = n - 1
	y = y + 1
print(c)


n = int(input())
z = 1
x = n + 1
if n == 1:
	print('1')
else:
	for y in range(n - 1, 1, -1):
		x = x + y * z + 1
		z = z + 1
	print(x)


n = int(input())
r = n
for i in range(n - 1):
	r += (n - (2 + i)) * (2 + i) + 1
print(r)


from functools import reduce
n = int(input())
s = reduce(lambda x, y: x + (n - y) * y, range(0, n))
print(s + n)


n = int(input())
sum1 = 0
know = 0
unknow = n
while unknow > 1:
	sum1 += (unknow - 1) * (know + 1)
	know += 1
	unknow -= 1
sum1 += n
print(sum1)


n = int(input())
m = n + 1 - 1
x = 0
sahi = 0
for i in range(n):
	x += m - 1
	x += sahi * (m - 1)
	sahi += 1
	m -= 1
	x += 1
print(x)


import sys
n = int(sys.stdin.readline().strip())
ans = 0
for i in range(n):
	t = n - i
	ans += (t - 1) * (i + 1) + 1
print(ans)


n = int(input())
if n == 1:
	print(1)
	exit()
i = 1
fs = 0
ss = 0
while i < n:
	fs += i * n
	if i > 1:
		ss += i * i
	i += 1
print(fs - ss + (n - 1))


from math import factorial as f
n = int(input())
s = n
for i in range(1, n):
	s += (n - i) * i
print(s)


n = int(input())
pushs = 1
bottoms = 0
for i in range(n, 1, -1):
	pushs += i
	pushs += bottoms * (i - 1)
	bottoms += 1
print(pushs)


n = int(input())
count = n
layer = 1
while layer < n:
	count += 1 + (layer + 1) * (n - layer - 1)
	layer += 1
print(count)


def solve(n):
	return sum((n - x + x * (n - 1 - x) for x in range(n)))

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


n = int(input())
s = 0
for i in range(1, n + 1):
	s += i * (n + 1 - i)
print(int(s - 0.5 * n * (n - 1)))


from collections import deque
from collections import OrderedDict
import math
import sys
import os
from io import BytesIO
import threading
import bisect
import operator
import heapq
input = lambda : sys.stdin.readline().rstrip('\r\n')

def getLucky(limit):
	ar = [0] * 5000
	(ar[0], ar[1]) = (4, 7)
	p2 = 1
	idx = 0
	while idx <= limit:
		if 4 * 10 ** p2 > limit:
			break
		for idx in range(idx, idx + 2 ** p2):
			ar[idx + 2 ** p2] = 4 * 10 ** p2 + ar[idx]
			ar[idx + 2 ** p2 * 2] = 7 * 10 ** p2 + ar[idx]
		idx += 1
		p2 += 1
	return ar
a = int(input())
answer = 0
lPass = 0
for i in range(a, 0, -1):
	answer += i + lPass * (i - 1)
	lPass += 1
print(answer)


Input = int(input())
(ans, counter) = (Input, 1)
for i in range(Input - 1, 0, -1):
	counter += 1
	ans = ans + (i - 1) * counter + 1
print(ans)


n = int(input())
moves = 0
for i in range(n):
	moves += n - i + (n - i - 1) * i
print(moves)


N = int(input())
step = 1
S = 0
while step <= N:
	S = S + step * (N - step) + 1
	step = step + 1
print(S)


n = int(input())
gV = [0] * (n + 1)
gV[1] = n
for i in range(1, n + 1):
	gV[i] = gV[i - 1] + 1 + (n - i) * i
print(gV[n])


from sys import stdin, stdout
DEBUG = True

class Scan:

	def __init__(self):
		self.read = stdin.read
		self.input = stdin.readline

	def integer(self, count=1):
		if count == 1:
			return self._integer()
		return [self._integer() for _ in range(count)]

	def _integer(self):
		sym: str = self.read(1)
		while sym != '-' and (not sym.isdigit()):
			sym = self.read(1)
		(number, sign) = (0, -1) if sym == '-' else (int(sym), 1)
		sym: str = self.read(1)
		while sym.isdigit():
			number = number * 10 + int(sym)
			sym = self.read(1)
		return number * sign

	def array(self, func=int, sep=' '):
		if func == str:
			return input().split(sep)
		return list(map(func, input().split(sep)))

	def string(self, count=1):
		if count == 1:
			return self._string()
		return [self._string() for _ in range(count)]

	def _string(self):
		sym = self.read(1)
		while sym in ('\n', '\r', ' '):
			sym = self.read(1)
		s = str()
		while sym not in ('\n', '\r', ' '):
			s += sym
			sym = self.read(1)
		return s

class Write:
	pass

class Number:

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

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

	def sqrt(n):
		sqrt_n = int(n ** 0.5)
		while sqrt_n * sqrt_n < n:
			sqrt_n += 1
		while sqrt_n * sqrt_n > n:
			sqrt_n -= 1
		return sqrt_n

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

class Constants:
	EPS = 10 ** (-9)
	INF = 10 ** 18
	MOD = 10 ** 9 + 7

def solution(scan: Scan, write: Write):
	n = scan.integer()
	ans = n
	for i in range(2, n):
		ans += 1 + i * (n - i)
	if n > 1:
		ans += 1
	print(ans)

def main():
	queries: int = 1
	(scan, write) = (Scan(), Write())
	for _ in range(queries):
		solution(scan, write)
main()


n = int(input())
answer = 1
adder = 1
counter = 1
for i in range(2, n + 1):
	answer += counter + adder
	adder = counter + adder
	counter += 1
print(answer)


buttons = int(input())
pushes = 0
for x in range(1, buttons):
	pushes += x * (buttons - x)
pushes += buttons
print(pushes)


n = int(input())
total = 1
add = 2
base = 2
for _ in range(1, n):
	total += add
	add = add + base
	base += 1
print(total)


n = int(input())
j = 0
res = 0
for i in range(n, 0, -1):
	if j == 0:
		res += i
	else:
		res += i * j
	j += 1
print(res)


import heapq as hp
import collections
import bisect
import math
import re

def unpack(func=int):
	return map(func, input().split())

def l_unpack(func=int):
	return list(map(func, input().split()))

def s_unpack(func=int):
	return sorted(map(func, input().split()))

def ml_unpack(n):
	return [int(input()) for i in range(n)]

def range_n():
	return range(int(input()))

def counter(a):
	d = {}
	for x in a:
		if x in d:
			d[x] += 1
		else:
			d[x] = 1
	return d

def getint():
	return int(input())

def setbits(x):
	count = 0
	while x:
		x = x & x - 1
		count += 1
	return count

def main():
	n = getint()
	print(n + n * n * (n - 1) // 2 - n * (n - 1) * (2 * n - 1) // 6)
main()


import os
import sys
from math import *
from collections import *
from bisect import *
from io import BytesIO, IOBase
from fractions import *

def vsInput():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
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')

def value():
	return tuple(map(int, input().split()))

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

def Int():
	return int(input())

def Str():
	return input()

def arrayS():
	return [i for i in input().split()]
n = Int()
ans = 1
c = 1
pressed = []
for i in range(1, n):
	ans += c
	c += 1
	pressed.append(ans)
print(sum(pressed) + 1)


class Solution:

	def __init__(self):
		self.n = int(input())

	def solve_and_print(self):
		print((self.n - 1) * (self.n + 6 + self.n ** 2) // 6 + 1)
Solution().solve_and_print()


t = int(input())
arr = [0] * (t + 1)
arr[1] = 1
for i in range(2, t + 1):
	arr[i] = i + arr[i - 1] + (i - 2) * (i - 1) // 2
print(arr[t])


n = int(input())
ans = n
known = 2
n -= 2
while n >= 0:
	ans += 1 + known * n
	known += 1
	n -= 1
print(ans)


n = int(input())
i = 1
ans = 0
while i <= n:
	left = n - i
	weight = i
	ans += left * weight + 1
	i += 1
print(ans)


n = int(input())
answer = n
m = 1
while m != n:
	answer += m * (n - (m + 1)) + (n - m)
	m += 1
print(answer)


def solve():
	n = int(input())
	res = 0
	for i in range(n, 0, -1):
		res += i * (n - i)
	print(res + n)
	return
solve()


t = int(input())
su = 0
w = int(t)
for i in range(t):
	su = su + w * i + 1
	w = w - 1
print(su)


knopok = int(input())
nazhatiy = 1
if knopok > 1:
	nazhatiy += knopok
	for i in range(2, knopok, 1):
		nazhatiy += i * (knopok - i) + 1
print(nazhatiy)


n = int(input())
coN = n
for i in range(1, n):
	coN += (n - i) * i
print(coN)


x = int(input())
i = 1
count = 0
while x - i >= 0:
	count += i * (x - i) + 1
	i += 1
print(count)


n = int(input())
Sum = 0
for y in range(1, n + 1):
	Sum += y * (n - 1) + 1
	n -= 1
print(Sum)


def button(n):
	(temp, hold) = (1, 0)
	while temp <= n:
		hold += (n - temp) * temp + 1
		temp += 1
	return hold
print(button(int(input())))


n = int(input())
a = n
known_button = 0
most_chance = 0
result = False
i = 0
while result is False:
	if known_button == a - 1:
		most_chance += 1
		break
	if i == 0:
		most_chance += n
		known_button += 1
	else:
		most_chance += (a - known_button - 1) * known_button + known_button + 1
		known_button += 1
	i += 1
print(most_chance)


import sys
n = int(sys.stdin.readline())
total = 0
for i in range(n, 0, -1):
	total += i + (n - i) * (i - 1)
print(total)


a = int(input())
tot = 0
for x in range(1, a):
	tot += x * (a - x)
tot += a
print(tot)


n = int(input())
p = 1
m = 0
while p < n:
	m += (n - p) * p
	p += 1
print(m + n)


n = int(input())
c = []
r = n - 1
i = 1
while i != n:
	c.append(i * r)
	r -= 1
	i += 1
print(sum(c) + n)


n = int(input())
op = 0
for k in range(1, n + 1):
	op += k * (n - k) + 1
print(op)


val = 0
n = int(input())
for i in range(n):
	val += n - i + i * (n - i - 1)
print(val)


t = int(input())
c = 0
for i in range(1, t + 1):
	c += i * (t - i)
c += t
print(c)


def f():
	x = int(input())
	s = 2 * x - 1
	l = x - 2
	v = 2
	while l > 0:
		s += l * v
		l -= 1
		v += 1
	print(s)
f()


n = int(input())
if n == 2:
	print(3)
else:
	print((n ** 3 + 5 * n) // 6)


n = int(input())
time = 0
for i in range(1, n):
	time += i * (n - i)
print(time + n)


n = int(input())
i = 1
sum = 0
while i < n:
	if i == 1:
		sum += n
	elif i > 1 and i < n - 1:
		sum += i * (n - i) + 1
	elif i == n - 1:
		sum += n + 1
	i += 1
if n <= 2:
	print(sum + 1)
else:
	print(sum)


n = int(input())
S = n
for i in range(1, n):
	S += (i + 1) * (n - i) - i
print(S)


n = int(input())
i = n
c1 = 1
sum = 0
while i >= 1:
	m = i * c1
	sum += m
	x = c1 - 1
	sum = sum - x
	i -= 1
	c1 += 1
print(sum)


n = int(input())
mod = 1000000007

def func(n):
	return int(n * (n + 1) * n / 2 - n * (n + 1) * (2 * n + 1) / 6 + n)
print(func(n))


n = int(input())
num = 2 * n - 1
for i in range(2, n):
	num += (n - i) * i
print(num)


def calc(n):
	tries = 0
	for i in range(1, n + 1):
		if i == n - 1 or i == n:
			tries += i * 1
		else:
			tries += i * (n - i)
	return tries
print(calc(int(input())))


from sys import stdin
n = int(stdin.readline())
print((n * n + 5) * n // 6)


x = int(input())
s = 0
for i in range(1, x + 1, 1):
	s += i * (x - i)
print(s + x)


N = int(input())
print(N * (N * N + 5) // 6)


n = int(input())
if n == 1:
	print(1)
	exit(0)
answer = 1
rise = 2
for i in range(2, n + 1):
	answer += rise
	rise += i
print(answer)


n = int(input())

def push(n):
	output = 0
	for i in range(n - 1):
		output += (n - i - 1) * (i + 1)
	output += n
	return output
print(push(n))


n = int(input())
s = 0
for m in range(0, n):
	s += (n - m) * (1 + m) - m
print(s)


n = int(input())
N = n
ans = 0
count = 0
while n > 1:
	count = count + 1
	ans = ans + (n - 1) * count
	n = n - 1
print(ans + N)


n = int(input())
sum = n
count = 1
for i in range(1, n):
	sum += (n - i) * count
	count += 1
print(sum)