stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#include<bits/stdc++.h>



using namespace std;



const int maxn = 1e5 +  5;



int a[maxn];



int main()

{

   int n;

   cin >> n;

   int ans = 0;

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

   {

       cin >> a[i];

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

   }

   ans += abs(a[n]);

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

   {

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

   }

   return 0;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cctype>



int n, a[100010], tot;



int read() {

    int ret, fl = 1;

    char ch;

    while(!isdigit(ch = getchar()))

        (ch == '-') && (fl = -1);

    ret = ch - '0';

    while(isdigit(ch = getchar()))

        ret *= 10, ret += ch - '0';

    return ret * fl;

}



void print(int x) {

    if(x < 0) putchar('-'), x = -x;

    if(x > 9) print(x / 10);

    putchar(x % 10 + '0');

}



int abs(int x) {

    return x > 0 ? x : -x;

}



int main() {

    n = read();

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

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

    tot += abs(a[n]);

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

        int ans;

        if(a[i] > a[i - 1]) {

            if(a[i + 1] > a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i + 1] * 2 - a[i] * 2;

                else ans = tot + a[i - 1] * 2 - a[i] * 2;

            }

        }

        else {

            if(a[i + 1] < a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i] * 2 - a[i - 1] * 2;

                else ans = tot + a[i] * 2 - a[i + 1] * 2;

            }

        }

        print(ans), putchar('\n');

    }

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

using namespace std;

typedef long long ll;

ll num[100005];

int main(){

	ll N,t=0;

	cin>>N;

	ll sum=0;

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

		cin>>num[i];

		sum=sum+abs(num[i]-t);

		t=num[i];

	}

	//下面开始丢弃数据

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

		int ans=sum;

		if(i!=0||i!=N-1){

			ans=ans-abs(num[i]-num[i-1])-abs(num[i+1]-num[i])+abs(num[i+1]-num[i-1])+abs(num[N-1]-0);

		}else if(i==0){

			ans=ans-abs(num[i]-0)-abs(num[i+1]-num[i])+abs(num[i+1]-0)+abs(num[N-1]-0);

		}else{

			ans=ans-abs(num[i]-num[i-1])+abs(num[i-1]-0);

		}

		cout<<ans<<endl;

	} 

	return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cctype>



int n, a[100010], tot;



int read() {

    int ret, fl = 1;

    char ch;

    while(!isdigit(ch = getchar()))

        (ch == '-') && (fl = -1);

    ret = ch - '0';

    while(isdigit(ch = getchar()))

        ret *= 10, ret += ch - '0';

    return ret * fl;

}



void print(int x) {

    if(x < 0) putchar('-'), x = -x;

    if(x > 9) print(x / 10);

    putchar(x % 10 + '0');

}



int abs(int x) {

    return x > 0 ? x : -x;

}



int main() {

    n = read();

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

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

    tot += abs(a[n]);

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

        int ans;

        if(a[i] > a[i - 1]) {

            if(a[i + 1] > a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i + 1] * 2 - a[i] * 2;

                else ans = tot + a[i - 1] * 2 - a[i] * 2;

            }

        }

        else {

            if(a[i + 1] < a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i] * 2 - a[i - 1] * 2;

                else ans = tot + a[i] * 2 - a[i + 1] * 2;

            }

        }

        print(ans), putchar('\n');

    }

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<iostream>

#include<fstream>

#include<cstdio>

#include<iomanip>

#include<algorithm>

#include<vector>

#include<set>

#include<list>

#include<queue>

#include<deque>

#include<unordered_map>

#include<map>

#include<string>

#include<cstring>

#include<stack>

#include<cmath>

#include<utility>



#define vint vector<int>

#define vstr vector<string>

#define vll vector<long long>

#define ll long long

#define pf printf

#define sf scanf

#define sfd(n) scanf("%d", &n)

#define sflf(n) scanf("%lf", &n)

#define sfll(n) scanf("%lld", &n)

#define pfd(n) printf("%d", n)

#define pflf(n) printf("%lf", n)

#define pfll(n) printf("%lld", n)

#define pft	printf("\t")

#define pfn printf("\n")

#define pfk printf(" ")

#define PI 3.1415926

#define MAX 100000

#define M 1e9



using namespace std;



int main() {

	int n;

	sfd(n);

	int* num = new int[n+2];

	vector<int> travel;

	num[0] = 0;

	int sum = 0, m;

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

		sfd(num[i]);

		m = abs(num[i]-num[i-1]);

		travel.push_back(m);

		sum += m;

	}

	num[n+1] = 0;

	sum += abs(num[n]);

	travel.push_back(abs(num[n]));

//	cout << "len = " << travel.size() << endl;

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

		pfd(sum-travel[i]-travel[i+1]+abs(num[i+2]-num[i]));

		pfn;

	}

	

	return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cctype>



int n, a[100010], tot;



int read() {

    int ret, fl = 1;

    char ch;

    while(!isdigit(ch = getchar()))

        (ch == '-') && (fl = -1);

    ret = ch - '0';

    while(isdigit(ch = getchar()))

        ret *= 10, ret += ch - '0';

    return ret * fl;

}



void print(int x) {

    if(x < 0) putchar('-'), x = -x;

    if(x > 9) print(x / 10);

    putchar(x % 10 + '0');

}



int abs(int x) {

    return x > 0 ? x : -x;

}



int main() {

    n = read();

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

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

    tot += abs(a[n]);

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

        int ans;

        if(a[i] > a[i - 1]) {

            if(a[i + 1] > a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i + 1] * 2 - a[i] * 2;

                else ans = tot + a[i - 1] * 2 - a[i] * 2;

            }

        }

        else {

            if(a[i + 1] < a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i] * 2 - a[i - 1] * 2;

                else ans = tot + a[i] * 2 - a[i + 1] * 2;

            }

        }

        print(ans), putchar('\n');

    }

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include <iostream>

#include <cmath>

#include <stdio.h>

#include <algorithm>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <stack>

#include <map>

#include <set>

#include <cstring>



using namespace std;



#define f first

#define s second

#define pb push_back

#define mp make_pair

#define ll long long

#define pii pair < int, int >

#define pll pair < long long, long long>

#define ull unsigned long long

#define vi vector < int >

#define vll vector < long long >

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

#define forit(it, s) for(__typeof(s.begin()) it = s.begin(); it != s.end(); it++)

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

#define sqr(x) ((x) * (x))

#define fname "searching"



const int inf = (int)1e9;

const ll INF = (ll)1e18;

const double eps = 1e-9;

const double pi = acos(-1.0);

const int mod = (int)1e9 + 7;



int n;

vll v;

ll sum[100100];



void solve(){

    cin >> n;

    v.pb(0);

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

        ll x;

        cin >> x;

        sum[i + 1] = sum[i] + abs(x - v.back());

        v.pb(x);

    }

    //for(int i = 0; i < n + 1; ++i) cout << sum[i] << " ";



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

        int cur = sum[i - 1] + abs(v[i + 1] - v[i - 1]) + sum[n] - sum[i + 1] + abs(v[n]);

        cout << cur << "\n";

    }

    cout << sum[n - 1] + abs(v[n - 1]) << "\n";

}



int main(){

    ios_base::sync_with_stdio(0);

    cin.tie(0);



    solve();

    

    return 0;

}

// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cctype>



int n, a[100010], tot;



int read() {

    int ret, fl = 1;

    char ch;

    while(!isdigit(ch = getchar()))

        (ch == '-') && (fl = -1);

    ret = ch - '0';

    while(isdigit(ch = getchar()))

        ret *= 10, ret += ch - '0';

    return ret * fl;

}



void print(int x) {

    if(x < 0) putchar('-'), x = -x;

    if(x > 9) print(x / 10);

    putchar(x % 10 + '0');

}



int abs(int x) {

    return x > 0 ? x : -x;

}



int main() {

    n = read();

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

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

    tot += abs(a[n]);

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

        int ans;

        if(a[i] > a[i - 1]) {

            if(a[i + 1] > a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i + 1] * 2 - a[i] * 2;

                else ans = tot + a[i - 1] * 2 - a[i] * 2;

            }

        }

        else {

            if(a[i + 1] < a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i] * 2 - a[i - 1] * 2;

                else ans = tot + a[i] * 2 - a[i + 1] * 2;

            }

        }

        print(ans), putchar('\n');

    }

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#include<bits/stdc++.h>

typedef long long ll;

#define dbg          cout<<"Freak"<<endl;

#define dbgg(i)      cout<<i<<endl;

#define N            1e9+7;

#define pb           push_back

using namespace std;

ll t;

ll arr[300005];

vector<ll>v;



int main()

{

    ll a,b,c,d,e,f,g,i,j;

    cin>>t;

    v.pb(0);

    f=0;

    for(i=0;i<t;i++)

    {

        cin>>a;

        v.push_back(a);

        b=abs(a-v[i]);

        f+=b;

    }

    v.pb(0);

    b=abs(0-v[t]);

    f+=b;

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

    {

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

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

        g=f-b-c;

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

        cout<<g<<endl;

    }

    return 0;

}


// Optimized solution to the same problem (faster):
#include <cstdio>

#include <cctype>



int n, a[100010], tot;



int read() {

    int ret, fl = 1;

    char ch;

    while(!isdigit(ch = getchar()))

        (ch == '-') && (fl = -1);

    ret = ch - '0';

    while(isdigit(ch = getchar()))

        ret *= 10, ret += ch - '0';

    return ret * fl;

}



void print(int x) {

    if(x < 0) putchar('-'), x = -x;

    if(x > 9) print(x / 10);

    putchar(x % 10 + '0');

}



int abs(int x) {

    return x > 0 ? x : -x;

}



int main() {

    n = read();

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

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

    tot += abs(a[n]);

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

        int ans;

        if(a[i] > a[i - 1]) {

            if(a[i + 1] > a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i + 1] * 2 - a[i] * 2;

                else ans = tot + a[i - 1] * 2 - a[i] * 2;

            }

        }

        else {

            if(a[i + 1] < a[i]) ans = tot;

            else {

                if(a[i + 1] > a[i - 1]) ans = tot + a[i] * 2 - a[i - 1] * 2;

                else ans = tot + a[i] * 2 - a[i + 1] * 2;

            }

        }

        print(ans), putchar('\n');

    }

    return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

  }



}

// Optimized solution to the same problem (faster):
#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;

  }

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

    }

}


// Optimized solution to the same problem (faster):
#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]));

	}

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}


// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#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;

} 

// Fastest known solution for this problem: