#include <algorithm>
#include <boost/optional.hpp>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#define REP(i, n) for(int i = 0, i##_MACRO = (n); i < i##_MACRO; i++)
#define RANGE(i, a, b) for(int i = (a), i##_MACRO = (b); i < i##_MACRO; i++)
#define EACH(e, a) for(auto&& e : a)
#define ALL(a) std::begin(a), std::end(a)
#define RALL(a) std::rbegin(a), std::rend(a)
#define FILL(a, n) memset((a), n, sizeof(a))
#define FILLZ(a) FILL(a, 0)
#define INT(x) (static_cast<int>(x))
#define PRECISION(x) std::fixed << std::setprecision(x)

using namespace std;

using ll = long long;
using VI = std::vector<int>;
using VI2D = std::vector<vector<int>>;
using VLL = std::vector<long long>;
using VLL2D = std::vector<vector<long long>>;

constexpr int INF = 2e9;
constexpr double EPS = 1e-10;
constexpr double PI = acos(-1.0);

constexpr int dx[] = {-1, 0, 1, 0};
constexpr int dy[] = {0, -1, 0, 1};

template <typename T, std::size_t N>
struct make_vector_type {
	using type =
		typename std::vector<typename make_vector_type<T, (N - 1)>::type>;
};

template <typename T>
struct make_vector_type<T, 0> {
	using type = typename std::vector<T>;
};

template <typename T, size_t N>
auto make_vector_impl(const std::vector<std::size_t>& ls, T init_value) {
	if constexpr(N == 0) {
		return std::vector<T>(ls[N], init_value);
	} else {
		return typename make_vector_type<T, N>::type(
			ls[N], make_vector_impl<T, (N - 1)>(ls, init_value));
	}
}

template <typename T, std::size_t N>
auto make_vector(const std::size_t (&ls)[N], T init_value) {
	std::vector<std::size_t> dimensions(N);
	for(int i = 0; i < N; i++) {
		dimensions[N - i - 1] = ls[i];
	}
	return make_vector_impl<T, N - 1>(dimensions, init_value);
}

template <typename T>
std::vector<T> make_vector(std::size_t size, T init_value) {
	return std::vector<T>(size, init_value);
}

template <typename T>
constexpr int sign(T x) {
	return x < 0 ? -1 : x > 0 ? 1 : 0;
}

template <>
constexpr int sign(double x) {
	return x < -EPS ? -1 : x > EPS ? 1 : 0;
}

template <typename T, typename U>
constexpr void chmax(T& m, U x) {
	m = max<T>(m, x);
}

template <typename T, typename U>
constexpr void chmin(T& m, U x) {
	m = min<T>(m, x);
}

template <typename T>
constexpr T square(T x) {
	return x * x;
}

template <long long MOD = 1000000007>
class ModInt {
	public:
	long long n;

	constexpr ModInt() : n(0) {}
	constexpr ModInt(long long n) : n(n < 0 ? n + MOD : n % MOD) {}

	constexpr long long get() const { return this->n; }
	constexpr long long get_mod() const { return MOD; }

	constexpr ModInt inv() const { return pow<ModInt<MOD>>(*this, MOD - 2); }

	constexpr ModInt& operator=(const long long rhs) {
		return *this = ModInt(rhs);
	}
	constexpr ModInt& operator+=(const ModInt rhs) {
		return *this = ModInt(this->n + rhs.n);
	}
	constexpr ModInt& operator-=(const ModInt rhs) {
		return *this = ModInt(this->n - rhs.n);
	}
	constexpr ModInt& operator*=(const ModInt rhs) {
		return *this = ModInt(this->n * rhs.n);
	}
	constexpr ModInt& operator/=(const ModInt rhs) {
		return *this *= rhs.inv();
	}
	constexpr bool operator==(const ModInt rhs) const {
		return this->n == rhs.n;
	}
};

template <long long MOD>
constexpr ModInt<MOD> operator+(const ModInt<MOD>& lhs,
								const ModInt<MOD>& rhs) {
	return ModInt<MOD>(lhs) += rhs;
}
template <long long MOD>
constexpr ModInt<MOD> operator+(const ModInt<MOD>& lhs, const long long& rhs) {
	return ModInt<MOD>(lhs) += rhs;
}
template <long long MOD>
constexpr ModInt<MOD> operator+(const long long& lhs, const ModInt<MOD>& rhs) {
	return ModInt<MOD>(lhs) += rhs;
}

template <long long MOD>
constexpr ModInt<MOD> operator-(const ModInt<MOD>& lhs,
								const ModInt<MOD>& rhs) {
	return ModInt<MOD>(lhs) -= rhs;
}
template <long long MOD>
constexpr ModInt<MOD> operator-(const ModInt<MOD>& lhs, const long long& rhs) {
	return ModInt<MOD>(lhs) -= rhs;
}
template <long long MOD>
constexpr ModInt<MOD> operator-(const long long& lhs, const ModInt<MOD>& rhs) {
	return ModInt<MOD>(lhs) -= rhs;
}

template <long long MOD>
constexpr ModInt<MOD> operator*(const ModInt<MOD>& lhs,
								const ModInt<MOD>& rhs) {
	return ModInt<MOD>(lhs) *= rhs;
}
template <long long MOD>
constexpr ModInt<MOD> operator*(const ModInt<MOD>& lhs, const long long& rhs) {
	return ModInt<MOD>(lhs) *= rhs;
}
template <long long MOD>
constexpr ModInt<MOD> operator*(const long long& lhs, const ModInt<MOD>& rhs) {
	return ModInt<MOD>(lhs) *= rhs;
}

template <long long MOD>
constexpr ModInt<MOD> operator/(const ModInt<MOD>& lhs,
								const ModInt<MOD>& rhs) {
	return ModInt<MOD>(lhs) /= rhs;
}
template <long long MOD>
constexpr ModInt<MOD> operator/(const ModInt<MOD>& lhs, const long long& rhs) {
	return ModInt<MOD>(lhs) /= rhs;
}
template <long long MOD>
constexpr ModInt<MOD> operator/(const long long& lhs, const ModInt<MOD>& rhs) {
	return ModInt<MOD>(lhs) /= rhs;
}

template <long long MOD>
std::ostream& operator<<(std::ostream& os, const ModInt<MOD>& x) {
	return os << x.n;
}

template <long long MOD>
std::istream& operator>>(std::istream& is, const ModInt<MOD>& x) {
	return is >> x.n;
}

// 計算量 前処理:O(n) クエリ:O(1)
template <long long MOD = 1000000007, long long COMB_MAX = 1000000>
class mod_comb {
	std::array<ModInt<MOD>, COMB_MAX> fact;
	std::array<ModInt<MOD>, COMB_MAX> fact_inv;
	std::array<ModInt<MOD>, COMB_MAX> inv;

	public:
	constexpr mod_comb() : fact{}, fact_inv{}, inv{} {}

	constexpr int init() {
		this->fact[0] = this->fact[1] = 1;
		this->fact_inv[0] = this->fact_inv[1] = 1;
		this->inv[1] = 1;

		for(int i = 2; i < COMB_MAX; i++) {
			this->fact[i] = this->fact[i - 1] * i;
			this->inv[i] = MOD - (this->inv[MOD % i] * (MOD / i));
			this->fact_inv[i] = this->fact_inv[i - 1] * this->inv[i];
		}
		return 0;
	}

	constexpr ModInt<MOD> operator()(long long n, long long r) {
		if(n < r || n < 0 || r < 0) {
			return ModInt<MOD>(0);
		}

		if(this->fact[0] == 0) {
			this->init();
		}
		return fact[n] * fact_inv[r] * fact_inv[n - r];
	}
};

// 高速素因数分解
class Factor {
	std::vector<int> divisors;

	public:
	Factor(int n) : divisors(n, 0) {
		std::iota(this->divisors.begin(), this->divisors.end(), 0);
		for(int i = 2; i * i < n; i++) {
			if(this->divisors[i] != i) {
				continue;
			}
			this->divisors[i] = i;
			for(int j = i * i; j < n; j += i) {
				if(this->divisors[j] == j) {
					this->divisors[j] = i;
				}
			}
		}
	}

	std::unordered_map<int, size_t> operator()(int n) {
		std::unordered_map<int, size_t> factors;
		while(n != 1) {
			int divisor = this->divisors[n];
			while(n % divisor == 0) {
				factors[divisor]++;
				n /= divisor;
			}
		}
		return factors;
	}
};

// 約数列挙
template <typename T>
std::vector<T> divisor(T n) {
	std::vector<T> divisors;
	for(T i = 1; i * i <= n; i++) {
		if(n % i != 0) {
			continue;
		}
		divisors.push_back(i);
		if(i * i != n) {
			divisors.push_back(n / i);
		}
	}
	return divisors;
}

auto comb = mod_comb();

void merge_unordered_map(unordered_map<int, size_t>& m1,
						 const unordered_map<int, size_t>& m2) {
	EACH(e, m2) { m1[e.first] += e.second; }
}

ModInt<> divisors_num(const unordered_map<int, size_t>& m) {
	ModInt ret = 1;
	EACH(e, m) { ret *= e.second + 1; }
	return ret;
}

int main() {
	int n;
	cin >> n;

	auto factor = Factor(n + 1);
	unordered_map<int, size_t> result;
	RANGE(i, 2, n + 1) {
		auto factors = factor(i);
		merge_unordered_map(result, factors);
	}

	cout << divisors_num(result) << endl;
	return 0;
}


Measured memory_bytes: 3616