#include<algorithm>

 #include<iostream>

 #include<cstdlib>

 #include<cstring>

 #include<cassert>

 #include<cstdio>

 #include<vector>

 #include<string>

 #include<map>

 #include<set>

 using std::cin;

 using std::max;

 using std::cout;

 using std::endl;

 using std::string;

 using std::istream;

 using std::ostream;

 #define sz(c) (int)(c).size()

 #define all(c) (c).begin(), (c).end()

 #define iter(c) decltype((c).begin())

 #define cls(arr,val) memset(arr,val,sizeof(arr))

 #define cpresent(c, e) (find(all(c), (e)) != (c).end())

 #define rep(i, j, n) for (int i = j; i < (int)(n); i++)

 #define fork(i, k, n) for (int i = (int)k; i <= (int)n; i++)

 #define tr(c, i) for (iter(c) i = (c).begin(); i != (c).end(); ++i)

 #define pb(e) push_back(e)

 #define mp(a, b) make_pair(a, b)

 struct BigN {

     typedef unsigned long long ull;

     static const int Max_N = ;

     int len, data[Max_N];

     BigN() { memset(data, , sizeof(data)), len = ; }

     BigN(const int num) {

         memset(data, , sizeof(data));

         *this = num;

     }

     BigN(const char *num) {

         memset(data, , sizeof(data));

         *this = num;

     }

     void clear() { len = , memset(data, , sizeof(data)); }

     BigN& clean(){ while (len >  && !data[len - ]) len--;  return *this; }

     string str() const {

         string res = "";

         for (int i = len - ; ~i; i--) res += (char)(data[i] + '');

         if (res == "") res = "";

         res.reserve();

         return res;

     }

     BigN operator = (const int num) {

         int j = , i = num;

         do data[j++] = i % ; while (i /= );

         len = j;

         return *this;

     }

     BigN operator = (const char *num) {

         len = strlen(num);

         for (int i = ; i < len; i++) data[i] = num[len - i - ] - '';

         return *this;

     }

     BigN operator + (const BigN &x) const {

         BigN res;

         int n = max(len, x.len) + ;

         for (int i = , g = ; i < n; i++) {

             int c = data[i] + x.data[i] + g;

             res.data[res.len++] = c % ;

             g = c / ;

         }

         return res.clean();

     }

     BigN operator * (const BigN &x) const {

         BigN res;

         int n = x.len;

         res.len = n + len;

         for (int i = ; i < len; i++) {

             for (int j = , g = ; j < n; j++) {

                 res.data[i + j] += data[i] * x.data[j];

             }

         }

         for (int i = ; i < res.len - ; i++) {

             res.data[i + ] += res.data[i] / ;

             res.data[i] %= ;

         }

         return res.clean();

     }

     BigN operator * (const int num) const {

         BigN res;

         res.len = len + ;

         for (int i = , g = ; i < len; i++) res.data[i] *= num;

         for (int i = ; i < res.len - ; i++) {

             res.data[i + ] += res.data[i] / ;

             res.data[i] %= ;

         }

         return res.clean();

     }

     BigN operator - (const BigN &x) const {

         assert(x <= *this);

         BigN res;

         for (int i = , g = ; i < len; i++) {

             int c = data[i] - g;

             if (i < x.len) c -= x.data[i];

             if (c >= ) g = ;

             else g = , c += ;

             res.data[res.len++] = c;

         }

         return res.clean();

     }

     BigN operator / (const BigN &x) const {

         BigN res, f = ;

         for (int i = len - ; ~i; i--) {

             f *= ;

             f.data[] = data[i];

             while (f >= x) {

                 f -= x;

                 res.data[i]++;

             }

         }

         res.len = len;

         return res.clean();

     }

     BigN operator % (const BigN &x) {

         BigN res = *this / x;

         res = *this - res * x;

         return res;

     }

     BigN operator += (const BigN &x) { return *this = *this + x; }

     BigN operator *= (const BigN &x) { return *this = *this * x; }

     BigN operator -= (const BigN &x) { return *this = *this - x; }

     BigN operator /= (const BigN &x) { return *this = *this / x; }

     BigN operator %= (const BigN &x) { return *this = *this % x; }

     bool operator <  (const BigN &x) const {

         if (len != x.len) return len < x.len;

         for (int i = len - ; ~i; i--) {

             if (data[i] != x.data[i]) return data[i] < x.data[i];

         }

         return false;

     }

     bool operator >(const BigN &x) const { return x < *this; }

     bool operator<=(const BigN &x) const { return !(x < *this); }

     bool operator>=(const BigN &x) const { return !(*this < x); }

     bool operator!=(const BigN &x) const { return x < *this || *this < x; }

     bool operator==(const BigN &x) const { return !(x < *this) && !(x > *this); }

     friend istream& operator >> (istream &in, BigN &x) {

         string src;

         in >> src;

         x = src.c_str();

         return in;

     }

     friend ostream& operator << (ostream &out, const BigN &x) {

         out << x.str();

         return out;

     }

 }A[], B;

 inline void init() {

     A[] = ;

     rep(i, , ) {

         B =  * i - ;

         A[i] = A[i - ] * B / (i + );

         B.clear();

     }

 }

 int main() {

 #ifdef LOCAL

     freopen("in.txt", "r", stdin);

     freopen("out.txt", "w+", stdout);

 #endif

     init();

     std::ios::sync_with_stdio(false);

     int n;

     while (cin >> n) cout << A[n] << endl;

     return ;

 }