stablegradients/pie-gem5-bysrc huggingface dataset:
// Original C++ solution (slower):
#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;

}

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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}


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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}

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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}

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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}

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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}




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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    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()

{

    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;

}


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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}

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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}

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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}

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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

} 

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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}






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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}


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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

}


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

 

int main(){

    long long int x;

    scanf("%lld",&x);

 

    char name[100];

    int i=0;

    

    while(x!=0){

        x--;

        int b = x%26;

        name[i] ='a'+ b;

        x/=26;

        i++;

    }

 

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

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

    }

    

    return 0;

}

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

#include<algorithm>

#include<string>

#include<vector>

#include<math.h>

using namespace std;

int main()

{

long long n;

cin >> n;

string s;

while(n--)

{

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

n=n/26;

}

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

cout<<s;

return 0;

}

    

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





int main () {

	long long int N;

	scanf("%lld", &N);

	char nama[100];

	int i = 0;

	

	while ( N != 0) {

		N--;

		int M = N % 26;

		nama[i] = 'a' + M;

		N /= 26;

		i++;

	}

	

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

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

	}

	

	return 0;

}

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

#include <iostream>

#include <algorithm>



using namespace std;

const int MAXN = 2e6 + 5;





char ans[MAXN];

//int main() {

//	long long n;

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

//		printf("%lld\n", n * (n + 1) / 2); 

//	}

//	return 0;

//}



int main() {

	long long n; scanf("%lld", &n); int l = 0;

	while (n) {n--;

		ans[++l] = n % 26 + 'a'; n /= 26; 

	}

	for (int i = l; i >= 1; i--) putchar(ans[i]);

	return 0;

}

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



int main(){

	

	long long a;

	scanf("%lld",&a);

	

	int i = 0;

	char str[100];

	

	while(a > 0){

		int temp = a % 26;

		

		if(temp == 0){

			str[i++] = 'z';

			a = (a/26) - 1;

		}else{

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

			a = a/26;

		}

	}

	str[i] = '\0';

	



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

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

	}

	

	

	return 0;

}


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

#include<string>

#include<algorithm>

using namespace std;

typedef long long ll;

const int maxn = 50;

int main(){

	ll n;

	cin >> n;

	string str = "";

	while(n){

		int a = (n-1)%26;

		n--;

		n/=26;

		char c = 'a' + a;

		str = c + str;

	}

	cout << str << endl;

	return 0;

}

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



int main(){

	

	long long a;

	scanf("%lld",&a);

	

	int i = 0;

	char str[100];

	

	while(a > 0){

		int temp = a % 26;

		

		if(temp == 0){

			str[i++] = 'z';

			a = (a/26) - 1;

		}else{

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

			a = a/26;

		}

	}

	str[i] = '\0';

	



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

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

	}

	

	

	return 0;

}


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

using namespace std;

typedef long long ll;

int main(){

	ll n;

	cin >> n;

	string s = "";

	while(n){

		n--;

		//cout << n << endl;

		char c = n % 26 + 'a';

		//cout << n << " % 26 = " << c << endl;

		s = c + s;

		n/=26;

	}

	cout << s << endl;

	return 0;

}

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



int main(){

	

	long long a;

	scanf("%lld",&a);

	

	int i = 0;

	char str[100];

	

	while(a > 0){

		int temp = a % 26;

		

		if(temp == 0){

			str[i++] = 'z';

			a = (a/26) - 1;

		}else{

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

			a = a/26;

		}

	}

	str[i] = '\0';

	



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

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

	}

	

	

	return 0;

}


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

#include <cstdio>

#include <cstring>

#include <string>

using namespace std;



int main(){

    long long n,k;

    string s="";

    cin >> n;

    k=n;

    while(k--){

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

        k /= 26;

    }

    cout << s;

    return 0;

}

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



int main(){

	

	long long a;

	scanf("%lld",&a);

	

	int i = 0;

	char str[100];

	

	while(a > 0){

		int temp = a % 26;

		

		if(temp == 0){

			str[i++] = 'z';

			a = (a/26) - 1;

		}else{

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

			a = a/26;

		}

	}

	str[i] = '\0';

	



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

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

	}

	

	

	return 0;

}


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

#include <vector> 

#include <cstdio>

#include <iostream>

#include <algorithm>

using namespace std;



vector<char> ans;



int main() {

	long long n;

	cin >> n;

	long long m = n;

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

		if(n == 0) break;

		if(n % 26) {

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

				

			n /= 26;

			ans.push_back(cc);

		}

		 else{

			char cc = 'a' + 25;

			n /= 26;

			n--;

			

			ans.push_back(cc);

		}

	}

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

		cout << ans[i];

	}

	return 0;

}

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



int main(){

	

	long long a;

	scanf("%lld",&a);

	

	int i = 0;

	char str[100];

	

	while(a > 0){

		int temp = a % 26;

		

		if(temp == 0){

			str[i++] = 'z';

			a = (a/26) - 1;

		}else{

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

			a = a/26;

		}

	}

	str[i] = '\0';

	



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

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

	}

	

	

	return 0;

}


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

#define rush() int T;scanf("%d",&T);int kase=1;while(T--)

#define pb(x) push_back(x)

#define pr pair<int,int>

#define mem(a) memset(a,0,sizeof(a))

#define  fi first

#define  se second

using namespace std;

typedef long long ll;

const ll maxn=2e6+5;

const ll mod=1e9+7;

ll quickpow(ll x,ll y,ll mod){ll ans=1;while(y){if(y&1)ans=ans*x%mod;x=x*x%mod;y>>=1;}return ans;}



int main()

{

    ll n;

    cin>>n;

    stack<int>s;

    while(n)

    {

        int t;

        t=n%26;

        if(t==0)

        t=26;

        n=(n-t)/26;

        s.push(t);

    }

    while(!s.empty())

    {

        int t=s.top();

        s.pop();

        char a='a'+t-1;

        cout<<a;

    }

    return 0;

}


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



int main(){

	

	long long a;

	scanf("%lld",&a);

	

	int i = 0;

	char str[100];

	

	while(a > 0){

		int temp = a % 26;

		

		if(temp == 0){

			str[i++] = 'z';

			a = (a/26) - 1;

		}else{

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

			a = a/26;

		}

	}

	str[i] = '\0';

	



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

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

	}

	

	

	return 0;

}


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

 using namespace std;

 inline int read(){

    int x=0,f=1; char ch=getchar();

    while(ch<'0' || ch>'9') {if(ch=='-') f=-1; ch=getchar();}

    while(ch>='0' && ch<='9') {x=x*10+ch-'0'; ch=getchar();}

    return x*f;

 }

 #define LL long long

 #define MAXN 100010

 LL N;

 int a[100010];

 int main(){

	cin>>N;

	int cnt = 0;

	LL base = 26;

	while (N){

		a[++cnt] = N%26;

		N /= 26;

	}

	//if (cnt>1 && a[cnt]==1) cnt--,a[cnt]+=26;

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

		if (a[i] <= 0){

			a[i] += 26; 

			a[i+1] --;

		}

	}

	while (a[cnt]<=0) cnt--;

	/*

	for (int i=cnt; i; i--){

		//putchar(a[i] + 'a'-1);

		printf("%d\n",a[i]);

	}

	*/

	for (int i=cnt; i; i--){

		putchar(a[i] + 'a'-1);

	}

	puts("");

 	return 0;

 }

 

 

 /*

2



27



123456789



1



26



702



475253

 */

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



int main(){

	

	long long a;

	scanf("%lld",&a);

	

	int i = 0;

	char str[100];

	

	while(a > 0){

		int temp = a % 26;

		

		if(temp == 0){

			str[i++] = 'z';

			a = (a/26) - 1;

		}else{

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

			a = a/26;

		}

	}

	str[i] = '\0';

	



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

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

	}

	

	

	return 0;

}


// Fastest known solution for this problem: