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

#define ll long long

using namespace std;

int main(){

    ll N; scanf("%lld", &N);

    // 26 26 * 26 26 * 26 * 26

    ll pre[12] = {0};

    ll sum = 26;

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

        pre[i] = pre[i - 1] + sum;

        sum = sum * 26;

    }

    int cur = 11;

    // pre[i - 1] + 1 ~ pre[i]

    // a = 0

    while(N < pre[cur] + 1){

        cur--;

    }

    N -= pre[cur];

    --N;

    int stk[13];

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

        stk[i] = N % 26;

        N /= 26;

    }

    for(int i = cur + 1; i >= 1; i--){

        printf("%c", (char)('a' + stk[i]));

    }

    return 0;

}

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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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

using namespace std;

typedef long long LL;

LL n;

int s[100000];

int main(){

    scanf("%lld", &n);

    LL x = 0, y = 1, z = 0;

    while(x <= n){

        y *= 26LL;

        x += y;

        ++z;

    }

    x -= y;

    if(n == x){

        for(int i = 1; i < z; i++) cout<<'z';

        cout<<endl;

    }

    else{

        

        int u = 0;

        LL a = n - x - 1LL;

        while(a > 0){

            s[++u] = a % 26LL;

            a /= 26LL;

        }

        for(int i = z; i >= 1; i--) printf("%c", s[i] + 'a');

        cout<<endl;

    }

    return 0;

}

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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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

#include<stack>

using namespace std;

long long n;



int main()

{

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

    {

        stack<char>p;

        while(n)

        {

            int t=n%26;



            if(n)

            {

            if(t==0)

            p.push('z');

            else

            p.push((char)('a'+t-1));

            }

            n/=26;

            if(!t)

            n--;

        }

        while(!p.empty())

        putchar(p.top()),p.pop();

        putchar('\n');

    }

    return 0;

}

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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

}
// Slower C++ solution:
#pragma GCC optimize ("O3")

#include<bits/stdc++.h>

using namespace std;







/// Info.

///****************************************************************************************************************************************///

/// author                : BAHAA El-DEEN OSAMA .

/// Problem name          : P - One Quadrillion and One Dalmatians

/// Method                : brute force

/// Online judge          : vjudge(Contest)

/// Date                  : 8/7/2020

///****************************************************************************************************************************************///



typedef long long ll ;

typedef unsigned long long ull ;



ll n;

string str = "";



int main()

{



    cin >> n;

	while (n)

    {

		int s = (n-1) % 26;

		str = (char)('a' + s) + str;

		n = (n-1)/ 26;

	}

	cout << str << endl;



	   return 0;

}


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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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



using namespace std;

typedef long long ll;

ll t , k,n,x , y , a, b,c , d ,sum;

string s;

char ch;

int main()

{

    cin >> n;

    a=26;

    s="";

    while(n>0)

    {

        //n--;

        x=(n-1)%26;

        s+=(x+'a');

        n=(n-1)/26;

    }

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

    cout << s;

    return 0;

}


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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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

using namespace std;

typedef long long ll;

typedef unsigned long long ull;



int main()

{

    ull n;

    string s="";

    cin>>n;

    while(n>0)

    {

        if(n%26==0)

            {s='z'+s;n-=1;}

        else

            {char x=((n%26)-1)+'a';s=x+s;}



        n/=26;

    }

        cout<<s;

}


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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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

#include <string>

#include <map>

#include <queue>

#include <vector>

#include<algorithm>

#include <set>

#include <stack>

#include <stdlib.h>



using namespace std;



int main()

{

    int long long a,z,p=0;

    char arr[27];

    char arr1[30];

    cin>>a;

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

    {

        arr[i]=char(i+96);

    }

    arr[0]='z';

    while(a!=0)

    {

        arr1[p++]=arr[a%26];

        z=a%26;

        if(z==0)

            z=26;

        a-=z;

        a/=26;

    }



    for(int i=p-1;i>=0;i--)

        cout<<arr1[i];

    return 0;

}

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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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



using namespace std;

long long dog;

char a[]={"zabcdefghijklmnopqrstuvwxy"};

int name[13];

int main() {

    cin>>dog;

    int i;

    for ( i=0; dog > 0; i++){

        if (dog%26 == 0) {

            name[i] = 0;

            dog/=26;

            dog--;

        }

        else {

            name[i] = (dog % 26);

            dog /= 26;

        }

    }

    i--;

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

        cout<<a[name[i]];

    return 0;

}


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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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

using namespace std;

int main()

{

  long long N;

  cin>>N;

  string s;

  char arr[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'};

  int x=0, y=0,count=0;

  while(true){

    if(N<26){

      

      break;

    }

    else{

      if(N%26!=0){

         N--;

        count++;

      }

      else if(N%26==0 && count==0){

        s+=arr[25];

        N-=1;

        N=N/26;

      }

      else{

        s+=arr[count-1];

        N=N/26;

        count=0;

      }

    }

  }

  if(N==26){

    s+=arr[0];

  }

  else if(N>=1&&N<26){

    s+=arr[N-1];

  }

  

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

cout<<s;

  return 0;

}

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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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

#include <bits/stdc++.h>



using namespace std;



int main()

{

    string result;

    long long n;

    cin >> n;

    while (n > 0)

    {

        n--;

        result += char(97 + (n % 26));

        n /= 26;

    }

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

    cout << result;

    return 0;

}

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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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

#include <bits/stdc++.h>

#include <stdio.h>



typedef long long ll;

using namespace std;







bool isPrime(ll n){

    if(n < 2){

        return 0;

    }

    if(n%2 == 0){

        return n==2;

    }

    for(ll i=3;i*i<=n;i++){

        if(n%i == 0) return 0;

    }

    return 1;

}



string toBinary(int x){

    string s = "";

    while(x > 0){

        if(x%2) s += "1";

        else s += "0";

        x /= 2;

    }

    string h = "";

    for(int i=s.size();i<31;i++){

        h += "0";

    }

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

    //cout<<"x "<<x<<" "<<(h+s)<<endl;

    return (h+s);

}



int toInt(string s){

    int h =0;

    for(int i=s.size()-1;i>=0;i--){

        if(s[i] ==  '1') h += pow(2,i);

    }

    return h;

}

int main() {

  // int n,m;

   //freopen("test.txt","w",stdout);

//   while(cin>>n){

//       cin>>m;

//       vector<int> v(n);

//       ll maxy = 0;

//       ll miny = 10e10;

//       for(int i=0;i<n;i++) { cin >> v[i];maxy= max(maxy,(ll)v[i]); }

//       int h = n-m+1;

//      // vector<int> vv;

//       ll k = 0;

//       int nn = 0;

//        int prevIndx = 0;

//        for(int i=0;i<h;i++) k += v[i];

//       for(int i=h;i<n;i++){

//          /* int j = i+1;

//            k += v[i];

//            nn++;

//           while(j<n && nn < h){

//               k += v[j];

//               j++;

//               nn++;

//           }

//         //  vv.push_back(k);

//         if(k < miny) miny = k;

//           k -= v[prevIndx];

//           i = j-1;

//           prevIndx++;

//           nn--;

//           */

//           if(k < miny) miny = k;

//           k -= v[prevIndx];

//           prevIndx++;

//           k += v[i];

//

//       }

//       cout<<max(miny,maxy)<<endl;

//

//   }

    ios_base::sync_with_stdio(false);

    cin.tie(0);

ll n;

cin>>n;

int indx= 1;

string s = "";

while(n > 0){

    n--;

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

    n /= (26);

}

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

cout<<s<<endl;

return 0;

}


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

 

int main(){

    long long int banyakAnjing;

    scanf("%lld",&banyakAnjing);

 

    char name[100];

    int a=0;

    

    while(banyakAnjing!=0){

        banyakAnjing--;

        int b = banyakAnjing%26;

        name[a] ='a'+ b;

        banyakAnjing/=26;

        a++;

    }

    for(int j=a-1;j>=0;j--)	{

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

    }

    return 0;

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

    #include <ext/pb_ds/assoc_container.hpp>

    using namespace __gnu_pbds;

    using namespace std;

     

    typedef long long ll;

    typedef tree<int,null_type,less<int>,rb_tree_tag,

    		tree_order_statistics_node_update> indexed_set;

     

    #define br printf("\n")

     

    string solve(ll num) {

    	ll ch = 26;

    	ll len = 0;

    	while (num > ch) {

    		num -= ch;

    		ch *= 26;

    		len++;

    	} len += 1;

    	num--;

    	string str = "";

    	while (len--) {

    		ll rem = num % 26;

    		num /= 26;

    		str += (char)(rem + 'a');

    	}

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

    	return str;

    }

    		

     

    int main () {

    	ios::sync_with_stdio(1);

    	cin.tie(0);

     

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

    //	freopen("output.txt", "w", stdout);

     

    	ll num;

    	cin >> num;

    	cout << solve(num) << '\n';

    	return 0;

    }

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

#include <string.h>



int main() {

    long long int input; 

	long long int modulo;

    char nama[55];

    scanf("%lld", &input);

    int i = 0;

    while (input > 0) {

        modulo = (input - 1) % 26;

        nama[i++] = 'a' + modulo;

        input = (input - modulo) / 26;

    }

    nama[i] = '\0';

    int panjang = strlen(nama);

    for (panjang--; panjang >= 0; panjang--) {

        printf("%c", nama[panjang]);

    }

return 0;    

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

#include <iostream>

#include <algorithm>

#include <cstring>

using namespace std;



const int maxn = 2e5+100;



long long res,bs=26;

char ans[maxn];

int main()

{

	ios::sync_with_stdio(false);

	cin>>res;

	int cnt=0;

	while(res)

	{

		long long ip = res%bs;

		res/=bs;

		if(ip==0) ip=26,res--;

		char op = 'a'+ip-1;

		ans[++cnt]=op;

		//cout<<ip<<endl;

	}

	for(int i=cnt;i>=1;i--) cout<<ans[i];

	cout<<endl;

	return 0;

}

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

#include <string.h>



int main() {

    long long int input; 

	long long int modulo;

    char nama[55];

    scanf("%lld", &input);

    int i = 0;

    while (input > 0) {

        modulo = (input - 1) % 26;

        nama[i++] = 'a' + modulo;

        input = (input - modulo) / 26;

    }

    nama[i] = '\0';

    int panjang = strlen(nama);

    for (panjang--; panjang >= 0; panjang--) {

        printf("%c", nama[panjang]);

    }

return 0;    

}
// Slower C++ solution:
#pragma GCC optimize(2)

#pragma GCC optimize(3)

#pragma GCC optimize("Ofast")

#pragma GCC optimize("inline")

#pragma GCC optimize("-fgcse")

#pragma GCC optimize("-fgcse-lm")

#pragma GCC optimize("-fipa-sra")

#pragma GCC optimize("-ftree-pre")

#pragma GCC optimize("-ftree-vrp")

#pragma GCC optimize("-fpeephole2")

#pragma GCC optimize("-ffast-math")

#pragma GCC optimize("-fsched-spec")

#pragma GCC optimize("unroll-loops")

#pragma GCC optimize("-falign-jumps")

#pragma GCC optimize("-falign-loops")

#pragma GCC optimize("-falign-labels")

#pragma GCC optimize("-fdevirtualize")

#pragma GCC optimize("-fcaller-saves")

#pragma GCC optimize("-fcrossjumping")

#pragma GCC optimize("-fthread-jumps")

#pragma GCC optimize("-funroll-loops")

#pragma GCC optimize("-fwhole-program")

#pragma GCC optimize("-freorder-blocks")

#pragma GCC optimize("-fschedule-insns")

#pragma GCC optimize("inline-functions")

#pragma GCC optimize("-ftree-tail-merge")

#pragma GCC optimize("-fschedule-insns2")

#pragma GCC optimize("-fstrict-aliasing")

#pragma GCC optimize("-fstrict-overflow")

#pragma GCC optimize("-falign-functions")

#pragma GCC optimize("-fcse-skip-blocks")

#pragma GCC optimize("-fcse-follow-jumps")

#pragma GCC optimize("-fsched-interblock")

#pragma GCC optimize("-fpartial-inlining")

#pragma GCC optimize("no-stack-protector")

#pragma GCC optimize("-freorder-functions")

#pragma GCC optimize("-findirect-inlining")

#pragma GCC optimize("-fhoist-adjacent-loads")

#pragma GCC optimize("-frerun-cse-after-loop")

#pragma GCC optimize("inline-small-functions")

#pragma GCC optimize("-finline-small-functions")

#pragma GCC optimize("-ftree-switch-conversion")

#pragma GCC optimize("-foptimize-sibling-calls")

#pragma GCC optimize("-fexpensive-optimizations")

#pragma GCC optimize("-funsafe-loop-optimizations")

#pragma GCC optimize("inline-functions-called-once")

#pragma GCC optimize("-fdelete-null-pointer-checks")

#include<vector>

#include<list>

#include<map>

#include<set>

#include<deque>

#include<stack>

#include<bitset>

#include<algorithm>

#include<functional>

#include<numeric>

#include<utility>

#include<sstream>

#include<iostream>

#include<iomanip>

#include<cstdio>

#include<cmath>

#include<cstdlib>

#include<cstring>

#include<ctime>

#include<stdio.h>

#define ll long long

#define maxn 100000

using namespace std;

ll n;

string ans;

int main()

{

	cin>>n;

	ans="";

	while(n>0)

	{

		n--;

		int tmp=n%26;

		n/=26;

		ans+='a'+tmp;

	}

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

	cout<<ans<<endl;

	return 0;

}

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

#include <string.h>



int main() {

    long long int input; 

	long long int modulo;

    char nama[55];

    scanf("%lld", &input);

    int i = 0;

    while (input > 0) {

        modulo = (input - 1) % 26;

        nama[i++] = 'a' + modulo;

        input = (input - modulo) / 26;

    }

    nama[i] = '\0';

    int panjang = strlen(nama);

    for (panjang--; panjang >= 0; panjang--) {

        printf("%c", nama[panjang]);

    }

return 0;    

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

#include <stdio.h>

#include<cmath>

#include<cctype>

#include<cstdio>

#include <algorithm>

#include <string.h>

#include<math.h>

#include<map>

#include<bits/stdc++.h>

#include<unordered_map>

#define Maxn 100005

#define ll long long

using namespace std;



char s[15];

int main(){

	ll n;

	int m=0;



	scanf("%lld",&n);

	while(n){

        s[m++]=(n-1)%26+'a';

        n--;

        n/=26;

	}

	for(int i=m-1;i>=0;i--)

        putchar(s[i]);

    printf("\n");

	return 0;

}


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

#include <string.h>



int main() {

    long long int input; 

	long long int modulo;

    char nama[55];

    scanf("%lld", &input);

    int i = 0;

    while (input > 0) {

        modulo = (input - 1) % 26;

        nama[i++] = 'a' + modulo;

        input = (input - modulo) / 26;

    }

    nama[i] = '\0';

    int panjang = strlen(nama);

    for (panjang--; panjang >= 0; panjang--) {

        printf("%c", nama[panjang]);

    }

return 0;    

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

using namespace std;

typedef long long ll;

vector<int> v;

int main(){

    ll num;scanf("%lld",&num);

    while(num--){

        v.push_back(num%26);

        num/=26;

    }

    for(int i=v.size()-1;i>=0;i--) printf("%c",(char)(v[i]+'a'));

    return 0;

}

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

#include <string.h>



int main() {

    long long int input; 

	long long int modulo;

    char nama[55];

    scanf("%lld", &input);

    int i = 0;

    while (input > 0) {

        modulo = (input - 1) % 26;

        nama[i++] = 'a' + modulo;

        input = (input - modulo) / 26;

    }

    nama[i] = '\0';

    int panjang = strlen(nama);

    for (panjang--; panjang >= 0; panjang--) {

        printf("%c", nama[panjang]);

    }

return 0;    

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

using namespace std;

long long n;



int main()

{

    ios::sync_with_stdio(false);

    cin.tie(0);

    long long n;

    cin>>n;

    string ans;

    while(n--){

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

        n/=26;

    }

    cout<<ans;

}

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

#include <string.h>



int main() {

    long long int input; 

	long long int modulo;

    char nama[55];

    scanf("%lld", &input);

    int i = 0;

    while (input > 0) {

        modulo = (input - 1) % 26;

        nama[i++] = 'a' + modulo;

        input = (input - modulo) / 26;

    }

    nama[i] = '\0';

    int panjang = strlen(nama);

    for (panjang--; panjang >= 0; panjang--) {

        printf("%c", nama[panjang]);

    }

return 0;    

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

using namespace std;

long long int n,r,an;



int main(){

	scanf("%lld",&n);

	r = 26;

	stack<long long int>s;

    while(n){

    	an = n%r;

    	if(an == 0){

    		an = 26;

    		n = n/r;

    		n --;

    	}else{

    		n = n/r;

    	}

        s.push(an);

    }

    while(!s.empty()){

        printf("%c",(int)s.top()+'a'-1);

        s.pop();

    }

    printf("\n");

    return 0;

}

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

#include <string.h>



int main() {

    long long int input; 

	long long int modulo;

    char nama[55];

    scanf("%lld", &input);

    int i = 0;

    while (input > 0) {

        modulo = (input - 1) % 26;

        nama[i++] = 'a' + modulo;

        input = (input - modulo) / 26;

    }

    nama[i] = '\0';

    int panjang = strlen(nama);

    for (panjang--; panjang >= 0; panjang--) {

        printf("%c", nama[panjang]);

    }

return 0;    

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

#include<math.h>

#include<vector>

#include<string>

#include<algorithm>



using namespace std;



#define vi vector<int>

#define vvi vector<vi>

#define rpt(i,x) for (int i = 0; i < x; i++)

#define fti(i,f,t) for (int i = f; i <= t; i++)

#define fte(i,f,t) for (int i = f; i < t; i++)

#define rptws(i,x,s) for (int i = 0; i < x; i += s)

#define llrpt(i,x) for (long long i = 0; i < x; i++)

#define llfti(i,f,t) for (long long i = f; i <= t; i++)

#define llfte(i,f,t) for (long long i = f; i < t; i++)



int main () {

	string alpha = "abcdefghijklmnopqrstuvwxyz";



	long long n;

	cin>>n;



	string ans[500];



	int i = 0;

	while (n) {

		n--;

		ans[i++] = alpha[n%26];

		n /= 26;

	}



	for (int j = i; j >= 0; j--) cout<<ans[j];

	return 0;

}




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

#include <string.h>



int main() {

    long long int input; 

	long long int modulo;

    char nama[55];

    scanf("%lld", &input);

    int i = 0;

    while (input > 0) {

        modulo = (input - 1) % 26;

        nama[i++] = 'a' + modulo;

        input = (input - modulo) / 26;

    }

    nama[i] = '\0';

    int panjang = strlen(nama);

    for (panjang--; panjang >= 0; panjang--) {

        printf("%c", nama[panjang]);

    }

return 0;    

}