ZS the Coder is playing a game. There is a number displayed on the screen and there are two buttons, ' + ' (plus) and '$\sqrt{}$' (square root). Initially, the number 2 is displayed on the screen. There are n + 1 levels in the game and ZS the Coder start at the level 1.

When ZS the Coder is at level k, he can :  Press the ' + ' button. This increases the number on the screen by exactly k. So, if the number on the screen was x, it becomes x + k. Press the '$\sqrt{}$' button. Let the number on the screen be x. After pressing this button, the number becomes $\sqrt{x}$. After that, ZS the Coder levels up, so his current level becomes k + 1. This button can only be pressed when x is a perfect square, i.e. x = m^2 for some positive integer m. 

Additionally, after each move, if ZS the Coder is at level k, and the number on the screen is m, then m must be a multiple of k. Note that this condition is only checked after performing the press. For example, if ZS the Coder is at level 4 and current number is 100, he presses the '$\sqrt{}$' button and the number turns into 10. Note that at this moment, 10 is not divisible by 4, but this press is still valid, because after it, ZS the Coder is at level 5, and 10 is divisible by 5.

ZS the Coder needs your help in beating the game — he wants to reach level n + 1. In other words, he needs to press the '$\sqrt{}$' button n times. Help him determine the number of times he should press the ' + ' button before pressing the '$\sqrt{}$' button at each level. 

Please note that ZS the Coder wants to find just any sequence of presses allowing him to reach level n + 1, but not necessarily a sequence minimizing the number of presses.


-----Input-----

The first and only line of the input contains a single integer n (1 ≤ n ≤ 100 000), denoting that ZS the Coder wants to reach level n + 1.


-----Output-----

Print n non-negative integers, one per line. i-th of them should be equal to the number of times that ZS the Coder needs to press the ' + ' button before pressing the '$\sqrt{}$' button at level i. 

Each number in the output should not exceed 10^18. However, the number on the screen can be greater than 10^18.

It is guaranteed that at least one solution exists. If there are multiple solutions, print any of them.


-----Examples-----
Input
3

Output
14
16
46

Input
2

Output
999999999999999998
44500000000

Input
4

Output
2
17
46
97



-----Note-----

In the first sample case:

On the first level, ZS the Coder pressed the ' + ' button 14 times (and the number on screen is initially 2), so the number became 2 + 14·1 = 16. Then, ZS the Coder pressed the '$\sqrt{}$' button, and the number became $\sqrt{16} = 4$. 

After that, on the second level, ZS pressed the ' + ' button 16 times, so the number becomes 4 + 16·2 = 36. Then, ZS pressed the '$\sqrt{}$' button, levelling up and changing the number into $\sqrt{36} = 6$.

After that, on the third level, ZS pressed the ' + ' button 46 times, so the number becomes 6 + 46·3 = 144. Then, ZS pressed the '$\sqrt{}$' button, levelling up and changing the number into $\sqrt{144} = 12$. 

Note that 12 is indeed divisible by 4, so ZS the Coder can reach level 4.

Also, note that pressing the ' + ' button 10 times on the third level before levelling up does not work, because the number becomes 6 + 10·3 = 36, and when the '$\sqrt{}$' button is pressed, the number becomes $\sqrt{36} = 6$ and ZS the Coder is at Level 4. However, 6 is not divisible by 4 now, so this is not a valid solution.

In the second sample case:

On the first level, ZS the Coder pressed the ' + ' button 999999999999999998 times (and the number on screen is initially 2), so the number became 2 + 999999999999999998·1 = 10^18. Then, ZS the Coder pressed the '$\sqrt{}$' button, and the number became $\sqrt{10^{18}} = 10^{9}$. 

After that, on the second level, ZS pressed the ' + ' button 44500000000 times, so the number becomes 10^9 + 44500000000·2 = 9·10^10. Then, ZS pressed the '$\sqrt{}$' button, levelling up and changing the number into $\sqrt{9 \cdot 10^{10}} = 300000$. 

Note that 300000 is a multiple of 3, so ZS the Coder can reach level 3.

Difficulty: MEDIUM_HARD

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


n = int(input())
c = 2
cnt = 0
for x in range(2, n + 2):
	b = x - 1
	if ((x * b) ** 2 - c) % (x - 1) == 0:
		print(((x * b) ** 2 - c) // (x - 1))
		c = x * b


from math import sqrt
m = 2
print(2)
k = 2
n = int(input())
while k < n + 1:
	print((k + 1) * (k + 1) * k - (k - 1))
	k += 1


n = int(input())
(x, k) = (2, 1)
while k <= n:
	y = ((k + 1) * k) ** 2
	print((y - x) // k)
	(x, k) = ((k + 1) * k, k + 1)


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


a = 2
n = 0
max = int(input())
for k in range(max + 1):
	if k == 0:
		continue
	n = k * (k + 1) * (k + 1) - a
	a = k
	print(n)


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


import math
n = int(input())
al = 2
for i in range(1, n + 1):
	ai = (i * i + i) ** 2
	res = (ai - al) // i
	al = int(math.sqrt(int(ai)))
	print(int(res))


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


n = int(input())
ans = [2]
for k in range(2, n + 1):
	ans.append(k ** 3 + 2 * k ** 2 + 1)
print(*ans, sep='\n')


n = int(input())
num = 2

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

def lcm(a, b):
	return a * b // gcd(a, b)
for i in range(1, n + 1):
	y = lcm(i + 1, i)
	x = y * y
	print(int((x - num) / i))
	num = y


N = int(input())
tmp1 = 2
tmp2 = 2
for i in range(1, N + 1):
	if i == 1:
		print(2)
		tmp2 *= 3
	else:
		print((tmp2 ** 2 - tmp1) // i)
		tmp1 = tmp2
		tmp2 //= i
		tmp2 *= i + 2


import sys
from collections import defaultdict, Counter
import string

def main():
	n = int(input())
	last = 2
	for i in range(1, n + 1):
		ops = ((i * (i + 1)) ** 2 - last) // i
		print(ops)
		last = i * (i + 1)
main()


x = int(input())
p = 2
for i in range(1, x + 1):
	c = ((i * (i + 1)) ** 2 - p) / i
	p = i * (i + 1)
	print(int(c))


def my_sqrt(x):
	res = int(x ** 0.5)
	for i in range(max(res - 10, 0), res + 10):
		if i * i == x:
			return int(i)
	return res
n = int(input())
x = 2
for level in range(1, n + 1):
	res = level * (level + 1) * (level + 1)
	res -= x // level
	print(res)
	x += res * level
	x = my_sqrt(x)


import sys
from math import gcd
n = int(input())
n = n - 1
print(2)
nw = 2
nwsq = 2
p = 1
while n > 0:
	next = nw + 1
	nok = next * nw // gcd(next, nw)
	dod = nok * nok
	ans = (dod - nwsq) // nw
	print(int(ans))
	nwsq = nok
	nw = next
	n = n - 1


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


n = int(input())
a = [((i * (i + 1)) ** 2 - (i - 1) * i if i != 1 else 2) // i for i in range(1, n + 1)]
print('\n'.join(map(str, a)))


from __future__ import division, print_function
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd

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

def si():
	return str(input())

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

def li():
	return list(mi())
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 = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

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

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)
	print(l)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = {}
	for i in range(n):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans
n = ii()
print(2)
for i in range(2, n + 1):
	print(int(i * pow(i + 1, 2) - (i - 1)))


n = int(input()) + 1
(k, x) = (1, 2)
for nextlevel in range(2, n + 1):
	nextX = (k * nextlevel) ** 2
	cost = (nextX - x) // k
	print(cost)
	x = int(nextX ** 0.5)
	k += 1


import math
n = int(input())
x = 2
for k in range(1, n + 1):
	ans = 0
	goal = (k + 1) * (k + 1) * k * k
	print(int((goal - x) / k))
	x = int(math.sqrt(goal))


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


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


import math, sys
from collections import defaultdict, deque
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')

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

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

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

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

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

def main():
	try:
		n = I()
		l = []
		for i in range(1, n + 1):
			l.append(pow(lcm(i, i + 1), 2))
		ans = []
		last = 2
		for i in range(n):
			temp = l[i] - last
			ans.append(temp // (i + 1))
			last = int(math.sqrt(l[i]))
		for x in ans:
			print(x)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


__author__ = 'Think'
data = input().split()[0]
n = int(data)
screen = 2
for level in range(1, n + 1):
	if screen / level != screen // level:
		print('Broken', screen, level)
	print(level * (level + 1) ** 2 - screen // level)
	screen = level * (level + 1)


n = int(input())
k = 1
m = 2
aux = 2
tmp = 4
while n > 0:
	print((m * m - aux) // k)
	k += 1
	aux = m
	m += tmp
	tmp += 2
	n -= 1


def main():
	(n,) = read()
	curr = 2
	for lv in range(1, n + 1):
		tgt = (lv * (lv + 1)) ** 2
		print((tgt - curr) // lv)
		curr = lv * (lv + 1)
	return

def read(typ=int):
	input_line = input().strip()
	if typ is None:
		return input_line
	return list(map(typ, input_line.split()))

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='')
write(main())


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


k = 1
m = 2
n = int(input())
i = 0
while i < n:
	a = ((k + 1) * (k + 1) * k * k - m) / k
	print(int(a))
	m = (k + 1) * k
	k = k + 1
	i = i + 1


a = [0] * 1000003
a[1] = 2
w = 4
for q in range(2, 1000003):
	a[q] += a[q - 1] + w
	w += 2
n = int(input())
if n == 1:
	print(2)
else:
	print(2)
	for q in range(2, n + 1):
		print((a[q] * a[q] - a[q - 1]) // q)


n = int(input())
screen = 2
for i in range(n):
	level = i + 1
	t = (i + 1) * (i + 2)
	t2 = t ** 2
	print((t2 - screen) // level)
	screen = t


n = int(input())
print(2)
for level in range(2, n + 1):
	x = level * (level + 1)
	sq = x * x
	cur = level * (level - 1)
	toprint = (sq - cur) // level
	assert toprint <= 1e+18
	print(toprint)


import math
n = int(input())
x = 2
for k in range(1, n + 1):
	xx = k ** 4 + 2 * k ** 3 + k ** 2
	delta = (xx - x) // k
	print(delta)
	x = math.sqrt(xx)
	x = int(x)


res = []
cur = 2
for k in range(1, int(input()) + 1):
	nxt = k * (k + 1)
	res.append(str((nxt ** 2 - cur) // k))
	cur = nxt
print('\n'.join(res))


n = int(input())
ccc = 2
s = 4
for i in range(1, n + 1):
	s = i ** 2 * (i + 1) ** 2
	t = int((s - ccc) / i)
	print(t)
	ccc = int(s ** 0.5)


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


n = int(input())
now = 2
lvl = 0
ans = []
for i in range(1, n + 1):
	to = (lvl + 1) * (lvl + 2)
	ans.append((to * to - now) / (lvl + 1))
	now = to
	lvl = lvl + 1
for i in ans:
	print(int(i))


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


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


print(2)
for k in range(2, 1 + int(input())):
	print(1 + k * (2 + k) * k)


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


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


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


from math import *
x = 2
for i in range(int(input())):
	y = (i + 1) * (i + 2) // gcd(i + 1, i + 2)
	print((y ** 2 - x) // (i + 1))
	x = y


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


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


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


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


from sys import stdin, stdout
from math import sqrt
n = int(stdin.readline())
number = 2
for lvl in range(1, n + 1):
	a = number // lvl
	number = round(sqrt((lvl * lvl * lvl + 2 * lvl * lvl + lvl) * lvl))
	stdout.write(str(lvl * lvl * lvl + 2 * lvl * lvl + lvl - a) + '\n')


from itertools import permutations as perm
from collections import *
from sys import stdin
from bisect import *
from heapq import *
from math import *
g = lambda : stdin.readline().strip()
gl = lambda : g().split()
gil = lambda : [int(var) for var in gl()]
gfl = lambda : [float(var) for var in gl()]
gcl = lambda : list(g())
gbs = lambda : [int(var) for var in g()]
mod = int(1000000000.0) + 7
inf = float('inf')
(n,) = gil()
ans = []
m = 2
for k in range(1, n + 1):
	i = k * (k + 1) ** 2 - m // k
	print(i)
	m = k * (k + 1)


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


import math
n = int(input())
x = 2
k = 1
while k != n + 1:
	v = math.floor(math.sqrt(x))
	while 1 == 1:
		u = v * v - x
		if u % k == 0:
			t = int(v * v * (k + 2) + u / k)
			x = int(math.sqrt(x + t * k))
			print(t)
			k = k + 1
			break
		v = v + 1


def solve(x):
	return ((x + 1) ** 2 * x ** 2 - (x * x - x)) / x
inp = int(input(''))
lvl = 1
print('2')
while inp >= 2:
	ops = solve(lvl + 1)
	print(int(ops))
	lvl = lvl + 1
	inp = inp - 1


from math import sqrt

def pow1(x, base):
	sq = 1
	while base > 0:
		if base % 2:
			base -= 1
			sq = sq * x
		base //= 2
		x = x * x
	return sq
(n, cum, root, tem) = (int(input()), [4], [2], 2)
for i in range(1, n + 1):
	print(int((cum[-1] - tem) // i))
	cum.append(pow1(root[-1] + 2 * (i + 1), 2))
	root.append(root[-1] + 2 * (i + 1))
	tem = int(root[-2])


from sys import stdin, stdout, stderr
import math
n = int(stdin.readline())

def go(lvl: int, cur: int, l: list):
	if cur % lvl != 0:
		return False
	if lvl == n + 1:
		return True
	for dx in range(0, 100000):
		cur += dx * lvl
		if cur % lvl != 0:
			cur -= dx * lvl
			return False
		x = int(math.sqrt(cur))
		if x * x == cur:
			l.append(dx)
			if go(lvl + 1, x, l):
				return True
			l.pop()
		cur -= dx * lvl

def main():
	cur = 2
	for lvl in range(1, n + 1):
		stdout.write('2\n' if lvl == 1 else str(lvl * (lvl + 1) * (lvl + 1) - lvl + 1) + '\n')
main()


import sys
n = int(input())
x = 2
for k in range(1, n + 1):
	y = k * (k + 1)
	print(int((y * y - x) / k))
	x = y


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


n = int(input())
st = 2

def sqrt(x):
	lo = 0
	hi = 1000000000000
	while lo < hi:
		mid = (lo + hi) // 2
		if mid * mid < x:
			lo = mid + 1
		else:
			hi = mid
	return lo
for i in range(1, n + 1):
	a = ((i * (i + 1)) ** 2 - st) / i
	a = int(a)
	print(a)
	st += i * a
	st = sqrt(st)


n = int(input())
bef = 2
for j in range(n):
	i = j + 1
	x = i + 1
	ans = (x * i * (x * i) - bef) / (x - 1)
	ans = int(ans)
	print(ans)
	bef = x * i


N = int(input())
n = 2
cur = 1
while cur <= N:
	now = (cur + 1) * (cur + 1) * cur * cur
	print((now - n) // cur)
	cur = cur + 1
	n = cur * (cur - 1)


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


n = int(input())
le = 1
num = 2
if n == 1:
	print(2)
else:
	print(2)
	le = 2
	while le <= n:
		ne = le * (le + 1)
		print(int((ne * ne - num) / le))
		num = ne
		le += 1


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


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


import math
n = int(input())
x = 2
k = 1
while k <= n:
	assert x % k == 0
	y = ((k + 1) * k) ** 2
	assert x <= y and (y - x) % k == 0
	assert (y - x) // k <= 10 ** 18
	print((y - x) // k)
	x = (k + 1) * k
	k += 1


def solve():
	n = int(input())
	k = 1
	m = 2
	while k <= n:
		a = m // k
		b = (k + 1) ** 2 * k - a
		print(b)
		m = k * (k + 1)
		k += 1
solve()


n = int(input())
ret = 2
q = 2
for k in range(1, n + 1):
	if q % (k + 1) != 0:
		q += k + 1 - q % (k + 1)
	while 1:
		w = q * q
		if (w - ret) % k == 0:
			print((w - ret) // k)
			ret = q
			break
		q += k + 1


import math
import sys
from math import sqrt
n = int(input())
for i in range(n):
	c = i + 1
	if i == 0:
		print(((c * (c + 1)) ** 2 - 2) // c)
	else:
		print(((c * (c + 1)) ** 2 - (c - 1) * c) // c)


from math import sqrt
n = int(input())
val = 2
for level in range(n):
	cur_level = level + 1
	t = cur_level * cur_level * (cur_level + 1) * (cur_level + 1)
	t -= val
	print(int(t / cur_level))
	val = int(sqrt(t))


n = int(input())
MOD = 1000000000000000000
p = 2
k = 2

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

def lcm(a, b, c):
	xx = a * b // gcd(a, b)
	yy = xx * c // gcd(xx, c)
	return yy
p = 2
k = 2
for i in range(n):
	clcm = lcm(k, k - 1, 1)
	aa = clcm * clcm
	bb = aa - p
	cc = bb // (k - 1)
	p = clcm
	cc %= MOD
	k += 1
	print(cc)


c = 2
dp = []
dp.append(0)
for i in range(1, 100003):
	dp.append(dp[i - 1] + c)
	c += 2
n = int(input())
print(2)
i = 1
while i < n:
	y = dp[i + 1] ** 2
	d = (y - dp[i]) // (i + 1)
	print(d)
	i += 1


def main():
	n = int(input())
	x = 2
	for i in range(n):
		y = (i + 1) * (i + 2)
		yy = y ** 2
		yy -= x
		yy //= i + 1
		print(yy)
		x = y
main()


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


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


import math
n = int(input(''))
a = 1
f = 2
for i in range(n):
	k = i + 2
	z = (k * k * a * a - f) / (k - 1)
	print(int(z + 0.5))
	f = math.sqrt(f + z * (k - 1))
	a = a + 1


import math
num = 2
n = int(input())
k = 1
while k < n + 1:
	inc = ((k * (k + 1)) ** 2 - num) // k
	print(inc)
	num = k * (k + 1)
	k = k + 1


import sys
import math
n = int(input())
recent = 2
for i in range(1, n + 1):
	q = recent // i
	t = (i + 1) ** 2 * i - q
	print(t)
	recent = math.ceil(math.sqrt(i * (t + q)))


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


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


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

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')
ALPHA = 'abcdefghijklmnopqrstuvwxyz'
M = 998244353
EPS = 1e-06

def Ceil(a, b):
	return a // b + int(a % b > 0)

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()
m = 2
ans = []
y = 1
for k in range(1, n + 1):
	C = (k + 1) ** 2
	while True:
		kx = C * y * y - m
		if kx % k == 0:
			x = kx // k
			break
		y += 1
	m = int(sqrt(m + k * x))
	print(x)


n = int(input())
level = 1
current = 2
while level <= n:
	target = (level * (level + 1)) ** 2
	left = target - current
	times = left // level
	print(times)
	current = level * (level + 1)
	level += 1


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


n = int(input())
ini = 2
lpre = 1
lnext = 2
m = 1
for i in range(1, n + 1):
	m = i
	print((m * m * lnext * lnext - ini) // lpre)
	ini = m * lnext
	m = 0
	lnext = lnext + 1
	lpre = lpre + 1


calculator = 2
level = 1
n = input()
n = int(n)
while n > 0:
	levelCalc = level * (level + 1)
	powerLevelCalc = levelCalc * levelCalc
	diff = powerLevelCalc - calculator
	a = diff / level
	print(int(a))
	level = level + 1
	calculator = levelCalc
	n = n - 1


n = int(input())
prev = 1
next = 2
cur = 2
for i in range(n):
	out = (prev * prev * next * next - cur) // (i + 1)
	print(out)
	cur = prev * next
	prev += 1
	next += 1


n = int(input())
a = 2
for i in range(1, n + 1):
	b = i * (i + 1) * (i * (i + 1))
	assert (b - a) % i == 0, str(i)
	c = (b - a) // i
	print(c)
	a = i * (i + 1)


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


n = int(input())
cur = 2
for level in range(1, n + 1):
	next = level * (level + 1)
	print(int((next * next - cur) / level))
	cur = next


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


value = [0] * (10 ** 5 + 2)
c = 2
for i in range(1, 10 ** 5 + 1):
	value[i] = value[i - 1] + c
	c = 2 * (i + 1)
dp = [0] * (10 ** 5 + 2)
for i in range(1, 10 ** 5 + 1):
	dp[i] = (value[i] ** 2 - value[i - 1]) // i
dp[1] = 2
n = int(input())
for i in range(1, n + 1):
	print(dp[i])


import bisect
from itertools import accumulate, count
import os
import sys
import math
from decimal import *
from io import BytesIO, IOBase
from sys import maxsize
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))

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

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

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

def primefactors(n):
	fac = []
	while n % 2 == 0:
		fac.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 2):
		while n % i == 0:
			fac.append(i)
			n = n // i
	if n > 1:
		fac.append(n)
	return sorted(fac)

def factors(n):
	fac = set()
	fac.add(1)
	fac.add(n)
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			fac.add(i)
			fac.add(n // i)
	return list(fac)

def modInverse(a, m):
	m0 = m
	y = 0
	x = 1
	if m == 1:
		return 0
	while a > 1:
		q = a // m
		t = m
		m = a % m
		a = t
		t = y
		y = x - q * y
		x = t
	if x < 0:
		x = x + m0
	return x
n = int(input())
for i in range(1, n + 1):
	if i == 1:
		print(2)
	else:
		print(i * (i + 1) * (i + 1) - (i - 1))


from math import ceil, sqrt
n = int(input())
k = 1
x = 2
cnt = 0
while k != n + 1:
	posnum = (k + 1) * max(ceil(x / (k + 1)), ceil(sqrt(x) / (k + 1)))
	while (posnum ** 2 - x) % k != 0:
		posnum += k + 1
	print(int((posnum ** 2 - x) / k))
	k += 1
	x = posnum


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


from sys import stdout
n = int(input())
stdout.write('2\n')
for lv in range(2, n + 1):
	stdout.write(str(lv * (lv + 1) * (lv + 1) - (lv - 1)) + '\n')


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


n = int(input())
print(2)
cur = 2
for i in range(2, n + 1):
	mod = cur % (i + 1)
	cur += mod * i
	walked = mod + (cur * cur - cur) / i
	print(int(walked))


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


n = int(input())
current = 2
level = 1
for i in range(n):
	if current < (level * (level + 1)) ** 2:
		print(int(((level * (level + 1)) ** 2 - current) / level))
		current = level * (level + 1)
		level += 1


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


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


from math import *
n = int(input())
x0 = 2
k = 1
while k < n + 1:
	r = (k * k * (k + 1) * (k + 1) - x0) / k
	x0 = k * (k + 1)
	k = k + 1
	print(int(r))


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


n = int(input())
A = [2] + [k * (k + 1) * (k + 1) - (k - 1) for k in range(2, n + 1)]
print('\n'.join(map(str, A)))


n = int(input())
current = 2
for i in range(n):
	next = (i + 1) * (i + 2)
	press = (i + 1) * (i + 2) * (i + 2) - current // (i + 1)
	current = next
	print(press)


def scarry(n):
	a = [2]
	for i in range(2, n + 1):
		a.append(i * (i + 1) * (i + 1) - (i - 1))
	return a
print(*scarry(int(input())), sep='\n')


(x, a) = (2, [])
for i in range(1, int(input()) + 1):
	y = i * (i + 1)
	a.append((y ** 2 - x) // i)
	x = y
print('\n'.join(map(str, a)))


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

def lcm(a, b):
	return a * b // gcd(a, b)
n = int(input())
k = 2
for i in range(1, n + 1):
	next = lcm(i, i + 1)
	ans = (next * next - k) // i
	if ans >= 1000000000000000000:
		print('fuckup')
		break
	print((next * next - k) // i)
	k = next


n = int(input())
i = 1
m = 2
j = 0
while i != n + 1:
	mi = i * (i - 1)
	ji = i * (i + 1) * (i + 1) - (i - 1)
	i += 1
	if i == 2:
		print(2)
	else:
		print(ji)


n = int(input())
start = 2
level = 1
while level <= n:
	target = level * level * (level + 1) * (level + 1)
	print((target - start) // level)
	start = level * (level + 1)
	level = level + 1


from math import sqrt, floor, ceil
n = int(input())
val = 2
ar = [0] * n
for i in range(1, n + 1):
	num = ceil(val / ((i + 1) * i)) * ((i + 1) * i) ** 2 - val
	val = ceil(val / ((i + 1) * i)) * ((i + 1) * i)
	print(num // i)


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


from math import ceil
n = int(input())

def primeSquares(num, min):
	i = ceil(min / num)
	while True:
		yield (i * num, (i * num) ** 2)
		i += 1
k = 1
x = 2
while k <= n:
	for (i, square) in primeSquares(k + 1, x):
		if square > x and (square - x) % k == 0:
			out = (square - x) // k
			print(out)
			x = i
			k += 1
			break


from math import *
n = int(input())
level = 1
p = 1
k = 0
now = 2
for i in list(range(n)):
	level += 1
	k = int(p * level * (p * level))
	print(int((k - now) / (level - 1)))
	now = p * level
	p += 1


import sys, math
n = int(input())
x = 2
for k in range(1, n + 1):
	to = k ** 2 * (k + 1) ** 2
	r = (to - x) // k
	print(r)
	x = int((x + r * k) ** 0.5 + 0.001)


n = int(input())
cn = 2
for l in range(1, n + 1):
	pro = l * l * (l + 1) * (l + 1)
	steps = (pro - cn) / l
	print(int(steps))
	cn = l * (l + 1)
	l += 1


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


n = int(input())
m = 2
curr = 1
for i in range(1, n + 1):
	temp = i * (i + 1)
	tmp = temp
	temp = temp * temp
	p = temp - m
	p = p // i
	print(p)
	m = tmp


(n,) = map(int, input().split())
curr = 2
for k in range(1, n + 1):
	print(k * (k + 1) * (k + 1) - curr)
	curr = k


N = int(input())
x = 2
for i in range(1, N + 1):
	(u, v) = (i, i + 1)
	p = u ** 2 * v ** 2
	d = p - x
	z = d // u
	assert z <= 10 ** 18
	print(z)
	x = u * v


n = int(input())
z = 2
for i in range(2, n + 2):
	r = i * i
	t = z
	p = pow(z // r + 1, 2)
	z = p * r * pow(i - 1, 2)
	print((z - t) // (i - 1))
	z = int(z ** 0.5)


import math
a = int(input())
p = 2
for i in range(a):
	k = (i + 1) * (i + 1) * (i + 2) * (i + 2)
	z = (k - p) / (i + 1)
	p = int(math.sqrt(k))
	print(int(z))


n = int(input())
l = [2]
cs = 2
for i in range(2, n + 1):
	xs = i * (i + 1)
	ys = xs * xs
	ax = ys - cs
	ax = ax // i
	cs = xs
	l.append(ax)
for i in range(len(l)):
	print(l[i])


import math
n = int(input())
x = 2
for i in range(1, n + 1):
	y = i * (i + 1)
	y *= y
	print(round((y - x) / i))
	x = math.sqrt(y)


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


n = int(input())
p = 1
ost = 2
for i in range(n):
	v = (p * (p + 1)) ** 2
	print(v // p - ost // p)
	ost = p * (p + 1)
	p += 1


n = int(input())
c = 2
ans = []
for i in range(1, n + 1):
	s = c // i
	c = i * (i + 1) * (i + 1) - s
	ans.append(c)
	c = i * (i + 1)
print('\n'.join(map(str, ans)))


N = int(input())
x = 2
n = 1
while n <= N:
	print(((n * (n + 1)) ** 2 - x) // n)
	x = n * (n + 1)
	n += 1


from sys import stdin, stdout
a = 0
n = int(stdin.readline())
for i in range(1, n + 1):
	a += 2 * i
	o = 2 if i != 1 else 0
	stdout.write(str(int((a * a - a) / i + o)) + '\n')


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


import math
n = int(input())
zs = 2
for lvl in range(1, n + 1):
	print(((lvl * (lvl + 1)) ** 2 - zs) // lvl)
	zs = lvl * (lvl + 1)


str = input()
n = int(str)
num = 2
lv = 1
t = 1
while n != 0:
	t = nlv = lv + 1
	t = lv * nlv
	print(lv * nlv * nlv - int(num / lv))
	num = t
	lv = nlv
	n -= 1


import math

def solve_eq(a, lvl):
	lvl2 = (lvl + 1) ** 2
	q = max(int(math.sqrt(a % lvl2)), 1)
	while q * q * lvl2 < a:
		q += 1
	while (q * q * lvl2 - a) % lvl != 0:
		q += 1
	return ((lvl + 1) * q, int((q * q * lvl2 - a) / lvl))

def find_nums(n):
	a = 2
	for i in range(1, n + 1):
		(a, tmp) = solve_eq(a, i)
		print(tmp)
find_nums(int(input()))


import sys
import math
n = int(input())
x = 2
for i in range(1, n + 1):
	y = i * (i + 1)
	y *= y
	c = (y - x) // i
	x += y - x
	x = int(math.sqrt(x))
	print(c)


import time
import math
n = int(input())
pr = [2, 3, 5, 7, 11, 13, 17, 19, 23]
start = time.time()
now = 2
level = 1
ans = []
while level < n + 1:
	new = level * (level + 1)
	pl = new ** 2
	ans.append((new ** 2 - now) // level)
	now = new
	level += 1
for i in ans:
	print(i)
finish = time.time()


x = int(input())
print(2)
k = 2
last = 2
for j in range(2, x + 1):
	print(str((k * k * (k + 1) * (k + 1) - last) // k))
	last = k * (k + 1)
	k += 1


import sys
input = sys.stdin.buffer.readline
import os
from math import *
n = int(input())
prev = 2
k = 1
for i in range(1, n + 1):
	var = i * (i + 1) * (i * (i + 1))
	print((var - prev) // k)
	prev = i * (i + 1)
	k += 1