import java.io.*;
import java.util.*;
import static java.lang.Math.min;
import static java.lang.Math.max;
public class Main {

    private static void solver(InputReader sc, PrintWriter out) throws Exception {
          long n = sc.nextLong();
          String ans = "";
          String arr[] = {"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"};
          //out.println(arr.length);
          while(n > 0){
              long mod = n%26;mod--;
              if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26;
              ans += (arr[(int) mod]);
          }
          for(int i=ans.length()-1; i>=0; i--) out.print(ans.charAt(i));
    }

    public static void main(String[] args) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solver(in,out);
        out.close();
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    }
}
class Pair implements Comparable<Pair>{
    int x,y;
    Pair(int x, int y){
        this.x = x;
        this.y = y;
    }
    public int compareTo(Pair p){
        return (int)(this.x - p.x);
    }
}
class Tuple{
    String s;
    int x, y;

    public Tuple(String s, int x, int y) {
        this.s = s;
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Tuple tuple = (Tuple) o;
        return x == tuple.x &&
                y == tuple.y &&
                s.equals(tuple.s);
    }

    @Override
    public int hashCode() {
        return Objects.hash(s, x, y);
    }
} import java.io.*; io.* java import java.util.*; util.* java import static java.lang.Math.min; import static java.lang.Math.min; import static java.lang.Math.min; import static java.lang.Math.max; import static java.lang.Math.max; import static java.lang.Math.max; public class Main {

    private static void solver(InputReader sc, PrintWriter out) throws Exception {
          long n = sc.nextLong();
          String ans = "";
          String arr[] = {"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"};
          //out.println(arr.length);
          while(n > 0){
              long mod = n%26;mod--;
              if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26;
              ans += (arr[(int) mod]);
          }
          for(int i=ans.length()-1; i>=0; i--) out.print(ans.charAt(i));
    }

    public static void main(String[] args) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solver(in,out);
        out.close();
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    }
} Main private static void solver(InputReader sc, PrintWriter out) throws Exception {
          long n = sc.nextLong();
          String ans = "";
          String arr[] = {"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"};
          //out.println(arr.length);
          while(n > 0){
              long mod = n%26;mod--;
              if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26;
              ans += (arr[(int) mod]);
          }
          for(int i=ans.length()-1; i>=0; i--) out.print(ans.charAt(i));
    } solver {
          long n = sc.nextLong();
          String ans = "";
          String arr[] = {"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"};
          //out.println(arr.length);
          while(n > 0){
              long mod = n%26;mod--;
              if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26;
              ans += (arr[(int) mod]);
          }
          for(int i=ans.length()-1; i>=0; i--) out.print(ans.charAt(i));
    } long n = sc.nextLong(); n sc.nextLong() sc.nextLong sc String ans = ""; ans "" String arr[] = {"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"}; arr {"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"} "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" while(n > 0){
              long mod = n%26;mod--;
              if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26;
              ans += (arr[(int) mod]);
          } n > 0 n 0 {
              long mod = n%26;mod--;
              if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26;
              ans += (arr[(int) mod]);
          } long mod = n%26; mod n%26 n 26 mod-- mod if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26; mod < 0 mod 0 {
                  mod = 25; n= n/26;
                  n--;
              } mod = 25 mod 25 n= n/26 n n/26 n 26 n-- n n = n/26 n n/26 n 26 ans += (arr[(int) mod]) ans (arr[(int) mod]) arr (int) mod for(int i=ans.length()-1; i>=0; i--) out.print(ans.charAt(i)); int i=ans.length()-1; int i=ans.length()-1; i ans.length()-1 ans.length() ans.length ans 1 i>=0 i 0 i-- i-- i out.print(ans.charAt(i)); out.print(ans.charAt(i)) out.print out ans.charAt(i) ans.charAt ans i InputReader sc sc PrintWriter out out public static void main(String[] args) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solver(in,out);
        out.close();
    } main {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solver(in,out);
        out.close();
    } InputStream inputStream = System.in; inputStream System.in System System.in OutputStream outputStream = System.out; outputStream System.out System System.out InputReader in = new InputReader(inputStream); in new InputReader(inputStream) PrintWriter out = new PrintWriter(outputStream); out new PrintWriter(outputStream) solver(in,out) solver in out out.close() out.close out String[] args args static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    } InputReader public BufferedReader reader; reader public StringTokenizer tokenizer; tokenizer public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        } InputReader {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        } reader = new BufferedReader(new InputStreamReader(stream), 32768) reader new BufferedReader(new InputStreamReader(stream), 32768) tokenizer = null tokenizer null InputStream stream stream public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        } next {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        } while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            } tokenizer == null || !tokenizer.hasMoreTokens() tokenizer == null tokenizer null !tokenizer.hasMoreTokens() tokenizer.hasMoreTokens() tokenizer.hasMoreTokens tokenizer {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            } try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                } IOException e {
                    throw new RuntimeException(e);
                } throw new RuntimeException(e); new RuntimeException(e) {
                    tokenizer = new StringTokenizer(reader.readLine());
                } tokenizer = new StringTokenizer(reader.readLine()) tokenizer new StringTokenizer(reader.readLine()) return tokenizer.nextToken(); tokenizer.nextToken() tokenizer.nextToken tokenizer public int nextInt() {
            return Integer.parseInt(next());
        } nextInt {
            return Integer.parseInt(next());
        } return Integer.parseInt(next()); Integer.parseInt(next()) Integer.parseInt Integer next() next public long nextLong() {
            return Long.parseLong(next());
        } nextLong {
            return Long.parseLong(next());
        } return Long.parseLong(next()); Long.parseLong(next()) Long.parseLong Long next() next public double nextDouble(){
            return Double.parseDouble(next());
        } nextDouble {
            return Double.parseDouble(next());
        } return Double.parseDouble(next()); Double.parseDouble(next()) Double.parseDouble Double next() next class Pair implements Comparable<Pair>{
    int x,y;
    Pair(int x, int y){
        this.x = x;
        this.y = y;
    }
    public int compareTo(Pair p){
        return (int)(this.x - p.x);
    }
} Pair int x x y; y Pair(int x, int y){
        this.x = x;
        this.y = y;
    } Pair {
        this.x = x;
        this.y = y;
    } this.x = x this.x this this.x x this.y = y this.y this this.y y int x x int y y public int compareTo(Pair p){
        return (int)(this.x - p.x);
    } compareTo {
        return (int)(this.x - p.x);
    } return (int)(this.x - p.x); (int)(this.x - p.x) this.x this this.x p.x p p.x Pair p p Comparable class Tuple{
    String s;
    int x, y;

    public Tuple(String s, int x, int y) {
        this.s = s;
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Tuple tuple = (Tuple) o;
        return x == tuple.x &&
                y == tuple.y &&
                s.equals(tuple.s);
    }

    @Override
    public int hashCode() {
        return Objects.hash(s, x, y);
    }
} Tuple String s; s int x x y; y public Tuple(String s, int x, int y) {
        this.s = s;
        this.x = x;
        this.y = y;
    } Tuple {
        this.s = s;
        this.x = x;
        this.y = y;
    } this.s = s this.s this this.s s this.x = x this.x this this.x x this.y = y this.y this this.y y String s s int x x int y y @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Tuple tuple = (Tuple) o;
        return x == tuple.x &&
                y == tuple.y &&
                s.equals(tuple.s);
    } equals {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Tuple tuple = (Tuple) o;
        return x == tuple.x &&
                y == tuple.y &&
                s.equals(tuple.s);
    } if (this == o) return true; this == o this o return true; true if (o == null || getClass() != o.getClass()) return false; o == null || getClass() != o.getClass() o == null o null getClass() != o.getClass() getClass() getClass o.getClass() o.getClass o return false; false Tuple tuple = (Tuple) o; tuple (Tuple) o return x == tuple.x &&
                y == tuple.y &&
                s.equals(tuple.s); x == tuple.x &&
                y == tuple.y &&
                s.equals(tuple.s) x == tuple.x &&
                y == tuple.y &&
                s.equals(tuple.s) x == tuple.x x tuple.x tuple tuple.x y == tuple.y y tuple.y tuple tuple.y s.equals(tuple.s) s.equals s tuple.s tuple tuple.s Object o o @Override
    public int hashCode() {
        return Objects.hash(s, x, y);
    } hashCode {
        return Objects.hash(s, x, y);
    } return Objects.hash(s, x, y); Objects.hash(s, x, y) Objects.hash Objects s x y public class Main {

    private static void solver(InputReader sc, PrintWriter out) throws Exception {
          long n = sc.nextLong();
          String ans = "";
          String arr[] = {"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"};
          //out.println(arr.length);
          while(n > 0){
              long mod = n%26;mod--;
              if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26;
              ans += (arr[(int) mod]);
          }
          for(int i=ans.length()-1; i>=0; i--) out.print(ans.charAt(i));
    }

    public static void main(String[] args) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solver(in,out);
        out.close();
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    }
} public class Main {

    private static void solver(InputReader sc, PrintWriter out) throws Exception {
          long n = sc.nextLong();
          String ans = "";
          String arr[] = {"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"};
          //out.println(arr.length);
          while(n > 0){
              long mod = n%26;mod--;
              if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26;
              ans += (arr[(int) mod]);
          }
          for(int i=ans.length()-1; i>=0; i--) out.print(ans.charAt(i));
    }

    public static void main(String[] args) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solver(in,out);
        out.close();
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    }
} Main
import java.io.*;
import java.util.*;
import static java.lang.Math.min;
import static java.lang.Math.max;
public class Main {

    private static void solver(InputReader sc, PrintWriter out) throws Exception {
          long n = sc.nextLong();
          String ans = "";
          String arr[] = {"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"};
          //out.println(arr.length);
          while(n > 0){
              long mod = n%26;mod--;
              if(mod < 0) {
                  mod = 25; n= n/26;
                  n--;
              }else n = n/26;
              ans += (arr[(int) mod]);
          }
          for(int i=ans.length()-1; i>=0; i--) out.print(ans.charAt(i));
    }

    public static void main(String[] args) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solver(in,out);
        out.close();
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;
        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }
        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    }
}
class Pair implements Comparable<Pair>{
    int x,y;
    Pair(int x, int y){
        this.x = x;
        this.y = y;
    }
    public int compareTo(Pair p){
        return (int)(this.x - p.x);
    }
}
class Tuple{
    String s;
    int x, y;

    public Tuple(String s, int x, int y) {
        this.s = s;
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Tuple tuple = (Tuple) o;
        return x == tuple.x &&
                y == tuple.y &&
                s.equals(tuple.s);
    }

    @Override
    public int hashCode() {
        return Objects.hash(s, x, y);
    }
}
