ZS the Coder is playing a game. There is a number displayed on the screen and there are two buttons, ' + ' (plus) and '<image>' (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 :

  1. 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.
  2. Press the '<image>' button. Let the number on the screen be x. After pressing this button, the number becomes <image>. 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 = m2 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 '<image>' 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 '<image>' button n times. Help him determine the number of times he should press the ' + ' button before pressing the '<image>' 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 '<image>' button at level i. 

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

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 '<image>' button, and the number became <image>. 

After that, on the second level, ZS pressed the ' + ' button 16 times, so the number becomes 4 + 16·2 = 36. Then, ZS pressed the '<image>' button, levelling up and changing the number into <image>.

After that, on the third level, ZS pressed the ' + ' button 46 times, so the number becomes 6 + 46·3 = 144. Then, ZS pressed the '<image>' button, levelling up and changing the number into <image>. 

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 '<image>' button is pressed, the number becomes <image> 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 = 1018. Then, ZS the Coder pressed the '<image>' button, and the number became <image>. 

After that, on the second level, ZS pressed the ' + ' button 44500000000 times, so the number becomes 109 + 44500000000·2 = 9·1010. Then, ZS pressed the '<image>' button, levelling up and changing the number into <image>. 

Note that 300000 is a multiple of 3, so ZS the Coder can reach level 3.
#include <bits/stdc++.h>
using namespace std;
inline namespace Infinity {
inline namespace Constant {
constexpr const int eof = EOF;
constexpr const int maxint = INT_MAX;
constexpr const long long maxll = LLONG_MAX;
constexpr const double eps = DBL_EPSILON;
}  // namespace Constant
inline namespace TypeDefine {
using uint = unsigned int;
using ull = unsigned long long int;
using ld = long double;
template <typename T = vector<int> >
using iter = typename T::iterator;
template <typename T = int>
using vector_vector = vector<vector<T> >;
template <typename T = int, typename U = int>
using vector_pair = vector<pair<T, U> >;
}  // namespace TypeDefine
inline namespace IO {
const char LF = '\n';
const char SP = ' ';
inline void write(const int n) { printf("%d", n); }
inline void write(const unsigned n) { printf("%u", n); }
inline void write(const long long n) { printf("%" PRId64, n); }
inline void write(const unsigned long long n) { printf("%" PRIu64, n); }
inline void writef(const double a, const int n = 10) { printf("%.*f", n, a); }
inline void writef(const long double a, const int n = 18) {
  printf("%.*Lf", n, a);
}
inline void write(const char c) { printf("%c", c); }
inline void write(const char s[]) { printf("%s", s); }
inline void write(const string &s) { printf("%s", s.data()); }
template <typename T, typename U>
inline void write(const pair<T, U> &p) {
  writeSP(p.first);
  write(p.second);
}
template <class T>
inline void write(const T a) {
  for (auto i = a.begin(); i != a.end(); i++) {
    if (i != a.begin()) write(SP);
    write(*i);
  }
}
template <typename T>
inline void write(initializer_list<T> list) {
  for (auto i = list.begin(); i != list.end(); i++) {
    if (i != list.begin()) write(SP);
    write(*i);
  }
}
template <typename T>
inline void writer(T begin, T end) {
  for (write(*begin++); begin != end; ++begin) write(SP), write(*begin);
}
inline void writeln() { write(LF); }
template <typename T>
inline void writeln(const T &a) {
  write(a);
  write(LF);
}
inline void writefln(const double a, int n) {
  printf("%.*f", n, a);
  write(LF);
}
inline void writefln(const long double a, int n = 18) {
  cout << setprecision(n) << fixed << a << endl;
}
inline void writesln(const int *a, const int l, const int r) {
  for (int i = l; i <= r; i++) printf("%d ", a[i]);
  writeln(LF);
}
template <typename T>
inline void writerln(T begin, T end) {
  for (write(*begin++); begin != end; ++begin) write(SP), write(*begin);
  write(LF);
}
template <class T>
inline void writelns(const T &a) {
  for (auto n : a) writeln(n);
}
template <typename T, typename... types>
inline void write(const T &a, const types &...args) {
  write(a);
  write(args...);
}
template <typename... types>
inline void writeln(const types &...args) {
  write(args...);
  write(LF);
}
template <typename... types>
inline void writeSP(const types &...args) {
  write(args...);
  write(SP);
}
inline void writelnYN(bool b) { writeln(b ? "YES" : "NO"); }
inline void writelnyn(bool b) { writeln(b ? "Yes" : "No"); }
string caseSharpSpace(int n) { return "Case #" + to_string(n) + ": "; }
string caseNoSharpSpace(int n) { return "Case " + to_string(n) + ": "; }
string caseSharpNoSpace(int n) { return "Case #" + to_string(n) + ":"; }
string caseNoSharpNoSpace(int n) { return "Case " + to_string(n) + ":"; }
inline int read(int &n) { return scanf("%d", &n); }
inline int read(long long &n) { return scanf("%" SCNd64, &n); }
template <typename T, typename... types>
inline int read(T &n, types &...args) {
  return read(n) == eof ? eof : read(args...) + 1;
}
inline char getcc() {
  char c;
  do c = getchar();
  while (isspace(c));
  return c;
}
inline int getint() {
  int n;
  read(n);
  return n;
}
inline long long getll() {
  long long n;
  read(n);
  return n;
}
inline double getdouble() {
  double n;
  scanf("%lf", &n);
  return n;
}
inline vector<int> getints(int n) {
  vector<int> v(n);
  for (int i = 0; i < n; i++) v[i] = getint();
  return v;
}
inline vector<pair<int, int> > getpairs(int n) {
  vector<pair<int, int> > v(n);
  for (int i = 0; i < n; i++) {
    int a = getint(), b = getint();
    v[i] = {a, b};
  }
  return v;
}
inline void read(string &str, const unsigned size) {
  char s[size];
  scanf("%s", s);
  str.assign(s);
}
inline string getstr(const unsigned size = 0x100000) {
  string s;
  read(s, size + 1);
  return s;
}
inline string getln(const unsigned size = 0x100000) {
  char s[size + 1];
  scanf("%[^\n]", s);
  getchar();
  return string(s);
}
}  // namespace IO
inline namespace Miscelleneous {
inline constexpr int ctoi(const char c) { return c - '0'; }
inline constexpr char itoc(const int n) { return n + '0'; }
inline int dtoi(const double d) { return round(d); }
template <typename T>
inline constexpr bool in(T x, T l, T r) {
  return l <= x && x <= r;
}
template <class T>
inline int size(const T &a) {
  return a.size();
}
template <class T>
inline void sort(T &a) {
  sort(a.begin(), a.end());
}
template <class T1, class T2>
inline void sort(T1 &a, T2 comp) {
  sort(a.begin(), a.end(), comp);
}
template <class T1, typename T2>
inline int lbound(const T1 &a, const T2 k) {
  return lower_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, typename T2>
inline int ubound(const T1 &a, const T2 k) {
  return upper_bound(a.begin(), a.end(), k) - a.begin();
}
template <class T1, class T2>
int count(T1 &a, T2 k) {
  return ubound(a, k) - lbound(a, k);
}
template <class T1, class T2>
int find(T1 &a, T2 k) {
  return count(a, k) ? lbound(a, k) : -1;
}
template <typename T>
inline void clear(T &a) {
  memset(a, 0, sizeof a);
}
template <typename T>
T gcd(T a, T b) {
  while (b) {
    T t = a % b;
    a = b;
    b = t;
  }
  return a;
}
template <typename T>
T lcm(T a, T b) {
  return a / gcd(a, b) * b;
}
long long qpow(long long a, long long b, long long c) {
  return b ? qpow(a * a % c, b >> 1, c) * (b & 1 ? a : 1) % c : 1;
}
template <typename T>
T exGcd(T a, T b, T &x, T &y) {
  T d = a;
  if (b) {
    d = exGcd(b, a % b, y, x);
    y -= a / b * x;
  } else {
    x = 1;
    y = 0;
  }
  return d;
}
template <typename T>
inline constexpr T mps(T l, T r, T k) {
  return ((r - (r % k + k) % k) - (l + (k - l % k) % k)) / k + 1;
}
template <typename T>
inline constexpr T sgn(T a) {
  return a ? a > 0 ? 1 : -1 : 0;
}
template <typename T>
inline constexpr T sq(T a) {
  return a * a;
}
template <typename T>
inline constexpr bool odd(T a) {
  return bool(a % 2);
}
template <typename T>
inline constexpr bool even(T a) {
  return !bool(a % 2);
}
template <typename T1, typename T2>
inline constexpr T1 smod(T1 x, T2 m) {
  return x > m ? x - m : x + m < m ? x + m : x;
}
template <typename T, typename F>
T dichotomy(T l, T r, F check, T prec = 1) {
  while (r - l > prec) {
    T m = l + (r - l) / 2;
    check(m) ? l = m : r = m;
  }
  return l;
}
template <typename T, typename F>
T dichotomy2(T l, T r, F check, T prec = 1) {
  while (r - l > prec) {
    T m = l + (r - l) - (r - l) / 2;
    check(m) ? r = m : l = m;
  }
  return r;
}
bool contains(const string &s, const string &t) {
  return s.find(t) != string::npos;
}
template <typename T>
bool contains(const T &s, typename T::value_type t) {
  for (typename T::value_type c : s)
    if (c == t) return true;
  return false;
}
}  // namespace Miscelleneous
}  // namespace Infinity
int main(int, char *[]) {
  int n = getint();
  writeln(2);
  for (long long i = 2; i <= n; i++) {
    writeln((i + 2) * sq(i) + 1);
  }
  return 0;
}
