/*
* C++11 code template for contests.
* @author: Andrei Kalendarov
* @e-mail: andreykalendarov@gmail.com
*/

//#define ANDREIKKAA_ALLOCATOR
const int _ML = 400;

const char _inpf[] =
#if defined(ANDREIKKAA)
        "input.txt"
#else
""
#endif
;
const char _outf[] =
#if defined(ANDREIKKAA)
        ""
#else
""
#endif
;

#if defined(ANDREIKKAA)
#undef NDEBUG
#else
#pragma GCC optimize("O3,no-stack-protector")
#endif
#include <bits/stdc++.h>
#if !defined(ANDREIKKAA)
#define endl '\n'
#endif
#define x first
#define y second
using namespace std;
#define rand abcdefghijklmnopqrstuvwxyz
#define random_shuffle abcdefghijklmnopqrstuvwxyz
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef double ld;
const ld PI = 3.14159265358979323846;
mt19937 rd(228);
#if defined(ANDREIKKAA_ALLOCATOR)
char _mem[_ML * 1024 * 1024];
size_t _ptr = 0;
inline void* operator new (size_t _x) { _ptr += _x; assert(_ptr < _ML * 1024 * 1024); return _mem + _ptr - _x; }
inline void operator delete (void*) { }
#endif
template<class T, class U> inline ostream &operator<< (ostream &, const pair<T, U> &);
template<class T, class U> inline istream &operator>> (istream &, pair<T, U> &);
template<class T> inline ostream &operator<< (ostream &, const vector<T> &);
template<class T> inline istream &operator>> (istream &, vector<T> &);
template<class T> inline ostream &operator<< (ostream &, const set<T> &);
template<class T> inline ostream &operator<< (ostream &, const multiset<T> &);
template<class T> inline ostream &operator<< (ostream &, const unordered_set<T> &);
template<class T> inline ostream &operator<< (ostream &, const unordered_multiset<T> &);
template<class T, class U> inline ostream &operator<< (ostream &, const map<T, U> &);
template<class T, class U> inline ostream &operator<< (ostream &, const unordered_map<T, U> &);

/* ________ CODE ________ */

/*void stup(int n)
{
    vector<int> a(n);
    for(int &i : a)
    {
        i = 2 * ((int)rd() % 15000 + 1);
        assert(i > 0);
    }
    
    for(;;)
    {
        bool ok;
        
        int sum = accumulate(all(a), 0);
        for(int i = 0; i < n; ++i)
        {
            if(sum % a[i] != 0)
            {
                ok = false;
            }
        }
        
        if(accumulate(all(a), 0, __gcd) != 1)
        {
            ok = false;
        }
        
        if(ok)
        {
            break;
        }
        
        
    }
}*/

inline int popc(int x)
{
    return __builtin_popcount(x);
}

vector<int> f(vector<int> b, int n, int md, int msk)
{
    b.push_back(15);
    
    int to = (1 << sz(b));
    for(int i = 0; i < to; ++i)
    {
        if(popc(i) != n || (i & msk) != msk)
        {
            continue;
        }
        
        vector<int> v;
        for(int j = 0; j < sz(b); ++j)
        {
            if((i >> j) & 1)
            {
                v.push_back(b[j]);
            }
        }
        
        if(accumulate(all(v), 0) % md == 0)
        {
            return v;
        }
    }
    
    assert(false);
    return{};
}

inline void _main_function()
{
    //for(int n = 3; n <= 30; ++n)
    //{
        vector<int> b = {2, 3, 4, 5, 6, 8, 9, 10, 12, 14, 16, 18, 20, 21, 22, 24, 25, 26, 27, 28, 30};
    
        int n;
        cin >> n;
    
        if(n < sz(b))
        {
            auto c = f(b, n, 30, 3);
            cout << c << endl;
            //continue;
            return;
        }
    
        vector<int> a(n);
    
        for(int i = 0; i + sz(b) <= n; i += sz(b))
        {
            for(int j = 0; j < sz(b); ++j)
            {
                a[i + j] = b[j] + (i / sz(b)) * 30;
            }
        }
    
        auto c = f(b, n - n / sz(b) * sz(b), 30, 0);
        for(int j = 0; j < sz(c); ++j)
        {
            a[n - j - 1] = c[j] + (n / sz(b)) * 30;
        }
    
    assert(*max_element(all(a)) <= 30000);
    sort(all(a));
    assert(unique(all(a)) == a.end());
    int sum = accumulate(all(a), 0);
    for(int i = 0; i < n; ++i)
    {
        if(__gcd((sum - a[i]), a[i]) == 1)
        {
            assert(false);
            cout << a[i] << endl;
        }
    }
    
        cout << a << endl;
    //}
}

/* ________ CODE ________ */

int main()
{
#if defined(ANDREIKKAA)
    time_t _start = clock();
#endif
    if (_inpf[0] != '\0') assert(freopen(_inpf, "r", stdin) != nullptr);
    if (_outf[0] != '\0') assert(freopen(_outf, "w", stdout) != nullptr);
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    
    cout << setprecision(20);
    //cout << fixed;
    
    _main_function();
#if defined(ANDREIKKAA)
    cout << "Time: " << (clock() - _start) / (ld)CLOCKS_PER_SEC << endl;
#endif
}

template<class T, class U> inline ostream &operator<< (ostream &_out, const pair<T, U> &_p)
{
    _out << _p.x << ' ' << _p.y;
    return _out;
}
template<class T, class U> inline istream &operator>> (istream &_in, pair<T, U> &_p)
{
    _in >> _p.x >> _p.y;
    return _in;
}
template<class T> inline ostream &operator<< (ostream &_out, const vector<T> &_v)
{
    if (_v.empty()) { return _out; }
    _out << *_v.begin();
    for (auto _it = ++_v.begin(); _it != _v.end(); ++_it) { _out << ' ' << *_it; }
    return _out;
}
template<class T> inline istream &operator>> (istream &_in, vector<T> &_v)
{
    for (auto &_i : _v) { _in >> _i; }
    return _in;
}
template<class T> inline ostream &operator<< (ostream &_out, const set<T> &_s)
{
    if (_s.empty()) { return _out; }
    _out << *_s.begin();
    for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; }
    return _out;
}
template<class T> inline ostream &operator<< (ostream &_out, const multiset<T> &_s)
{
    if (_s.empty()) { return _out; }
    _out << *_s.begin();
    for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; }
    return _out;
}
template<class T> inline ostream &operator<< (ostream &_out, const unordered_set<T> &_s)
{
    if (_s.empty()) { return _out; }
    _out << *_s.begin();
    for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; }
    return _out;
}
template<class T> inline ostream &operator<< (ostream &_out, const unordered_multiset<T> &_s)
{
    if (_s.empty()) { return _out; }
    _out << *_s.begin();
    for (auto _it = ++_s.begin(); _it != _s.end(); ++_it) { _out << ' ' << *_it; }
    return _out;
}
template<class T, class U> inline ostream &operator<< (ostream &_out, const map<T, U> &_m)
{
    if (_m.empty()) { return _out; }
    _out << '(' << _m.begin()->x << ": " << _m.begin()->y << ')';
    for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) { _out << ", (" << _it->x << ": " << _it->y << ')'; }
    return _out;
}
template<class T, class U> inline ostream &operator<< (ostream &_out, const unordered_map<T, U> &_m)
{
    if (_m.empty()) { return _out; }
    _out << '(' << _m.begin()->x << ": " << _m.begin()->y << ')';
    for (auto _it = ++_m.begin(); _it != _m.end(); ++_it) { _out << ", (" << _it->x << ": " << _it->y << ')'; }
    return _out;
}

Measured memory_bytes: 512