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

using namespace std;



string base26 (long long n)

{

    string t = "zabcdefghijklmnopqrstuvwxy" ,res;

    while(n > 0)

    {

        long long x = n%26;

        res = t[x]+res;

        n = ceil((double)n/26)-1;

    }

    return res;

}



int main()

{

    long long n;

    cin >> n;

    cout << base26(n)<<endl;

    return 0;

}

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



int main(){

	

	long long int n;

	scanf("%lld", &n);

	int i=0, temp;;

	char word[100];

	while(n>0){

		temp=0;

		temp=n%26;

		if(temp==0){

			word[i] = 'z';

			n=n/26-1;

		}

		else{

			word[i] = temp+'a'-1;

			n/=26;

		}

//		n/=26;

//		printf("%c", temp+'a'-1);

		i++;

	}

//	printf("%d", i);

	word[i]='\0';

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

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

	}

	return 0;

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

using namespace std; 





int main()  

{ 



    long long n;

    cin >> n;

    int arr[10000]; 

    int i=0; 

   

    while(n){ 

        arr[i]=n%26; 

        n=n/26; 

        i++; 

    } 

   

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

        if (arr[j]<=0) { 

            arr[j]+=26; 

            arr[j+1]=arr[j+1]-1; 

        } 

    } 

    for (int j=i; j>= 0; j--) { 

        if (arr[j]>0) 

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

    } 

    cout << endl; 

    return 0;

} 

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



int main(){

	

	long long int n;

	scanf("%lld", &n);

	int i=0, temp;;

	char word[100];

	while(n>0){

		temp=0;

		temp=n%26;

		if(temp==0){

			word[i] = 'z';

			n=n/26-1;

		}

		else{

			word[i] = temp+'a'-1;

			n/=26;

		}

//		n/=26;

//		printf("%c", temp+'a'-1);

		i++;

	}

//	printf("%d", i);

	word[i]='\0';

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

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

	}

	return 0;

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

#include<iomanip>

#include<cmath>

#include<algorithm>

#include<string>

using namespace std;

int main()

{

    long long n;

    cin>>n;

    string dog="";

while(n>0){

if(n%26==0){

    dog='z'+dog;

    n--;

}

  else if(n<703){

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

    dog=answer+dog;

     }

  else if(n<18279){

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

    dog=answer+dog;

     }

     else if(n<47255){

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

    dog=answer+dog;

     }else if(n>47255){

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

    dog=answer+dog;

     }

     n=n/26;

}

cout<<dog;

}






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



int main(){

	

	long long int n;

	scanf("%lld", &n);

	int i=0, temp;;

	char word[100];

	while(n>0){

		temp=0;

		temp=n%26;

		if(temp==0){

			word[i] = 'z';

			n=n/26-1;

		}

		else{

			word[i] = temp+'a'-1;

			n/=26;

		}

//		n/=26;

//		printf("%c", temp+'a'-1);

		i++;

	}

//	printf("%d", i);

	word[i]='\0';

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

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

	}

	return 0;

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

using namespace std;

#define mx 38461538461538

typedef long long int ll;

int main(){

    ll n,m;

    cin>>n;

    vector<char>v;

    deque<char>duck;

    v.push_back('z');

    v.push_back('a');

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

        v.push_back('a'+i);

    }

    while(n!=0){

       if(n%26==0){

        duck.push_front(v[n%26]);

        n=(n/26)-1;

       }

       else{

        duck.push_front(v[n%26]);

        n=n/26;

       }

    }

    for(int i=0;i<duck.size();i++)cout<<duck[i];

    cout<<endl;

    duck.clear();

    return 0;

}


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



int main(){

	

	long long int n;

	scanf("%lld", &n);

	int i=0, temp;;

	char word[100];

	while(n>0){

		temp=0;

		temp=n%26;

		if(temp==0){

			word[i] = 'z';

			n=n/26-1;

		}

		else{

			word[i] = temp+'a'-1;

			n/=26;

		}

//		n/=26;

//		printf("%c", temp+'a'-1);

		i++;

	}

//	printf("%d", i);

	word[i]='\0';

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

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

	}

	return 0;

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

#include <bits/stdc++.h>

using namespace std;



// Common file

#include <ext/pb_ds/assoc_container.hpp>

// Including tree_order_statistics_node_update

#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;

#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>







#define pb push_back

#define F first

#define S second

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



using ll = long long;

using ld = long double;

using ul = unsigned long long;

using ii = pair<int, int>;

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

#define ReadFile            freopen("input.in","r",stdin)

#define WriteFile           freopen("output.txt","w",stdout)

const ll mod7 = 1000000007,mod = 1000000000,OO = 0x3f3f3f3f;

const ld EPS = 1e-7;

double Pi=acos(-1);

const ld rad=Pi/180.0;

ll power(ll x, ll y, ll p)

{

    ll res = 1;

    while (y > 0)

    {

        if (y & 1)

            res = (res*x) % p;

            y = y>>1;

            x = (x*x) % p;

    }

    return res;

}

ll nCr (ll n,ll m)

{

    return(m == 0)?1:n*nCr(n-1,m-1)/m;

}



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



int main()

{

    ll n;

    string ans;

    cin >> n;



    while(n > 0) {

        n -= 1;

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

        n /= 26;

    }



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



    cout << ans << "\n";



    return 0;

}


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



int main(){

	

	long long int n;

	scanf("%lld", &n);

	int i=0, temp;;

	char word[100];

	while(n>0){

		temp=0;

		temp=n%26;

		if(temp==0){

			word[i] = 'z';

			n=n/26-1;

		}

		else{

			word[i] = temp+'a'-1;

			n/=26;

		}

//		n/=26;

//		printf("%c", temp+'a'-1);

		i++;

	}

//	printf("%d", i);

	word[i]='\0';

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

		printf("%c", word[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.291377726734612x):
#include <stdio.h>

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	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.37287439506584x):
#include <stdio.h>

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	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.3120832751432765x):
#include <stdio.h>

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	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.238730779750863x):
#include <stdio.h>

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	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.250953843982637x):
#include <stdio.h>

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	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.3661895136782745x):
#include <stdio.h>

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	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.295820747566765x):
#include <stdio.h>

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	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.398567636107657x):
#include <stdio.h>

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	return 0;

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



using namespace std;



typedef long long ll;



int main()

{

    ll n,x,pow=1,cumm=-1,siz=0;

    cin>>n;

    string s;

    while(cumm+pow<n){

        cumm+=pow;

        pow*=26;

        siz++;

    }

    n-=cumm;

    n--;

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

        x=n%26;

        s+=x+'a';

        n/=26;

    }

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

    cout<<s;



    return 0;

}


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

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	return 0;

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

#include <bits/stdc++.h>

using namespace std;

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

#define pb push_back

#define loop(i,start,n)  for(int i=start;i<n;i++)

#define rloop(i,start,n)  for(int i=start;i>n;i--)



using ll = long long;

using vi = vector<int>;

using vll = vector<ll>;

using vvi = vector<vi>;

using vs = vector<string>;

const ll inf = 2e9+3;



void solve(){

    int tc=1 ;

    //cin >> tc;

    while(tc--) {

        ll n; cin >> n;

        string res = "";

        while (n){

            int c = n%26;



            if(c-1>=0)res+=char('a'+c-1);

            else res+='z';



            if(c==0) n--;

            n/=26;

        }

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

        cout << res << endl;

    }

}



int main()

{

    ios_base::sync_with_stdio(false);

    cin.tie(0);

    cout.tie(0);

    solve();

    return 0;

}

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

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	return 0;

}
// Slower C++ solution:
#define ll long long int



#include <bits/stdc++.h>



using namespace std;



const int N = 2e5 + 5;

ll arr[N];

bool b[N];



int main() {



    ll n;

    cin >> n;

    string temp = "";

    while (n) {

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

        temp += c;

        n--;

        n /= 26;

    }



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

    cout << temp << endl;

    return 0;

}

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

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	return 0;

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

using namespace std;



string base26 (long long n)

{

    string t = "zabcdefghijklmnopqrstuvwxy" ,res;

    while(n > 0)

    {

        long long x = n%26;

        res = t[x]+res;

        n = ceil((double)n/26)-1;

    }

    return res;

}



int main()

{

    long long n;

    cin >> n;

    cout << base26(n)<<endl;

    return 0;

}

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

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	return 0;

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

using namespace std; 





int main()  

{ 



    long long n;

    cin >> n;

    int arr[10000]; 

    int i=0; 

   

    while(n){ 

        arr[i]=n%26; 

        n=n/26; 

        i++; 

    } 

   

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

        if (arr[j]<=0) { 

            arr[j]+=26; 

            arr[j+1]=arr[j+1]-1; 

        } 

    } 

    for (int j=i; j>= 0; j--) { 

        if (arr[j]>0) 

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

    } 

    cout << endl; 

    return 0;

} 

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

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	return 0;

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

#include<iomanip>

#include<cmath>

#include<algorithm>

#include<string>

using namespace std;

int main()

{

    long long n;

    cin>>n;

    string dog="";

while(n>0){

if(n%26==0){

    dog='z'+dog;

    n--;

}

  else if(n<703){

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

    dog=answer+dog;

     }

  else if(n<18279){

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

    dog=answer+dog;

     }

     else if(n<47255){

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

    dog=answer+dog;

     }else if(n>47255){

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

    dog=answer+dog;

     }

     n=n/26;

}

cout<<dog;

}






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

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	return 0;

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

using namespace std;

#define mx 38461538461538

typedef long long int ll;

int main(){

    ll n,m;

    cin>>n;

    vector<char>v;

    deque<char>duck;

    v.push_back('z');

    v.push_back('a');

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

        v.push_back('a'+i);

    }

    while(n!=0){

       if(n%26==0){

        duck.push_front(v[n%26]);

        n=(n/26)-1;

       }

       else{

        duck.push_front(v[n%26]);

        n=n/26;

       }

    }

    for(int i=0;i<duck.size();i++)cout<<duck[i];

    cout<<endl;

    duck.clear();

    return 0;

}


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

#include <string.h>



int main() {

	long long int a;

	

	char ans[255] = {};

		

	scanf("%lld", &a);



	int i = 0;



		while(a > 0) {

			a--;

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

			a /= 26;

			i++;

		}

	

	ans[i] = '\0';

	int len = strlen(ans);

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

	

	printf("%c", ans[len]);

	

	}

	

	return 0;

}