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

using namespace std;



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

#define fr(i,n) for(auto i=n-1;i>=0;i--)

#define fs(i,a,b,c) for(auto i=a;i!=b;i+=c)

#define fl(i,x) for(auto i : x)

#define nl cout<<"\n";

#define ll long long int

#define vl vector<ll>

#define mid(a,b) ((a+b)/2)

#define pb push_back



class triplet{ll f, s, t;};



vl in(ll n){vl v;ll x;

    f(i,n)

    cin>>x, v.pb(x);

    return v;}

void out(vl v){fl(i,v)cout<<i;}

void out(vl v, char ch){

    fl(i,v)

    cout<<i<<ch;}



ll attack(ll ar[10000][10000], ll i, ll j, ll k){

    return ((i+2 < k) && (j+1 < k)) + ((i+2 < k) && (j-1 >= 0)) + ((i-2 >= 0) && (j+1 < k)) + ((i-2 >= 0) && (j-1 >= 0));

}



void solve(){

    char ch;

    cin>>ch;

    cout<<(char)(ch+1);

}

int main(){

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

    solve();

   return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>



int main () {

	int huruf;

	scanf("%c", &huruf);

	

	huruf = huruf + 1;

	printf("%c", huruf);

	

	return 0;

}

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

using namespace std;



typedef long long ll;



int main() {

	char x;

	cin >> x;

	cout << (char) (++x);

	return 0;

}


// Optimized solution to the same problem (faster):
#include<stdio.h>



int main () {

	int huruf;

	scanf("%c", &huruf);

	

	huruf = huruf + 1;

	printf("%c", huruf);

	

	return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):


#include <bits/stdc++.h>

#include<algorithm>

#include<cstring>

#include<cmath>

#include<cstdlib>

#include<string.h>

using namespace std;

#define pb push_back

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

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

#define per(i,n,v) for(i=n;i>v;i--)

#define ff first 

#define ss second 

#define pp pair<ll,ll>

#define ll  long long

#define endl '\n'

void solve()

{

  ll n, a,m=0,b=1, c,k=0, i, j,l=1e9+7;

  string s, r, y;

  char e;

  cin>>e;

  cout<<++e;

}

int main()

{

 ios_base::sync_with_stdio(false);

  cin. tie(0);cout. tie(0);

    ll t=1;

//   cin>>t;

    while(t--)

    {

      solve();

    }

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>



int main () {

	int huruf;

	scanf("%c", &huruf);

	

	huruf = huruf + 1;

	printf("%c", huruf);

	

	return 0;

}

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

using namespace std;



typedef long long ll;



main()

{

    char c;

    cin >> c;

    c++;

    cout << c ;







}











///promy_pompom

//hello world


// Optimized solution to the same problem (faster):
#include<stdio.h>



int main () {

	int huruf;

	scanf("%c", &huruf);

	

	huruf = huruf + 1;

	printf("%c", huruf);

	

	return 0;

}

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

using namespace std;



char z;



int main () {

	cin >> z;

	z = z+1;

	cout << (char)z << endl;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main(){

	char C;

	scanf("%c", &C);

	printf("%c", C + 1);

	return 0;

}

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

#include <string>

using namespace std;



int john,doe;

char c;



int main(){

	cin>>c;

	john=(int)c;

	doe=john+1;

	cout<<(char)doe<<endl;

}


// Optimized solution to the same problem (faster):
#include<stdio.h>

int main(){

	char C;

	scanf("%c", &C);

	printf("%c", C + 1);

	return 0;

}

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

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

// Optimized solution to the same problem (faster):
#include<stdio.h> 

int main() {

	int a;

	int b;

	scanf("%c",&a);

	b=++a;

	printf("%c",b);

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
//AC



#include<stdio.h>

#include<bits/stdc++.h>

using namespace std;

int main()

{



	char a;

	while(cin>>a)

	{

		cout<<++a<<endl;

	}

}

// Optimized solution to the same problem (faster):
#include<stdio.h> 

int main() {

	int a;

	int b;

	scanf("%c",&a);

	b=++a;

	printf("%c",b);

}


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

using namespace std;

int main()

{

	char a;

	cin>>a;

	printf("%c",a+1);

} 

// Optimized solution to the same problem (faster):
#include<stdio.h> 

int main() {

	int a;

	int b;

	scanf("%c",&a);

	b=++a;

	printf("%c",b);

}


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

using namespace std;

int main()

{

	char a;

	scanf("%c",&a);

	printf("%c",a+1);

}

// Optimized solution to the same problem (faster):
#include<stdio.h>



int main()

{

	char c;

	

	scanf("%c", &c);

	char next = c + 1;

	

	printf("%c", next);

	

	return 0;

}

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

using namespace std;

int main()

{

    char ch;

    cin >> ch;

    ch=ch+1;

    cout << ch << endl;

    return 0;

}


// Optimized solution to the same problem (faster):
#include<stdio.h>



int main()

{

	char c;

	

	scanf("%c", &c);

	char next = c + 1;

	

	printf("%c", next);

	

	return 0;

}

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

    #define ll long long

    using namespace std;

    int main(){

        char a;

        cin>>a;

        cout<<char(a+1)<<endl;

        return 0;

    }

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main (){

char a;

char b;

scanf("%c",&a);

b=a+1;

printf("%c",b);



return 0;

}

// Fastest known solution for this problem:
// Original C++ solution (slower):
//بسم الله الرحمن الرحيم

///   ***   ---   |||		 In the name of ALLAH		|||   ---   ***   ///

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

#define el << endl

#define PI 3.141592653589793238

#define _test_ int t; cin >> t; while(t--)

#define optimize() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)

#define file() freopen("input.txt", "r", stdin); freopen("output.txt", "w", stdout)

ll gcd ( ll  a, ll b ) { return __gcd ( a, b ); }

ll lcm ( ll a, ll b ) { return a * ( b / gcd ( a, b ) ); }

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

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

///*......................*//* LET'S BEGIN (-_^) *//*............................///

const int mx= 1e6+123;

char c;



void _case_()

{

    cin >> c;

    cout << char(c+1) el;

   // cout << c << " is followed by " << char(c+1)  << '.' << endl;

}







int main()

{

    optimize();

    //_test_

      _case_();

}



///////////*  N A Y E M  *///////////

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main (){

char a;

char b;

scanf("%c",&a);

b=a+1;

printf("%c",b);



return 0;

}

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



int main() {

	char c;

	std::cin >> c;

	c++;

	std::cout << c << std::endl;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main (){

char a;

char b;

scanf("%c",&a);

b=a+1;

printf("%c",b);



return 0;

}

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

using namespace std;



int main() {

	char c,x;

	cin>>c; 

	x=c+1;	

	cout<<x;



	return 0;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

	char alpha;

	char n;



	

	scanf("%c", &alpha);

	printf("%c", n = alpha + 1);	

	

	

	return 0;

}

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

using namespace std;

int main(){

    char a;

    cin >> a;

    cout << (char)(a+1);

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

	char alpha;

	char n;



	

	scanf("%c", &alpha);

	printf("%c", n = alpha + 1);	

	

	

	return 0;

}

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

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long ll;

const int inf = 0x3f3f3f3f;

const int mod = (1 ? 1e9+7 : 998244353);







int main()

{

	ios::sync_with_stdio(false); cin.tie(0);

	ll a, b, c, d, e, f, g, T;

	char z;

	cin >> z;

	z++;

	cout << z << endl;

}






// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

	char alpha;

	char n;



	

	scanf("%c", &alpha);

	printf("%c", n = alpha + 1);	

	

	

	return 0;

}

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

using namespace std;



int main()

{

	char c;

	cin>>c;

	cout<<++c;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>

int main(){

	char alpha;

	char n;



	

	scanf("%c", &alpha);

	printf("%c", n = alpha + 1);	

	

	

	return 0;

}

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

using namespace std;

int main()

{

 char a;

 cin>>a;

cout<<++a;

}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main()

{

    char C,result;

    scanf("%c", &C);

    result = C + 1;

    printf("%c", result);



}

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

using namespace std;

int main()

{ 

     char c;

     int a ;

     cin>>c;

     a = (int )c;

     cout<<(char)(a+1);

     return 0;

}

     


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main()

{

    char C,result;

    scanf("%c", &C);

    result = C + 1;

    printf("%c", result);



}

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

using namespace std;

#define int  long long

#define tc(t)  int t; cin>>t; while(t--)

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

#define endl   "\n"















int32_t main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

     char alpa;

     cin>>alpa;

     int asi=alpa;

     asi++;

     char answer=asi;

     cout<<answer<<endl;

     













}

// Optimized solution to the same problem (faster):
#include <stdio.h>



int main()

{

    char C,result;

    scanf("%c", &C);

    result = C + 1;

    printf("%c", result);



}

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

#define ll long long

#define vl vector<ll int>

#define vs vector<string>

#define v vector<int>

#define mi map<int,int>

#define mc map<char,int>

//ios_base::sync_with_stdio(false);cin.tie(NULL);



using namespace std;



int main(){

	ios_base::sync_with_stdio(false);cin.tie(NULL);

	char get,res;

	cin>>get;

	res=get+1;

	cout<<res;

}


// Optimized solution to the same problem (faster):
#include <stdio.h>



int main()

{

    char C,result;

    scanf("%c", &C);

    result = C + 1;

    printf("%c", result);



}

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

using namespace std;

long long s,sum,n,a[1000001],b[1000001],cnt,ans;

long long f(long long x,long long y)

{

	if (x*y%9!=0)

		return x*y%9;

	if (x==0)

		return 0;

	return 9; 

} 

int main()

{

	cin>>n;

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

	{

		cin>>a[i]>>b[i];

		ans+=b[i];

	}

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

	{

		cnt=0;

		for (int j=0;j<=8;++j)

			if (f(a[i],j)+a[i]>9)

				cnt++;

		cnt*=(b[i]/9);

		for (int j=0;j<=b[i]%9-1;++j)

			if (f(a[i],j)+a[i]>9)

				cnt++;

		if (f(a[i],0)+a[i]>9)

			cnt--;

		ans+=cnt;

	}

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

		a[i]=f(a[i],b[i]);

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

		{

			sum+=a[i];

			if (sum>9)

			{

				sum-=9;

				ans++;

			}

		}

	cout<<ans-1<<endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main(){

	long long t=0,sum=0,n,k[200010],s[200010];

	scanf("%lld",&n);

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

		scanf("%lld%lld",&k[i],&s[i]);

		sum+=k[i]*s[i];

		t+=s[i];

	}

	if(sum%9==0) printf("%lld",sum/9+t-2);

	else printf("%lld",sum/9+t-1);

	return 0;

}

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

#include<cstdio>

#include<cstdlib>

#include<cmath>

#include<cstring>

#include<algorithm>

#include<queue>

#define LL long long

#define inl inline

#define re register

#define MAXN 201000

using namespace std;

struct dig

{

	int d;

	LL c;

}g[MAXN];

int m;

int map[11][11],t[11][11];

int now;

LL ans;

void push(int x){ans+=t[now][x];now=map[now][x];}

void work(int d,LL c)

{

	if(c==0)return ;

	ans+=c/2*t[d][d];

	if(c&1)push(d);

	work(map[d][d],c/2);

}

int main()

{

	scanf("%d",&m);

	for(int i=0;i<=9;i++)

		for(int j=0;j<=9;j++)

		{

			map[i][j]=i+j;t[i][j]=1;

			while(map[i][j]>=10)

			{

				map[i][j]=map[i][j]/10+map[i][j]%10;

				t[i][j]++;

			}

		}

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

	{

		int d;LL c;

		scanf("%d%lld",&d,&c);

		work(d,c);

	}

	cout<<ans-1;

	return 0;

}




// Optimized solution to the same problem (faster):
#include<stdio.h>

int main(){

	long long t=0,sum=0,n,k[200010],s[200010];

	scanf("%lld",&n);

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

		scanf("%lld%lld",&k[i],&s[i]);

		sum+=k[i]*s[i];

		t+=s[i];

	}

	if(sum%9==0) printf("%lld",sum/9+t-2);

	else printf("%lld",sum/9+t-1);

	return 0;

}

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

#define WR "txt"



void Open() { freopen(WR".in", "r", stdin); freopen(WR".out", "w", stdout); }

void Close() { fclose(stdin); fclose(stdout); }

using namespace std;

long long Read()  {

	long long val = 0, opt = 1; char ch;

	while (!isdigit(ch = getchar() )) if (ch == '-') opt = -1;

	while (isdigit( ch )) (val *= 10) += ch - '0', ch= getchar();

	return val * opt;

}



long long Sum, n, b, c, Ans;



void work()  {

	n = Read();

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

		b = Read(), c = Read();

		Ans += (c - 1) + (b * c - 1) / 9;

		Sum += (b * c - 1) % 9 + 1; 

	}

	Ans += (n - 1) + (Sum - 1) / 9;

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

}



int main(void)  {

	//Open();

	work();

	//Close();

	return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

int main(){

	long long t=0,sum=0,n,k[200010],s[200010];

	scanf("%lld",&n);

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

		scanf("%lld%lld",&k[i],&s[i]);

		sum+=k[i]*s[i];

		t+=s[i];

	}

	if(sum%9==0) printf("%lld",sum/9+t-2);

	else printf("%lld",sum/9+t-1);

	return 0;

}

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

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

#define RREP(i, n) for (int i = (n); i >= 0; i--)

#define FOR(i, m, n) for (int i = (m); i < (n); i++)

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

using namespace std;

using llong = long long;



const int INF = 100100100;

const int MOD = 1e9 + 7;



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);



    llong M;

    cin >> M;



    llong d[300000];

    llong c[300000];

    REP(i, M) {

        llong tmp_d, tmp_c;

        cin >> tmp_d >> tmp_c;

        d[i] = tmp_d;

        c[i] = tmp_c;

    }



    llong now = d[0];

    c[0]--;

    llong index = 0;

    llong count = 0;

    while (index < M) {

        llong sum = now + c[index] * d[index];

        if (sum >= 10) {

            if (sum % 9 == 0) {

                count += c[index] + sum / 9 - 1;

                now = 9;

            } else {

                count += c[index] + sum / 9;

                now = sum % 9;

            }

        } else {

            count += c[index];

            now = sum;

        }



        /*

        while (c[index] >= 1) {

            now += d[index];

            c[index]--;

            count++;

            if (now >= 10) {

                now = now - 9;

                count++;

            }

        }

        */

        index++;

    }



    cout << count << "\n";



    return 0;

}


// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>

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

#define RREP(i, n) for (int i = (n); i >= 0; i--)

#define FOR(i, m, n) for (int i = (m); i < (n); i++)

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

using namespace std;

using llong = long long;



const int INF = 100100100;

const int MOD = 1e9 + 7;



int main() {

    cin.tie(0);

    ios::sync_with_stdio(false);



    llong M;

    cin >> M;



    llong sum = 0;

    llong ans = 0;

    REP(i, M) {

        llong d, c;

        cin >> d >> c;

        ans += c;

        sum += d * c;

    }



    cout << ((sum - 1) / 9) + ans - 1 << "\n";



    return 0;

}


// Fastest known solution for this problem:
// Original C++ solution (slower):
#pragma GCC optimize("Ofast")

#pragma GCC optimize("inline")

#include <bits/stdc++.h>

#define rint register int

using namespace std;

const int MOD = 1000000007;

const int N = 3001;

int n,cur;

long long dp[2][N];

char ch;

inline void adj(long long &x) {if(x>=MOD)x-=MOD;}

int main()

{

    scanf("%d\n",&n);

    dp[0][1]=1LL;

    for (rint i=2;i<=n;i++,cur^=1)

    {

        scanf("%c",&ch);

        if (ch=='<')

        {

            dp[cur^1][1]=0LL;

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

            {

                dp[cur^1][j]=dp[cur^1][j-1]+dp[cur][j-1];

                adj(dp[cur^1][j]);

            }

        }

        else 

        {

            dp[cur^1][i]=0LL;

            for (rint j=i-1;j>=1;j--) 

            {

                dp[cur^1][j]=dp[cur^1][j+1]+dp[cur][j];

                adj(dp[cur^1][j]);

            }

        }

    }

    for (rint i=1;i<n;i++) dp[cur][n]+=dp[cur][i];

    printf("%lld\n",dp[cur][n]%MOD);

    return 0;

}


// Optimized solution to the same problem (faster):
#pragma GCC optimize("Ofast")

#include <cstdio>

#define rint register int

using namespace std;

const int MOD = 1000000007;

const int N = 3001;

int n,cur;

long long dp[2][N];

char ch;

inline void adj(long long &x) {if(x>=MOD)x-=MOD;}

int main()

{

    scanf("%d\n",&n);

    dp[0][1]=1LL;

    for (rint i=2;i<=n;i++,cur^=1)

    {

        scanf("%c",&ch);

        if (ch=='<')

        {

            dp[cur^1][1]=0LL;

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

            {

                dp[cur^1][j]=dp[cur^1][j-1]+dp[cur][j-1];

                adj(dp[cur^1][j]);

            }

        }

        else 

        {

            dp[cur^1][i]=0LL;

            for (rint j=i-1;j>=1;j--) 

            {

                dp[cur^1][j]=dp[cur^1][j+1]+dp[cur][j];

                adj(dp[cur^1][j]);

            }

        }

    }

    for (rint i=1;i<n;i++) dp[cur][n]+=dp[cur][i];

    printf("%lld\n",dp[cur][n]%MOD);

    return 0;

}


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

#include<cstdio>

using namespace std;

typedef long long LL;

int main()

{

      int  n,m;

      LL sum_even,sum_odd,mul;

      while(cin>>n>>m)

      {

           sum_even=sum_odd=0;

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

           {

                mul=(LL) i*m;

                if(mul%2==1)continue;

                if(mul/2>n)break;

                if(mul/2%m==0)++sum_even;

                else ++sum_odd;

           }

           cout<<sum_odd*sum_odd*sum_odd+sum_even*sum_even*sum_even<<endl;

      }

}


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

#include <algorithm>

using namespace std;



long long n, k;

inline long long calc(long long x) { return x * x * x; }



int main() {

    scanf("%lld%lld", &n, &k);

    if (k & 1) {

        printf("%lld\n", calc(n / k));

    } else {

        printf("%lld\n", calc(n / k) + calc(n / k + (n % k >= k / 2)));

    }

    return 0;

}

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

#include <cstdio>

#include <algorithm>



const int N = 2e5 + 7;

long long a[N], n, k;



int main() {

    scanf("%lld%lld", &n, &k);

    for (int i = 1; i <= n; i++) a[i % k]++;

    long long ans = 0;

    ans = a[0] * a[0] * a[0];

    if (!(k % 2)) ans += a[k / 2] * a[k / 2] * a[k / 2];

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

    return 0;

}

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

#include <algorithm>

using namespace std;



long long n, k;

inline long long calc(long long x) { return x * x * x; }



int main() {

    scanf("%lld%lld", &n, &k);

    if (k & 1) {

        printf("%lld\n", calc(n / k));

    } else {

        printf("%lld\n", calc(n / k) + calc(n / k + (n % k >= k / 2)));

    }

    return 0;

}

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

using namespace std;

#define flash ios_base::sync_with_stdio(0); cin.tie(0)

int main()

{



    flash;

    long long n,k,cnt1=0,cnt2=0, ans=0,y;

    cin>>n>>k;



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

    {

        if(i % k == 0)

            cnt1++;

    }



    ans = cnt1*cnt1*cnt1;



    if(k % 2 == 0)

    {

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

        {



            if(i %k == k/2 )

                cnt2++;

        }

    }



    ans += cnt2*cnt2*cnt2;





    cout<<ans<<endl;

    return 0;

}


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

#include <cstring>

#include <algorithm>

void Unused(...) {}

#ifndef DEBUG

  #define echo(...) Unused(__VA_ARGS__)

#else

  #define echo(...) fprintf(stderr, __VA_ARGS__)

#endif



typedef long long laolin;



const int MaxN = int(1e5) + 7;



int n, k;



int main()

{

    scanf("%d %d", &n, &k);

    laolin ans = n / k;

    laolin ano = 0;

    if (k % 2 == 0)

        ano = n / k + (n % k >= k / 2);

    printf("%lld\n", ans * ans * ans + ano * ano * ano);

    return 0;

}



/*

 * given a, then:

 *  - a + b %=k 0 => b = sk - a

 *  - a + c %=k 0 => c = tk - a

 *  - b + c %=k 0 => (s+t-p)k = 2a

 */




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

using namespace std;

typedef long long ll;

const int maxn=2e5+7;



int a[maxn];//各个同余系的个数



int main()

{

    int n,k;

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

    {

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

        {

            a[i]=n/k;

        }

        int r=n%k;

        for(int i=1;i<=r;i++) a[i]++;

        ll ans=0;



        ans+=(ll)a[k]*(ll)a[k]*(ll)a[k];

        if(k%2==0)

            ans+=(ll)a[k/2]*(ll)a[k/2]*(ll)a[k/2];

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

    }

    return 0;

}

// Optimized solution to the same problem (faster):
#include<stdio.h>

#include<algorithm>

using namespace std;

#define ll long long

int main()

{

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

	ll n,k;

	scanf("%lld%lld",&n,&k);

	if(k&1){//ji

		if(k>n)printf("0\n");

		else{

			ll cnt1=(n-k)/k;

			cnt1++;

			printf("%lld",cnt1*cnt1*cnt1);

		}

	}else{

		if(k/2>n)printf("0\n");

		else{

			ll cnt1=0;

			if(k<=n){

		cnt1=(n-k)/k;

			cnt1++;

			}

		ll cnt2=(n-(k/2))/k;

		cnt2++;

		printf("%lld",cnt1*cnt1*cnt1+cnt2*cnt2*cnt2);

		}

	}

}

// Fastest known solution for this problem: