stablegradients/pie-gem5-pairs huggingface dataset:
// 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.327577166017643x):
//1,000,000,000,000,001	dogs dinomorin

//trs dinamain 1-26 a-z

//27-702 aa, ab, ac-zy, zz

//703-18278 aaa, aab, aac-zzy, zzz

//18279 - 475254 aaaa, aaab-zzzy, zzzz

//dst

//trs ditanya, utk anjing ke N, siapa namanya

//1<=N<=1000000000000001

//inputnya int sekali doang



#include <stdio.h>

int main(){

	long long int pilih;

	scanf("%lld", &pilih);	//nomor ajgnya

	

	char namaAnjing[16]={0};	//kosong semua

	

	pilih--;	//biar dia sesuai sama indeks

	

	int i = 0;

	while(pilih > -1)

	{

		namaAnjing[i] = pilih % 26 + 'a';	//isi dari namaAnjing ke i itu huruf

											//dia bakal bagi 26 biar jadi angka yg bisa diubah jadi huruf

											//kl a bagi 26 kan 0 sisa baginya, abis soalnya, trs tambahin 'a' biar jadi huruf

											//kalo b kan 1, ditambah a jadi asciinya b, dst

		pilih = pilih / 26;					//ini fungsinya cmn 1 sebenernya, biar dia bisa abis, jd kl ga dibagi dia bakal gede terus angkanya, trs namanya panjang

											//kan salah eta, kita maunya urutan kan, makanya dibagi 26 jadi kayak tiap udah 1 huruf muncul, ya berarti udh 1 abjad terlewati kan

		i++; //biar dia isi nama indeksnya bener urutannya maju

		pilih--;		//biar dia tetep masuk dlm array

	}										

	

	

	while(i--)		//ini kan bakal kebalik munculnya di inya, jadi biar bener urutannya

	{					//print aja dari paling gede trs dikurangin, slesai

		printf("%c", namaAnjing[i]);		//di print terus sampe dia udah keluar dari array

	}

	

	//kalo udah biar aman, ato kalo user gila inputnya gaada

	printf("\n");

	

	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.264235953798238x):
//1,000,000,000,000,001	dogs dinomorin

//trs dinamain 1-26 a-z

//27-702 aa, ab, ac-zy, zz

//703-18278 aaa, aab, aac-zzy, zzz

//18279 - 475254 aaaa, aaab-zzzy, zzzz

//dst

//trs ditanya, utk anjing ke N, siapa namanya

//1<=N<=1000000000000001

//inputnya int sekali doang



#include <stdio.h>

int main(){

	long long int pilih;

	scanf("%lld", &pilih);	//nomor ajgnya

	

	char namaAnjing[16]={0};	//kosong semua

	

	pilih--;	//biar dia sesuai sama indeks

	

	int i = 0;

	while(pilih > -1)

	{

		namaAnjing[i] = pilih % 26 + 'a';	//isi dari namaAnjing ke i itu huruf

											//dia bakal bagi 26 biar jadi angka yg bisa diubah jadi huruf

											//kl a bagi 26 kan 0 sisa baginya, abis soalnya, trs tambahin 'a' biar jadi huruf

											//kalo b kan 1, ditambah a jadi asciinya b, dst

		pilih = pilih / 26;					//ini fungsinya cmn 1 sebenernya, biar dia bisa abis, jd kl ga dibagi dia bakal gede terus angkanya, trs namanya panjang

											//kan salah eta, kita maunya urutan kan, makanya dibagi 26 jadi kayak tiap udah 1 huruf muncul, ya berarti udh 1 abjad terlewati kan

		i++; //biar dia isi nama indeksnya bener urutannya maju

		pilih--;		//biar dia tetep masuk dlm array

	}										

	

	

	while(i--)		//ini kan bakal kebalik munculnya di inya, jadi biar bener urutannya

	{					//print aja dari paling gede trs dikurangin, slesai

		printf("%c", namaAnjing[i]);		//di print terus sampe dia udah keluar dari array

	}

	

	//kalo udah biar aman, ato kalo user gila inputnya gaada

	printf("\n");

	

	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.3041328482705055x):
//1,000,000,000,000,001	dogs dinomorin

//trs dinamain 1-26 a-z

//27-702 aa, ab, ac-zy, zz

//703-18278 aaa, aab, aac-zzy, zzz

//18279 - 475254 aaaa, aaab-zzzy, zzzz

//dst

//trs ditanya, utk anjing ke N, siapa namanya

//1<=N<=1000000000000001

//inputnya int sekali doang



#include <stdio.h>

int main(){

	long long int pilih;

	scanf("%lld", &pilih);	//nomor ajgnya

	

	char namaAnjing[16]={0};	//kosong semua

	

	pilih--;	//biar dia sesuai sama indeks

	

	int i = 0;

	while(pilih > -1)

	{

		namaAnjing[i] = pilih % 26 + 'a';	//isi dari namaAnjing ke i itu huruf

											//dia bakal bagi 26 biar jadi angka yg bisa diubah jadi huruf

											//kl a bagi 26 kan 0 sisa baginya, abis soalnya, trs tambahin 'a' biar jadi huruf

											//kalo b kan 1, ditambah a jadi asciinya b, dst

		pilih = pilih / 26;					//ini fungsinya cmn 1 sebenernya, biar dia bisa abis, jd kl ga dibagi dia bakal gede terus angkanya, trs namanya panjang

											//kan salah eta, kita maunya urutan kan, makanya dibagi 26 jadi kayak tiap udah 1 huruf muncul, ya berarti udh 1 abjad terlewati kan

		i++; //biar dia isi nama indeksnya bener urutannya maju

		pilih--;		//biar dia tetep masuk dlm array

	}										

	

	

	while(i--)		//ini kan bakal kebalik munculnya di inya, jadi biar bener urutannya

	{					//print aja dari paling gede trs dikurangin, slesai

		printf("%c", namaAnjing[i]);		//di print terus sampe dia udah keluar dari array

	}

	

	//kalo udah biar aman, ato kalo user gila inputnya gaada

	printf("\n");

	

	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.258084102334914x):
//1,000,000,000,000,001	dogs dinomorin

//trs dinamain 1-26 a-z

//27-702 aa, ab, ac-zy, zz

//703-18278 aaa, aab, aac-zzy, zzz

//18279 - 475254 aaaa, aaab-zzzy, zzzz

//dst

//trs ditanya, utk anjing ke N, siapa namanya

//1<=N<=1000000000000001

//inputnya int sekali doang



#include <stdio.h>

int main(){

	long long int pilih;

	scanf("%lld", &pilih);	//nomor ajgnya

	

	char namaAnjing[16]={0};	//kosong semua

	

	pilih--;	//biar dia sesuai sama indeks

	

	int i = 0;

	while(pilih > -1)

	{

		namaAnjing[i] = pilih % 26 + 'a';	//isi dari namaAnjing ke i itu huruf

											//dia bakal bagi 26 biar jadi angka yg bisa diubah jadi huruf

											//kl a bagi 26 kan 0 sisa baginya, abis soalnya, trs tambahin 'a' biar jadi huruf

											//kalo b kan 1, ditambah a jadi asciinya b, dst

		pilih = pilih / 26;					//ini fungsinya cmn 1 sebenernya, biar dia bisa abis, jd kl ga dibagi dia bakal gede terus angkanya, trs namanya panjang

											//kan salah eta, kita maunya urutan kan, makanya dibagi 26 jadi kayak tiap udah 1 huruf muncul, ya berarti udh 1 abjad terlewati kan

		i++; //biar dia isi nama indeksnya bener urutannya maju

		pilih--;		//biar dia tetep masuk dlm array

	}										

	

	

	while(i--)		//ini kan bakal kebalik munculnya di inya, jadi biar bener urutannya

	{					//print aja dari paling gede trs dikurangin, slesai

		printf("%c", namaAnjing[i]);		//di print terus sampe dia udah keluar dari array

	}

	

	//kalo udah biar aman, ato kalo user gila inputnya gaada

	printf("\n");

	

	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.259714231897639x):
//1,000,000,000,000,001	dogs dinomorin

//trs dinamain 1-26 a-z

//27-702 aa, ab, ac-zy, zz

//703-18278 aaa, aab, aac-zzy, zzz

//18279 - 475254 aaaa, aaab-zzzy, zzzz

//dst

//trs ditanya, utk anjing ke N, siapa namanya

//1<=N<=1000000000000001

//inputnya int sekali doang



#include <stdio.h>

int main(){

	long long int pilih;

	scanf("%lld", &pilih);	//nomor ajgnya

	

	char namaAnjing[16]={0};	//kosong semua

	

	pilih--;	//biar dia sesuai sama indeks

	

	int i = 0;

	while(pilih > -1)

	{

		namaAnjing[i] = pilih % 26 + 'a';	//isi dari namaAnjing ke i itu huruf

											//dia bakal bagi 26 biar jadi angka yg bisa diubah jadi huruf

											//kl a bagi 26 kan 0 sisa baginya, abis soalnya, trs tambahin 'a' biar jadi huruf

											//kalo b kan 1, ditambah a jadi asciinya b, dst

		pilih = pilih / 26;					//ini fungsinya cmn 1 sebenernya, biar dia bisa abis, jd kl ga dibagi dia bakal gede terus angkanya, trs namanya panjang

											//kan salah eta, kita maunya urutan kan, makanya dibagi 26 jadi kayak tiap udah 1 huruf muncul, ya berarti udh 1 abjad terlewati kan

		i++; //biar dia isi nama indeksnya bener urutannya maju

		pilih--;		//biar dia tetep masuk dlm array

	}										

	

	

	while(i--)		//ini kan bakal kebalik munculnya di inya, jadi biar bener urutannya

	{					//print aja dari paling gede trs dikurangin, slesai

		printf("%c", namaAnjing[i]);		//di print terus sampe dia udah keluar dari array

	}

	

	//kalo udah biar aman, ato kalo user gila inputnya gaada

	printf("\n");

	

	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.301243360812061x):
//1,000,000,000,000,001	dogs dinomorin

//trs dinamain 1-26 a-z

//27-702 aa, ab, ac-zy, zz

//703-18278 aaa, aab, aac-zzy, zzz

//18279 - 475254 aaaa, aaab-zzzy, zzzz

//dst

//trs ditanya, utk anjing ke N, siapa namanya

//1<=N<=1000000000000001

//inputnya int sekali doang



#include <stdio.h>

int main(){

	long long int pilih;

	scanf("%lld", &pilih);	//nomor ajgnya

	

	char namaAnjing[16]={0};	//kosong semua

	

	pilih--;	//biar dia sesuai sama indeks

	

	int i = 0;

	while(pilih > -1)

	{

		namaAnjing[i] = pilih % 26 + 'a';	//isi dari namaAnjing ke i itu huruf

											//dia bakal bagi 26 biar jadi angka yg bisa diubah jadi huruf

											//kl a bagi 26 kan 0 sisa baginya, abis soalnya, trs tambahin 'a' biar jadi huruf

											//kalo b kan 1, ditambah a jadi asciinya b, dst

		pilih = pilih / 26;					//ini fungsinya cmn 1 sebenernya, biar dia bisa abis, jd kl ga dibagi dia bakal gede terus angkanya, trs namanya panjang

											//kan salah eta, kita maunya urutan kan, makanya dibagi 26 jadi kayak tiap udah 1 huruf muncul, ya berarti udh 1 abjad terlewati kan

		i++; //biar dia isi nama indeksnya bener urutannya maju

		pilih--;		//biar dia tetep masuk dlm array

	}										

	

	

	while(i--)		//ini kan bakal kebalik munculnya di inya, jadi biar bener urutannya

	{					//print aja dari paling gede trs dikurangin, slesai

		printf("%c", namaAnjing[i]);		//di print terus sampe dia udah keluar dari array

	}

	

	//kalo udah biar aman, ato kalo user gila inputnya gaada

	printf("\n");

	

	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.255027006740848x):
//1,000,000,000,000,001	dogs dinomorin

//trs dinamain 1-26 a-z

//27-702 aa, ab, ac-zy, zz

//703-18278 aaa, aab, aac-zzy, zzz

//18279 - 475254 aaaa, aaab-zzzy, zzzz

//dst

//trs ditanya, utk anjing ke N, siapa namanya

//1<=N<=1000000000000001

//inputnya int sekali doang



#include <stdio.h>

int main(){

	long long int pilih;

	scanf("%lld", &pilih);	//nomor ajgnya

	

	char namaAnjing[16]={0};	//kosong semua

	

	pilih--;	//biar dia sesuai sama indeks

	

	int i = 0;

	while(pilih > -1)

	{

		namaAnjing[i] = pilih % 26 + 'a';	//isi dari namaAnjing ke i itu huruf

											//dia bakal bagi 26 biar jadi angka yg bisa diubah jadi huruf

											//kl a bagi 26 kan 0 sisa baginya, abis soalnya, trs tambahin 'a' biar jadi huruf

											//kalo b kan 1, ditambah a jadi asciinya b, dst

		pilih = pilih / 26;					//ini fungsinya cmn 1 sebenernya, biar dia bisa abis, jd kl ga dibagi dia bakal gede terus angkanya, trs namanya panjang

											//kan salah eta, kita maunya urutan kan, makanya dibagi 26 jadi kayak tiap udah 1 huruf muncul, ya berarti udh 1 abjad terlewati kan

		i++; //biar dia isi nama indeksnya bener urutannya maju

		pilih--;		//biar dia tetep masuk dlm array

	}										

	

	

	while(i--)		//ini kan bakal kebalik munculnya di inya, jadi biar bener urutannya

	{					//print aja dari paling gede trs dikurangin, slesai

		printf("%c", namaAnjing[i]);		//di print terus sampe dia udah keluar dari array

	}

	

	//kalo udah biar aman, ato kalo user gila inputnya gaada

	printf("\n");

	

	return 0;

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

using namespace std;

int main()

{

   string c="abcdefghijklmnopqrstuvwxyz";

  long long int n;

  cin>>n;

  string s="";

  if(n<=26)

  {

    cout<<c[n-1];

    return 0;

  }

  while(n)

  {

    int x=n%26;

    if(x)

    {

      s=c[x-1]+s;

    }

    else

    {

      s = 'z'+s;

    }

    if(!x)

    {

      n/=26;

      n--;

    }

    else

    {

      n/=26;

    }

  }

  cout<<s<<endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.361798585058825x):
#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;

int main(){

    long long x,i=1,temp=26;

    cin>>x;

    x--;

    while(temp<=x){

        x-=temp;

        temp*=26;

        i++;

    }

    string out="";

    while(i--){

        out=(char)(x%26+'a')+out;

        x/=26;

    }

    cout<<out;

}


// Faster C++ solution for the same problem (measured speedup: 5.337030627764841x):
#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;

using ll = long long int;

ll n;

string k;

void displ()

{

	cin>>n;

	while(n){

		k = char(n%26?(n%26)+'a'-1:'z')+k,n--;

	    	n/=26;

	}

	cout<<k<<"\n";

}



int main()

{

	displ();

}

// Faster C++ solution for the same problem (measured speedup: 5.338485284569723x):
#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 <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.243134288933393x):
#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;

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.308099638312569x):
#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<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.908188138111809x):
#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:
#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.358119203616808x):
#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;

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.294414867668755x):
#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;

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.334540483830657x):
#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;

}