stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#include <math.h>

#include <iomanip>

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }

template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

const int INF=1001001001;

vector<pair<int64_t,int64_t>>pppp(int64_t x){

  vector<pair<int64_t,int64_t>>p;

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

    int cnt=0;

    if(x%i==0){

    while(x%i==0){cnt++;x/=i;}

    p.push_back(make_pair(i,cnt));

    }

  }

  if(x!=1){p.push_back(make_pair(x,1));}

  return p; 

}

 

int main() {

  int64_t N;

  cin>>N;

  string k;

  while(N>0){

    N--;

    k=(char)(N%26+'a')+k;

    N/=26;

  }

  cout<<k<<endl;

  return 0;

}


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

#include <string.h>



int main() {



 	long long int n;

 	scanf("%lld", &n);

 	

 	char name[20]={};

	n--;

 	for(long long int i=0; n>=0; i++){

		name[i]=(n%26)+'a';

		n/=26;

		n--;	

	 }

	 

  	long long int nn = strlen(name);

	for(long long int i = nn-1; i >= 0; i--){

 	 printf("%c", name[i]);

	}

	

	printf("\n");





    return 0;

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

#include<vector>

#include<map>

#include<set>

#include<string>

#include<algorithm>

#include<math.h>

#include<bits/stdc++.h>

#include<cmath>

#include<iomanip>

#include<queue>

#include<string>

using namespace std;



const double PI  =3.141592653589793238463;

#define pb push_back

#define pf push_front

#define sz(v)  ((int)(v).size());

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

typedef unsigned long long ull;

typedef long long ll;



typedef vector<int> vi;

typedef pair<int,int> pi;

//2 7 3 4 9



void printVec(vi v1)

{

    for(int i=0; i<v1.size(); i++)

        cout<<v1[i]<<" ";

    cout<<endl;

}

ll rec(ll r,ll c){



if(r<=1 || c<=1){

    return 1;

}





return rec(r-1,c)+rec(r,c-1);

}



int main()

{

    ios::sync_with_stdio(false);

    cout.tie(NULL);

    cin.tie(NULL);

ull n;cin>>n;

string str="";

while(n>=1){

    n--;

    str+='a'+(n%26);

    n/=26;

}reverse(str.begin(),str.end());

 cout<<str;

    return 0;

}


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

#include <string.h>



int main() {



 	long long int n;

 	scanf("%lld", &n);

 	

 	char name[20]={};

	n--;

 	for(long long int i=0; n>=0; i++){

		name[i]=(n%26)+'a';

		n/=26;

		n--;	

	 }

	 

  	long long int nn = strlen(name);

	for(long long int i = nn-1; i >= 0; i--){

 	 printf("%c", name[i]);

	}

	

	printf("\n");





    return 0;

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



using namespace std;



int main() {

  ios_base::sync_with_stdio(0), cin.tie(0), cout .tie(0);

  long long n;

  cin >> n;

  string k;

  while (n) {

    n -= 1;

    k.push_back('a' + n % 26LL);

    n /= 26LL;

  }



  for (int i = k.size(); i > 0; i--) cout << k[i - 1]; 

  return 0;

}


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

#include <string.h>



int main() {



 	long long int n;

 	scanf("%lld", &n);

 	

 	char name[20]={};

	n--;

 	for(long long int i=0; n>=0; i++){

		name[i]=(n%26)+'a';

		n/=26;

		n--;	

	 }

	 

  	long long int nn = strlen(name);

	for(long long int i = nn-1; i >= 0; i--){

 	 printf("%c", name[i]);

	}

	

	printf("\n");





    return 0;

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



using namespace std;



int main()

{

    stack<char> out;

    long long int n;

    cin>>n;

    while(n)

    {

        --n;

        out.push('a'+n%26);

        n/=26;//number of alphabet letters i.e base

    }

    while(!out.empty()){

        cout<<out.top();

        out.pop();

    }

    return 0;

}


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

#include <string.h>



int main() {



 	long long int n;

 	scanf("%lld", &n);

 	

 	char name[20]={};

	n--;

 	for(long long int i=0; n>=0; i++){

		name[i]=(n%26)+'a';

		n/=26;

		n--;	

	 }

	 

  	long long int nn = strlen(name);

	for(long long int i = nn-1; i >= 0; i--){

 	 printf("%c", name[i]);

	}

	

	printf("\n");





    return 0;

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



using namespace std;



typedef long long LL;



LL f[20];



LL p[20];



int main(){

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



    f[0]=1;

    for(int i=1;i<=12;++i)f[i]=26ll*f[i-1];

    for(int i=2;i<=12;++i)f[i]+=f[i-1];



    p[0]=1;

    for(int i=1;i<=12;++i)p[i]=26ll*p[i-1];



    int idx=1;

    while(f[idx]<n)++idx;



    string res;



    LL cnt;

    if(idx==1)cnt=0;

    else cnt=f[idx-1];



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

        for(int ch=0;ch<=25;++ch){

            LL t=cnt+1ll*(ch+1)*p[idx-i];

            if(t>=n){

                res+=ch+'a';

                cnt+=1ll*ch*p[idx-i];

                break;

            }

        }

    }



    cout<<res;



    return 0;

}


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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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

#include <string>

#include <algorithm>

using namespace std;

int main(){

	long long n,i=1;

	string k ="";

	cin >> n;

	while(n!=0){

		k+=char('a'+((n-1)%26));

		n--;

		n/=26;

	

	};

	reverse(k.begin(),k.end());

	cout <<  k << endl;

	return 0;

}

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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

}
// Slower C++ solution:


#include <iostream>

#include <cstdio>

#include <cstring>

#include <algorithm>

#include <vector>

#include <map>

#include <cmath>

#include <queue>

#include <set>

#include <ctime>

#define rep(i,j,k) for(int i = j; i <= k; i++)

#define dow(i,j,k) for(int i = j; i >= k; i--)

#define ez(i,x) for(int i = h[x]; i; i = e[i].next)

#define fi first

#define se second

#define MS(x) memset(x, 0, sizeof(x))

using namespace std;



long long f[100];



int main() {

	f[1] = 1;

	f[2] = 26;

	rep(i,3,80) f[i] = f[i-1] * 26;

	rep(i,2,80) f[i] += f[i-1];

	long long a;

	string s;

	cin >> a;

	int b = 0;

	rep(i,1,50) {

		//cout << a << " " << f[i] << endl;

        if (a < f[i]) {

        a -= f[i-1], b= i-1;;

       

        break;

        }

	}

	rep(i,1,b) {

		s.push_back(a % 26 + 'a');

		a /= 26;

	}

	reverse(s.begin(), s.end());

	cout << s << endl;

}

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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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

using namespace std;

int a[1007],c[1007];

long long b[1007];

long long aaa=(long long)1000000000000001;

int h=0;

int main()

{

	long long n;

	scanf("%lld",&n);

	b[1]=26;

	int h=0;

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

	{

		b[i]=(b[i-1]+1)*26;

		if(b[i]>aaa||b[i]<=0)

		{

			h=i;break;

		}

	}

	b[h+1]=0x3f3f3f3f3f3f3f3f;

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

	{

		c[i]=n%26;

		n=(n-1)/26;

		if(n==0)

		{

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

			{

				if(c[j]==0)cout<<"z";

				else

				cout<<(char)(c[j]+'a'-1);

			}

			break;

		}

	}

return 0;

}

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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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

#include <stack>

using namespace std;

char rec[26] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};

void decTo26(long long dec,stack<char> q)

{

    long long temp = dec;

    while(temp){

        temp--;

        char c = rec[temp%26];

        q.push(c);

        temp = temp/26;

    }

    while(!q.empty()){

        cout<<q.top();

        q.pop();

    }

    cout<<endl;

}



int main()

{//26进制

    long long n;

    cin >> n;

    stack<char> q;

    decTo26(n,q);

    return 0;

}


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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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

#include <bits/stdc++.h>



using namespace std;



int main()

{

    string str = "";

    long long num, rem;

    bool flag = true;



    cin >> num;



    while(num > 0)

    {

        rem = num % 26;

        num /= 26;

        if(rem == 0)

        {

            rem = 26;

            num--;

        }

        str += (char)(rem + 96);

    }

    for(int i = str.length() - 1; i >= 0; i--)

        cout << str[i];

    cout << endl;

    return 0;

}

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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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

#include <algorithm>

#include <set>

#include <string>

#include <vector>

#include <queue>

#include <deque>

#include <sstream>

#include <map>

#include <cmath>

#include <stack>



using namespace std;



typedef long long ll;

int main() {

    ll n; cin >> n;

    int j = 0;

    stack<char> sk;

    while (n > 0) {

        if(n % 26 == 0) {

            // break;

            sk.push('z');

            n--;

            n /= 26;

            continue;

        }

        j = (n-1) % 26 ;

        // if(j == -1) j = 25;

        sk.push('a' + j);

        n /= 26;

    }

    while (!sk.empty())

    {

        cout << sk.top();

        sk.pop();

    }





}

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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

}
// Slower C++ solution:


#include <iostream>

using namespace std;

typedef long long ll;

#include<algorithm>

char a[30] {'a','b','c','d','e','f','g'

,'h','i','j','k','l',

'm','n','o','p','q','r','s','t','u','v',

'w','x','y','z'};

 int main()

   {

     ll N,X,i=0;

     string s;

     cin>>N;

     while(N)

       

       {

         X= N%26;

         if(X==0){X=26;}

         s+= a[X-1];

         N=(N-1)/26;

         

       }

       reverse(s.begin(),s.end());

       cout<<s<<endl;

   }

   

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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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

using namespace std;

#include <math.h>

#include <iomanip>

template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }

template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

const int INF=1001001001;

vector<pair<int64_t,int64_t>>pppp(int64_t x){

  vector<pair<int64_t,int64_t>>p;

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

    int cnt=0;

    if(x%i==0){

    while(x%i==0){cnt++;x/=i;}

    p.push_back(make_pair(i,cnt));

    }

  }

  if(x!=1){p.push_back(make_pair(x,1));}

  return p; 

}

 

int main() {

  int64_t N;

  cin>>N;

  string k;

  while(N>0){

    N--;

    k=(char)(N%26+'a')+k;

    N/=26;

  }

  cout<<k<<endl;

  return 0;

}


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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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

#include<vector>

#include<map>

#include<set>

#include<string>

#include<algorithm>

#include<math.h>

#include<bits/stdc++.h>

#include<cmath>

#include<iomanip>

#include<queue>

#include<string>

using namespace std;



const double PI  =3.141592653589793238463;

#define pb push_back

#define pf push_front

#define sz(v)  ((int)(v).size());

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

typedef unsigned long long ull;

typedef long long ll;



typedef vector<int> vi;

typedef pair<int,int> pi;

//2 7 3 4 9



void printVec(vi v1)

{

    for(int i=0; i<v1.size(); i++)

        cout<<v1[i]<<" ";

    cout<<endl;

}

ll rec(ll r,ll c){



if(r<=1 || c<=1){

    return 1;

}





return rec(r-1,c)+rec(r,c-1);

}



int main()

{

    ios::sync_with_stdio(false);

    cout.tie(NULL);

    cin.tie(NULL);

ull n;cin>>n;

string str="";

while(n>=1){

    n--;

    str+='a'+(n%26);

    n/=26;

}reverse(str.begin(),str.end());

 cout<<str;

    return 0;

}


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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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



using namespace std;



int main() {

  ios_base::sync_with_stdio(0), cin.tie(0), cout .tie(0);

  long long n;

  cin >> n;

  string k;

  while (n) {

    n -= 1;

    k.push_back('a' + n % 26LL);

    n /= 26LL;

  }



  for (int i = k.size(); i > 0; i--) cout << k[i - 1]; 

  return 0;

}


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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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



using namespace std;



int main()

{

    stack<char> out;

    long long int n;

    cin>>n;

    while(n)

    {

        --n;

        out.push('a'+n%26);

        n/=26;//number of alphabet letters i.e base

    }

    while(!out.empty()){

        cout<<out.top();

        out.pop();

    }

    return 0;

}


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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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

#include <math.h>

#include <stack>



using namespace std;



int main()

{

    long long int n,y,z,temp,i;

    long double x;

    stack <int> s;

    cin>>n;

    temp=1;

    while(n>0)

    {

        n--;

        s.push(n%26);

        n/=26;

    }

    while(!s.empty())

    {

        cout<<char(s.top()+'a');

        s.pop();



    }

    cout<<"\n";

}


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

 

int main()

{

    long long int b;

    scanf("%lld",&b);

    int i = 0;

    char str[100];

    

    while(b > 0)

	{

        int check = b % 26;

        

        if (check == 0)

		{

            str[i++] = 'z';

            b = (b/26) - 1;

        }

		else

		{

            str[i++] = (check - 1) + 'a';

            b /= 26;

        }

    }

    str[i] = '\0';

    

	int j;

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

	{

        printf("%c", str[j]);

    }

    

    return 0;

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



using namespace std;



void f(long long n){

    n-=1;

    if(n<26){

        cout <<(char)('a' + n);

        return;

    }



    f(n/26);

    cout <<(char)('a' + n%26);

}



int main(){

    long long n;

    cin >>n;

    f(n);

}


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

#include <string.h>



int main(){

	char a[100];

	long long N, hb, sisa;

	scanf("%lld", &N);

	int j=0;

	while(1){

		hb=N/26;

		sisa=N%26;

		if(sisa==0){

			a[j]='z';

			hb-=1;

		}

		if(sisa!=0){

			a[j]=sisa-1+'a';

		}

		j++;

		if(hb==0){

			break;

		}

		N=hb;

	}

	a[j] = '\0';

	int len = strlen(a);

	for(int i=len-1; i>=0; i--){

		printf("%c", a[i]);

	}

	printf("\n");

	

	return 0;

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

using namespace std;



int main(){



    long long n;

    cin >> n;



    /*int len = 0;

    long long sum = 0, p = 1;

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

        p*=26;

        sum+=p;

        if(n<=sum){

            len = i;

            break;

        }

    }

    cout << len << endl;*/



    string name = "";

    long long d = 0, r = 0;

    while(n>0){

        d = n/26;

        r = n%26;

        if(r==0){

            d = d-1;

            name = "z" + name;

        }

        else{

            name = (char)(r-1+'a') + name;

        }

        n = d;

    }



    cout << name << endl;

}


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

#include <string.h>



int main(){

	char a[100];

	long long N, hb, sisa;

	scanf("%lld", &N);

	int j=0;

	while(1){

		hb=N/26;

		sisa=N%26;

		if(sisa==0){

			a[j]='z';

			hb-=1;

		}

		if(sisa!=0){

			a[j]=sisa-1+'a';

		}

		j++;

		if(hb==0){

			break;

		}

		N=hb;

	}

	a[j] = '\0';

	int len = strlen(a);

	for(int i=len-1; i>=0; i--){

		printf("%c", a[i]);

	}

	printf("\n");

	

	return 0;

}
// Slower C++ solution:
//problem - p(indu)

#include<iostream>

#include<cmath>

#include<cstdio>



int main()

{

    long long int num{0};

    int remain{0},count{0};

    char s[20] = {0};

    

    scanf("%lli",&num);

    

    while(num > 0){

        remain = num % 26;

        

        if(remain == 0){

            s[count] = 26;

        }else{

            s[count] = remain;

        }

        

        num -= 1;

        num /= 26;

        count++;

    }

    

    while(--count >= 0){

        printf("%c",s[count] + 'a' - 1);

    }

    

    printf("\n");

    return 0;

}

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

#include <string.h>



int main(){

	char a[100];

	long long N, hb, sisa;

	scanf("%lld", &N);

	int j=0;

	while(1){

		hb=N/26;

		sisa=N%26;

		if(sisa==0){

			a[j]='z';

			hb-=1;

		}

		if(sisa!=0){

			a[j]=sisa-1+'a';

		}

		j++;

		if(hb==0){

			break;

		}

		N=hb;

	}

	a[j] = '\0';

	int len = strlen(a);

	for(int i=len-1; i>=0; i--){

		printf("%c", a[i]);

	}

	printf("\n");

	

	return 0;

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

using namespace std;



typedef long long ll;



string solve(ll n)

{

    ll x = 26;

    int cnt = 1;

    while (n > x)

    {

        n -= x;

        x = x * 26;

        cnt ++;

    }



    n -= 1;

    string ans = "";

    while (n)

    {

        ans = (char)('a' + (n % 26ll)) + ans;

        n /= 26;

    }

    // cout << ans << endl;

    // cout << (cnt - ans.length()) << endl;

    int len = cnt - ans.length();

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

        ans = 'a' + ans;

    return ans;

    

}



int main()

{

    ll n;

    cin >> n;

    cout << solve(n) << endl;

    // n --;

    // if (n == 0)

    // {

    //     cout << 'a' << endl;

    //     return 0;

    // }

    // string ans;

    // while (n)

    // {



    //     ans = (char)('a' + (n % 26ll)) + ans;

    //     n /= 26;

    // }

    // cout << ans << endl;

    

}

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

#include <string.h>



int main(){

	char a[100];

	long long N, hb, sisa;

	scanf("%lld", &N);

	int j=0;

	while(1){

		hb=N/26;

		sisa=N%26;

		if(sisa==0){

			a[j]='z';

			hb-=1;

		}

		if(sisa!=0){

			a[j]=sisa-1+'a';

		}

		j++;

		if(hb==0){

			break;

		}

		N=hb;

	}

	a[j] = '\0';

	int len = strlen(a);

	for(int i=len-1; i>=0; i--){

		printf("%c", a[i]);

	}

	printf("\n");

	

	return 0;

}