Problem: Given n, find n consecutive positive integers. However, all numbers must have divisors other than 1 and the number itself.

Hint

In Sample Output 2, 8, 9 and 10 are selected as three consecutive integers.
The second and third lines output 3, as a divisor of 9, and the fourth line outputs 5, as a divisor of 10.



Input

The input is given in the following format.


n


The input meets the following constraints.
1 ≤ n ≤ 1,500

Output

Print the smallest of the n consecutive positive integers you choose on the first line.
Output the divisor for each value from the 2nd line to the n + 1 line.
Any value may be output unless the divisor is 1 or the number itself.
Let x be the number output on the first line, and output the divisor of x + i-2 on the i line.

The output value must not exceed 5,000 digits.

Examples

Input

2


Output

8
2
3


Input

3


Output

8
2
3
5

Solution (in CPP):

Solution:
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cstring>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <bitset>
#include <numeric>
#include <utility>
#include <iomanip>
#include <algorithm>
#include <functional>
using namespace std;

typedef long long ll;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef pair<int,int> pint;

#define DE 1
#define FI first
#define SE second
#define PB push_back
#define MP make_pair
#define ALL(s) (s).begin(),(s).end()
#define REP(i,n) for (int i = 0; i < (int)(n); ++i)
#define EACH(i,s) for (__typeof__((s).begin()) i = (s).begin(); i != (s).end(); ++i)
#define COUT(x) cout<<#x<<" = "<<(x)<<" (L"<<__LINE__<<")"<<endl

template<class T1, class T2> ostream& operator<<(ostream &s, pair<T1,T2> P){return s<<'<'<<P.first<<", "<<P.second<<'>';}
template<class T> ostream& operator<<(ostream &s, vector<T> P) {s<<"{ ";for(int i=0;i<P.size();++i){if(i>0)s<<", ";s<<P[i];}return s<<" }"<<endl;}
template<class T1, class T2> ostream& operator<<(ostream &s, map<T1,T2> P) {s<<"{ ";for(__typeof__(P.begin()) it=P.begin();it!=P.end();++it){if(it!=P.begin())s<<", ";s<<'<'<<it->first<<"->"<<it->second<<'>';}return s<<" }"<<endl;}



const int MAX_D = 10000;
const long long B = 10000;
const int LB = 4;
struct Bigint {
    int size;
    long long digit[MAX_D/LB];
    
    Bigint(int size = 1, long long a = 0) : size(size) {
        memset(digit, 0, sizeof(digit));
        digit[0] = a;
    }
    Bigint normalize();
    long long tolong();
    string tostr();
    inline const Bigint& operator = (long long a);
    inline const Bigint& operator = (const string &s);
    inline const Bigint& operator += (const Bigint& x);
    inline const Bigint& operator += (long long x);
    inline const Bigint& operator -= (const Bigint& x);
    inline const Bigint& operator -= (long long x);
    inline const Bigint& operator *= (const Bigint& x);
    inline const Bigint& operator *= (long long x);
    inline const Bigint& operator /= (const Bigint& x);
    inline const Bigint& operator /= (long long x);
    inline const Bigint& operator %= (const Bigint& x);
    inline const Bigint& operator %= (long long x);
};

Bigint Bigint::normalize() {
    long long c = 0;
    for (int i = 0; i < (*this).size; ++i) {
        while ((*this).digit[i] < 0) {
            (*this).digit[i+1] -= 1;
            (*this).digit[i] += B;
        }
        long long a = (*this).digit[i] + c;
        (*this).digit[i] = a % B;
        c = a / B;
    }
    for (; c > 0; c /= B) (*this).digit[(*this).size++] = c % B;
    while ((*this).size > 1 && (*this).digit[(*this).size-1] == 0) --(*this).size;
    return *this;
}
long long Bigint::tolong() {
    long long res = 0;
    for (int i = LB; i >= 0; --i) {
        res *= B;
        res += (*this).digit[i];
    }
    return res;
}
string Bigint::tostr() {
    stringstream ss;
    ss << (*this).digit[(*this).size-1];
    for (int i = (*this).size-2; i >= 0; --i)
        ss << setw(LB) << setfill('0') << (*this).digit[i];
    return ss.str();
}
Bigint tobig(long long a) {
    return Bigint(1, a).normalize();
}
Bigint tobig(const string &s) {
    Bigint x;
    int i = s.size() % LB;
    if (i > 0) i -= LB;
    for (; i < (int)s.size(); i += LB) {
        long long a = 0;
        for (int j = 0; j < LB; ++j)
            a = 10 * a + (i + j >= 0 ? s[i+j] - '0' : 0);
        x.digit[x.size++] = a;
    }
    reverse(x.digit, x.digit+x.size);
    return x.normalize();
}
inline const Bigint& Bigint::operator = (long long a) {
    *this = tobig(a);
    return *this;
}
inline const Bigint& Bigint::operator = (const string &s) {
    *this = tobig(s);
    return *this;
}
ostream &operator << (ostream &os, Bigint x) {
    os << x.digit[x.size-1];
    for (int i = x.size-2; i >= 0; --i)
        os << setw(LB) << setfill('0') << x.digit[i];
    return os;
}
istream &operator >> (istream &is, Bigint &x) {
    string s; is >> s;
    x = tobig(s);
    return is;
} 
bool operator < (Bigint x, Bigint y) {
    if (x.size != y.size) return x.size < y.size;
    for (int i = x.size-1; i >= 0; --i)
        if (x.digit[i] != y.digit[i]) return x.digit[i] < y.digit[i];
    return false;
}
bool operator > (Bigint x, Bigint y) { 
    return y < x;
}
bool operator <= (Bigint x, Bigint y) { 
    return !(y < x); 
}
bool operator >= (Bigint x, Bigint y) { 
    return !(x < y); 
}
bool operator != (Bigint x, Bigint y) { 
    return x < y || y < x; 
}
bool operator == (Bigint x, Bigint y) { 
    return !(x < y) && !(y < x); 
}
Bigint operator + (Bigint x, Bigint y) {
    if (x.size < y.size) x.size = y.size;
    for (int i = 0; i < y.size; ++i)
        x.digit[i] += y.digit[i];
    return x.normalize();
}
Bigint operator + (Bigint x, long long y) {
    Bigint Y; Y = y;
    return x + Y;
}
Bigint operator - (Bigint x, Bigint y) {
    for (int i = 0; i < y.size; ++i)
        x.digit[i] -= y.digit[i];
    return x.normalize();
}
Bigint operator - (Bigint x, long long y) {
    Bigint Y; Y = y;
    return x - Y;
}
Bigint operator * (Bigint x, Bigint y) {
    Bigint z(x.size + y.size);
    for (int i = 0; i < x.size; ++i)
        for (int j = 0; j < y.size; ++j)
            z.digit[i+j] += x.digit[i] * y.digit[j];
    return z.normalize();
}
Bigint operator * (Bigint x, long long a) {
    for (int i = 0; i < x.size; ++i)
        x.digit[i] *= a;
    return x.normalize();
}
pair<Bigint, long long> divmod(Bigint x, long long a) {
    long long c = 0, t;
    for (int i = x.size-1; i >= 0; --i) {
        t = B * c + x.digit[i];
        x.digit[i] = t / a;
        c = t % a;
    }
    x.normalize();
    return pair<Bigint, long long>(x, c);
}
Bigint operator / (Bigint x, long long a) {
    return divmod(x, a).first;
}
long long operator % (Bigint x, long long a) {
    return divmod(x, a).second;
}
pair<Bigint, Bigint> divmod(Bigint x, Bigint y) {
    Bigint zero(1, 0);
    if (x.size < y.size) return pair<Bigint, Bigint>(zero, x);
    int F = B / (y.digit[y.size-1] + 1);
    x = x * F; y = y * F;
    Bigint z(x.size - y.size + 1);
    for (int k = z.size-1, i = x.size-1; k >= 0; --k, --i) {
        z.digit[k]  = (i+1 < x.size ? x.digit[i+1] : 0) * B + x.digit[i];
        z.digit[k] /= y.digit[y.size-1];
        Bigint t(k + y.size);
        for (int m = 0; m < y.size; ++m)
            t.digit[k+m] = z.digit[k] * y.digit[m];
        t.normalize();
        while (x < t) {
            z.digit[k] -= 1;
            for (int m = 0; m < y.size; ++m)
                t.digit[k+m] -= y.digit[m];
            t.normalize();
        }
        x = x - t;
    }
    return pair<Bigint, Bigint>(z.normalize(), x / F);
}
Bigint operator / (Bigint x, Bigint y) {
    return divmod(x, y).first;
}
Bigint operator % (Bigint x, Bigint y) {
    return divmod(x, y).second;
}
Bigint power(Bigint x, long long n) {
    Bigint res(1, 1);
    while (n > 0) {
        if (n & 1) res = res * x;
        x = x * x;
        n >>= 1;
    }
    return res;
}
inline const Bigint& Bigint::operator += (const Bigint& x) {*this = *this + x; return *this;}
inline const Bigint& Bigint::operator += (long long x) {*this = *this + x; return *this;}
inline const Bigint& Bigint::operator -= (const Bigint& x) {*this = *this - x; return *this;}
inline const Bigint& Bigint::operator -= (long long x) {*this = *this + x; return *this;}
inline const Bigint& Bigint::operator *= (const Bigint& x) {*this = *this * x; return *this;}
inline const Bigint& Bigint::operator *= (long long x) {*this = *this * x; return *this;}
inline const Bigint& Bigint::operator /= (const Bigint& x) {*this = *this / x; return *this;}
inline const Bigint& Bigint::operator /= (long long x) {*this = *this / x; return *this;}
inline const Bigint& Bigint::operator %= (const Bigint& x) {*this = *this % x; return *this;}
inline const Bigint& Bigint::operator %= (long long x) {*this = *this % x; return *this;}



int n;

int main() {
    cin >> n;
    Bigint res; res = 1;
    for (ll i = 1; i <= n+1; ++i) {
        res *= i;
    }
    res += 2;
    cout << res << endl;
    for (int i = 2; i <= n+1; ++i) cout << i << endl;
    
    return 0;
}