// 2022.10.21
#define _GLIBCXX_DEBUG //
// #define __USE_MATH_DEFINES // const double PI = acos(-1.0)
#include <bits/stdc++.h>
using namespace std;
// (*) snipet
// type name
using ll = long long;
using pii = pair<int, int>; using pil = pair<int, ll>; using pli = pair<ll, int>; using pll = pair<ll, ll>;
using vi = vector<int>; using vvi = vector<vi>; using vvvi = vector<vvi>;
using vl = vector<ll>; using vvl = vector<vl>; using vvvl = vector<vvl>;
using vpii = vector<pii>; using vpil = vector<pil>; using vpli = vector<pli>; using vpll = vector<pll>;
using vb = vector<bool>; using vvb = vector<vb>; using vvvb = vector<vvb>;
using vd = vector<double>; using vvd = vector<vd>; using vvvd = vector<vvd>;
template <typename T> using pq = priority_queue<T, vector<T>>;
template <typename T> using pql = priority_queue<T, vector<T>, greater<T>>;
// rep
#define rep0(goal) for (int cnt = 0; cnt < int(goal); ++cnt)
#define rep(cnt, goal) for (int cnt = 0; cnt < int(goal); ++cnt)
#define rep2(cnt, start, goal) for (int cnt = int(start); cnt < int(goal); ++cnt)
#define rep3(cnt, start, goal) for (int cnt = int(start); cnt > int(goal); --cnt)
// all
#define all(ctn) begin(ctn), end(ctn)
// chmax, chmin
template <typename T> bool chmax(T &x, const T y) { if (x < y) { x = y; return true; } else { return false; }}
template <typename T> bool chmin(T &x, const T y) { if (x > y) { x = y; return true; } else { return false; }}
// etc.
void Yn(const bool &exp) { if (exp) cout << "Yes" << endl; else cout << "No" << endl;}
void set_prec(const int &dig) { cout << fixed << setprecision(dig); cerr << fixed << setprecision(dig);}
// template <typename T> T INF() { return numeric_limits<T>::max();}
// template <typename T> T MIN_INF() { return numeric_limits<T>::min();}

// #include <atcoder/all>
// using namespace atcoder;
// // using mint = atcoder::modint1000000007;
// using mint = atcoder::modint998244353;
// // using mint = atcoder::modint;
// void pr(const mint &MINT) { cerr << MINT.val(); } // mint
// using pmm = pair<mint, mint>; using pim = pair<int, mint>; using pmi = pair<mint, int>; using plm = pair<ll, mint>; using pml = pair<mint, ll>;
// using vm = vector<mint>; using vvm = vector<vm>; using vvvm = vector<vvm>;

// debug
template <typename T> void pr(const T &obj) { cerr << obj; } // single
template <typename T, typename ...Ts> void pr(const T &first, const Ts &...rest) { pr(first); cerr << ", "; pr(rest...); } // multi(plural)
template <typename S, typename T> void pr(const pair<S, T> &PAIR) { cerr << "("; pr(PAIR.first); cerr << ", "; pr(PAIR.second); cerr << ")"; } // pair
template <typename S, typename T, typename U> void pr(const tuple<S, T, U> &trp) { cerr << "("; pr(get<0>(trp)); cerr << ", "; pr(get<1>(trp)); cerr << ", "; pr(get<2>(trp)); cerr << ")"; } // tuple(3)
template <typename T> void pr(const vector<T> &vec) { cerr << "{"; for (T obj : vec) { pr(obj); cerr << ", "; } cerr << "}"; } // vector
template <typename T> void pr(const vector<vector<T>> &vv) { rep(row, vv.size()) { cerr << endl; cerr << "[" << row << "]: "; pr(vv[row]); }} // vector(multi-D)
template <typename T> void pr(const set<T> &SET) { cerr << "{"; for (T obj : SET) { pr(obj); cerr << ", "; } cerr << "}"; } // set
template <typename T> void pr(const multiset<T> &MS) { cerr << "{"; for (T obj : MS) { pr(obj); cerr << ", "; } cerr << "}"; } // multiset
template <typename S, typename T> void pr(const map<S, T> &MAP) { cerr << "{"; for (pair<S, T> p : MAP) { pr(p.first); cerr << ": "; pr(p.second); cerr << ", "; } cerr << "}";} // map
template <typename T> void pr(const queue<T> &que) { queue<T> q = que; cerr << "{"; while (!q.empty()) { pr(q.front()); q.pop(); cerr << ", ";} cerr << "}";} // queue
template <typename T> void pr(const deque<T> &deq) { deque<T> d = deq; cerr << "{"; while (!d.empty()) { pr(d.front()); d.pop_front(); cerr << ", ";} cerr << "}";} // deque
template <typename T> void pr(const stack<T> &stc) { stack<T> s = stc; vector<T> v; while (!s.empty()) { v.push_back(s.top()); s.pop();} reverse(all(v)); cerr << "{"; for (T obj : v) cerr << obj << ", "; cerr << "}";} // stack
template <typename T> void pr(const priority_queue<T> &pq) { priority_queue<T> p = pq; cerr << "{"; while (!p.empty()) { pr(p.top()); p.pop(); cerr << ", "; } cerr << "}";} // priority_queue
template <typename T> void pr(const priority_queue<T, vector<T>, greater<T>> &pq) { priority_queue<T, vector<T>, greater<T>> p = pq; cerr << "{"; while (!p.empty()) { pr(p.top()); p.pop(); cerr << ", ";} cerr << "}";} // priority_queue(from less)

#define db(obj) cerr << #obj << ": "; pr(obj); cerr << " ";
#define dl(obj) db(obj); cerr << endl;
#define dm(...) cerr << "(" << #__VA_ARGS__ << "): ("; pr(__VA_ARGS__); cerr << ") ";
#define dml(...) dm(__VA_ARGS__); cerr << endl;

// kグループに分かれる場合の数を考え、k=1~N について足し合わせる

// 同じグループに入る夫婦がi組「以上」であるとする (k<=i<=N) -> 包除原理
// N組の夫婦からi組の夫婦を選ぶ方法はC(N,i)通り
// i組の夫婦をk個のグループに分ける方法はS2(i,k)通り
// それ以外の2(N-i)人について、k個のグループのいずれかに入れる方法はkΠ2(N-i) = k^(2N-2i)通り
// C(N,i)*S2(i,k)*kΠ2(N-i) を i=N mod2 のとき足し、そうでないとき引く

// global
int N;

vvl dp; // dp[N][N] // S2
vvl dp2; // dp[2N][N] // Pi
vvl dp3; // dp[N][K] // C
ll m = 1e9 + 7; // 998244353; // MOD

void input() {
	cin >> N;
}

void init() {
	dp = vvl(N + 1, vl(N + 1, -1));
	dp2 = vvl(2 * N + 1, vl(N + 1, -1));
	dp3 = vvl(N + 1, vl(N + 1, -1));
}

ll kPin(int n, int k) {
	assert(0 <= n); assert(0 <= k);
	if (dp2[n][k] != -1) return dp2[n][k];

	if (n == 0 && k == 0) return dp2[n][k] = 1;
	if (n == 0) return dp2[n][k] = 1; // 玉がない
	if (k == 0) return dp2[n][k] = 0; // 箱がない

	ll res = 0;
	res = k * kPin(n - 1, k) % m; // (n)は箱(k個)のどれかに入れる
	return dp2[n][k] = res;
}

ll S2(int n, int k) {
	assert(0 <= n); assert(0 <= k);
	if (dp[n][k] != -1) return dp[n][k];

	if (n == 0 && k == 0) return dp[n][k] = 1;
	if (n == 0) return dp[n][k] = 0; // 玉がない -> グループに分けられない
	if (k == 0) return dp[n][k] = 0; // 箱がない

	ll res = 0;
	res = (res + S2(n - 1, k - 1)) % m; // (n)が単独のグループ
	res = (res + k * S2(n - 1, k) % m) % m; // それ以外。(n)の入る箱はk通り
	return dp[n][k] = res;
}

ll kCn(int n, int k) {
	assert(0 <= n); assert(0 <= k);
	if (dp3[n][k] != -1) return dp3[n][k];

	if (n == 0 && k == 0) return dp3[n][k] = 1;
	if (n == 0) return dp3[n][k] = 1; // 玉がない
	if (k == 0) return dp3[n][k] = 0; // 箱がない

	ll res = 0;
	res = (res + kCn(n - 1, k - 1)) % m; // [k]に玉を入れる
	res = (res + kCn(n, k - 1)) % m; // [k]に玉を入れない
	return dp3[n][k] = res;
}

ll sub_solve(int k) {
	ll res = 0;
	rep2(i, k, N + 1) {
		// dml(k, i); //
		ll temp = 1;
		temp = (temp * kCn(i, N)) % m; // dl(kCn(i, N)); //
		temp = (temp * S2(i, k)) % m; // dl(S2(i, k)); //
		temp = (temp * kPin(2 * (N - i), k)) % m; // dl(kPin(2 * (N - i), k)); //
		if ((k - i) % 2 == 0) res = (res + temp) % m;
		else res = (res - temp + m) % m;
		// dml(k, i, temp); //
	}
	// dml(k, res); //
	return res;
}

void solve() {
	ll ans = 0;
	rep2(k, 1, N + 1) ans = (ans + sub_solve(k)) % m;
	// dl(dp); dl(dp2); dl(dp3); //
	cout << ans << endl;
};

int main() {
	input();
	init();
	solve();
}