stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<iostream>

#include<stdio.h>

#include<cstring>

#include<cmath>

#include<algorithm>

#include<vector>

#include<map>

#include<set>

#include<queue>

#define ll long long

using namespace std;

int pos(int n)

{

    if(n<0)

        return 0;

    else

        return n;

}

int main()

{

    int a[100002][2]= {0};

    int n;

    cin>>n;

    ll sum=0;

    for(int i=1; i<=n; i++)

    {

        scanf("%d",&a[i][0]);

 

        sum+=abs(a[i-1][0]-a[i][0]);

    }

    sum+=abs(a[n][0]);

    for(int i=1; i<=n; i++)

    {

 

            cout<<sum-abs(a[i][0]-a[i+1][0])-abs(a[i][0]-a[i-1][0])+abs(a[i-1][0]-a[i+1][0])<<endl;

 

  

    }

}

// Faster C++ solution for the same problem (measured speedup: 1.7667093645637952x):
////////////////////////// Author

////////////////////////// Nasim Hossain Rabbi

////////////////////////// JU-CSE28

////////////////////////// CF - imnasim3.1415

////////////////////////// UVA - imnasim3.1415

////////////////////////// Mail - imnasim3.1415@gmail.com

#include<bits/stdc++.h>

using namespace std;

#define sz size()

#define mk make_pair

#define clr clear()

#define B begin()

#define E end()

#define EM empty()

#define mem(a,b) memset(a,b,sizeof(a))

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

#define Rep(i,n) for(i=1;i<=n;i++)

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

#define pb push_back

string en="\n";

string t="hello";

#define sqr(a) ((a) * (a))

#define fast ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL)

#define pi 3.1415926535897932384626433832795

#define vi vector<int>

#define vl vector<long long>

#define vs vector<string>

#define vp(vi,x) cin>>x; vi.pb(x);

#define LB(a,x) (lower_bound(aov(a),x)-a.begin())

#define UB(a,x) (upper_bound(aov(a),x)-a.begin())

typedef long long LL;

typedef unsigned long long ULL;

bool isVowel(char ch){ ch=toupper(ch); if(ch=='A'||ch=='U'||ch=='I'||ch=='O'||ch=='E') return true; return false;}

int toInt(string s){int sm;stringstream ss(s);ss>>sm;return sm;}

template<typename T>inline T gcd(T a,T b){if(a<0)return gcd(-a,b);if(b<0)return gcd(a,-b);return (b==0)?a:gcd(b,a%b);}

template<typename T>inline T lcm(T a,T b) {if(a<0)return lcm(-a,b);if(b<0)return lcm(a,-b);return a*(b/gcd(a,b));}

int main()

{

//    fast;

    LL i,j,k,n,m,l,s=0,x,y,tc=1,c=0;

    while(cin>>n)

    {

        vi a,aa;

        l=0,s=0;

        a.pb(0);

        rep(i,n)

        {

            cin>>x;

            a.pb(x);

            l=abs(l-x);

            s+=l;

            l=x;

        }

        a.pb(0);

        l=abs(l-0);

        s+=l;

//        rep(i+1,n)

        for(i=1;i<n+1;i++)

        {

            x=s-(abs(a[i]-a[i-1])+abs(a[i+1]-a[i]));

            x+=abs(a[i+1]-a[i-1]);

            cout<<x<<en;

        }

    }

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int main() {

  int N;

  int a[100000] = {};



  cin >> N;

  for(int i = 1; i <= N; i++){

    cin >> a[i];

  }



  int s = 0;

  for(int i = 0; i <= N; i++){

    s += abs(a[i] - a[i+1]);

  }



  int ans = 0;

  for(int i = 1;i <=N; i++){

    ans = s - abs(a[i-1] - a[i]) - abs(a[i] - a[i+1]) + abs(a[i-1] - a[i+1]);

    cout << ans << endl;

  }



}

// Faster C++ solution for the same problem (measured speedup: 1.3893315099054917x):
#include <bits/stdc++.h>

#define dum(x) cout<<#x<<'='<<x<<endl

#define ll long long

using namespace std;



int main() {

  int n;

  cin >> n;

  vector<int> v(n);

  for (int i = 0; i < n; i++) {

    cin >> v.at(i);

  }

  v.insert(v.begin(), 0);

  v.push_back(0);

  int d = 0;

  for (int i = 0; i < v.size() - 1; i++) {

    d += abs(v.at(i) - v.at(i + 1));

  }

  int ans = 0;

  for (int i = 1; i < v.size() - 1; i++) {

    ans = d - abs(v.at(i - 1) - v.at(i)) - abs(v.at(i) - v.at(i + 1)) + abs(v.at(i - 1) - v.at(i + 1));

    cout << ans << endl;

  }

}
// Slower C++ solution:
#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n,m,a[100004]= {0},ans[100002]= {0};

    cin>>n;

    int sum=0;

    for(int i=1; i<=n; i++)

    {

        cin>>a[i];

        sum+=abs(a[i]-a[i-1]);

    }

    sum+=abs(a[n]-0);

    for(int i=1; i<=n; i++)

    {

        int tp=sum;

        if(a[i]>a[i-1]&&a[i]>a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        if(a[i]<a[i-1]&&a[i]<a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        cout<<tp<<endl;

    }

}


// Faster C++ solution for the same problem (measured speedup: 1.4032244286061255x):
# include <bits/stdc++.h>

 

using namespace std;



int main() {

	int n;

	cin >> n;

	vector < int > a(n + 2);

	long long total = 0;

	for ( int i = 1; i <= n; i++ ) {

		cin >> a[i];

	}

	for ( int i = 1; i <= n + 1; i++ ) {

		total += abs( a[i - 1] - a[i] );

	}

	for ( int i = 1; i <= n; i++ ) {

		long long t = total;

		t -= abs( a[i - 1] - a[i] );

		t -= abs( a[i + 1] - a[i] );

		t += abs( a[i - 1] - a[i + 1] );

		cout << t << '\n';

	}

}
// Slower C++ solution:
#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n,m,a[100004]= {0},ans[100002]= {0};

    cin>>n;

    int sum=0;

    for(int i=1; i<=n; i++)

    {

        cin>>a[i];

        sum+=abs(a[i]-a[i-1]);

    }

    sum+=abs(a[n]-0);

    for(int i=1; i<=n; i++)

    {

        int tp=sum;

        if(a[i]>a[i-1]&&a[i]>a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        if(a[i]<a[i-1]&&a[i]<a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        cout<<tp<<endl;

    }

}


// Faster C++ solution for the same problem (measured speedup: 1.387010634666546x):
#include<bits/stdc++.h>

#define ll long long

using namespace std;



long long a,b,n;

string ss;

int main(){

    cin>>n;

    vector<int>v(n+2,0);

    for (int i=1; i<=n; i++){

        cin>>v[i];

        b+=abs(v[i]-v[i-1]);

    }

    b+=abs(v[n]);

    for (int i=1; i<=n; i++){

        cout<<b-abs(v[i]-v[i-1])-abs(v[i]-v[i+1])+abs(v[i-1]-v[i+1])<<endl;

    }

}
// Slower C++ solution:
#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n,m,a[100004]= {0},ans[100002]= {0};

    cin>>n;

    int sum=0;

    for(int i=1; i<=n; i++)

    {

        cin>>a[i];

        sum+=abs(a[i]-a[i-1]);

    }

    sum+=abs(a[n]-0);

    for(int i=1; i<=n; i++)

    {

        int tp=sum;

        if(a[i]>a[i-1]&&a[i]>a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        if(a[i]<a[i-1]&&a[i]<a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        cout<<tp<<endl;

    }

}


// Faster C++ solution for the same problem (measured speedup: 1.4220121401961805x):
#include<iostream>

#include<string.h>

#include<algorithm>

#include<stdio.h>

#include<math.h>

#include<vector>

#include<map>

#include<set>

#include<time.h> 

#define debug(a) cout << "*" << a << "*" << endl

#define ls	(k << 1)

#define rs	((k << 1) | 1)

#define mid	((l + r) >> 1)

using namespace std;

typedef long long ll;

ll a[100005], n, sum;

int main()

{

	scanf("%lld", &n);

	for (int i = 1; i <= n; i++)	

	{

		scanf("%lld", a + i);

		sum += abs(a[i] - a[i - 1]);

	}

	sum += abs(a[n]);

	for (int i = 1; i <= n; i++)

	{

		printf("%lld\n", sum + abs(a[i - 1] - a[i + 1]) - abs(a[i - 1] - a[i]) - abs(a[i] - a[i + 1]));

	}

}
// Slower C++ solution:
#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n,m,a[100004]= {0},ans[100002]= {0};

    cin>>n;

    int sum=0;

    for(int i=1; i<=n; i++)

    {

        cin>>a[i];

        sum+=abs(a[i]-a[i-1]);

    }

    sum+=abs(a[n]-0);

    for(int i=1; i<=n; i++)

    {

        int tp=sum;

        if(a[i]>a[i-1]&&a[i]>a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        if(a[i]<a[i-1]&&a[i]<a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        cout<<tp<<endl;

    }

}


// Faster C++ solution for the same problem (measured speedup: 1.4016654703523188x):
#include<iostream>

#include<math.h>

using namespace std;

const int N=1e5+10;

long long a[N],sum[N];

// 0~tmp-1 tmp+1-n 

int main()

{

	int n;cin>>n;

	for(int i=1;i<=n;i++)

	{

		cin>>a[i];

	}

	for(int i=0;i<=n+1;i++)

	{

		sum[i]=sum[i-1]+abs(a[i]-a[i-1]);

		//cout<<i<<" "<<sum[i]<<endl;

	}

	int tmp=1;

	while(tmp<=n)

	{

		//cout<<tmp<<" "<<sum[n+1]-sum[tmp+1]<<" "<<sum[tmp-1]-sum[0]<<" "<<abs(a[tmp+1]-a[tmp-1])<<endl;

		cout<<sum[n+1]-sum[tmp+1]+sum[tmp-1]-sum[0]+abs(a[tmp+1]-a[tmp-1])<<endl;

		//cout<<endl;

		tmp++;

	}

}
// Slower C++ solution:
#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{

    int n,m,a[100004]= {0},ans[100002]= {0};

    cin>>n;

    int sum=0;

    for(int i=1; i<=n; i++)

    {

        cin>>a[i];

        sum+=abs(a[i]-a[i-1]);

    }

    sum+=abs(a[n]-0);

    for(int i=1; i<=n; i++)

    {

        int tp=sum;

        if(a[i]>a[i-1]&&a[i]>a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        if(a[i]<a[i-1]&&a[i]<a[i+1])

        {

            tp=sum-abs(a[i]-a[i-1])-abs(a[i+1]-a[i])+abs(a[i+1]-a[i-1]);

        }

        cout<<tp<<endl;

    }

}


// Faster C++ solution for the same problem (measured speedup: 1.3910002714812666x):
#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>



using namespace __gnu_pbds;  

using namespace std;



typedef long long ll;



typedef tree<

pair <int, int>,

null_type,

less<pair <int, int>>,

rb_tree_tag,

tree_order_statistics_node_update>

os;



double getTime() {

  return clock() / (double) CLOCKS_PER_SEC;

}



void read() {};



template<typename T, typename... Args>

void read(T& a, Args&... args) {

  cin >> a;

  read(args...);

}



void print() {};



template <typename T, typename... Args>

void print(T a, Args... args) {

  cout << a << " \n"[sizeof...(args) == 0];

  print(args...);

}



const int N = 55;



int g[N][N];

int dp[N][N][2];

int n, m;



int get(int x, int y) {

  return x == 0 and y == 1;

}



int go(int x, int y, int last) {

  if(x == n - 1 and y == m - 1) {

    return get(last, g[x][y]);

  }

  if(dp[x][y][last] != -1) return dp[x][y][last];

  int gettis = get(last, g[x][y]);

  int cur = 1e9;

  if(x + 1 < n) cur = min(cur, gettis + go(x + 1, y, g[x][y]));

  if(y + 1 < m) cur = min(cur, gettis + go(x, y + 1, g[x][y]));

  return dp[x][y][last] = cur;

}



int main() {

  int n; cin >> n;

  vector <int> a(n + 2);

  a[0] = 0, a[n + 1] = 0;

  int tot = 0;

  for(int i = 1; i <= n; i++) {

    cin >> a[i];

  }

  for(int i = 0; i < n + 1; i++) {

    tot += abs(a[i] - a[i + 1]);

  }

  for(int i = 1; i <= n; i++) {

    int l = i - 1, r = i + 1;

    int cur = tot;

    cur -= (abs(a[l] - a[i]) + abs(a[r] - a[i]));

    cur += abs(a[l] - a[r]);

    print(cur);

  }

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;



ll prime[1005];

bool is_prime[1005];

ll mod=1000000000+7;

ll sieve(ll n){

	ll p=0;

	for(ll i=0;i<=n;i++) is_prime[i]=true;

	is_prime[0]=is_prime[1]=false;

	for(ll i=2;i<=n;i++){

		if(is_prime[i]){

			prime[p++]=i;

			for(ll j=2*i;j<=n;j+=i) is_prime[j]=false;

		}

	}

	return p;

}

ll a[1005];



int main()

{

	ll n;

	

	

	scanf("%lld",&n);

	ll p=sieve(n);

	memset(a,0,sizeof(a));

	//2for(ll i=0;i<p;i++){

	//	printf("%lld ",prime[i]);

	//}

	//printf("\n");

	for(ll i=1;i<=n;i++){

		ll k=i;

		while(1){

			if(k==1) break;

			for(ll j=0;j<p;j++){

				if(k%prime[j]==0){

					a[prime[j]]++;

					k/=prime[j];

				

				}

			}

		}

		

	}

	//for(ll i=1;i<=n;i++){

	//	printf("%lld ",a[i]);

	//}

	//printf("====\n");

	ll res=1;

	

	for(ll i=1;i<=n;i++){

		res*=a[i]+1;

		res%=mod;

		//res=res%mod*(a[i]+1)%mod;

	}

	printf("%lld\n",res);

	

	

	

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.2415652475538845x):
#include <cstdio>

typedef long long LL;



const int mod = 1e9 + 7;

LL p[1010];



void getp(int x) {

	for(int i = 2; i * i <= x; ++i) {

		if(x % i == 0) {

			while(x % i == 0) {

				p[i]++;

				x /= i;

			}

		}

	}

	if(x > 1) p[x]++;

}



int main() {

	int n;

	scanf("%d", &n);

	for(int i = 2; i <= n; ++i) {

		getp(i);

	}

	LL sum = 1;

	for(int i = 1; i <= n; ++i) {

		sum = (sum * (p[i] + 1)) % mod;

	}

	printf("%lld\n", sum);

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

//---------------------------

using namespace std;

//---------------------------

#define REP(i,n) for(int i = 0; i < (n); i++)

#define P(x) cout << (x) << "\n"



#define MOD 1000000007 // 1e9+7

#define PI 3.1415926525

#define ll long long int // 10^18

#define INF 1000000001 // 1e9+1



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

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

//---------------------------

ll cnt[1001];

int main(){

  std::ios::sync_with_stdio(false);

  std::cin.tie(0);



  // ifstream in("input.txt");

  // cin.rdbuf(in.rdbuf());



  int n;cin>>n;

  REP(i,1001)cnt[i]=1;

  for(int i=1;i<=n;i++){

    int f=i;

    for(int j=2;j<=1000;j++){

      while(f%j==0){

        f=f/j;

        cnt[j]++;

      }

    }

  }

  ll ans=1;

  // REP(i,1000)P(cnt[i]);

  REP(i,1000){

    ans*=cnt[i];

    ans%=MOD;

  }

  P(ans);

  return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.3312874823871275x):
#include <bits/stdc++.h>

//---------------------------

using namespace std;

//---------------------------

#define REP(i,n) for(int i = 0; i < (n); i++)

#define P(x) cout << (x) << "\n"



#define MOD 1000000007 // 1e9+7

#define PI 3.1415926525

#define ll long long int // 10^18

#define INF 1000000001 // 1e9+1



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

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

//---------------------------

ll MAX_N=1000;



typedef tuple<long long, long long> Pair;

Pair factor_sub(long long n, long long m){

  long long i=0;

  while(n%m==0){

    i++;

    n/=m;

  }

  return make_tuple(i,n);

}



vector<Pair> factorization(long long n){

  vector<Pair> a;

  long long c,m;

  tie(c, m) = factor_sub(n, 2);

  if(c>0)a.push_back(make_tuple(2, c));

  for(long long i=3;i*i<=m;i+=2){

    tie(c,m)=factor_sub(m, i);

    if(c>0)a.push_back(make_tuple(i,c));

  }

  if(m>1)a.push_back(make_tuple(m,1));

  return a;

}



long long divisor_numbers(long long n){

  long long a=1;

  for(auto& x: factorization(n)){

    a*=get<1>(x)+1;

  }

  return a;

}

ll factor_memo[1001];

int main(){

  std::ios::sync_with_stdio(false);

  std::cin.tie(0);



  // ifstream in("input.txt");

  // cin.rdbuf(in.rdbuf());



  int n;cin>>n;

  for(int i=1;i<=n;i++){

    ll fcs=i;

    for(auto& x:factorization(fcs)){

      factor_memo[get<0>(x)]+=get<1>(x);

    }

  }

  ll psum=1;

  for(int i=0;i<1001;i++){

    psum*=factor_memo[i]+1;

    psum%=MOD;

  }

  P(psum);

  return 0;

}
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<algorithm>

#include<cmath>

#include<string>

#include<cstring>

#include<vector>

#include<map>

#include<list>

#include<stack>

#include<queue>

#include<climits> //INT_MIN/MAX

using namespace std;



#define FOR(i,s,e) for(ll (i)=(s);(i)<(e);(i)++)

#define FORR(i,s,e) for(ll (i)=(s);(i)>(e);(i)--)

#define MOD 1000000007

#define debug(x) cout<<#x<<": "<<x<<endl

typedef long long ll;



/* 2017/01/18 問題 -----  abc052 c /Link ----- */

/* -----解説等-----

問題:



1000!がでかすぎる。



*/

 

ll N;



int main()

{

    cin.tie(0);

    ios_base::sync_with_stdio(false);



    cin >> N;



    //prime

    vector<int>primes;

    primes.push_back(2);

    for (int i = 3; i < 1001; i += 2) {

        int flag = 0;

        FOR(j, 2, i) {

            if (i%j==0) {

                flag = 1;

                break;

            }

        }

        if (flag == 0) {

            primes.push_back(i);

        }

    }





    ll ans = 1;



    FOR(i, 0, primes.size()) {

        int p = primes[i];

        int cnt = 0;

        while (p <= N) {

            cnt += N / p; //2,4,8,16,....

            p = p*primes[i];

        }

        ans = (ans*(cnt + 1)) % MOD;

    }





    cout << ans << endl;



    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.3974478376881172x):
#include <bits/stdc++.h>

using namespace std;



using VS = vector<string>;    using LL = long long;

using VI = vector<int>;       using VVI = vector<VI>;

using PII = pair<int, int>;   using PLL = pair<LL, LL>;

using VL = vector<LL>;        using VVL = vector<VL>;



#define ALL(a)  begin((a)),end((a))

#define RALL(a) (a).rbegin(), (a).rend()

#define PB push_back

#define EB emplace_back

#define MP make_pair

#define SZ(a) int((a).size())

#define SORT(c) sort(ALL((c)))

#define RSORT(c) sort(RALL((c)))

#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)

#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)

#define debug(x) cerr << #x << ": " << x << endl

const int INF = 1e9;                          const LL LINF = 1e16;

const LL MOD = 1000000007;                    const double PI = acos(-1.0);

int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 };    int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };



/* -----  2018/02/14  Problem: 067_arc_a / Link: https://abc052.contest.atcoder.jp/tasks/arc067_a?lang=en  ----- */

/* ------問題------







-----問題ここまで----- */

/* -----解説等-----







----解説ここまで---- */





void dividenum(int n, VI&a) {

	for (int i = 2; i*i <= n; i++) {

		while (n%i == 0) {

			n /= i;

			a[i]++;

		}

	}

	if (n > 1)a[n]++;

}

LL N;



LL ans = 0LL;



int main() {

	cin.tie(0);

	ios_base::sync_with_stdio(false);



	cin >> N;

	ans = 1;

	VI a(1001,0);

	FOR(i, 2, N + 1) {

		dividenum(i, a);

	}

	FOR(i, 2, N + 1) {

		if (a[i])

			ans *= (a[i] + 1);

		ans %= MOD;

	}

	cout << ans << "\n";



	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h> 

using namespace std;

 

int INF = 0x3f3f3f3f;

const int mod = 1000000007;

 

 

 

int main(){

	int prime[1005];

	long long int i,j;

	for(i=1;i<=1000;i++){

		prime[i]=1;

	}

	prime[1]=0;

	prime[2]=1;

	for(i=2;i<=1000;i++){

		if(prime[i]==1){

			for(j=2;j*i<=1000;j++){

				prime[j*i]=0;

			}

		}

	}

	long long int n;

	cin>>n;

	int num[1005];

	long long int namae;

	memset(num,0,sizeof(num));

	for(i=2;i<=n;i++){

		if(prime[i]==1){

			num[i]+=1;

		}else{

			for(j=2;j<=i;j++){

				namae = i;

				while(prime[j]==1 && namae%j==0){

					num[j]+=1;

					namae=namae/j;

				}

			}

		}

	}

	long long int ans=1;

	for(i=1;i<=n;i++){

		ans *= (num[i]+1);

		ans = ans%mod;

	}

	cout<<ans<<endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.796708939122459x):
#include<cstdio>

#include<cstring>

#include<algorithm>

typedef long long LL;

const LL mod=1e9+7;

const int N=1006;

using namespace std;

LL f[N];



LL fun(int n)

{

	LL ans=1;

	memset(f,0,sizeof(f));

	for(int i=2;i<=n;i++)

	{

		int k=i;

		for(int j=2;j<=k;j++)

		{

			while(k%j==0)

			{

				f[j]++;

				k/=j;

			}

		}

		if(k)

			f[k]++;

	}

	for(int i=2;i<=n;i++)

	{

		if(f[i])

			ans=ans*(f[i]+1)%mod;

	}

	return ans%mod;

}

int main()

{

	int n;

	while(~scanf("%d",&n))

	{

		printf("%lld\n",fun(n));

	}

	return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll INF= 1LL << 60;

#define REP(i,n) for(ll i=0; i<n; i++)

#define FOR(i,a,n) for(ll i=a; i<n; i++)

#define tl 1'000'000'007

int mmax=10000;

void erasuru(vector<ll> &A){

    A[0] = 0; // 0は素数ではない

    A[1] = 0; // 1は素数ではない

    

    for(size_t i=2; i*i<=mmax; ++i) // 0からsqrt(max)まで調べる

        if(A[i]) // iが素数ならば

            for(size_t j=2; i*j<=mmax; ++j) // (max以下の)iの倍数は

                A[i*j] = 0;      // 素数ではない

}

int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    ll n;

    cin >> n;

    

    vector<ll>A(mmax,1);

    erasuru(A);

    ll ans= 1;

    

    REP(i,mmax){

        if(A[i]){

            ll cc= 0;

            ll x;

            for(ll j=2; j<=n; j++){ 

                x= j;

                while(x%i==0){

                    cc++;

                    x/=i;

                }

            }

            // cout << cc << endl;

            ans*= cc+1;

            ans%= tl;

        }

    }

    cout << ans << endl;



}

// Faster C++ solution for the same problem (measured speedup: 1.5497988415679262x):
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll INF= 1LL << 60;

#define REP(i,n) for(ll i=0; i<n; i++)

#define FOR(i,a,n) for(ll i=a; i<n; i++)

#define tl 1'000'000'007

int mmax;

void erasuru(vector<ll> &A){

    A[0] = 0; // 0は素数ではない

    A[1] = 0; // 1は素数ではない

    

    for(size_t i=2; i*i<=mmax; ++i) // 0からsqrt(max)まで調べる

        if(A[i]) // iが素数ならば

            for(size_t j=2; i*j<=mmax; ++j) // (max以下の)iの倍数は

                A[i*j] = 0;      // 素数ではない

}

int main(){

    cin.tie(0);

    ios::sync_with_stdio(false);

    ll n;

    cin >> n;

    mmax= n;

    vector<ll>A(n+1,1);

    erasuru(A);

    ll ans= 1;

    

    REP(i,n+1){

        if(A[i]){

            ll cc= 0;

            ll x;

            for(ll j=2; j<=n; j++){ 

                x= j;

                while(x%i==0){

                    cc++;

                    x/=i;

                }

            }

            // cout << cc << endl;

            ans*= cc+1;

            ans%= tl;

        }

    }

    cout << ans << endl;



}