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

#include <vector>



using namespace std;



unsigned long long int power(int times)

{

    unsigned long long int pow = 1;

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

        pow *= 26;

    return pow;

}



int main()

{

    unsigned long long int n, mini = 1, maxi = 26, diff, sub;

    int i;

    cin >> n;

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

    {

        if (n >= mini && n <= maxi)

            break;

        mini = maxi + 1;

        maxi = maxi + power(i+1);

    }

    vector<int> digits(i, 0);

    diff = n - mini;

    sub = diff / 26;

    digits[0] = diff - 26 * sub;

    for (int j = 1 ; sub > 0 ; j++)

    {

        if (sub < 26)

        {

            digits[j] = sub;

            break;

        }

        else

        {

            diff = sub;

            sub /= 26;

            digits[j] = diff - 26 * sub;

        }

    }

    for (int j = digits.size()-1 ; j >= 0 ; j--)

    {

        cout << char('a' + digits[j]);

    }

    cout << endl;

    return 0;

}


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

#include <string.h>

 

int main()

{

    long long n;

    scanf("%lld",&n);

    char x[100]={0};

    int i=0;

    n--;

    while(n>=0){

        x[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

using namespace std;

typedef long long ll;

int main()

{

    ll n,mod,div,i;

    string s;

    vector<char>v;

    cin>>n;

    while(n>0)

    {

        n--;

        mod=n%26;

        //div=n/26;

        n/=26;

        /*if(mod==0)

        {

            mod=26;

            n--;

        }*/

        char j='a'+mod;

        v.push_back(j);

        //cout<<mod<<endl;

    }

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

    for(i=0; i<v.size(); i++)

        cout<<v[i];

    v.clear();

    return 0;

}


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

#include <string.h>

 

int main()

{

    long long n;

    scanf("%lld",&n);

    char x[100]={0};

    int i=0;

    n--;

    while(n>=0){

        x[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

}
// Slower C++ solution:
#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;

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

}
// Slower C++ solution:
#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;

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

}
// Slower C++ solution:
#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;

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

}
// Slower C++ solution:
#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;

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

}
// Slower C++ solution:
#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;

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

}
// Slower C++ solution:
#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;

}


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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

}
// Slower C++ solution:
 #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

 */

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

#include<stack>

using namespace std;

int ans[100];

int main(){

    long long N;

    while(~scanf("%lld",&N)){

        int temp = 0;

        while(N){

            ans[temp++]=(N-1)%26;

            N--;

            N/=26;

        }

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

            cout << (char)('a'+ans[i]);

        }

        cout << endl;

    }

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

#include<algorithm>

#include<cmath>

#include<queue>

#include<list>

#include<cstdio>

#include<set>

using namespace std;

int  main()

{

	long long n;

	cin>>n;

	int a;

	int x[1000];

	int num=0;

	while(n)

	{

		a=(n-1)%26;

		x[num++]=a;

		n--;

		n=n/26;

	}

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

		cout<<static_cast<char>(x[i]+'a');

    return 0;

}




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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

#include <cstring>

#include <algorithm>

#include <cmath>

#define N 100006

#define ll long long

#define dd double

#define esp 1e-10

using namespace std;



ll n;

int a[106],cnt;



int main(){

	scanf("%lld",&n);

	--n;

	cnt=0;

	while(n>0){

		a[++cnt]=n%26;

		n/=26;

		--n;

	}

	if(n==0)

		++cnt;

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

		cout<<(char)(a[i]+'a');

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

using namespace std;

typedef long long ll;

const int N=25;

const int M=26;

#define endl '\n'



char str[N];



int main(){

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

	cout.setf(ios::fixed),cout.precision(3);

	ll n,base=26,cnt=0;

	cin>>n;

	n--;

	while(n>=base){

		n-=base;

		base*=M;

	}

	base/=M;

	while(base){

		str[cnt++]=(n/base)+'a';

		n%=base;

		base/=M;

	}

	str[cnt]='\0';

	cout<<str<<endl;

	return 0;

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

#include <algorithm>

#include <vector>



using namespace std;



typedef long long ll;

typedef unsigned long long ull;







int main(){

    ll n;

    cin >> n;

    string s = "";

    while (n){

        if (n%26==0){

            s += 'z';

            n--;

        }

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

        n/=26;

    }

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

    cout << s;

    

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

using namespace std;



int main()

{

    ios::sync_with_stdio(0);

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

    long long n; cin >> n;

    string s = "";

    while (n)

    {

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

        n /= 26;

    }

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

    cout << s << '\n';

    return 0;

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

#include <bits/stdc++.h>

#include <string>

using namespace std;

int main()

{

    string s;

    long long n, k;

    cin >> n;

    while (n--)

    {

        k = n % 26 + 97;

        n /= 26;

        s += char (k);

    }

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

    cout << s;

    return 0;

}


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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

#define ll long long

#define endl "\n"

#define pb push_back

#define READ(FILE) freopen(FILE,"r",stdin)

#define WRITE(FILE) freopen(FILE,"w",stdout)

#define loop(i,s,e) for(int i=s;i<e;i++)

#define mego fast();

using namespace std;

void fast()

{

    ios::sync_with_stdio(0);

    cin.tie(0);

    cout.tie(0);

}



ll lcm(ll x, ll y)

{

    return (x*y)/__gcd(x,y);

}

int sum(string s)

{

    int x=0,sz=s.size();

    loop(i,0,sz)x+=(s[i]-'0');

    return x;

}

int main()

{

    mego

ll x,y=1;

cin>>x;

string ans="";

while(x)

{

    x--;

    ans+=('a'+((x%26)));

    x/=26;

}

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

    cout<<ans;

    return 0;

}

/*26*/


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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

#define ll long long

#define _ ios::sync_with_stdio(false);cout.tie(NULL);cin.tie(NULL);

using namespace std;



int main() { _

    ll n; cin >> n;

    string s;

    while(n != 0){

        n--;

        ll temp = n % 26;

        s += 'a' + temp;

        n /= 26;

    }

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

        cout << s[i];

    }

}

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

#include <algorithm>

#include <string>

using namespace std;

typedef long long ll ;

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;

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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

#include <vector>



using namespace std;



unsigned long long int power(int times)

{

    unsigned long long int pow = 1;

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

        pow *= 26;

    return pow;

}



int main()

{

    unsigned long long int n, mini = 1, maxi = 26, diff, sub;

    int i;

    cin >> n;

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

    {

        if (n >= mini && n <= maxi)

            break;

        mini = maxi + 1;

        maxi = maxi + power(i+1);

    }

    vector<int> digits(i, 0);

    diff = n - mini;

    sub = diff / 26;

    digits[0] = diff - 26 * sub;

    for (int j = 1 ; sub > 0 ; j++)

    {

        if (sub < 26)

        {

            digits[j] = sub;

            break;

        }

        else

        {

            diff = sub;

            sub /= 26;

            digits[j] = diff - 26 * sub;

        }

    }

    for (int j = digits.size()-1 ; j >= 0 ; j--)

    {

        cout << char('a' + digits[j]);

    }

    cout << endl;

    return 0;

}


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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

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

using namespace std;

typedef long long ll;

int main()

{

    ll n,mod,div,i;

    string s;

    vector<char>v;

    cin>>n;

    while(n>0)

    {

        n--;

        mod=n%26;

        //div=n/26;

        n/=26;

        /*if(mod==0)

        {

            mod=26;

            n--;

        }*/

        char j='a'+mod;

        v.push_back(j);

        //cout<<mod<<endl;

    }

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

    for(i=0; i<v.size(); i++)

        cout<<v[i];

    v.clear();

    return 0;

}


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

int main()

{

    long long n;

    scanf("%lld",&n);

    char S[100]={0};

    int i=0;

    n--;

    while(n>=0){

        S[i]=n%26+'a';

        n/=26;

        i++;

        n--;

    }

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

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

    }

    return 0;

}
// Slower C++ solution:
#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;

}

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

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

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

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

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#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;

}

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

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

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

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

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#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;

}

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

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

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

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

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#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;

}

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

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

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

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

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#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;

}

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

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

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

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

	}

	puts("");

	return 0;

}
// Slower C++ solution:
#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;

}


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

#define ll long long



int main(){

	ll n, rev, i = 0;

	scanf("%lld", &n);

	char str[100];

	while(n){

		n--;

		rev = n % 26;

		n /= 26;

		str[i] = 'a' + rev;

		i++;

	}

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

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

	}

	puts("");

	return 0;

}