// Original C++ solution (slower):
#include <iostream>

#include <bits/stdc++.h>

#include<string>

#include <stdio.h>

#include <algorithm>

#include <cstring>

#include <math.h>

#include <fstream>

#include <vector>



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

#define ll long long

#define SPACE " "

#define nLINE '\n'

#define ss second

#define ff first

//scanf("%d",&x) ,s.insert(x);



using namespace std;



ll GCD(ll a, ll b) {

	//Euclidian

	if (!b) return a;

	else return GCD(b, a % b);

}

const ll MAX = 51;

bool prime[MAX];

void sieve() {

	for (int p = 2; p * p <= MAX; p++)

		if (prime[p] == false)

			for (int i = p * 2; i <= MAX; i += p)

				prime[i] = true;

}



int comb(int a, int b)

{

	if (a < b) return 0;

	if (a == b) return 1;

	if (b == 0) return 1;

	return comb(a - 1, b) + comb(a - 1, b - 1);

}

int x[30];

long long int y[30];

long long int func(int s, int t)

{

	if (t == 0) return 1;

	if (s == 0) return 1;



	if (x[s] == 0) return func(s - 1, t);

	else

	{

		long long int sum = 0;

		for (int i = 0;i <= t;i++) sum += comb(s - 1, i) * y[i];



		long long int s1 = sum;



		sum = 0;

		for (int i = 0;i <= t - 1;i++) sum += comb(s - 1, i) * y[i];

		long long int s2 = (x[s] - 1) * sum;

		long long int s3 = func(s - 1, t - 1);

		return s1 + s2 + s3;

	}

}







int dp[13][1 << 13];

double arr[20][20];

int n;

int dvds[13],svs[13];

vector<double> sssp(int);

vector<double> minDis[20];

int Size;



double solve() {

    ll N,K,W;

    cin >> N >> K >> W;

    map<pair <ll,ll> , pair<ll,ll> > rects;

    pair<ll,ll> pairs[2*N];

    ll AL,BL,CL,DL,AH,BH,CH,DH,H[N],L[N];

    int indx=0;

    for(int k=0;k<K;k++){

        cin >> L[k];

        pairs[indx].ff = L[k];

        pairs[indx].ss = 0;

        indx ++;

        pairs[indx].ff = L[k]+W;

        indx++;

    }

    cin >> AL >> BL >> CL >> DL;

    indx = 0;

    int Irects = 0;

    for(int k=0; k<K ;k++){

        cin >> H[k];

        pairs[++indx].ss = H[k];

        indx++;

        rects[pairs[indx-2]] = pairs[indx-1];

        Irects++;

    }

    cin >> AH >> BH >> CH >> DH;



    for(int n=K;n<N;n++){

        cout << "DA5AL HNA" << nLINE;

        L[n] = ((AL*L[n-2]+BL*L[n-1]+CL)%DL)+1;

        H[n] = ((AH*H[n-2]+BH*H[n-1]+CH)%DH)+1;

        pairs[indx].ff = L[n];

        pairs[indx++].ss = 0;

        pairs[indx].ff = L[n]+W;

        pairs[indx++].ss = H[n];

        rects[pairs[indx-2]] = rects[pairs[indx-1]];

        Irects++;

    }



    sort(pairs,pairs+indx);

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

        cout << pairs[i].ff << SPACE << pairs[i].ss << SPACE << rects[pairs[i]].ff << SPACE << rects[pairs[i]].ff << nLINE;



    pair<ll,ll> x1 = pairs[0];

    pair<ll,ll> x2;

    vector<pair<ll,ll> > opened;

    ll per = rects[x1].ss;

    opened.push_back(x1);

    for(int j=0;j<N;j++){

        for(int i=1;i<2*j;i++){

            x2 = pairs[i];

            per+= (x2.ff - x1.ff);

            per = max(per,per+(rects[x2].ss - rects[x1].ss));

            if(x2.ss == 0){

                opened.push_back(x2);

            }

            else {

                for(int v=0;v<opened.size();v++){

                    if(x2.ff == (opened.at(v).ff)+W){

                        vector<pair<ll,ll> >::iterator it = opened.begin();

                        opened.erase(it+i);

                    }

                }

            }

            x1 = x2;

            cout << per << nLINE;

        }

        per+=x1.ss;

        per+=(pairs[indx-1].ff-pairs[0].ff);

        cout << "*******************" << per << nLINE;

    }

}



int nextMin(int,int);

int lis[100001];



bool cmp(pair<char, int>& a,pair<char, int>& b){

    return a.second < b.second;

}





int main() {

	IO;

	ll num;

	cin >> num;

	string col="";

    while(num){

        num --;

        col += (num%26 + 'a');

        num = num/26;

    }

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

    cout << col << nLINE;

    return 0;

}





bool used[20];

vector<double> sssp(int src) {

	vector<double> disSource(n);

	fill(disSource.begin(), disSource.end(), INT_MAX);

	disSource[src] = 0;

	int curr = src;

	memset(used, false, sizeof used);

	used[curr] = true;

	while (curr != -1) {

		for (int j = 0;j < n;j++) {

			if (arr[curr][j] != -1) {

				if (disSource[j] == INT_MAX) disSource[j] = arr[curr][j] + disSource[curr];

				else disSource[j] = std::min(disSource[j], disSource[curr] + arr[curr][j]);

			}

		}

		used[curr] = true;

		curr = nextMin(curr,src);

	}

	return disSource;

}



int nextMin(int curr,int src) {

	int indx = -1;

	double Min = 1e9;

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

		if (arr[curr][i]!=-1 && arr[curr][i] <= Min && used[i] == false) {

			Min = arr[curr][i];

			indx = i;

		}

	}

	if (indx == -1){

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

            if(arr[src][i]!=-1 && arr[curr][i] <= Min && used[i]== false)

                indx = i , Min = arr[curr][i];

	}

	if (indx == -1) return -1;

	return indx;

}


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

int main()

{ 

    long long dogs;

    scanf("%lld",&dogs);

    int i = 0;

    char str[100];

    while(dogs > 0){

        int temp = dogs % 26;

        if(temp == 0){

            str[i++] = 'z';

            dogs = (dogs/26) - 1;

        }else{

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

            dogs = dogs/26;

        }

    }

    str[i] = '\0';

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

	{

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

    }

    return 0;

}

// Fastest known solution for this problem: