import java.util.HashMap;
import java.util.Scanner;
import java.util.TreeMap;

public class P849C
{
	public static void main(String[] args)
	{
		Scanner scan = new Scanner(System.in);
		TreeMap<Integer, Integer> tri = new TreeMap<>();
		for (int i = 1; i <= 447; i++)
		{
			int t = i*(i-1)/2;
			tri.put(t, i);
		}
		int k = scan.nextInt();
		if (k == 0)
		{
			System.out.println("a");
			return;
		}
		char lett = 'a';
		StringBuilder sb = new StringBuilder();
		while (k > 0)
		{
			int cost = tri.floorKey(k);
			int num = tri.get(cost);
			for (int i = 0; i < num; i++)
				sb.append(lett);
			lett++;
			k -= cost;
		}
		System.out.println(sb);
	}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class C431 {
	public static void main(String[] args) {
		try (Scanner in = new Scanner(System.in)) {
			int n = in.nextInt();
			if (n == 0) {
				System.out.println("a");
				return;
			}
			List<Integer> result = new ArrayList<>();
			while (n > 0) {
				int binarySearch = binarySearch(n);
				result.add(binarySearch);
				n -= (binarySearch * (binarySearch - 1)) / 2;
			}
			StringBuilder sb = new StringBuilder();
			for (int i = 0; i < result.size(); i++) {
				String c = (char) ('a' + i) + "";
				sb.append(String.join("", Collections.nCopies(result.get(i), c)));
			}
			System.out.println(sb);
		}
	}

	static int binarySearch(int n) {
		int low = 2;
		int high = n;
		while (low < high - 1) {
			int mid = low + (high - low) / 2;
			if ((long)mid * (mid - 1) < 2 * n) {
				low = mid;
			} else if ((long)mid * (mid - 1) > 2 * n) {
				high = mid;
			} else {
				return mid;
			}
		}
		return low;
	}
}

import java.io.*;    //PrintWriter
import java.math.*;  //BigInteger, BigDecimal
import java.util.*;  //StringTokenizer, ArrayList

public class R431_Div2_C
{
	FastReader in;
	PrintWriter out;

	public static void main(String[] args)  {
		new R431_Div2_C().run();
	}

	void run()
	{
		in = new FastReader(System.in);
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	void solve()
	{
		int k = in.nextInt();

		char c = 'a';
		StringBuilder sb = new StringBuilder(c + "");
		int num = 1;
		while (k > 0) {
			k -= num;
			if (k < 0) {
				k += num;
				num = 1;
				c++;
			} else if (k > 0)
				num++;
			sb.append(c);
		}

		out.println(sb);
	}

	//-----------------------------------------------------
	void runWithFiles() {
		in = new FastReader(new File("input.txt"));
		try {
			out = new PrintWriter(new File("output.txt"));
		}
		catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		solve();
		out.close();
	}

	class FastReader
	{
	    BufferedReader br;
	    StringTokenizer tokenizer;

	    public FastReader(InputStream stream)
	    {
	        br = new BufferedReader(new InputStreamReader(stream));
	        tokenizer = null;
	    }
		public FastReader(File f) {
			try {
				br = new BufferedReader(new FileReader(f));
				tokenizer = null;
			}
			catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}

	    private String next() {
	        while (tokenizer == null || !tokenizer.hasMoreTokens())
	            try {
	            	tokenizer = new StringTokenizer(br.readLine());
	            }
	            catch (IOException e) {
	                throw new RuntimeException(e);
	            }
	        return tokenizer.nextToken();
	    }
		public String nextLine() {
			try	{
				return br.readLine();
			}
			catch(Exception e) {
				throw(new RuntimeException());
			}
		}

	    int nextInt() {
	        return Integer.parseInt(next());
	    }
	    long nextLong() {
	        return Long.parseLong(next());
	    }
	    double nextDouble() {
	        return Double.parseDouble(next());
	    }
	    BigInteger nextBigInteger() {
	        return new BigInteger(next());
	    }
	    BigDecimal nextBigDecimal() {
	        return new BigDecimal(next());
	    }
	}
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;

/**
 * Created by shikhar on 01/09/17.
 */
public class TellYourWorld
{
    static String fin = "";
    static int cost(String a, String b)
    {
        int char1[] = new int[26];
        int char2[] = new int[26];
        for(char ch : a.toCharArray())
            char1[ch-'a']++;
        for(char ch : b.toCharArray())
            char2[ch-'a']++;
        int sum = 0;
        for(int i =0; i<26; i++)
            sum+=char1[i]*char2[i];
        return sum;
    }
    static void util(String ans, int k, int val)
    {
      if(val>k) return;
      if(val==k){
          if(fin.length()==0)
          fin = ans;
       return;
      }

      if(fin.length()!=0) return;
      for(int i =0; i <26 ; i++)
      {
          char ch = (char)('a'+i);
          util(ans+ch, k, val+cost(ans,""+ch));
      }

      util(ans+ans, k, val+cost(ans,ans));

    }
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);

        int N = in.nextInt();
        util("a",N,0);
        System.out.println(fin);
    }
}

        import java.io.*;
        import java.lang.reflect.Array;
        import java.util.*;
        import java.lang.*;
        import static java.lang.Math.*;
        public class main implements Runnable {

            static ArrayList<Integer> adj[];

            static void Check2(int n) {
                adj = new ArrayList[n + 1];
                for (int i = 0; i <= n; i++) {
                    adj[i] = new ArrayList<>();
                }

            }
            static void add(int i, int j)
            {
                adj[i].add(j);
                adj[j].add(i);
            }

            public static void main(String[] args) {
                new Thread(null, new main(), "Check2", 1 << 26).start();// to increse stack size in java
            }
            static long mod = (long) (1e9 + 7);
            public void run() {
                InputReader in = new InputReader(System.in);
                PrintWriter w = new PrintWriter(System.out);

                int co=1;
                char c='a';
                String ans="";
                ans=ans+c;
                int k=in.nextInt();
                while (k>0){

                    if(co>k){

                        co=1;
                           c++;
                        ans=ans+c;

                    }
                    else{
                        k-=co;
                        ans=ans+c;
                        co++;
                    }

                }
                w.println(ans);

                w.close();
            }

/*            static class cmp implements Comparator<pair>{

                public int compare(pair o1,pair o2){

                    return o1.b<o2.b?-1:o1.b>o2.b?1:0;
                }

            }*/
            static class pair {

              long x,y;
                pair(int a,long b){

                    x=a;
                    y=b;
                }
              /*  public boolean equals(Object obj) {      //  override equals method for object to remove tem from arraylist and sets etc.......
                    if (this == obj)
                        return true;
                    if (obj == null)
                        return false;
                    if (getClass() != obj.getClass())
                        return false;
                    pair other = (pair) obj;
                    if (b!= other.b||a!=other.a)
                        return false;
                    return true;
                }
        */
            }

            static long modinv(long a,long b)
            {
                long p=power(b,mod-2);

                p=a%mod*p%mod;
                p%=mod;

                return p;

            }

            static long power(long x,long y){
                if(y==0)return 1%mod;
                if(y==1)return x%mod;

                long res=1;
                x=x%mod;
                while(y>0){

                    if((y%2)!=0){
                        res=(res*x)%mod;
                    }

                    y=y/2;
                    x=(x*x)%mod;
                }

                return res;

            }
            static  int gcd(int a,int b){

                if(b==0)return a;
                return gcd(b,a%b);
            }

            static  void sev(int a[],int n){

                for(int i=2;i<=n;i++)a[i]=i;
                for(int i=2;i<=n;i++){

                    if(a[i]!=0){
                        for(int j=2*i;j<=n;){

                            a[j]=0;
                            j=j+i;
                        }
                    }

                }

            }

            static class node{

                int y;
                int val;

                node(int a,int b){

                    y=a;
                    val=b;

                }

            }

            static class InputReader
            {
                private InputStream stream;
                private byte[] buf = new byte[1024];
                private int curChar;
                private int numChars;
                private SpaceCharFilter filter;

                public InputReader(InputStream stream)
                {
                    this.stream = stream;
                }

                public int read()
                {
                    if (numChars==-1)
                        throw new InputMismatchException();

                    if (curChar >= numChars)
                    {
                        curChar = 0;
                        try
                        {
                            numChars = stream.read(buf);
                        }
                        catch (IOException e)
                        {
                            throw new InputMismatchException();
                        }

                        if(numChars <= 0)
                            return -1;
                    }
                    return buf[curChar++];
                }

                public String nextLine()
                {
                    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                    String str = "";
                    try
                    {
                        str = br.readLine();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                    return str;
                }
                public int nextInt()
                {
                    int c = read();

                    while(isSpaceChar(c))
                        c = read();

                    int sgn = 1;

                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }

                    int res = 0;
                    do
                    {
                        if(c<'0'||c>'9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    while (!isSpaceChar(c));

                    return res * sgn;
                }

                public long nextLong()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    int sgn = 1;
                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }
                    long res = 0;

                    do
                    {
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    while (!isSpaceChar(c));
                    return res * sgn;
                }

                public double nextDouble()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    int sgn = 1;
                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }
                    double res = 0;
                    while (!isSpaceChar(c) && c != '.')
                    {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    if (c == '.')
                    {
                        c = read();
                        double m = 1;
                        while (!isSpaceChar(c))
                        {
                            if (c == 'e' || c == 'E')
                                return res * Math.pow(10, nextInt());
                            if (c < '0' || c > '9')
                                throw new InputMismatchException();
                            m /= 10;
                            res += (c - '0') * m;
                            c = read();
                        }
                    }
                    return res * sgn;
                }

                public String readString()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    StringBuilder res = new StringBuilder();
                    do
                    {
                        res.appendCodePoint(c);
                        c = read();
                    }
                    while (!isSpaceChar(c));

                    return res.toString();
                }

                public boolean isSpaceChar(int c)
                {
                    if (filter != null)
                        return filter.isSpaceChar(c);
                    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
                }

                public String next()
                {
                    return readString();
                }

                public interface SpaceCharFilter
                {
                    public boolean isSpaceChar(int ch);
                }
            }

        }

import java.io.*;
import java.util.*;

public class problem {
    static FastScanner in = new FastScanner();
    static StringBuilder ans = new StringBuilder();
    static int i = 0;
    static String getString(int len, int value) {
        char chars[] = new char[len];
        Arrays.fill(chars, (char) (value + 97));
        return new String(chars);
    }
    static void process(int n) {
        if (n <= 0) return;
        int k = (int) ((Math.sqrt(8 * n + 1) - 1) / 2);
        ans.append(getString(k + 1, i));
        i++;
        process(n - k * (k + 1) / 2);
    }
    static void solve() {
        int n = in.nextInt();
        if (n == 0) {
            System.out.println("a");
        } else {
            process(n);
            System.out.println(ans);
        }
    }

    public static void main(String[] args) throws IOException {
        new problem().solve();
    }
}

class FastScanner {
    public static String debug = null;

    private final InputStream in = System.in;
    private int ptr = 0;
    private int buflen = 0;
    private byte[] buffer = new byte[1024];
    private boolean eos = false;

    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                if (debug != null) {
                    buflen = debug.length();
                    buffer = debug.getBytes();
                    debug = "";
                    eos = true;
                } else {
                    buflen = in.read(buffer);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen < 0) {
                eos = true;
                return false;
            } else if (buflen == 0) {
                return false;
            }
        }
        return true;
    }

    private int readByte() {
        if (hasNextByte())
            return buffer[ptr++];
        else
            return -1;
    }

    private static boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }

    private void skipUnprintable() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
            ptr++;
    }

    public boolean isEOS() {
        return this.eos;
    }

    public boolean hasNext() {
        skipUnprintable();
        return hasNextByte();
    }

    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public long nextLong() {
        if (!hasNext())
            throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while (true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if (b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }

    public int nextInt() {
        return (int) nextLong();
    }

    public long[] nextLongList(int n) {
        return nextLongTable(1, n)[0];
    }

    public int[] nextIntList(int n) {
        return nextIntTable(1, n)[0];
    }

    public long[][] nextLongTable(int n, int m) {
        long[][] ret = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ret[i][j] = nextLong();
            }
        }
        return ret;
    }

    public int[][] nextIntTable(int n, int m) {
        int[][] ret = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ret[i][j] = nextInt();
            }
        }
        return ret;
    }
}

import java.io.*;
import java.util.*;
import java.math.*;
public class A {
	public static void main(String[] args)throws IOException {
		FastIO sc = new FastIO(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int k = sc.nextInt();
		String alph = "abcdefghijklmnopqrstuvwxyz";
		int arr[] = new int[26];
		if(k==0) {
			System.out.println('a');
			System.exit(0);
		}
		Arrays.fill(arr, 0);
		int idx = 0;
		while(k>0) {
			int a = 1;
			while((a*a-a)/2<=k) {
				a++;
			}
			a--;
			k-=(a*a-a)/2;
			arr[idx] = a;
			idx++;
		}
		for(int i=0; i<26; ++i) {
			for(int j=0; j<arr[i]; ++j) {
				System.out.print(alph.charAt(i));
			}
		}
		out.close();
	}
	static class FastIO {
		InputStream dis;
		byte[] buffer = new byte[1 << 17];
		int pointer = 0;
		public FastIO(String fileName) throws IOException {
			dis = new FileInputStream(fileName);
		}
		public FastIO(InputStream is) throws IOException {
			dis = is;
		}
		int nextInt() throws IOException {
			int ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}

			return (negative) ? -ret : ret;
		}
		long nextLong() throws IOException {
			long ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}
			return (negative) ? -ret : ret;
		}
		byte nextByte() throws IOException {
			if (pointer == buffer.length) {
				dis.read(buffer, 0, buffer.length);
				pointer = 0;
			}
			return buffer[pointer++];
		}
		String next() throws IOException {
			StringBuffer ret = new StringBuffer();

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			while (b > ' ') {
				ret.appendCodePoint(b);
				b = nextByte();
			}

			return ret.toString();
		}
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Hola solver = new Hola();
        solver.solve(1, in, out);
        out.close();
    }

    static class Hola {
        PrintWriter out;
        InputReader in;
        long mod = (long)1e9 + 7;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            this.out = out;
            this.in = in;
            int n = ni();
            if(n == 0){
                pn("a");
                return;
            }
            StringBuilder str = new StringBuilder();
            int i = 0;
            int sum = 0;
            for(i = 0; i < 26; i++){
                int j = 1;
                while(sum + j <= n){
                    sum += j;
                    j++;
                }
                for(int k = 0; k < j; k++)
                    str.append((char)(97 + i));
                if(sum == n)
                    break;
            }
            pn(str);

        }
        void sort(int[] A){
            PriorityQueue<Integer> pq = new PriorityQueue();
            int i = 0;
            for(i = 0; i < A.length; i++)
                pq.add(A[i]);
            for(i = 0; i < A.length; i++)
                A[i] = pq.poll();
        }
        int gcd(int a, int b)
        {
            if (a == 0)
                return b;

            return gcd(b%a, a);
        }
        long mul(long a,long b){
            if(a>=mod)a%=mod;
            if(b>=mod)b%=mod;
            a*=b;
            if(a>=mod)a%=mod;
            return a;
        }
        long modPow(long a, long p){
            long o = 1;
            while(p>0){
                if((p&1)==1)o = mul(o,a);
                a = mul(a,a);
                p>>=1;
            }
            return o;
        }
        final Comparator<Tuple> com = new Comparator<Tuple>() {
            @Override
            public int compare(Tuple t1, Tuple t2) {
                if(t1.x != t2.x)
                    return Long.compare(t1.x, t2.x);
                else
                    return Long.compare(t2.y, t1.y);
            }
        };
        class Tuple{
            int x, y;
            Tuple(int x, int y){
                this.x = x;
                this.y = y;
            }
        }
        int ni() {
            return in.nextInt();
        }
        long nl() {
            return in.nextLong();
        }
        void pn(Object o) {
            out.println(o);
        }
        void p(Object o) {
            out.print(o);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1)
                throw new UnknownError();
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new UnknownError();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

        public String next() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuffer res = new StringBuffer();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));

            return res.toString();
        }

        private boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

    }
}

import java.io.*;
import java.util.*;
import java.util.Map.Entry;
import java.lang.Math;
import java.math.BigInteger;

public class Problem {

	int INF = -1000 * 1000 * 1000 - 100;
	int counter;
	int[] arr;
	int[] t;

	void solve() throws IOException {
		int n = rI();
		int curChar = 0;
		ArrayList<Character> ansList = new ArrayList<>();
		if(n==0){
			ansList.add('z');
		}
		while(n>0){
			ansList.add((char)('a'+curChar));
			int x = 1;
			int sum = 1 ;
			while(n-sum>=0){
				x++;
				ansList.add((char)('a'+curChar));
				sum += x;
			}
			sum-=x;
			n -= sum;
			curChar++;
		}
		for(char a: ansList){
			out.print(a);
		}
	}

	long get(int r) {
		long sum = 0;
		for (int i = r; i >= 1; i = (i & (i + 1)) - 1) {
			sum += t[i];
		}
		return sum;
	}

	void init() {
		for (int i = 1; i < arr.length; ++i) {
			inc(i, arr[i]);
		}
	}

	void inc(int i, int delta) {
		for (; i < arr.length; i = i | (i + 1)) {
			t[i] += delta;
		}
	}

	public static void main(String[] args) throws IOException {

		new Problem().run();
	}

	boolean isLower(char a) {
		return ((int) a) >= 97 ? true : false;
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok;
	Random rnd = new Random();
	static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	Problem() throws FileNotFoundException {

		if (ONLINE_JUDGE) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		} else {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
		tok = new StringTokenizer("");
	}

	long checkBit(long mask, int bit) {
		return (mask >> bit) & 1;
	}

	// ======================================================

	// ======================================================
	void run() throws IOException {
		solve();
		out.close();
	}

	char[] reverseCharArray(char[] arr) {
		char[] ans = new char[arr.length];
		for (int i = 0; i < arr.length; ++i) {
			ans[i] = arr[arr.length - i - 1];
		}
		return ans;
	}

	int sqrt(double m) {
		int l = 0;
		int r = 1000000000 + 9;
		int i = 1000;
		while (r - l > 1) {
			int mid = (r + l) / 2;
			if (mid * mid > m) {
				r = mid;
			} else {
				l = mid;
			}
		}
		return l;
	}

	int countPow(int m, int n) {
		int ans = 0;
		while (m % n == 0 && m > 0) {
			ans++;
			m /= n;
		}
		return ans;
	}

	long binPow(long a, long b) {
		if (b == 0) {
			return 1;
		}
		if (b % 2 == 1) {
			return a * binPow(a, b - 1);
		} else {
			long c = binPow(a, b / 2);
			return c * c;
		}

	}

	int gcd(int a, int b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	long pow(long x, long k) {
		long ans = 1;
		for (int i = 0; i < k; ++i) {
			ans *= x;
		}
		return ans;
	}

	// ////////////////////////////////////////////////////////////////////

	String delimiter = " ";

	String readLine() throws IOException {
		return in.readLine();
	}

	String rS() throws IOException {
		while (!tok.hasMoreTokens()) {
			String nextLine = readLine();
			if (null == nextLine)
				return null;

			tok = new StringTokenizer(nextLine);
		}

		return tok.nextToken(delimiter);
	}

	int rI() throws IOException {
		return Integer.parseInt(rS());
	}

	long rL() throws IOException {
		return Long.parseLong(rS());
	}

	double rD() throws IOException {
		return Double.parseDouble(rS());
	}

	int[] rA(int b) {
		int a[] = new int[b];
		for (int i = 0; i < b; i++) {
			try {
				a[i] = rI();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return a;
	}

	int[] readSortedIntArray(int size) throws IOException {
		Integer[] array = new Integer[size];

		for (int index = 0; index < size; ++index) {
			array[index] = rI();
		}
		Arrays.sort(array);

		int[] sortedArray = new int[size];
		for (int index = 0; index < size; ++index) {
			sortedArray[index] = array[index];
		}

		return sortedArray;
	}

	int[] sortedIntArray(int size, int[] array) throws IOException {
		for (int index = 0; index < size; ++index) {
			array[index] = rI();
		}
		Arrays.sort(array);

		int[] sortedArray = new int[size];
		for (int index = 0; index < size; ++index) {
			sortedArray[index] = array[index];
		}

		return sortedArray;
	}
}

import java.io.*;
import java.util.*;

public class ProblemA {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastScanner input = new FastScanner();

		TreeMap<Integer,Integer> triangular = new TreeMap<Integer, Integer>();

		int sum = 0;
		for(int b = 1; b <= 10000; b++) {
			sum += b;
			triangular.put(sum, b+1);
		}

		int x = input.nextInt();
		int reps = 0;
		StringBuilder  output = new StringBuilder();
		output.append('z');
		while(x != 0) {
			int lowerKey = triangular.lowerKey(x+1);
			int lowerValue = triangular.get(lowerKey);
			x -= lowerKey;
			for(int q = 0; q < lowerValue; q++) {
				output.append((char) (reps + 'a'));
			}

			reps++;
		}
		System.out.println(output);

	}
	public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }
        public FastScanner() {
            this(new InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        String readNextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        int[] readIntArray(int n) {
            int[] a = new int[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextInt();
            }
            return a;
        }
        long[] readLongArray(int n) {
            long[] a = new long[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextLong();
            }
            return a;
        }
    }
}

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException{
        Solution sol = new Solution();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        System.out.println(sol.solve(n));
    }
}

class Solution {
    String solve(int x) {
		if(x == 0) {
			return "a";
		}
		StringBuilder sb = new StringBuilder();
		for (int i = 0; i < 26; i++) {
			if (x == 0) {
				break;
			}
			int cur = 0;
			while (cur * (cur - 1) / 2 <= x) {
				cur++;
			}
			--cur;
			x -= cur * (cur - 1) / 2;
			char c = (char)('a' + i);
			for (int z = 0; z < cur; z++) {
				sb.append(c);
			}
		}
		return sb.toString();
	}
}

import java.io.BufferedInputStream;
import java.util.Scanner;

/**
 * Created by leen on 28/09/2017.
 */
public class _848A {

    public static void main(String[] args) {

        Scanner scan = new Scanner(new BufferedInputStream(System.in, 1024 * 1024));
        int k = scan.nextInt();

        if(k == 0) {
            System.out.println('a');
            return;
        }

        int[] f = new int[100000];

        f[1] = 0;

        for(int i = 2; i < f.length; i++) {
            if(i % 2 == 0) {
                f[i] = 2*f[i/2] + i*i/4;
            }
            else {
                int j = i/2;
                f[i] = f[j] + f[j+1] + j*(j+1);
            }
        }

        StringBuilder buf = new StringBuilder();
        char c = 'a';
        while(k > 0) {
            int idx = floor(f, k);
            for(int i = 0; i < idx; i++)
                buf.append(c);
            k -= f[idx];
            c++;
        }

        System.out.println(buf.toString());
    }

    static int floor(int[] f, int v) {
        int l = 0, h = f.length;

        while(l < h) {
            int m = (l+h)/2;
            if(f[m] < v) {
                l = m + 1;
            }
            else if(f[m] > v) {
                h = m;
            }
            else {
                return m;
            }
        }

        return l-1;
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int k = in.nextInt();
            StringBuilder sb = new StringBuilder();
            char last = 'a';
            sb.append(last);
            ++last;
            while (k > 0) {
                int n = 1;
                while (n * (n - 1) / 2 <= k) {
                    ++n;
                }
                --n;
                for (int i = 0; i < n; i++) {
                    sb.append(last);
                }
                last++;
                k -= n * (n - 1) / 2;
            }
            out.println(sb.toString());
        }

    }

    static class FastScanner {
        private BufferedReader in;
        private StringTokenizer st;

        public FastScanner(InputStream stream) {
            in = new BufferedReader(new InputStreamReader(stream));
        }

        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.*;
import java.util.StringTokenizer;

public class R431C {

    FastScanner sc;
    PrintWriter out;

    int needMinCost;

    int getCost(String a, String b) {
        int cost = 0;
        for (int i=0; i<a.length(); i++) {
            for (int j=0; j<b.length(); j++) {
                if ( a.charAt(i) == b.charAt(j) ) {
                    cost++;
                }
            }
        }
        return cost;
    }

    public void solve()  {
        needMinCost = sc.nextInt();

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

            while ((cnt+1) * cnt/2 <= needMinCost) {
                cnt++;
            }

            needMinCost -= cnt*(cnt-1)/2;

            for (int j=0; j<cnt; j++) {
                System.out.printf("%c", 'a' + i);
            }
        }

    }

    private void run() {
        //sc = new FastScanner(new File("input.txt"));
        sc = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();
        out.close();
    }

    public static void main(String[] args) {
        new R431C().run();
    }

    private class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

/*

3
a b c
a+b, c // 1
a+b+c // 3
total = 4

 */

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int k = in.nextInt();
            if (k == 0) {
                out.println("a");
                return;
            }
            char[] ret = new char[10000];
            int idx = 0, x = 0;
            while (k > 0) {
                int lo = 1, hi = 10000;
                while (lo < hi) {
                    int mid = (lo + hi + 1) / 2;
                    if (mid * (mid - 1) / 2 > k) hi = mid - 1;
                    else lo = mid;
                }
                k -= lo * (lo - 1) / 2;
                while (lo-- > 0) ret[idx++] = (char) ('a' + x);
                x++;
            }
            out.println(new String(ret, 0, idx));
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (this.numChars == -1) {
                throw new InputMismatchException();
            } else {
                if (this.curChar >= this.numChars) {
                    this.curChar = 0;

                    try {
                        this.numChars = this.stream.read(this.buf);
                    } catch (IOException var2) {
                        throw new InputMismatchException();
                    }

                    if (this.numChars <= 0) {
                        return -1;
                    }
                }

                return this.buf[this.curChar++];
            }
        }

        public int nextInt() {
            int c;
            for (c = this.read(); isSpaceChar(c); c = this.read()) {
                ;
            }

            byte sgn = 1;
            if (c == 45) {
                sgn = -1;
                c = this.read();
            }

            int res = 0;

            while (c >= 48 && c <= 57) {
                res *= 10;
                res += c - 48;
                c = this.read();
                if (isSpaceChar(c)) {
                    return res * sgn;
                }
            }

            throw new InputMismatchException();
        }

        public static boolean isSpaceChar(int c) {
            return c == 32 || c == 10 || c == 13 || c == 9 || c == -1;
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }
}

/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
What do you think? What do you think?
1st on Billboard, what do you think of it
Next is a Grammy, what do you think of it
However you think, I’m sorry, but shit, I have no fcking interest
*******************************
I'm standing on top of my Monopoly board
That means I'm on top of my game and it don't stop
til my hip don't hop anymore
https://www.a2oj.com/Ladder16.html
*******************************
300iq as writer = Sad!
*/
import java.util.*;
import java.io.*;
import java.math.*;

   public class A
   {
      public static void main(String hi[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int K = Integer.parseInt(st.nextToken());
         if(K == 0)
         {
            System.out.println("a");
            return;
         }
         StringBuilder sb = new StringBuilder();
         for(int c=0; c < 26; c++)
         {
            if(K == 0)
               break;
            int low = 1;
            int high = 446;
            while(low != high)
            {
               int mid = (low+high+1)/2;
               if(mid*(mid+1)/2 > K)
                  high = mid-1;
               else
                  low = mid;
            }
            K -= low*(low+1)/2;
            while(low-->-1)
               sb.append((char)('a'+c));
         }
         if(K > 0)
         {
            int lol = 4/0;
         }
         System.out.print(sb);
      }
   }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class C {

	public static void main(String[] args) {
		FastScanner scan = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);
		int k = scan.nextInt();
		if(k == 0) out.println("a");
		else {
			StringBuilder res = new StringBuilder();
			char c = 'a';
			while(k > 0) {
				long lo = 1, hi = k;
				for(int bs = 0; bs < 20; bs++){
					long mid = (lo+hi)>>1;
					if(mid*(mid+1)/2 > k) hi = mid;
					else lo = mid;
				}
				for(int i = 0; i <= lo; i++) res.append(c);
				k -= lo*(lo+1)/2;
				c++;
			}
			out.println(res);
		}
		out.close();
	}

	static class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				st = new StringTokenizer(br.readLine());
			} catch (Exception e){e.printStackTrace();}
		}

		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}

		public int nextInt() {return Integer.parseInt(next());}

		public long nextLong() {return Long.parseLong(next());}

		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			if(st.hasMoreTokens()) line = st.nextToken();
			else try {return br.readLine();}catch(IOException e){e.printStackTrace();}
			while(st.hasMoreTokens()) line += " "+st.nextToken();
			return line;
		}

		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}

		public long[] nextLongArray(int n){
			long[] a = new long[n];
			for(int i = 0; i < n; i++) a[i] = nextLong();
			return a;
		}

		public double[] nextDoubleArray(int n){
			double[] a = new double[n];
			for(int i = 0; i < n; i++) a[i] = nextDouble();
			return a;
		}

		public char[][] nextGrid(int n, int m){
			char[][] grid = new char[n][m];
			for(int i = 0; i < n; i++) grid[i] = next().toCharArray();
			return grid;
		}
	}

}

import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

import static java.lang.Math.*;

public class Sol {

    static long mod = 1000000007;

    public static void main(String args[]) throws Exception {
        //Scanner in;
        InputReader in;
        PrintWriter w;
        boolean online = false;
        String fileName = "input";

        if (online) {
            //in = new Scanner(new File(fileName + ".in"));
            in = new InputReader(new FileInputStream(new File(fileName + ".in")));
            w = new PrintWriter(new FileWriter("out.txt"));
        } else {
            //in = new Scanner(System.in);
            in = new InputReader(System.in);
            w = new PrintWriter(System.out);
        }

        //int T = in.nextInt();
        //in.nextLine();
        int T = 1;

        for (int t = 1; t <= T; t++) {
            int k = in.nextInt();

            bs = new int[(int)1e5][2];
            ind = 1;
            int val = 1;

            int res = 2;

            for(int i=1;val<=(int)1e6;i++) {
                val = i * (i + 1);
                val = val / 2;

                bs[ind][0] = val;
                bs[ind][1] = res;

                res++;
                ind++;
            }

            for(int i=ind;i<bs.length;i++) bs[i][0] = Integer.MAX_VALUE;

            int id = 0;
            char c[] = new char[(int)1e5];
            int ind1 = 0;

            if(k > 0) {
                while(k > 0) {
                    int l = lowestBound(k);

                    char C = (char)('a' + id);

                    if(bs[l][0] != k) l--;

                    for(int i=0;i<bs[l][1];i++) {
                        c[ind1++] = C;
                    }

                    //System.out.println(l);

                    k -= bs[l][0];
                    id++;
                }

                for(int i=0;i<ind1;i++) w.print(c[i]);
            }
            else w.println("a");
        }

        w.close();
    }

    static int bs[][];
    static int ind;

    static int lowestBound(int x) {
        int l = 1, r = ind;
        while (l < r) {
            int m = (l + r) / 2;
            if (bs[m][0] < x) l = m + 1;
            else r = m;
        }

        return l;
    }

    static class InputReader {

        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }

            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }

                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public String nextLine() {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public int nextInt() {
            int c = read();

            while (isSpaceChar(c)) {
                c = read();
            }

            int sgn = 1;

            if (c == '-') {
                sgn = -1;
                c = read();
            }

            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));

            return res * sgn;
        }

        public long nextLong() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;

            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public double nextDouble() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, nextInt());
                }
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E') {
                        return res * Math.pow(10, nextInt());
                    }
                    if (c < '0' || c > '9') {
                        throw new InputMismatchException();
                    }
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));

            return res.toString();
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next() {
            return readString();
        }

        public interface SpaceCharFilter {

            public boolean isSpaceChar(int ch);
        }
    }
}

import java.io.*;
import java.util.StringTokenizer;

/**
 * Created by Katushka on 11.03.2020.
 */
public class FromY2Y {
    static int[] readArray(int size, InputReader in) {
        int[] a = new int[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextInt();
        }
        return a;
    }

    static long[] readLongArray(int size, InputReader in) {
        long[] a = new long[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextLong();
        }
        return a;
    }

    public static void main(String[] args) throws FileNotFoundException {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        int n = in.nextInt();
        long[] trian = new long[10000];
        trian[1] = 1;
        int i = 1;
        while (trian[i] <= n) {
            i++;
            trian[i] = i * (i + 1) / 2;
        }
        if (n == 0) {
            out.println('a');
        } else {
            StringBuilder str = new StringBuilder();
            int k = i;
            char ch = 'a';
            while (n > 0 && k >= 0) {
                if (trian[k] <= n) {
                    for (int j = 0; j < k + 1; j++) {
                        str.append(ch);
                    }
                    n -= trian[k];
                    ch++;
                } else {
                    k--;
                }
            }
            out.println(str.toString());
        }

        out.close();
    }

    private 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 String nextString() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public char nextChar() {
            return next().charAt(0);
        }
    }
}

import java.math.BigInteger;
import java.util.StringTokenizer;
import java.util.*;
import java.io.*;
public class Wtf {
    public static void main(String[] args) throws IOException {
        Ifmo ifmo = new Ifmo();
    }
}

class Ifmo {
    ArrayList<Integer> Graph[];
    int n, l, m, primes, timer;
    char[][] field;
    ArrayList<FUCKINGVERTEX> Ribs;
    int[][] roofs, ans, up;
    Vertex[][] highes;
    ArrayList<Integer> fin;
    static int cur;
    int[] p, size, tin, tout;
    boolean[] used;
    int logn;
    int[][] pref;
    int[][] longest;
    int[][][] dp = new int[31][31][51];
    ArrayList<Integer>[] tree, bit;
    Ifmo() throws IOException {
        FScanner fs = new FScanner(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        int k = fs.nextInt();
        int[] mas = new int[100000];
        mas[2] = 1;
        int size = 3;
        if (k == 0) {
            System.out.println('a');
            System.exit(0);
        }
        for (int i = 3; i<100000; i++) {
            mas[i]  = mas[i-1]+i-1;
            if (mas[i]>k) {
                size = i+1;
                break;
            }
        }
        int s = 0;
        while (k!=0) {
            int i;
            for (i = 1; i<100000; i++) {
                if (mas[i+1]>k)
                    break;
            }
            k-=mas[i];
            for (int j = 0; j<i; j++)
                pw.print((char)('a'+s));
            s++;
        }

        pw.close();
    }

    private void dfs1(int v, int p) {
        used[v] = true;
        if (v !=0) {
            longest[v][0] = gcd(longest[p][0], size[v]);
        }
        for (int i = 0; i<tree[v].size(); i++) {
            if (!used[tree[v].get(i)])
                dfs1(tree[v].get(i), v);
        }
    }

    void dfs_combo(int cur, int it,  int[] p, int[] q) {
        used[cur] = true;
        if (q[cur] == -1 || q[cur] == p[cur]);
    }

    void dfs(int cur, int[] mas, HashMap<Integer, Integer> numofv, HashMap<Integer, HashSet<Integer>> fullis, HashSet<Integer> currents, ArrayList<Integer>[] bin) {
        used[cur] = true;
        if (bin[mas[cur]].size() == 0)
            primes++;
        else {
            currents.add(mas[cur]);
            for (int i = 0; i<bin[cur].size(); i+=2) {
                int val = bin[cur].get(i);
                int how = bin[cur].get(i+1);
                if (numofv.containsKey(val)) {

                }
            }
        }

    }

    boolean upper(int a, int b) {
        return tin[a]<=tin[b] && tout[a]>=tout[b];
    }

    int lca(int a, int b) {
        if (upper(a, b)) return a;
        if (upper(b, a)) return b;
        for (int i = logn-1; i>=0; i--) {
            if (!upper(up[a][i], b))
                a = up[a][i];
        }
        return up[a][0];
    }

    int log_2(int g) {
        int s = 1;
        int ans = 0;
        while (g>=s)
        {
            ans++;
            s*=2;
        }
        return ans;
    }

    int dsu_get(int v) {
        return p[v] == v? v : (p[v] = dsu_get(p[v]));
    }

    void dsu_unit(int a, int b) { // a or dsu_get(a)? what's your choice?
        if (a!=b) {
            if (size[b]>size[a])
            {
                int q = a;
                a = b;
                b = q;
            }
            p[b] = a;
            size[a]+=size[b];
        }
    }
    int gcd (int a, int b) {
        if (b == 0)
            return a;
        else
            return gcd (b, a % b);
    }
}

class forStr {
    int a, b, size;
    forStr(int a1, int b1, int size1) {
        a = a1;
        b = b1;
        size = size1;
    }
}
class Pair implements Comparable<Pair> {
    int x, y;
    Pair(int x1, int y1) {
        x = x1;
        y = y1;
    }

    @Override
    public int compareTo(Pair o) {
        return Integer.compare(x, o.x);
    }
}

class Lines implements Comparable<Lines> {
    int pos;
    boolean start;
    Lines(int x, boolean f) {
        pos = x;
        start = f;
    }

    @Override
    public int compareTo(Lines o) {
       return Integer.compare(pos, o.pos);
    }
}

class Vertex implements Comparable<Vertex> {
    int a, b, c;
    Vertex(int a1, int b1, int c1) {
        a = a1;
        b = b1;
        c = c1;
    }

    @Override
    public int compareTo(Vertex o) {
        return Integer.compare(a, o.a);
    }
}

class FUCKINGVERTEX implements Comparable<FUCKINGVERTEX> {
    int a, b, c, d;
    FUCKINGVERTEX(int a1, int b1, int c1, int d1) {
        a = a1;
        b = b1;
        c = c1;
        d = d1;
    }

    @Override
    public int compareTo(FUCKINGVERTEX o) {
        return Integer.compare(a, o.a);
    }
}
class FScanner {
    StringTokenizer st;
    BufferedReader reader;
    FScanner(InputStreamReader isr) throws IOException {
        reader = new BufferedReader(isr);
    }

    String nextLine() throws IOException {
        return reader.readLine();
    }

    String nextToken() throws IOException{
        while (st == null || !st.hasMoreTokens()) {
            String s = reader.readLine();
            if (s == null)
                return null;
            st = new StringTokenizer(s);
        }
        return st.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    char nextChar() throws IOException {
        return (char) reader.read();
    }
}

/*
 * Author Ayub Subhaniya
 * Institute DA-IICT
 */

import java.io.*;
import java.math.*;
import java.util.*;

public class Codeforces429C
{

	InputStream in;
	PrintWriter out;

	int MAX=1000;
	void solve()
	{
		int k=ni();
		if (k==0)
		{
			out.println("a");
			return;
		}
		int sum[]=new int[MAX];
		sum[0]=0;
		for (int i=1;i<MAX;i++)
			sum[i]=sum[i-1]+i;

		int cnt[]=new int[26];
		int j=MAX-1;
		for (int i=0;i<26&&k>0;i++)
		{
			//tr(j);
			for (;j>0;j--)
			{
				if (sum[j]<=k)
				{
					cnt[i]=j+1;
					k-=sum[j];
					//tr(j+" "+sum[j]+" "+k);
					break;
				}
			}
		}
		for (int i=0;i<26;i++)
			for (int l=1;l<=cnt[i];l++)
				out.print((char)('a'+i));
	}

	void run() throws Exception
	{
		String INPUT = "C:/Users/ayubs/Desktop/input.txt";
		in = oj ? System.in : new FileInputStream(INPUT);
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis() - s + "ms");

	}
	public static void main(String[] args) throws Exception
	{
		new Codeforces429C().run();
	}

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf)
		{
			ptrbuf = 0;
			try
			{
				lenbuf = in.read(inbuf);
			}
			catch (IOException e)
			{
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean inSpaceChar(int c)
	{
		return !(c >= 33 && c <= 126);
	}

	private int skip()
	{
		int b;
		while ((b = readByte()) != -1 && inSpaceChar(b))
			;
		return b;
	}

	private double nd()
	{
		return Double.parseDouble(ns());
	}

	private char nc()
	{
		return (char) skip();
	}

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(inSpaceChar(b)))
		{ // when nextLine, (inSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(inSpaceChar(b)))
		{
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}
			else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}
			else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

	private void tr(Object... o)
	{
		if (!oj)
			System.out.println(Arrays.deepToString(o));
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.StringTokenizer;
import java.io.Writer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author zodiacLeo
 */
public class Main
{
    public static void main(String[] args)
    {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        FastPrinter out = new FastPrinter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC
    {
        private int T = 448;
        private int[] t = new int[T];

        public void solve(int testNumber, FastScanner in, FastPrinter out)
        {
            for (int i = 0; i < T; i++)
            {
                t[i] = i;
                t[i] *= (i + 1);
                t[i] /= 2;
            }

            char now = 'a';
            StringBuilder sb = new StringBuilder("");
            int cost = in.nextInt();
            if (cost == 0)
            {
                out.println("ab");
                return;
            }
            while (cost > 0)
            {
                int c = getT(cost);
                StringBuilder temp = getString(now, c + 1);
                sb.append(temp);
                now++;
                cost -= t[c];
            }
            out.println(sb);
        }

        private StringBuilder getString(char a, int count)
        {
            StringBuilder sb = new StringBuilder("");
            while (count-- > 0)
            {
                sb.append(a);
            }
            return sb;
        }

        private int getT(int v)
        {
            int low = -1;
            int high = T;
            while (high - low > 1)
            {
                int mid = low + (high - low) / 2;
                if (t[mid] <= v)
                {
                    low = mid;
                } else
                {
                    high = mid;
                }
            }
            return low;
        }

    }

    static class FastScanner
    {
        public BufferedReader br;
        public StringTokenizer st;

        public FastScanner(InputStream is)
        {
            br = new BufferedReader(new InputStreamReader(is));
        }

        public FastScanner(File f)
        {
            try
            {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e)
            {
                e.printStackTrace();
            }
        }

        public String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                String s = null;
                try
                {
                    s = br.readLine();
                } catch (IOException e)
                {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        public int nextInt()
        {
            return Integer.parseInt(next());
        }

    }

    static class FastPrinter extends PrintWriter
    {
        public FastPrinter(OutputStream out)
        {
            super(out);
        }

        public FastPrinter(Writer out)
        {
            super(out);
        }

    }
}

import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {

        new Main().go();
    }

    PrintWriter out;
    Reader in;
    BufferedReader br;

    Main() throws IOException {

        try {

            //br = new BufferedReader( new FileReader("input.txt") );
            in = new Reader("input.txt");
            out = new PrintWriter( new BufferedWriter(new FileWriter("output.txt")) );
        }
        catch (Exception e) {

            //br = new BufferedReader( new InputStreamReader( System.in ) );
            in = new Reader();
            out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
        }
    }

    void go() throws IOException {

        int t = 1;
        while (t > 0) {
            solve();
            //out.println();
            t--;
        }

        out.flush();
        out.close();
    }

    int inf = 2000000000;
    int mod = 1000000007;
    double eps = 0.00000001;

    int n;
    int m;

    //ArrayList<Integer>[] g = new ArrayList[200010];

    void solve() throws IOException {

        int n = in.nextInt();

        if (n == 0) {

            out.println('a');
            return;
        }

        int a = 'a';

        while (n > 0) {
            for (int i = 500; i >= 2; i--)
                if (sum(i-1) <= n) {
                    n -= sum(i-1);
                    for (int j = 0; j < i; j++)
                        out.print((char)a);
                    a++;
                    break;
                }
        }

    }

    int sum(int n) {
        return n*(n+1)/2;
    }

    int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a%b);
    }

    class Pair implements Comparable<Pair>{

        int a;
        int b;

        Pair(int a, int b) {

            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {

            if (a > p.a) return 1;
            if (a < p.a) return -1;
            if (b > p.b) return 1;
            if (b < p.b) return -1;
            return 0;
        }
    }

    class Item {

        int a;
        int b;
        int c;

        Item(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

    }

    class Reader {

        BufferedReader  br;
        StringTokenizer tok;

        Reader(String file) throws IOException {
            br = new BufferedReader( new FileReader(file) );
        }

        Reader() throws IOException {
            br = new BufferedReader( new InputStreamReader(System.in) );
        }

        String next() throws IOException {

            while (tok == null || !tok.hasMoreElements())
                tok = new StringTokenizer(br.readLine());
            return tok.nextToken();
        }

        int nextInt() throws NumberFormatException, IOException {
            return Integer.valueOf(next());
        }

        long nextLong() throws NumberFormatException, IOException {
            return Long.valueOf(next());
        }

        double nextDouble() throws NumberFormatException, IOException {
            return Double.valueOf(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

    }

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class Div1_431A {

	public static void main(String[] args) throws IOException {
		BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter printer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
		int k = Integer.parseInt(reader.readLine());

		if (k == 0) {
			printer.println('a');
			printer.close();
		}

		for (int i = 0; k > 0; i++) {
			int n = 0;
			while ((n + 1) * n / 2 <= k) {
				n++;
			}
			k -= n * (n - 1) / 2;
			for (int j = 0; j < n; j++) {
				printer.print((char) ('a' + i));
			}
		}
		printer.println();
		printer.close();
	}

}

import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;
import java.util.LinkedList;

public class C {
	public static void main(String[] args) {
		FastScannerC sc = new FastScannerC(System.in);

		int N = sc.nextInt();
		int[] sums = new int[451];
		for(int i = 1; i <= 450; i++){
			sums[i] = i * (i + 1) / 2;
			//System.out.println(sums[i]);
		}

		if(N == 0){
			System.out.println('a');
			System.exit(0);
		}

		LinkedList<Integer> list = new LinkedList<>();
		while(N > 0){
			int last = -1;
			for(int i = 1; i < 451; i++){
				if(sums[i] <= N) last = i;
				else break;
			}
			list.add(last);
			N -= sums[last];
		}
		StringBuilder sb = new StringBuilder();
		char curr = 'a';
		for(int i : list){
			for(int j = 0; j<=i; j++) sb.append(curr);
			curr++;
		}
		System.out.println(sb);

	}
}

class FastScannerC{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastScannerC(InputStream stream)
    {
        this.stream = stream;
    }

    public int read()
    {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars)
        {
            curChar = 0;
            try
            {
                numChars = stream.read(buf);
            } catch (IOException e)
            {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-')
        {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do
        {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String next()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do
        {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public double nextDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        double res = 0;
        while (!isSpaceChar(c) && c != '.') {
            if (c == 'e' || c == 'E')
                return res * Math.pow(10, nextInt());
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        }
        if (c == '.') {
            c = read();
            double m = 1;
            while (!isSpaceChar(c)) {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                m /= 10;
                res += (c - '0') * m;
                c = read();
            }
        }
        return res * sgn;
    }

    public long nextLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public boolean isLineEndChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == '\n' || c == '\r' || c == -1;
    }

    public interface SpaceCharFilter
    {
        public boolean isSpaceChar(int ch);
    }
}

import java.util.*;
import java.awt.Point;
import java.io.*;

public class C{
	public static void main(String[] args) {
		FastScannerC sc = new FastScannerC(System.in);

		int N = sc.nextInt();

		if(N == 0){
			System.out.println('s');
			System.exit(0);
		}

		StringBuilder sb = new StringBuilder();

		char c = 'a';

		long sum = 0;

		while(sum < N){

			int currChar = 0;
			sb.append(c);

			while( sum + (currChar + 1) <= N){
				sb.append(c);
				currChar++;
				sum += currChar;
			}
//			System.out.println(sum + " char " + c);
			c = (char) (c + 1);

		}

		System.out.println(sb.toString());

	}

}

class FastScannerC{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastScannerC(InputStream stream)
    {
        this.stream = stream;
    }

    public int read()
    {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars)
        {
            curChar = 0;
            try
            {
                numChars = stream.read(buf);
            } catch (IOException e)
            {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-')
        {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do
        {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String next()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do
        {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public String nextLine()
    {
        int c = read();
        StringBuilder res = new StringBuilder();
        do
        {
            res.appendCodePoint(c);
            c = read();
        } while (!isLineEndChar(c));
        return res.toString();
    }

    public double nextDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        double res = 0;
        while (!isSpaceChar(c) && c != '.') {
            if (c == 'e' || c == 'E')
                return res * Math.pow(10, nextInt());
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        }
        if (c == '.') {
            c = read();
            double m = 1;
            while (!isSpaceChar(c)) {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                m /= 10;
                res += (c - '0') * m;
                c = read();
            }
        }
        return res * sgn;
    }

    public long nextLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public boolean isLineEndChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == '\n' || c == '\r' || c == -1;
    }

    public interface SpaceCharFilter
    {
        public boolean isSpaceChar(int ch);
    }
}

/*
LANG: JAVA
TASK:
*/

import java.io.*;
import java.util.*;
public class cf3
{
	public static void main(String[] args)
	{
		Scanner c = new Scanner(System.in);
		int K = c.nextInt();
		ArrayList<Integer> list = new ArrayList<Integer>();
		if(K==0)
		{
			System.out.println("a");
			return;
		}
		while(K>0)
		{
//			System.out.println(K);
			int f = (int) Math.sqrt(2*K);
			if(f*(f+1) <= 2*K)
			{
				list.add(f); K-= (f*f+f)/2;
			}
			else
			{
				list.add(f-1); K-=(f*f-f)/2;
			}
		}
//		System.out.println(list);
		StringBuilder sb = new StringBuilder();
		char ch = 97;
		for(int i=0; i<list.size(); i++)
		{
			for(int j=0; j<list.get(i)+1; j++) sb.append(ch);
			ch++;
		}

		System.out.println(sb);
	}
}

import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;

public class A {
    static class Node{
        int id;
        long y;
        public Node(int id,long x){
            this.id=id;
            this.y=y;
        }
    }
    //public static PrintWriter pw;
    public static PrintWriter pw = new PrintWriter(System.out);

    public static void solve() throws IOException {
//	pw=new PrintWriter(new FileWriter("C:\\Users\\shree\\Downloads\\small_output_in"));
        FastReader sc = new FastReader();
        long k=sc.L();
        StringBuilder sb=new StringBuilder("");
        int c=0;
        if(k==0) sb.append("a");
        while(k>0 && c<26){
            long n1=1;
            while((n1*(n1-1))/2<k) n1++;
            if((n1*(n1-1))/2!=k) n1--;
            char ch=(char)(c+'a');
            for(int i=1;i<=n1;i++) sb.append(ch);
            c++;
            k-=(n1*(n1-1))/2;
        }
        pw.println(sb);

        pw.close();

    }

    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                try {

                    solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();

    }

    static BufferedReader br;
    static long M = (long) 1e9 + 7;

    static class FastReader {

        StringTokenizer st;

        public FastReader() throws FileNotFoundException {
            //br=new BufferedReader(new FileReader("C:\\Users\\shree\\Downloads\\B-small-practice.in"));
            br = new BufferedReader(new InputStreamReader(System.in));

        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int I() {
            return Integer.parseInt(next());
        }

        long L() {
            return Long.parseLong(next());
        }

        double D() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public boolean hasNext() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                String s = br.readLine();
                if (s == null) {
                    return false;
                }
                st = new StringTokenizer(s);
            }
            return true;
        }

    }
}

import java.util.*;
public class Main {
	static long[] a=new long[501];
	static long dfs(int x){
		if(a[x]!=-1)return a[x];
		return a[x]=dfs(x/2)+dfs(x-x/2)+(x/2)*(x-x/2);
	}
	static int ed=0;
	static char[] ans=new char[10000];
	public static void main(String args[]){
		Scanner jin=new Scanner(System.in);
		int n=jin.nextInt();
		if(n==0){
			System.out.println("a");
			return;
		}
		for(int i=1;i<=500;i++){
			a[i]=-1;
		}
		a[0]=0;
		a[1]=0;
		a[2]=1;
		for(int i=1;i<=500;i++){
			dfs(i);
		}
		int t=0;
		while(n>0){
			int k=1;
			for(;k<=500;k++){
				if(a[k]>n)break;
			}
			k--;
			for(int i=1;i<=k;i++){
				ed++;
				ans[ed]=(char)('a'+t);
			}
			t++;
			if(t>=25)System.out.println("GG");
			n-=a[k];
		}
		for(int i=1;i<=ed;i++)System.out.print(ans[i]);
		System.out.println();
	}
}

import java.io.*;
import java.util.*;

public class C {

    public static void main(String[] args) {
        	Scanner in = new Scanner(System.in);
	    	PrintWriter out = new PrintWriter(System.out);
			int k = in.nextInt();
            int[] kol = new int[500];
            int dob = 1;
            for (int i = 1 ; i < 500 ; i++) {
                kol[i] = kol[i - 1] + dob;
                dob += 1;
            }
            if (k == 0) {
                out.println("a");
                out.close();
                return;
            }
            char letter = 'a';
            StringBuilder sb = new StringBuilder("");
            while (k > 0) {
                int i = 0;
                while (i < 500 && kol[i] <= k) i += 1;
                i -= 1;
                k -= kol[i];
                for (int j = 0 ; j <= i ; j++) sb.append(letter);
                letter += 1;
            }
            out.println(sb.toString());
			out.close();
    }
}

/* Author: Ronak Agarwal */
import java.io.* ; import java.util.* ; import java.math.* ;
import static java.lang.Math.min ;
import static java.lang.Math.max ;
import static java.lang.Math.abs ;
/* Thread is created here to increase the stack size of the java code so that recursive dfs can be performed */
public class Codeshefcode{
	public static void main(String[] args) throws IOException{
		new Thread(null,new Runnable(){	public void run(){ exec_Code() ;} },"Solver",1l<<27).start() ;
	}
	static void exec_Code(){
		try{
			Solver Machine = new Solver() ;
			Machine.Solve() ; Machine.Finish() ;}
		catch(Exception e){ e.printStackTrace() ; print_and_exit() ;}
		catch(Error e){ e.printStackTrace() ; print_and_exit() ; }
	}
	static void print_and_exit(){ System.out.flush() ; System.exit(-1) ;}
}
/* Implementation of the pair class, useful for every other problem */
class pair implements Comparable<pair>{
	int x ; int y ;
	pair(int x,int y){ this.x=x ; this.y=y ;}
	public int compareTo(pair p){
		return (this.x<p.x ? -1 : (this.x>p.x ? 1 : (this.y<p.y ? -1 : (this.y>p.y ? 1 : 0)))) ;
	}
}
/* Main code starts here */
class Solver extends Template{
	int MAX = 100000 ;
	public void Solve() throws IOException{
		pair data[] = new pair[MAX+1] ;
		data[0] = new pair(0,0) ;
		for(int i=1 ; i<=MAX ; i++){
			int sm=1,idx=-1,j=1 ;
			int mdis = INT_MAX ;
			while((i-sm)>=0){
				int dis = data[i-sm].y ;
				if(dis<mdis){
					mdis = dis ;
					idx = j ;
				}
				j++ ;
				sm+=j ;
			}
			data[i] = new pair(idx,mdis+1) ;
		}
		int k = ip.i() ;
		if(k==0){
			pln("a") ;
			return ;
		}
		char c = 'a' ;
		while(k!=0){
			int ct = data[k].x ;
			for(int i=0 ; i<=ct ; i++) p(c) ;
			c++ ;
			k-=((ct*(ct+1))/2) ;
		}
		pln("") ;
	}
}

/* All the useful functions,constants,renamings are here*/
class Template{
	/* Constants Section */
	final int INT_MIN = Integer.MIN_VALUE ; final int INT_MAX = Integer.MAX_VALUE ;
	final long LONG_MIN = Long.MIN_VALUE ; final long LONG_MAX = Long.MAX_VALUE ;
	static long MOD = 1000000007 ;
	static Reader ip = new Reader(System.in) ;
	static PrintWriter op = new PrintWriter(System.out) ;
	/* Methods for writing */
	static void p(Object o){ op.print(o) ; }
	static void pln(Object o){ op.println(o) ;}
	static void Finish(){ op.flush();	op.close(); }
	/* Implementation of operations modulo MOD */
	static long inv(long a){ return powM(a,MOD-2) ; }
	static long m(long a,long b){ return (a*b)%MOD ; }
	static long d(long a,long b){ return (a*inv(b))%MOD ; }
	static long powM(long a,long b){
		if(b<0) return powM(inv(a),-b) ;
		long val=a ; long ans=1 ;
		while(b!=0){
			if((b&1)==1) ans = (ans*val)%MOD ;
			val = (val*val)%MOD ;
			b/=2 ;
		}
		return ans ;
	}
	/* Renaming of some generic utility classes */
	final static class mylist extends ArrayList<Integer>{}
	final static class myset extends TreeSet<Long>{}
	final static class mystack extends Stack<Integer>{}
	final static class mymap extends TreeMap<Integer,Integer>{}
}

class Reader{
	BufferedReader reader;
	StringTokenizer tkz;
	Reader(InputStream input) {
		reader = new BufferedReader(new InputStreamReader(input)) ;
		tkz = new StringTokenizer("") ;
	}
	String s() throws IOException{
		while (!tkz.hasMoreTokens()) tkz = new StringTokenizer(reader.readLine()) ;
		return tkz.nextToken() ;
	}
	int i() throws IOException{ return Integer.parseInt(s()) ;}
	long l() throws IOException{ return Long.parseLong(s()) ;}
	double d() throws IOException{	return Double.parseDouble(s()) ;}
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;

// atharva washimkar
// Sep 01, 2017

public class CODEFORCES_849_C {

	public static void main (String[] t) throws IOException {
		INPUT in = new INPUT (System.in);
		PrintWriter out = new PrintWriter (System.out);

		int K = in.iscan ();
		int[] cnt = new int[26];

		NavigableMap<Integer, Integer> map = new TreeMap<Integer, Integer> ();
		NavigableMap<Integer, Integer> rev = new TreeMap<Integer, Integer> ();
		for (int i = 0, j = 1; i <= 100000; ++j) {
			map.put (i, j);
			rev.put (j, i);
			i += j;
		}

		if (K == 0) {
			cnt[0] = 1;
		}

		out:
		while (K > 0) {
			Map.Entry<Integer, Integer> pos = map.floorEntry (K);

			for (int i = 0; i < 26; ++i) {
				if (cnt[i] == 0) {
					cnt[i] = pos.getValue ();
					break;
				}
			}

			K -= pos.getKey ();
		}

		for (int i = 0; i < 26; ++i)
			for (int j = 0; j < cnt[i]; ++j)
				out.print ((char) (i + 'a'));

		out.close ();
	}

	private static class INPUT {

		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar, numChars;

		public INPUT (InputStream stream) {
			this.stream = stream;
		}

		public INPUT (String file) throws IOException {
			this.stream = new FileInputStream (file);
		}

		public int cscan () throws IOException {
			if (curChar >= numChars) {
				curChar = 0;
				numChars = stream.read (buf);
			}

			return buf[curChar++];
		}

		public int iscan () throws IOException {
			int c = cscan (), sgn = 1;
			while (space (c)) c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			int res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();
			}
			while (!space (c));

			return res * sgn;
		}

		public String sscan () throws IOException {
			int c = cscan ();
			while (space (c)) c = cscan ();

			StringBuilder res = new StringBuilder ();

			do {
				res.appendCodePoint (c);
				c = cscan ();
			}
			while (!space (c));

			return res.toString ();
		}

		public double dscan () throws IOException {
			int c = cscan (), sgn = 1;
			while (space (c)) c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			double res = 0;

			while (!space (c) && c != '.') {
				if (c == 'e' || c == 'E') return res * UTILITIES.fast_pow (10, iscan ());
				res *= 10;
				res += c - '0';
				c = cscan ();
			}

			if (c == '.') {
				c = cscan ();
				double m = 1;

				while (!space (c)) {
					if (c == 'e' || c == 'E') return res * UTILITIES.fast_pow (10, iscan ());

					m /= 10;
					res += (c - '0') * m;
					c = cscan ();
				}
			}

			return res * sgn;
		}

		public long lscan () throws IOException {
			int c = cscan (), sgn = 1;
			while (space (c)) c = cscan ();

			if (c == '-') {
				sgn = -1;
				c = cscan ();
			}

			long res = 0;

			do {
				res = (res << 1) + (res << 3);
				res += c - '0';
				c = cscan ();

			}
			while (!space (c));

			return res * sgn;
		}

		public boolean space (int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	}

	public static class UTILITIES {

		static final double EPS = 10e-6;

		public static int lower_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] >= x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static int upper_bound (int[] arr, int x) {
			int low = 0, high = arr.length, mid = -1;

			while (low < high) {
				mid = (low + high) / 2;

				if (arr[mid] > x)
					high = mid;
				else
					low = mid + 1;
			}

			return low;
		}

		public static int gcd (int a, int b) {
			return b == 0 ? a : gcd (b, a % b);
		}

		public static int lcm (int a, int b) {
			return a * b / gcd (a, b);
		}

		public static int fast_pow_mod (int b, int x, int mod) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow_mod (b * b % mod, x / 2, mod) % mod;

			return b * fast_pow_mod (b * b % mod, x / 2, mod) % mod;
		}

		public static int fast_pow (int b, int x) {
			if (x == 0) return 1;
			if (x == 1) return b;
			if (x % 2 == 0) return fast_pow (b * b, x / 2);

			return b * fast_pow (b * b, x / 2);
		}

		public static long choose (long n, long k) {
			k = Math.min (k, n - k);
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = val * (n - i) / (i + 1);

			return val;
		}

		public static long permute (int n, int k) {
			if (n < k) return 0;
			long val = 1;

			for (int i = 0; i < k; ++i)
				val = (val * (n - i));

			return val;
		}
	}
}

/**
 * Created by Aminul on 9/1/2017.
 */

import java.io.*;
import java.util.*;

public class C_2 {
    public static HashSet<Integer> set;
    static int index[];
    public static void main(String[] args)throws Exception {
        InputReader in = new InputReader(System.in);
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
        preCal();
        int n = in.nextInt();
        int [] res = solve(n); //debug(res);

        char c = 'a';
        for(int i = 0; i < 3; i++, c++){
            int x = index[res[i]];
            if(x > 0) x++;
            //debug(x);
            for(int j = 0; j < x; j++){
                pw.print(c);
            }
        }
        if(n == 0) pw.print("a");
        pw.println();

        pw.close();
    }

    static int[] solve(int n){
        for(int j : set){
            for(int k : set){
                if(set.contains(n - j - k)){
                    return new int[]{j, k, n-j-k};
                }
            }
        }
        return null;
    }

    static void preCal(){
        set = new HashSet<>();
        index = new int[(int)1e5+50];
        int sum = 0;
        for(int i = 0; i < 1000; i++){
            sum += i;
            if(sum > (int)1e5) break;
            set.add(sum);
            index[sum] = i;
        }
    }

    static void debug(Object...obj) {
        System.err.println(Arrays.deepToString(obj));
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tokenizer = null;
        }

        public String next()throws Exception {
            while (tokenizer == null || !tokenizer.hasMoreTokens())
                tokenizer = new StringTokenizer(reader.readLine());
            return tokenizer.nextToken();
        }

        public String nextLine()throws Exception {
            String line = null;
            tokenizer = null;
            line =  reader.readLine();
            return line;
        }

        public int nextInt()throws Exception {
            return Integer.parseInt(next());
        }

        public double nextDouble() throws Exception{
            return Double.parseDouble(next());
        }

        public long nextLong()throws Exception {
            return Long.parseLong(next());
        }

    }
}

import java.io.*;
import java.util.*;
import java.util.Map.*;

/**
 * Ariana Herbst, 9/1/2017
 */

public class cfs431C {

    public static void main(String[] args) {
        StringBuilder ans = new StringBuilder();
        FastScanner sc = new FastScanner();
        int k = sc.nextInt();
        ArrayList<Integer> numsToUse = new ArrayList<Integer>();
        numsToUse.add(0);
        numsToUse.add(0);
        int curr = 1;
        int dx = 2;
        while (curr <= k) {
            numsToUse.add(curr);
            curr += dx;
            dx++;
        }
        Map<Integer, Integer> count = new HashMap<Integer, Integer>();
        int index = 0;
        count.put(index, 1);
        index++;
        int i = numsToUse.size()-1;
        while (k != 0) {
            if (numsToUse.get(i) <= k) {
                k -= numsToUse.get(i);
                count.put(index, i);
                index++;
            } else {
                i--;
            }
        }
        for (Entry<Integer, Integer> entry : count.entrySet()) {
            for (int j = 0; j < entry.getValue(); j++) {
                ans.append((char)('a' + entry.getKey()));
            }
        }
        System.out.println(ans);
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }

        public FastScanner() {
            this(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String readNextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        int[] readIntArray(int n) {
            int[] a = new int[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextInt();
            }
            return a;
        }

        long[] readLongArray(int n) {
            long[] a = new long[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextLong();
            }
            return a;
        }
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int[] memo = new int[451];
            for (int i = 1; i <= 450; i++) {
                memo[i] = (i * (i + 1)) / 2;
            }
            int k = in.nextInt();
            char cur = 'a';
            StringBuilder ans = new StringBuilder();
            while (k > 0) {
                int idx = Utils.lowerBound(memo, 1, memo.length - 1, k);
                for (int i = 0; i < idx + 1; i++) ans.append(cur);
                k -= memo[idx];
                cur++;
            }
            if (ans.length() == 0) out.print('a');
            else out.print(ans.toString());
        }

    }

    static class InputReader {
        private int lenbuf = 0;
        private int ptrbuf = 0;
        private InputStream in;
        private byte[] inbuf = new byte[1024];

        public InputReader(InputStream in) {
            this.in = in;
        }

        private int readByte() {
            if (lenbuf == -1) throw new InputMismatchException();
            if (ptrbuf >= lenbuf) {
                ptrbuf = 0;
                try {
                    lenbuf = in.read(inbuf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (lenbuf <= 0) return -1;
            }
            return inbuf[ptrbuf++];
        }

        public int nextInt() {
            int num = 0, b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

    }

    static class Utils {
        public static int lowerBound(int[] arr, int l, int r, int x) {
            int m, ans = -1;
            while (l <= r) {
                m = l + (r - l) / 2;
                if (arr[m] <= x) {
                    ans = m;
                    l = m + 1;
                } else {
                    r = m - 1;
                }
            }
            return ans;
        }

    }
}

import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import java.io.*;

public class Main {
    double eps = 0.0000001;

    public class point {
        int t, d, p;

        point(int a, int b, int c) {
            t = a;
            d = b;
            p = c;
        }
    }

    public void solve() throws IOException {
        int k = nextInt();
        char t = 'a';
        if(k == 0){
            out.print(t);
        }
        while (k > 0) {
            int z = (int) Math.sqrt(k);
            while (z * (z + 1) / 2 <= k) {
                z++;
            }
            for(int i = 0; i < z; i++){
                out.print(t);
            }
            k -= z * (z - 1) / 2;
            t++;
        }
    }

    BufferedReader br;
    StringTokenizer sc;
    PrintWriter out;

    public String nextToken() throws IOException {
        while (sc == null || !sc.hasMoreTokens()) {
            try {
                sc = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return sc.nextToken();
    }

    public boolean hasNext() throws IOException {
        while (sc == null || !sc.hasMoreTokens()) {
            try {
                sc = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return false;
            }
        }
        return true;
    }

    public Integer nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    public Long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    public Double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    public static void main(String[] args) throws IOException {
        try {
            Locale.setDefault(Locale.US);
        } catch (Exception e) {
        }
        new Main().run();
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
//            br = new BufferedReader(new FileReader("shooting.in"));
//            out = new PrintWriter(new File("shooting.out"));
            solve();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
}

import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main
{
    static int dx[] = {-1,1,0,0};
    static int dy[] = {0,0,1,-1};
    static long MOD = 1000000007;
    static int INF = Integer.MAX_VALUE/10;
    static PrintWriter pw;
    static Reader scan;
    static int ni() throws IOException{return scan.nextInt();}
    static long nl() throws IOException{return scan.nextLong();}
    static double nd() throws IOException{return scan.nextDouble();}
    static void pl() throws IOException{pw.println();}
    static void pl(Object o){pw.println(o);}
    static void p(Object o){pw.print(o+" ");}
    static void psb(StringBuilder sb){pw.print(sb);}
    public static void main(String[] args) {
        new Thread(null,null,"BaZ",99999999)
        {
            public void run()
            {
                try
                {
                    solve();
                }
                catch(Exception e)
                {
                    e.printStackTrace();
                    System.exit(1);
                }
            }
        }.start();
    }
    static void solve() throws IOException
    {
        scan = new Reader();
        pw = new PrintWriter(System.out,true);
        StringBuilder sb = new StringBuilder();
        long k = ni();
        if(k==0)
            pl("abcdef");
        char c = 'a';
        while(k>0)
        {
           // pl("K : "+k);
            long n = bs(k);
           // pl("N : "+n+" sumn : "+sumn(n));
            for(int i=0;i<=n;++i)
                sb.append(c);
            c++;
            k-=sumn(n);
        }
        pl(sb);
        pw.flush();
        pw.close();
    }
    static long bs(long req)
    {
        long low = 1;
        long high = req;
        while(low<high)
        {
            long mid = (low+high)>>1;
            if(sumn(mid)<=req)
            {
                if(sumn(mid+1)>req)
                {
                    return mid;
                }
                low = mid+1;
            }
            else high = mid-1;
        }
        return low;
    }
    static long sumn(long n)
    {
        return (n*(n+1))/2;
    }
    static boolean islong(double d)
    {
        return Math.ceil(d)==d;
    }
    static double roundLikeCpp(double d,double precision)
    {
        if(islong(d))
            return d;
        d*=(long)pow(10,precision+1);
        if(d%10==5)
            d--;
        return d/pow(10,precision+1);
    }
    static class Reader {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Reader() {
        din = new DataInputStream(System.in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public Reader(String file_name) throws IOException {
        din = new DataInputStream(new FileInputStream(file_name));
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
        byte[] buf = new byte[64];
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n') break;
            buf[cnt++] = (byte) c;
        }
        return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
        int ret = 0;
        byte c = read();
        while (c <= ' ') c = read();
        boolean neg = (c == '-');
        if (neg) c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');
        if (neg) return -ret;
        return ret;
    }

    public long nextLong() throws IOException {
        long ret = 0;
        byte c = read();
        while (c <= ' ') c = read();
        boolean neg = (c == '-');
        if (neg) c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');
        if (neg) return -ret;
        return ret;
    }

    public double nextDouble() throws IOException {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ') c = read();
        boolean neg = (c == '-');
        if (neg) c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');
        if (c == '.') while ((c = read()) >= '0' && c <= '9') ret += (c - '0') / (div *= 10);
        if (neg) return -ret;
        return ret;
    }

    private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1) buffer[0] = -1;
    }

    private byte read() throws IOException {
        if (bufferPointer == bytesRead) fillBuffer();
        return buffer[bufferPointer++];
    }

    public void close() throws IOException {
        if (din == null) return;
        din.close();
    }
}
}

import java.io.*;
import java.util.*;

public class Main
{
	private InputStream is;
	private PrintWriter out;
	int time = 0, DP[], start[], end[], dist[], black[], MOD = (int) (1e9 + 7),
			arr[], weight[][], x[], y[], parent[];
	int MAX = 1000000, N, K;
	long red[];
	ArrayList<Character>[] amp;
	ArrayList<Pair>[][] pmp;
	boolean b[], boo[][];
	Pair prr[];
	HashMap<Pair, Integer> hm = new HashMap();
	long Dp[][][][] = new long[110][110][12][12];

	void soln()
	{
		is = System.in;
		out = new PrintWriter(System.out);
		long s = System.currentTimeMillis();
		solve();
		// out.close();
		out.flush();
		// tr(System.currentTimeMillis() - s + "ms");
	}

	public static void main(String[] args) throws Exception
	{
		new Thread(null, new Runnable()
		{
			public void run()
			{
				try
				{
					// new CODEFORCES().soln();
				} catch (Exception e)
				{
					System.out.println(e);
				}
			}
		}, "1", 1 << 26).start();
		new Main().soln();
	}

	int ans = 0, cost = 0, D[][];
	char ch[], ch1[];
	int hash = 29;
	TreeSet<Cell> ts;
	int x2, y2;
	void solve()
	{
		int k = ni();
		StringBuilder sb = new StringBuilder();
		for(char ch = 'a';ch<='z';ch++) sb.append(ch);
		for(char ch = 'a';ch<='z';ch++){
			for(int i = 1;i<100000;i++){
				if(i>k) break;
				else{
					k-=i;
					sb.append(ch);
				}
			}
		}
		System.out.println(sb);
	}
	void recur(int a, int b, int k){
		if(k==0){
			if(a==x2 && b==y2) ans++;
			return;
		}
		recur(a,b+1,k-1);
		recur(a,b-1,k-1);
		recur(a+1,b,k-1);
		recur(a-1,b,k-1);
	}
	int min(int a, int b)
	{
		return (a<b)?a:b;
	}
	private class Cell implements Comparable<Cell>
	{
		int u, v, s;
		public Cell(int u, int v, int s)
		{
			this.u = u;
			this.v = v;
			this.s = s;
		}
		public int hashCode()
		{
			return Objects.hash();
		}
		public int compareTo(Cell other)
		{
			return (Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s)):(Long.compare(v, other.v)!=0?Long.compare(v, other.v):Long.compare(u, other.u)))
					&((Long.compare(s, other.s) != 0 ? (Long.compare(s, other.s)):(Long.compare(u, other.v)!=0?Long.compare(u, other.v):Long.compare(v, other.u))));
		}
		public String toString()
		{
			return this.u + " " + this.v;
		}
	}

	class Pair implements Comparable<Pair>
	{
		int u, v, i;

		Pair(int u, int v)
		{
			this.u = u;
			this.v = v;
		}

		Pair()
		{

		}

		Pair(int u, int v, int i)
		{
			this.u = u;
			this.v = v;
			this.i = i;
		}

		public int hashCode()
		{
			return Objects.hash();
		}

		public boolean equals(Object o)
		{
			Pair other = (Pair) o;
			return ((u == other.u && v == other.v) | ((u == other.v && v == other.u)));
		}

		public int compareTo(Pair other)
		{
			// return Integer.compare(val, other.val);
			return Integer.compare(u, other.u);//((Long.compare(u, other.u) != 0 ? (Long.compare(u, other.u)): (Long.compare(v, other.v)))
					//&(Long.compare(u, other.v) != 0 ? (Long.compare(u, other.v)): (Long.compare(v, other.u))));
		}

		public String toString()
		{
			return this.u + " " + this.v;
		}
	}

	long max(long a, long b)
	{
		if (a > b)
			return a;
		return b;
	}

	public static class FenwickTree
	{

		int[] array; // 1-indexed array, In this array We save cumulative
						// information to perform efficient range queries and
						// updates

		public FenwickTree(int size)
		{
			array = new int[size + 1];
		}

		public int rsq(int ind)
		{
			assert ind > 0;
			int sum = 0;
			while (ind > 0)
			{
				sum += array[ind];
				// Extracting the portion up to the first significant one of the
				// binary representation of 'ind' and decrementing ind by that
				// number
				ind -= ind & (-ind);
			}
			return sum;
		}

		public int rsq(int a, int b)
		{
			assert b >= a && a > 0 && b > 0;
			return rsq(b) - rsq(a - 1);
		}

		public void update(int ind, int value)
		{
			assert ind > 0;
			while (ind < array.length)
			{
				array[ind] += value;
				// Extracting the portion up to the first significant one of the
				// binary representation of 'ind' and incrementing ind by that
				// number
				ind += ind & (-ind);
			}
		}

		public int size()
		{
			return array.length - 1;
		}
	}

	void buildGraph(int n)
	{
		for (int i = 0; i < n; i++)
		{
			int x1 = ni() - 1, y1 = ni() - 1, z = ni();
			ts.add(new Cell(x1,y1,z));
			hm.put(new Pair(x1,y1), z);
			ans += z;
		}
	}

	long modInverse(long a, long mOD2)
	{
		return power(a, mOD2 - 2, mOD2);
	}

	long power(long x, long y, long m)
	{
		if (y == 0)
			return 1;
		long p = power(x, y / 2, m) % m;
		p = (p * p) % m;

		return (y % 2 == 0) ? p : (x * p) % m;
	}

	public long gcd(long a, long b)
	{
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}

	static class ST1
	{
		int arr[], st[], size;

		ST1(int a[])
		{
			arr = a.clone();
			size = 10 * arr.length;
			st = new int[size];
			build(0, arr.length - 1, 1);
		}

		void build(int ss, int se, int si)
		{
			if (ss == se)
			{
				st[si] = arr[ss];
				return;
			}
			int mid = (ss + se) / 2;
			int val = 2 * si;
			build(ss, mid, val);
			build(mid + 1, se, val + 1);
			st[si] = Math.min(st[val], st[val + 1]);
		}

		int get(int ss, int se, int l, int r, int si)
		{
			if (l > se || r < ss || l > r)
				return Integer.MAX_VALUE;
			if (l <= ss && r >= se)
				return st[si];
			int mid = (ss + se) / 2;
			int val = 2 * si;
			return Math.min(get(ss, mid, l, r, val),
					get(mid + 1, se, l, r, val + 1));
		}
	}

	static class ST
	{
		int arr[], lazy[], n;

		ST(int a)
		{
			n = a;
			arr = new int[10 * n];
			lazy = new int[10 * n];
		}

		void up(int l, int r, int val)
		{
			update(0, n - 1, 0, l, r, val);
		}

		void update(int l, int r, int c, int x, int y, int val)
		{
			if (lazy[c] != 0) {
				lazy[2 * c + 1] += lazy[c];
				lazy[2 * c + 2] += lazy[c];
				if (l == r)
					arr[c] += lazy[c];
				lazy[c] = 0;
			}
			if (l > r || x > y || l > y || x > r)
				return;
			if (x <= l && y >= r)

			{
				lazy[c] += val;
				return;
			}
			int mid = l + r >> 1;
			update(l, mid, 2 * c + 1, x, y, val);
			update(mid + 1, r, 2 * c + 2, x, y, val);
			arr[c] = Math.max(arr[2 * c + 1], arr[2 * c + 2]);
		}

		int an(int ind)
		{
			return ans(0, n - 1, 0, ind);
		}

		int ans(int l, int r, int c, int ind)
		{
			if (lazy[c] != 0)
			{
				lazy[2 * c + 1] += lazy[c];
				lazy[2 * c + 2] += lazy[c];
				if (l == r)
					arr[c] += lazy[c];
				lazy[c] = 0;
			}
			if (l == r)
				return arr[c];
			int mid = l + r >> 1;
			if (mid >= ind)
				return ans(l, mid, 2 * c + 1, ind);
			return ans(mid + 1, r, 2 * c + 2, ind);
		}
	}

	public static int[] shuffle(int[] a, Random gen)
	{
		for (int i = 0, n = a.length; i < n; i++)
		{
			int ind = gen.nextInt(n - i) + i;
			int d = a[i];
			a[i] = a[ind];
			a[ind] = d;
		}
		return a;
	}

	long power(long x, long y, int mod)
	{
		long ans = 1;
		while (y > 0)
		{
			if (y % 2 == 0)
			{
				x = (x * x) % mod;
				y /= 2;
			} else
			{
				ans = (x * ans) % mod;
				y--;
			}
		}
		return ans;
	}

	// To Get Input
	// Some Buffer Methods
	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf)
		{
			ptrbuf = 0;
			try
			{
				lenbuf = is.read(inbuf);
			} catch (IOException e)
			{
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean isSpaceChar(int c)
	{
		return !(c >= 33 && c <= 126);
	}

	private int skip()
	{
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}

	private double nd()
	{
		return Double.parseDouble(ns());
	}

	private char nc()
	{
		return (char) skip();
	}

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b)))
		{ // when nextLine, (isSpaceChar(b) && b != '
									// ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(isSpaceChar(b)))
		{
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			} else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			} else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

	private void tr(Object... o)
	{
		if (!oj)
			System.out.println(Arrays.deepToString(o));
	}
}

import java.util.*;
import java.io.*;

/**
 * 01-Sep-2017
 * 7:50:12 PM
 * @author HulkBuster
 *
 */
public class CF849C {
public static int mod = (int) (1e9 + 7);
public static InputReader in;
public static PrintWriter out;

public static void solve() throws FileNotFoundException {

	in = new InputReader(System.in);
	out = new PrintWriter(System.out);
	int k = in.ni();
	int ar[] = new int[26];
	int sum = 0;
	int i =0;
	while(sum<k){
		if((sum+ar[i])<=k)
		{
			sum+=ar[i];
			ar[i]++;

		}
		else{
			i++;
		}

	}
	if(k==0)
		ar[i]++;
	for(int j=0;j<26;j++){
		while(ar[j]>0){
			char c = (char)('a'+(char)j);
			out.print(c);
			ar[j]--;
		}
	}
	out.close();
}

public static void main(String[] args) {
	new Thread(null, new Runnable() {
		public void run() {
			try {
				solve();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}, "1", 1 << 26).start();
}

static class Pair implements Comparable<Pair> {

	int x, y, i;

	Pair(int x, int y, int i) {
		this.x = x;
		this.y = y;
		this.i = i;
	}

	Pair(int x, int y) {
		this.x = x;
		this.y = y;
	}

	public int compareTo(Pair o) {
		if (this.x != o.x)
			return Integer.compare(this.x, o.x);
		else
			return Integer.compare(this.y, o.y);
		//return 0;
	}

	public boolean equals(Object o) {
		if (o instanceof Pair) {
			Pair p = (Pair) o;
			return p.x == x && p.y == y && p.i == i;
		}
		return false;
	}

	public int hashCode() {
		return new Integer(x).hashCode() * 31 + new Integer(y).hashCode() + new Integer(i).hashCode() * 37;
	}

}

public static long add(long a, long b) {
	long x = (a + b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static long sub(long a, long b) {
	long x = (a - b);
	while (x < 0)
		x += mod;
	return x;
}

public static long mul(long a, long b) {
	long x = (a * b);
	while (x >= mod)
		x -= mod;
	return x;
}

public static boolean isPal(String s) {
	for (int i = 0, j = s.length() - 1; i <= j; i++, j--) {
		if (s.charAt(i) != s.charAt(j))
			return false;
	}
	return true;
}

public static String rev(String s) {
	StringBuilder sb = new StringBuilder(s);
	sb.reverse();
	return sb.toString();
}

public static long gcd(long x, long y) {
	if (x % y == 0)
		return y;
	else
		return gcd(y, x % y);
}

public static int gcd(int x, int y) {
	if (x % y == 0)
		return y;
	else
		return gcd(y, x % y);
}

public static long gcdExtended(long a, long b, long[] x) {

	if (a == 0) {
		x[0] = 0;
		x[1] = 1;
		return b;
	}
	long[] y = new long[2];
	long gcd = gcdExtended(b % a, a, y);

	x[0] = y[1] - (b / a) * y[0];
	x[1] = y[0];

	return gcd;
}

public static long mulmod(long a, long b, long m) {
	if (m <= 1000000009)
		return a * b % m;

	long res = 0;
	while (a > 0) {
		if ((a & 1) != 0) {
			res += b;
			if (res >= m)
				res -= m;
		}
		a >>= 1;
		b <<= 1;
		if (b >= m)
			b -= m;
	}
	return res;
}

public static int abs(int a, int b) {
	return (int) Math.abs(a - b);
}

public static long abs(long a, long b) {
	return (long) Math.abs(a - b);
}

public static int max(int a, int b) {
	if (a > b)
		return a;
	else
		return b;
}

public static int min(int a, int b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long max(long a, long b) {
	if (a > b)
		return a;
	else
		return b;
}

public static long min(long a, long b) {
	if (a > b)
		return b;
	else
		return a;
}

public static long pow(long n, long p, long m) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		if (result >= m)
			result %= m;
		p >>= 1;
		n *= n;
		if (n >= m)
			n %= m;
	}
	return result;
}

public static long pow(long n, long p) {
	long result = 1;
	if (p == 0)
		return 1;
	if (p == 1)
		return n;
	while (p != 0) {
		if (p % 2 == 1)
			result *= n;
		p >>= 1;
		n *= n;
	}
	return result;
}

public static void debug(Object... o) {
	System.out.println(Arrays.deepToString(o));
}

static class InputReader {
	private final InputStream stream;
	private final byte[] buf = new byte[8192];
	private int curChar, snumChars;
	private SpaceCharFilter filter;

	public InputReader(InputStream stream) {
		this.stream = stream;
	}

	public int snext() {
		if (snumChars == -1)
			throw new InputMismatchException();
		if (curChar >= snumChars) {
			curChar = 0;
			try {
				snumChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (snumChars <= 0)
				return -1;
		}
		return buf[curChar++];
	}

	public int ni() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		int res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public long nl() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		int sgn = 1;
		if (c == '-') {
			sgn = -1;
			c = snext();
		}
		long res = 0;
		do {
			if (c < '0' || c > '9')
				throw new InputMismatchException();
			res *= 10;
			res += c - '0';
			c = snext();
		} while (!isSpaceChar(c));
		return res * sgn;
	}

	public int[] nIArr(int n) {
		int a[] = new int[n];
		for (int i = 0; i < n; i++) {
			a[i] = ni();
		}
		return a;
	}

	public long[] nLArr(int n) {
		long a[] = new long[n];
		for (int i = 0; i < n; i++) {
			a[i] = nl();
		}
		return a;
	}

	public String readString() {
		int c = snext();
		while (isSpaceChar(c)) {
			c = snext();
		}
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isSpaceChar(c));
		return res.toString();
	}

	public String nextLine() {
		int c = snext();
		while (isSpaceChar(c))
			c = snext();
		StringBuilder res = new StringBuilder();
		do {
			res.appendCodePoint(c);
			c = snext();
		} while (!isEndOfLine(c));
		return res.toString();
	}

	public boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}

	private boolean isEndOfLine(int c) {
		return c == '\n' || c == '\r' || c == -1;
	}

	public interface SpaceCharFilter {
		public boolean isSpaceChar(int ch);
	}

}
}

import java.util.Scanner;

/**
 * @author Albert Hambardzumyan
 */
public class Problem_835A {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int k = in.nextInt();

    for (int i=0; i<26; i++){
        int cnt=0;
        while (cnt*(cnt+1)/2<=k)
            cnt++;
        k-=cnt*(cnt-1)/2;
        for (int j=1; j<=cnt; j++)
             System.out.print((char)('a'+i));
    }

    }
}

import java.io.*;
import java.math.*;
import java.util.*;
public class Main
{
    static int mod=((int)1e9)+7;
    public static int gcd(int a,int b)
    {
        if(b==0)
        return a;
        else
        return gcd(b,a%b);
    }
    public static int pow_mod(int n,int x)
    {
        if(x==0)
        return 1;
        else
        {
            if((x&1)==0)
            {
                return (pow_mod((((n%mod)*(n%mod))%mod),(x/2)));
            }
            else
            {
                return (((n%mod)*(pow_mod((((n%mod)*(n%mod))%mod),((x-1)/2))%mod)));
            }
        }
    }
    public static int lower_bound(int[]arr,int val)
    {
        int lo=0;
        int hi=arr.length-1;
        while(lo<hi)
        {
            int mid=lo+((hi-lo+1)/2);
            if(arr[mid]==val)
            {
                return mid;
            }
            else if(arr[mid]>val)
            {
                hi=mid-1;
            }
            else
            lo=mid;
        }
        if(arr[lo]<=val)
        return lo;
        else
        return -1;
    }
    public static int upper_bound(int[]arr,int val)
    {
        int lo=0;
        int hi=arr.length-1;
        while(lo<hi)
        {
            int mid=lo+((hi-lo)/2);
            if(arr[mid]==val)
            {
                return mid;
            }
            else if(arr[mid]>val)
            {
               hi=mid;;
            }
            else
            lo=mid+1;
        }
        if(arr[lo]>=val)
        return lo;
        else
        return -1;
    }
    public static int min_req(int n)
    {
        int i=1;
        while((i*(i+1))<=(n))
        ++i;
        return (i-1);
    }
    public static void main (String[] args) throws java.lang.Exception
    {
        Reader sn=new Reader();
        Print p=new Print();
        int n=sn.nextInt();
        int[]arr=new int[100001];
        for(int i=1;i<=100000;++i)
        arr[i]=min_req(i);
        String[]add={"ab","cd","ef","gh","ij","kl","mn","op","qr"};
        int k=0;String ans="";
        if(n==0)
          ans+="a";
        while(n!=0)
        {
            //System.out.println(n);
          if(n==1)
          {
            ans+=("zz");
            n--;
          }
          else
          {
            for(int i=0;i<=arr[n];++i)
              ans+=add[k];
            n-=(arr[n]*(arr[n]+1));
            k++;
          }}
        p.printLine(ans);
        p.close();
    }
}
class Pair implements Comparable<Pair> {
  int val;
  int in;
  Pair(int a, int b){
   val=a;
         in=b;
  }
  @Override
  public int compareTo(Pair o) {
   if(val==o.val)
   return Integer.compare(in,o.in);
   else
   return Integer.compare(val,o.val);
  }}
class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
class Print
{
    private final BufferedWriter bw;
    public Print()
    {
        bw=new BufferedWriter(new OutputStreamWriter(System.out));
    }
    public void print(String str)throws IOException
    {
        bw.append(str);
    }
    public void printLine(String str)throws IOException
    {
        print(str);
        bw.append("\n");
    }
    public void close()throws IOException
    {
        bw.close();
    }}

import java.util.*;
import java.io.*;
import java.math.BigInteger;

/* spar5h */

public class codechef implements Runnable{

    public void run(){

		InputReader s =  new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);

		ArrayList<Integer> list = new ArrayList<Integer>();

		for(int i = 1; i * (i - 1) / 2 <= 100000; i++)
			list.add(i * (i - 1) / 2);

		int k = s.nextInt();

		StringBuilder str = new StringBuilder(); char ch = 'a' - 1;

		if(k == 0)
			str.append("a");

		while(k > 0) {

			int l = 0, r = list.size() - 1; ch++;

			int ans = 0;

			while(l <= r) {

				int mid = (l + r) / 2;

				if(list.get(mid) > k) {
					r = mid - 1;
				}

				if(list.get(mid) <= k) {
					l = mid + 1; ans = mid;
				}
			}

			k -= list.get(ans);

			for(int i = 0; i <= ans; i++)
				str.append((char)ch);
		}

		w.println(str);

		w.close();
	}

	static class InputReader {

		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
			String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

			int res = 0;
			do
			{
				if(c<'0'||c>'9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

			do
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			while (!isSpaceChar(c));
				return res * sgn;
		}

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}

	public static void main(String args[]) throws Exception
	{
		new Thread(null, new codechef(),"codechef",1<<26).start();
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Nathaniel Lahn
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();

            StringBuilder sb = new StringBuilder();

            if (n == 0) {
                out.println('a');
                return;
                //System.exit(0);
            }
            char c = 'a';
            while (n > 0) {
                int i;
                for (i = 0; (((long) i) * (i - 1)) / 2 <= n; i++) ;
                i--;
                n -= (i * (i - 1)) / 2;
                for (int j = 0; j < i; j++) {
                    sb.append(c);
                }
                c++;
            }
            out.println(sb);
        }

    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }

        public FastScanner(InputStream in) {
            this(new InputStreamReader(in));
        }

        public String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.util.Scanner;

public class FromYtoY {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int k = in.nextInt();
		int rem = 0;
		String ans = "";
		int i = 0;
		if(k == 0)
		{
			System.out.println("a");
		}
		else
		{
			while(k > 0)
			{
				rem = ((int)Math.floor((Math.sqrt(1 + 8*k) - 1)/2.0));
				if(k - rem*(rem+1)/2 >= 0)
				{
					for(int j = 0; j <= rem; j++ )
						ans += (char)(97+i);
				}
				i++;
				rem = rem*(rem+1)/2;
				k = k - rem;
			}
			System.out.println(ans);
		}
		in.close();
	}

}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class CF431C {
	static List<Integer> ans = new ArrayList<>();

	static void rec(int n) {
		if (n != 0) {
			int max = max(n);
			ans.add(max);
			rec(n - (max * max + max) / 2);
		}
	}

	static int max(int n) {
		for (int i = 0; i <= n + 2; i++)
			if (n - (i * (i + 1)) / 2 < 0)
				return i - 1;
		return 0;
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt(), ch = 'a';
		rec(n);
		StringBuilder sb = new StringBuilder();
		for (int i : ans) {
			for (int j = 0; j <= i; j++)
				sb.append((char) ch);
			ch++;
		}
		System.out.println(n == 0 ? 'o' : sb.toString());
	}
}

import java.io.*;
import java.util.*;
import java.math.*;
import java.util.concurrent.*;

public final class round_431_c
{
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	static FastScanner sc=new FastScanner(br);
    static PrintWriter out=new PrintWriter(System.out);
	static Random rnd=new Random();

	static int t(int n)
	{
		return (n*(n+1))/2;
	}

	static char[] go(int val1,int val2,int val3)
	{
		char[] res=new char[val1+val2+val3+3];

		int ptr=0;

		for(int i=0;i<=val1;i++)
		{
			res[ptr++]='a';
		}

		for(int j=0;j<=val2;j++)
		{
			res[ptr++]='b';
		}

		for(int k=0;k<=val3;k++)
		{
			res[ptr++]='c';
		}

		return res;
	}

    public static void main(String args[]) throws Exception
    {
		int cost=sc.nextInt();

		if(cost==0)
		{
			out.println("a");
		}

		else
		{
			int val1=0,val2=0,val3=0;

			outer:
			for(int i=0;i<=500;i++)
			{
				for(int j=0;j<=500;j++)
				{
					for(int k=0;k<=500;k++)
					{
						if(t(i)+t(j)+t(k)==cost)
						{
							val1=i;val2=j;val3=k;

							break outer;
						}

						if(t(i)+t(j)+t(k)>cost)
						{
							break;
						}
					}
				}
			}

			//System.out.println(val1+" "+val2+" "+val3);

			out.println(new String(go(val1,val2,val3)));
		}

		out.close();
    }
}
class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

	public String next() throws Exception {
		return nextToken().toString();
	}

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}

//package CF_431;

import java.io.*;
import java.util.*;

public class C {
	public static void main(String[] args) throws Exception{ new C(new Reader()); }
	public C(Reader rr) throws IOException{
		int k=rr.ni();
		if(k==0) System.out.println("ab");
		int[] values=new int[450];
		int inc=1;
		int num=0;
		int largestIndex=0;
		for(int i=0; i<450; i++){
			if(k>=num) largestIndex=i;
			values[i]=num;
			num+=inc;
			inc++;
		}
		int total=0;
		int nextChar=97;
		while(total<k){
			total+=values[largestIndex];
			for(int i=0; i<largestIndex+1; i++)
				System.out.print(Character.toChars(nextChar));
			while(largestIndex>0&&k-total<values[largestIndex]) largestIndex--;
			nextChar++;
		}
	}
	static class Reader{
		private DataInputStream din;
		private byte[] buffer=new byte[1024];
		private int bufP, bytR;
		public Reader() throws IOException{
			din=new DataInputStream(System.in);
			bufP=bytR=0;
		}
		public Reader(String file) throws IOException{
			din=new DataInputStream(new FileInputStream(file));
			bufP=bytR=0;
		}
		private String rl() throws IOException{
			byte[] buf=new byte[1024];
			int cnt=0, c;
			while((c=read())!=-1){
				if(c=='\n') break;
				buf[cnt++]=(byte)c;
			}
			return new String(buf, 0, cnt);
		}
		private int ni() throws IOException{
			int num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private long nl() throws IOException{
			long num=0;
			byte c=read();
			while(c<=' ') c=read();
			boolean neg=(c=='-');
			if(neg) c=read();
			do{
				num=num*10+c-'0';
			} while((c=read())>='0'&&c<='9');
			if(neg) return -num;
			return num;
		}
		private double nd() throws IOException{ return Double.parseDouble(ns()); }
		private char nc() throws IOException{ return (char)next(); }
		private String ns() throws IOException{
			int c=next();
			StringBuilder sb=new StringBuilder();
			while(!(isChar(c))){
				sb.appendCodePoint(c);
				c=read();
			}
			return sb.toString();
		}
		private char[] ns(int n) throws IOException{
			char[] buf=new char[n];
			int c=next(), r=0;
			while(r<n&&!(isChar(c))){
				buf[r++]=(char)c;
				c=next();
			}
			return n==r?buf:Arrays.copyOf(buf, r);
		}
		private char[][] nm(int n, int m) throws IOException{
			char[][] map=new char[n][];
			for(int i=0; i<n; i++) map[i]=ns(m);
			return map;
		}
		private int[] na(int n) throws IOException{
			int[] a=new int[n];
			for(int i=0; i<n; i++) a[i]=ni();
			return a;
		}
		private boolean isChar(int c) throws IOException{ return !(c>=33&&c<=126); }
		private int next() throws IOException{ int c; while((c=read())!=-1&&isChar(c)); return c; }
		private byte read() throws IOException{
			if(bufP==bytR){
				bytR=din.read(buffer, bufP=0, 1024);
				if(bytR==-1) buffer[0]=-1;
			}
			return buffer[bufP++];
		}
		public void close() throws IOException{
			if(din==null) return;
			din.close();
		}
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();

            long[] t = new long[2000];
            for (int i = 0; i < 2000; i++) {
                t[i] = (long) i * (i - 1) / 2;
            }

            StringBuilder sb = new StringBuilder();
            int idx = 0;
            for (int i = 1999; i >= 3; i--) {
                if (n >= t[i]) {
                    for (int j = 0; j < i; j++) {
                        sb.append((char) ('a' + idx));
                    }
                    idx++;
                    n -= t[i];
                }
            }

            for (int i = 0; i < n; i++) {
                sb.append((char) ('a' + idx));
                sb.append((char) ('a' + idx));
                idx++;
            }

            out.println("".equals(sb.toString()) ? "a" : sb.toString());
        }

    }

    static class InputReader {
        BufferedReader in;
        StringTokenizer tok;

        public String nextString() {
            while (!tok.hasMoreTokens()) {
                try {
                    tok = new StringTokenizer(in.readLine(), " ");
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
            }
            return tok.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(nextString());
        }

        public InputReader(InputStream inputStream) {
            in = new BufferedReader(new InputStreamReader(inputStream));
            tok = new StringTokenizer("");
        }

    }
}

import java.util.*;
import java.io.*;
import java.math.*;
/*

@author... Bishwajeet Kumar Nit Silchar.

*/
    public  class Sample implements Runnable
    {

          public static void solve()
          {
             int n=i();
             if(n==0){out.println("a"); return;}
              String ans="";
             int i=97;
             while(n>0){
                int val=(int)Math.floor((-1+Math.sqrt(8*n+1))/2.0);
                int news =n-(val*(val+1))/2;
               // out.println(val+""+news);
                int lol=(val*(val+1))/2;

                for(int k=0;k<=val;k++){
                  ans+=(char)i;
                }
                n=news;
                i++;

             }

             out.println(ans);

          }
/////////////////////////////////////  Rest Code   /////////////////////////////////////////////////////////
          public void run()
          {
              solve();
              out.close();
          }

          public static void main(String[] args) throws IOException
          {
                new Thread(null, new Sample(), "whatever", 1<<26).start();
          }
         static class Pair implements Comparable<Pair>
         {
            long a;
            int b;
            Pair(){}
            Pair(long a,int b)
            {
                       this.a=a;
                       this.b=b;
            }

            public int compareTo(Pair x)
           {
                return Long.compare(x.a,this.a);
           }
        }

////////////////////////////////////////////////////// Merge Sort ////////////////////////////////////////////////////////////////////////

   static class Merge
   {

        public static void sort(long inputArr[])
        {
            int length = inputArr.length;
            doMergeSort(inputArr,0, length - 1);
        }

        private static void doMergeSort(long[] arr,int lowerIndex, int higherIndex)
        {
            if (lowerIndex < higherIndex) {
                int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
                doMergeSort(arr,lowerIndex, middle);
                doMergeSort(arr,middle + 1, higherIndex);
                mergeParts(arr,lowerIndex, middle, higherIndex);
            }
        }

        private static void mergeParts(long[]array,int lowerIndex, int middle, int higherIndex)
        {
            long[] temp=new long[higherIndex-lowerIndex+1];
            for (int i = lowerIndex; i <= higherIndex; i++)
            {
                temp[i-lowerIndex] = array[i];
            }
            int i = lowerIndex;
            int j = middle + 1;
            int k = lowerIndex;
            while (i <= middle && j <= higherIndex)
            {
                if (temp[i-lowerIndex] < temp[j-lowerIndex])
                {
                    array[k] = temp[i-lowerIndex];
                    i++;
                } else {
                    array[k] = temp[j-lowerIndex];
                    j++;
                }
                k++;
            }
            while (i <= middle)
            {
                array[k] = temp[i-lowerIndex];
                k++;
                i++;
            }
            while(j<=higherIndex)
            {
                array[k]=temp[j-lowerIndex];
                k++;
                j++;
            }
        }

    }

    /////////////////////////////////////////////////////////// Methods ////////////////////////////////////////////////////////////////////////

     static boolean isPal(String s)
     {
        for(int i=0, j=s.length()-1;i<=j;i++,j--)
        {
                if(s.charAt(i)!=s.charAt(j)) return false;
        }
        return true;
     }
     static String rev(String s)
     {
                StringBuilder sb=new StringBuilder(s);
                sb.reverse();
                return sb.toString();
     }
     static int gcd(int a,int b){return (a==0)?b:gcd(b%a,a);}
     static long gcdExtended(long a,long b,long[] x)
     {

        if(a==0){
            x[0]=0;
            x[1]=1;
            return b;
        }
        long[] y=new long[2];
        long gcd=gcdExtended(b%a, a, y);

        x[0]=y[1]-(b/a)*y[0];
        x[1]=y[0];

        return gcd;
    }

     boolean findSum(int set[], int n, long sum)
    {
      if (sum == 0)
         return true;
      if (n == 0 && sum != 0)
         return false;
      if (set[n-1] > sum)
         return findSum(set, n-1, sum);
      return findSum(set, n-1, sum) ||findSum(set, n-1, sum-set[n-1]);
    }

      public static long modPow(long base, long exp, long mod)
     {
        base = base % mod;
        long result = 1;
        while (exp > 0)
       {
            if (exp % 2 == 1)
            {
                result = (result * base) % mod;
            }
            base = (base * base) % mod;
            exp = exp >> 1;
       }
        return result;
    }

    static long[] fac;
    static long[] inv;
    static long mod=(long)1e9+7;
    public static void cal()
    {
        fac = new long[1000005];
        inv = new long[1000005];
        fac[0] = 1;
        inv[0] = 1;
        for (int i = 1; i <= 1000000; i++)
        {
            fac[i] = (fac[i - 1] * i) % mod;
            inv[i] = (inv[i - 1] * modPow(i, mod - 2, mod)) % mod;
        }
    }

    public static long ncr(int n, int r)
    {
        return (((fac[n] * inv[r]) % mod) * inv[n - r]) % mod;
    }

////////////////////////////////////////// Input Reader ////////////////////////////////////////////////////////////////////////////////////////////////////

    static InputReader sc = new InputReader(System.in);
    static PrintWriter out= new PrintWriter(System.out);

    static class InputReader {

          private final InputStream stream;
          private final byte[] buf = new byte[8192];
          private int curChar, snumChars;
          private SpaceCharFilter filter;

          public InputReader(InputStream stream) {
                  this.stream = stream;
          }

          public int snext()
         {
                  if (snumChars == -1)
                          throw new InputMismatchException();
                  if (curChar >= snumChars) {
                          curChar = 0;
                          try {
                                  snumChars = stream.read(buf);
                          } catch (IOException e) {
                                  throw new InputMismatchException();
                          }
                          if (snumChars <= 0)
                                  return -1;
                  }
                  return buf[curChar++];
          }

          public int nextInt()
         {
                  int c = snext();
                  while (isSpaceChar(c))
                  {
                          c = snext();
                  }
                  int sgn = 1;
                  if (c == '-')
                  {
                          sgn = -1;
                          c = snext();
                  }
                  int res = 0;
                  do {
                          if (c < '0' || c > '9')
                                  throw new InputMismatchException();
                          res *= 10;
                          res += c - '0';
                          c = snext();
                  } while (!isSpaceChar(c));
                  return res * sgn;
          }

          public long nextLong()
          {
                  int c = snext();
                  while (isSpaceChar(c))
                  {
                          c = snext();
                  }
                  int sgn = 1;
                  if (c == '-')
                  {
                          sgn = -1;
                          c = snext();
                  }
                  long res = 0;
                  do {
                          if (c < '0' || c > '9')
                                  throw new InputMismatchException();
                          res *= 10;
                          res += c - '0';
                          c = snext();
                  } while (!isSpaceChar(c));
                  return res * sgn;
          }

          public int[] nextIntArray(int n)
          {
                  int a[] = new int[n];
                  for (int i = 0; i < n; i++)
                  {
                          a[i] = nextInt();
                  }
                  return a;
          }

          public long[] nextLongArray(int n)
          {
                  long a[] = new long[n];
                  for (int i = 0; i < n; i++)
                  {
                          a[i] = nextLong();
                  }
                  return a;
          }

          public String nextLine()
         {
                  int c = snext();
                  while (isSpaceChar(c))
                          c = snext();
                  StringBuilder res = new StringBuilder();
                  do {
                          res.appendCodePoint(c);
                          c = snext();
                  } while (!isEndOfLine(c));
                  return res.toString();
          }

          public boolean isSpaceChar(int c)
          {
                  if (filter != null)
                          return filter.isSpaceChar(c);
                  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }

          private boolean isEndOfLine(int c)
          {
                  return c == '\n' || c == '\r' || c == -1;
          }

          public interface SpaceCharFilter
          {
                  public boolean isSpaceChar(int ch);
          }

    }

    static int i()
    {
        return sc.nextInt();
    }
    static long l(){
        return sc.nextLong();
    }
    static int[] iarr(int n)
    {
        return sc.nextIntArray(n);
    }
    static long[] larr(int n)
    {
        return sc.nextLongArray(n);
    }
    static String s(){
        return sc.nextLine();
    }

 }

import java.util.Scanner;
import java.util.ArrayList;
// import java.util.Arrays;
// import java.util.HashMap;
// import java.util.HashSet;
import java.util.Collections;

public class ans3{
    static int mod = (int)10e8;

    public static int lower(int arr[],int key){
        int low = 0;
        int high = arr.length-1;
        while(low < high){
            int mid = low + (high - low)/2;
            if(arr[mid] >= key){
                high = mid;
            }
            else{
                low = mid+1;
            }
        }
        return arr[low - 1];
    }

    public static int justGreater(int[] arr, int val, int s, int e){
        // Returns the index of first element greater than val.
        // If no such value is present, returns the size of the array.
        if (s >= e){
            return arr[s] <= val ? s+1 : s;
        }
        int mid = (s + e) >> 1;
        if (arr[mid] < val) return justGreater(arr, val, mid+1, e);
        return justGreater(arr, val, s, mid);
    }

    public static int upper(int arr[],int key){
        int low = 0;
        int high = arr.length-1;
        while(low < high){
            int mid = low + (high - low+1)/2;
            if(arr[mid] <= key){
                low = mid;
            }
            else{
                high = mid-1;
            }
        }
        return low;
    }

    public static int lower_bound(ArrayList<Integer> ar,int k)
{
    int s=0;
    int e=ar.size();
    while (s !=e)
    {
        int mid = s+e>>1;
        if(ar.get(mid) == k) return mid + 1;
        if (ar.get(mid) <k)
        {
            s=mid+1;
        }
        else
        {
            e=mid;
        }
    }
    if(s==ar.size())
    {
        return -1;
    }
    return s;
}

    public static void main(String args[]){
        Scanner scn = new Scanner(System.in);

        int k = scn.nextInt();

        int si = 0;
        int sum =0;
        ArrayList<Integer> list = new ArrayList<>();
        if(k == 0){
            System.out.println('a');
            return;
        }
        while(sum <= k){
            sum +=  si;
            list.add(sum);
            si++;
        }
        StringBuilder sb = new StringBuilder();
        if(sum == k){
            for(int i = 0 ; i < si ; i++){
                sb.append('a');
                System.out.println(sb);
                return;
            }
        }

        int c = 0;
        while(k != 0){
            int a = lower_bound(list, k);
            int t = a - 1;
            a = list.get(a - 1);

            k-= a;
            for(int i = 0 ; i < t + 1 ; i++){
                sb.append((char)(c + 97));
            }
            c++;
            // System.out.println(k);
        }

        System.out.println(sb);

    }
}

import java.io.*;
import java.util.*;

public class JavaCourses {

    @SuppressWarnings("empty-statement")
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        int n = in.nextInt();

        if(n == 0)
        {
            System.out.println('a');
            return ;

        }

        String s = new String();
        char c ='a';
        while (n > 0) {
            int sum = 0, tmp = 1;

            while (sum + tmp <= n) {
                sum += tmp;
                tmp++;
            }
            for (int i = 0; i < tmp ; i++) {
                s += c;
            }
            n -= sum;
            c++;
        }
        System.out.println(s);

    }
}

import java.util.*;
import java.io.*;
import java.math.*;
public class Solution
{
    public static void main(String args[])throws IOException
    {
        PrintWriter out=new PrintWriter(System.out);
        Reader sc=new Reader();
        int n=sc.i();
        if(n==0)
        {
            System.out.println("ab");
            System.exit(0);
        }
        // each character will contribute n*(n-1)/2;
        StringBuilder ans=new StringBuilder("");
        int charac=97;
        while(n!=0)
        {
            int sum=0;
            int i=0;
            for(i=1;;i++)
            {
                sum+=i;
                if(sum>n)
                break;
            }
            sum-=i;
            int pos=i;
            n-=sum;
            for(i=0;i<pos;i++)
            ans=ans.append((char)charac);
            charac++;
        }
        System.out.println(ans);
    }

    static class Reader
    {
        private InputStream mIs;
        private byte[] buf = new byte[1024];
        private int curChar,numChars;
        public Reader() { this(System.in); }
        public Reader(InputStream is) { mIs = is;}
        public int read() {
            if (numChars == -1) throw new InputMismatchException();
            if (curChar >= numChars) {
                curChar = 0;
                try { numChars = mIs.read(buf);} catch (IOException e) { throw new InputMismatchException();}
                if (numChars <= 0) return -1;
            }
            return buf[curChar++];
        }
        public String nextLine(){
            int c = read();
            while (isSpaceChar(c)) c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString() ;
        }
        public String s(){
            int c = read();
            while (isSpaceChar(c)) c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            }while (!isSpaceChar(c));
            return res.toString();
        }
        public long l(){
            int c = read();
            while (isSpaceChar(c)) c = read();
            int sgn = 1;
            if (c == '-') { sgn = -1 ; c = read() ; }
            long res = 0;
            do{
                if (c < '0' || c > '9') throw new InputMismatchException();
                res *= 10 ; res += c - '0' ; c = read();
            }while(!isSpaceChar(c));
            return res * sgn;
        }
        public int i(){
            int c = read() ;
            while (isSpaceChar(c)) c = read();
            int sgn = 1;
            if (c == '-') { sgn = -1 ; c = read() ; }
            int res = 0;
            do{
                if (c < '0' || c > '9') throw new InputMismatchException();
                res *= 10 ; res += c - '0' ; c = read() ;
            }while(!isSpaceChar(c));
            return res * sgn;
        }
        public double d() throws IOException {
             return Double.parseDouble(s()) ;
        }
        public boolean isSpaceChar(int c) { return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1; }
        public boolean isEndOfLine(int c) { return c == '\n' || c == '\r' || c == -1; }
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;

public class C {

	public static void main(String[] args) {
		try (Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
				PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)))) {
			out.println(solve(in.nextInt()));
		}
	}

	private static String solve(int k) {
		if (k == 0) {
			return "a";
		}
		StringBuilder ans = new StringBuilder();
		for (int i = 0; i < 26; i++) {
			int cnt = 1;
			while ((cnt + 1) * cnt / 2 <= k) {
				cnt++;
			}
			k -= cnt * (cnt - 1) / 2;
			if (cnt > 1) {
				for (int j = 0; j < cnt; j++) {
					ans.append((char) ('a' + i));
				}
			}
		}
		return ans.toString();
	}

}

import java.io.*;
import java.text.*;
import java.util.*;
public class C {
	public static void main(String[] args) throws Exception {
		new C().run();
	}
	int[][] dp;
	int[] arr;
	int[] vals;
	int index;
	boolean stop;
	public void run() throws Exception {
		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
		int cost = Integer.parseInt(f.readLine());
		if(cost == 0) {
			System.out.println("a");
			return;
		}
		vals = new int[450];
		for(int i = 0; i < vals.length; i++)
			vals[i] = i*(i+1)/2;
		dp = new int[vals.length][cost+1];
		dp[0][0] = 0;
		for(int i = 0; i < vals.length; i++) {
			dp[i][0] = 0;
			for(int j = 1; j <= cost; j++) {
				dp[i][j] = 27;
				if(j >= vals[i] && dp[i][j-vals[i]] != 27) dp[i][j] = dp[i][j-vals[i]] + 1;
				if(i != 0) dp[i][j] = Math.min(dp[i-1][j], dp[i][j]);
			}
		}
		arr = new int[26];
		recur(vals.length-1, cost);
		int i = 0;
		while(arr[i] != 0) {
			while(arr[i]-->0) System.out.print((char) ('a'+i));
			i++;
		}
		System.out.println();
	}
	public void recur(int r, int c) {
		if(c == 0) {
			stop = true;
			return;
		}
		if(r == -1 || dp[r][c] == 27 || stop) return;
		if(vals[r] <= c) {
			arr[index++] = r+1;
			recur(r,c-vals[r]);
			if(stop) return;
			arr[--index] = 0;
		}
		recur(r-1,c);
	}
}

import java.util.*;
import java.io.*;

public class _0848_A_FromYToY {

	public static void main(String[] args) throws IOException {
		int K = readInt();
		char c[] = new char[100000];
		int sz = 0, sum = 0;
		for(int i = 0; i<26; i++) {
			c[sz++] = (char) ('a' + i);
			for(int j = 1; j<100000; j++) {
				if(j + sum > K) break;
				c[sz++] = (char) ('a' + i);
				sum += j;
			}
		}
		for(int i = 0; i<sz; i++) print(c[i]);
		exit();
	}

	final private static int BUFFER_SIZE = 1 << 16;
	private static DataInputStream din = new DataInputStream(System.in);
	private static byte[] buffer = new byte[BUFFER_SIZE];
	private static int bufferPointer = 0, bytesRead = 0;
	static PrintWriter pr = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));

	public static String readLine() throws IOException {
		byte[] buf = new byte[64]; // line length
		int cnt = 0, c;
		while ((c = Read()) != -1) {
			if (c == '\n')
				break;
			buf[cnt++] = (byte) c;
		}
		return new String(buf, 0, cnt);
	}

	public static String read() throws IOException {
		byte[] ret = new byte[1024];
		int idx = 0;
		byte c = Read();
		while (c <= ' ') {
			c = Read();
		}
		do {
			ret[idx++] = c;
			c = Read();
		} while (c != -1 && c != ' ' && c != '\n' && c != '\r');
		return new String(ret, 0, idx);
	}

	public static int readInt() throws IOException {
		int ret = 0;
		byte c = Read();
		while (c <= ' ')
			c = Read();
		boolean neg = (c == '-');
		if (neg)
			c = Read();
		do {
			ret = ret * 10 + c - '0';
		} while ((c = Read()) >= '0' && c <= '9');

		if (neg)
			return -ret;
		return ret;
	}

	public static long readLong() throws IOException {
		long ret = 0;
		byte c = Read();
		while (c <= ' ')
			c = Read();
		boolean neg = (c == '-');
		if (neg)
			c = Read();
		do {
			ret = ret * 10 + c - '0';
		} while ((c = Read()) >= '0' && c <= '9');
		if (neg)
			return -ret;
		return ret;
	}

	public static double readDouble() throws IOException {
		double ret = 0, div = 1;
		byte c = Read();
		while (c <= ' ')
			c = Read();
		boolean neg = (c == '-');
		if (neg)
			c = Read();

		do {
			ret = ret * 10 + c - '0';
		} while ((c = Read()) >= '0' && c <= '9');

		if (c == '.') {
			while ((c = Read()) >= '0' && c <= '9') {
				ret += (c - '0') / (div *= 10);
			}
		}

		if (neg)
			return -ret;
		return ret;
	}

	private static void fillBuffer() throws IOException {
		bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
		if (bytesRead == -1)
			buffer[0] = -1;
	}

	private static byte Read() throws IOException {
		if (bufferPointer == bytesRead)
			fillBuffer();
		return buffer[bufferPointer++];
	}

	static void print(Object o) {
		pr.print(o);
	}

	static void println(Object o) {
		pr.println(o);
	}

	static void flush() {
		pr.flush();
	}

	static void println() {
		pr.println();
	}

	static void exit() throws IOException {
		din.close();
		pr.close();
		System.exit(0);
	}
}

import java.io.*;
import java.util.LinkedList;
import java.util.StringTokenizer;

/**
 * Created by eugen on 01.09.2017.
 */
public class ExC {

    public static void main(String[] args) {
        MyScanner sc = new MyScanner();
        out = new PrintWriter(new BufferedOutputStream(System.out));

        /*Solution starts here*/

        int k = sc.nextInt();

        int charOffset = 0;

        if(k == 0) {
            out.print("a");
            out.close();
            return;
        }

        while ( k != 0 ) {
            int n = 2;
            int cost = 1;

            while (cost <= k) {
                n ++;
                cost = (n-1)*n / 2;
            }

            n--;
            cost = (n-1)*n / 2;
            k -= cost;

            char c = (char)((int)'a'+charOffset);
            for (int i = 0; i < n; i++) {
                out.print(c);
            }
            charOffset++;
        }

        /*Solution ends here*/

        out.close();
    }

    /**
     * CodeForces Competition
     * IO Functionality by Flatfoot <= thx (http://codeforces.com/blog/entry/7018)
     */
    //-----------PrintWriter for faster output---------------------------------
    public static PrintWriter out;

    //-----------MyScanner class for faster input----------
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine(){
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

    }

}

	import java.io.OutputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.PrintWriter;
	import java.util.StringTokenizer;
	import java.io.BufferedReader;
	import java.io.InputStreamReader;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Comparator;
	import java.util.PriorityQueue;

	public class Main {
		public static void main(String[] args) {
			InputStream inputStream = System.in;
			OutputStream outputStream = System.out;
			InputReader in = new InputReader(inputStream);
			PrintWriter out = new PrintWriter(outputStream);
			TaskC solver = new TaskC();
			solver.solve(1, in, out);
			out.close();
		}

		static class TaskC {
			public void solve(int testNumber, InputReader in, PrintWriter out) {
				long k = in.nextInt();
				StringBuilder s = new StringBuilder();
				long currentNumberOfActions = 0;
				for (char c = 'a'; c <= 'z'; c++) {
					s.append(c);
					long numberOfCInS = 1;
					while (currentNumberOfActions + numberOfCInS <= k) {
						s.append(c);
						currentNumberOfActions += numberOfCInS++;
					}
				}
				out.println(s.toString());
			}

		}

		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 nextFloat() {
				return Double.parseDouble(next());
			}

			public double nextDouble() {
				return Double.parseDouble(next());
			}

		}
	}

/**
 * @author: Mehul Raheja
 */

import java.util.*;
import java.io.*;

public class YtoY{

    /*
        Runtime = O()
     */
    static int N, M, K;
    static String s;
    static StringTokenizer st;
    static boolean[][] dp = new boolean[100001][27];
    static int[] d = new int[100000];
    static int[] ans = new int[27];

    static boolean DFS(int i, int j){
        if(i == N){
            return true;
        }else if(j == 27){
            return false;
        }

        if(dp[i][j]){
            return false;
        }
        dp[i][j] = true;

        for (int k = 1; k < d.length && d[k] <= N-i; k++) {
            ans[j] = k;
            if(DFS(i + d[k],j+1)){
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        for (int i = 1; i < 100000; i++) {
            d[i] = d[i-1] + (i-1);
        }
        d[0] = 10000000;

        //int[] use = new int[27];

//        for (int i = 1; i <= 26; i++) {
//            for (int j = 1; j <= 100000; j++) {
//                if(N < d[j]){
//                    N -= d[j-1];
//                    System.out.println(N + " " + j);
//
//                   // System.out.println(j);
//                    for (int k = 0; k < j-2; k++) {
//                        System.out.println((char)(i + 96));
//                    }
//                    break;
//                }
//            }
//        }

        DFS(0,1);

        ans[1] = 1;
        //System.out.println(Arrays.toString(ans));
        for (int i = 1; i < ans.length; i++) {
            for (int j = 0; j < ans[i]; j++) {
                System.out.print((char)(i + 96) + "");
            }
        }
//        System.out.println("");
//        System.out.println(Arrays.toString(ans));
//        System.out.println("");

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.io.Closeable;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Thread thread = new Thread(null, new TaskAdapter(), "", 1 << 27);
        thread.start();
        thread.join();
    }

    static class TaskAdapter implements Runnable {
        @Override
        public void run() {
            InputStream inputStream = System.in;
            OutputStream outputStream = System.out;
            FastInput in = new FastInput(inputStream);
            FastOutput out = new FastOutput(outputStream);
            AFromYToY solver = new AFromYToY();
            solver.solve(1, in, out);
            out.close();
        }
    }

    static class AFromYToY {
        public void solve(int testNumber, FastInput in, FastOutput out) {
            int n = in.readInt();

            if (n == 0) {
                out.append('a');
                return;
            }

            for (int i = 'a'; i <= 'z' && n > 0; i++) {
                int cnt = 0;
                while (pick2(cnt + 1) <= n) {
                    cnt++;
                }
                n -= pick2(cnt);
                for (int j = 0; j < cnt; j++) {
                    out.append((char) i);
                }
            }

        }

        public long pick2(long n) {
            return n * (n - 1) / 2;
        }

    }

    static class FastInput {
        private final InputStream is;
        private byte[] buf = new byte[1 << 13];
        private int bufLen;
        private int bufOffset;
        private int next;

        public FastInput(InputStream is) {
            this.is = is;
        }

        private int read() {
            while (bufLen == bufOffset) {
                bufOffset = 0;
                try {
                    bufLen = is.read(buf);
                } catch (IOException e) {
                    bufLen = -1;
                }
                if (bufLen == -1) {
                    return -1;
                }
            }
            return buf[bufOffset++];
        }

        public void skipBlank() {
            while (next >= 0 && next <= 32) {
                next = read();
            }
        }

        public int readInt() {
            int sign = 1;

            skipBlank();
            if (next == '+' || next == '-') {
                sign = next == '+' ? 1 : -1;
                next = read();
            }

            int val = 0;
            if (sign == 1) {
                while (next >= '0' && next <= '9') {
                    val = val * 10 + next - '0';
                    next = read();
                }
            } else {
                while (next >= '0' && next <= '9') {
                    val = val * 10 - next + '0';
                    next = read();
                }
            }

            return val;
        }

    }

    static class FastOutput implements AutoCloseable, Closeable, Appendable {
        private StringBuilder cache = new StringBuilder(1 << 20);
        private final Writer os;

        public FastOutput append(CharSequence csq) {
            cache.append(csq);
            return this;
        }

        public FastOutput append(CharSequence csq, int start, int end) {
            cache.append(csq, start, end);
            return this;
        }

        public FastOutput(Writer os) {
            this.os = os;
        }

        public FastOutput(OutputStream os) {
            this(new OutputStreamWriter(os));
        }

        public FastOutput append(char c) {
            cache.append(c);
            return this;
        }

        public FastOutput flush() {
            try {
                os.append(cache);
                os.flush();
                cache.setLength(0);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
            return this;
        }

        public void close() {
            flush();
            try {
                os.close();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }

        public String toString() {
            return cache.toString();
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author PM
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        int findLowest(int goal) {
            for (int i = 0; i < 1000; i++) {
                if (i * (i - 1) / 2 > goal) {
                    return i - 1;
                }
            }
            throw new RuntimeException();
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int sum = in.nextInt();
            StringBuilder sb = new StringBuilder("z");
            char c = 'a';
            while (sum > 0) {
                int x = findLowest(sum);
                for (int i = 0; i < x; i++) {
                    sb.append(c);
                }
                c++;
                sum -= x * (x - 1) / 2;
//            System.out.println("x=" + x);
//            System.out.println("sum left:" + sum);
            }
            out.println(sb.toString());
        }

    }

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

    }
}

import java.io.*;
import java.util.*;
public class Main {

	public static void main(String[] args) {
		Scanner sc=new Scanner(System.in);
		PrintWriter pw=new PrintWriter(System.out);
		while(sc.hasNext()){
			int k=sc.nextInt();
			if(k==0){
				pw.println("ab");
			}else{
				int s=0;
				StringBuilder sb=new StringBuilder();
				while(k>0){
					long start=1;
					long end=k;
					long res=0;
					while(start<=end){
						long mid=(start+end)/2;
						if(mid*(mid+1)/2<=k){
							res=mid;
							start=mid+1;
						}else{
							end=mid-1;
						}
					}
					k-=res*(res+1)/2;
					char q=(char)('a'+s);
					for(int o=1;o<=res+1;o++){
						sb.append(q);
					}
					s++;
				}
				pw.println(sb.toString());
			}
			pw.flush();
		}

	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;
import java.util.Collections;
import java.util.ArrayList;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Yuan Lei
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        private static final int N = 111111;

        public void solve(int testNumber, Scanner in, PrintWriter out) {
            final ArrayList<Integer> numbers = new ArrayList<>();
            for (int i = 2; i * (i - 1) / 2 <= N; ++i) {
                numbers.add(i * (i - 1) / 2);
            }
            int n = in.nextInt();
            if (n == 0) {
                out.println("a");
                return;
            }
            char c = 'a';
            while (n > 0) {
                int cnt = Collections.binarySearch(numbers, n);
                if (cnt < 0) {
                    cnt = -(cnt + 1);
                    --cnt;
                }
                n -= numbers.get(cnt);
                for (int i = 0; i < cnt + 2; ++i) out.print(c);
                c++;
            }
            out.println();
        }

    }
}

import java.io.FileNotFoundException;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.PrintStream;
import java.util.*;

/**
 *
 * @author TRUE
 */

public class Main {
    public static void main(String args[]) {
        Scanner cin;
        PrintStream cout;
        try{
            cin = new Scanner(new FileInputStream("in.in"));
            cout = new PrintStream("out.out");
        }catch (FileNotFoundException e) {
            cin = new Scanner (new BufferedInputStream(System.in));
            cout = System.out;
        }
        String ch = "abcdefghijklmnopqrstuvwxyz";
        int k;
        k = cin.nextInt();
        for(int i = 10000, j = 0; i>0; i--) {
            while(i*(i-1)/2 <= k) {
                k -= i*(i-1)/2;
                for(int l = 0; l < i; l++) {
                    cout.print(ch.charAt(j));
                }
                j = j+1;
                if(k == 0) {
                    break;
                }
            }
        }
        cout.print('\n');
    }
}

import java.io.FileNotFoundException;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.PrintStream;
import java.util.*;
//import java.math.*;

/**
 *
 * @author TRUE
 */

public class Main {
    public static void main(String args[]) {
        Scanner cin;
        PrintStream cout;
//        try{
//            cin = new Scanner(new FileInputStream("in.in"));
//            cout = new PrintStream("out.out");
//        }catch (FileNotFoundException e) {
            cin = new Scanner (new BufferedInputStream(System.in));
            cout = System.out;
//        }
        String ch = "abcdefghijklmnopqrstuvwxyz";
        int k;
        k = cin.nextInt();
        for(int i = 10000, j = 0; i>0; i--) {
            while(i*(i-1)/2 <= k) {
                k -= i*(i-1)/2;
                for(int l = 0; l < i; l++) {
                    cout.print(ch.charAt(j));
                }
                j = j+1;
                if(k == 0) {
                    break;
                }
            }
        }
        cout.print('\n');
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

/**
 * @author Don Li
 */
public class FromYToY {

    int N = (int) 1e5 + 10;

    void solve() {
        int k = in.nextInt();
        if (k == 0) {
            out.println('a');
            return;
        }

        long[] dp = new long[N];
        dp[0] = dp[1] = 0;
        for (int i = 2; i < N; i++) dp[i] = (long) (i - 1) * i / 2;

        int[] res = new int[26];
        int i = 0;
        while (k > 0) {
            int x = upperBound(dp, k);
            res[i++] = x - 1;
            k -= dp[x - 1];
        }

        for (int j = 0; j < 26; j++) {
            for (int t = 0; t < res[j]; t++) out.print((char) ('a' + j));
        }
        out.println();
    }

    int upperBound(long[] a, long k) {
        int lb = -1, ub = a.length;
        while (ub - lb > 1) {
            int m = (lb + ub) >> 1;
            if (a[m] > k) ub = m;
            else lb = m;
        }
        return ub;
    }

    public static void main(String[] args) {
        in = new FastScanner(new BufferedReader(new InputStreamReader(System.in)));
        out = new PrintWriter(System.out);
        new FromYToY().solve();
        out.close();
    }

    static FastScanner in;
    static PrintWriter out;

    static class FastScanner {
        BufferedReader in;
        StringTokenizer st;

        public FastScanner(BufferedReader in) {
            this.in = in;
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(in.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(nextToken());
        }

        public long nextLong() {
            return Long.parseLong(nextToken());
        }

        public double nextDouble() {
            return Double.parseDouble(nextToken());
        }
    }
}

import java.io.*;
import java.util.*;

public class Competitive_2 {

	static int[][] p;

	public static void main(String[] args) {
		FastReader in = new FastReader();
		int k=in.nextInt();
		int freq[] = new int[26];

		StringBuilder ans = new StringBuilder();

		for(int i=0; i<26; i++){
			while((freq[i]*(freq[i]+1))/2 <= k)
				freq[i]++;
			k -= (freq[i]*(freq[i]-1))/2;

			for(int j=0; j<freq[i]; j++)
				ans.append((char)('a'+i));
		}

		System.out.println(ans.toString());
	}

	static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }

}

import java.util.Scanner;
public class A{
   static int c =0,j=0;
   static char x='a',y='b';
    public static void main(String[] args)throws Exception {
    int T =0 ;
    Scanner in = new Scanner (System.in);
    T=in.nextInt();
 // T=3;
      in.close();
    int count=0;
    int i=0;
    String str="";
       while(true) {
            if(T==0){System.out.println("ab");
                break;}
            else if (count==T){
                System.out.println(str);
                break;}
            else if ((count+(i*2))<=T){
            count=count+i*2;
            str=str+""+x+""+y+"";}
            else if ((count+(i))<=T){
            count=count+i;
            str=str+""+x;}
            else {
            //j=0;c=0;

            y=(char)(y+2);
            x=(char)(x+2);
         //   System.out.println(x +""+y);
            T=T-count;
            count=0;
            i=-1;
           // str=str+find(T-count);
             //   count=c+count;
            }

           i++;
        }

    }
}

 /*   public static String find (int n){

        String s;
    if (n==0)return"";
    else if ((c+j*2)<=n){
            c=c+j*2;
            j++;
            s=x+""+y+""+find(n-c);
            return s;}
    else if ((c+j)<=n){
            c=c+j;
            j++;
            s=""+x+""+find(n-c);
            return s;}

    else return s=find(n-c);
  }
}
*/
/*
From beginning till end, this message has been waiting to be conveyed.

For a given unordered multiset of n lowercase English letters ("multi" means that a letter may appear more than once), we treat all letters as strings of length 1, and repeat the following operation n - 1 times:

    Remove any two elements s and t from the set, and add their concatenation s + t to the set.

The cost of such operation is defined to be , where f(s, c) denotes the number of times character c appears in string s.

Given a non-negative integer k, construct any valid non-empty set of no more than 100 000 letters, such that the minimum accumulative cost of the whole process is exactly k. It can be shown that a solution always exists.
Input

The first and only line of input contains a non-negative integer k (0 ≤ k ≤ 100 000) — the required minimum cost.
Output

Output a non-empty string of no more than 100 000 lowercase English letters — any multiset satisfying the requirements, concatenated to be a string.

Note that the printed string doesn't need to be the final concatenated string. It only needs to represent an unordered multiset of letters.

Note

For the multiset {'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b'}, one of the ways to complete the process is as follows:

    {"ab", "a", "b", "a", "b", "a", "b"}, with a cost of 0;
    {"aba", "b", "a", "b", "a", "b"}, with a cost of 1;
    {"abab", "a", "b", "a", "b"}, with a cost of 1;
    {"abab", "ab", "a", "b"}, with a cost of 0;
    {"abab", "aba", "b"}, with a cost of 1;
    {"abab", "abab"}, with a cost of 1;
    {"abababab"}, with a cost of 8.

The total cost is 12, and it can be proved to be the minimum cost of the process.
*/

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author liymsheep
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int[] root = new int[100007];
            Arrays.fill(root, -1);
            for (int i = 1; i <= 1000; ++i) {
                if (i * i < root.length) {
                    root[i * (i - 1) / 2] = i;
                }
            }
            int a = in.nextInt();
            for (int i = 1; i <= 1000; ++i) {
                for (int j = 1; j <= 1000; ++j) {
                    int c = a - i * (i - 1) / 2 - j * (j - 1) / 2;
                    if (c >= 0 && root[c] != -1) {
                        StringBuilder answer = new StringBuilder();
                        for (int u = 0; u < i; ++u) {
                            answer.append('a');
                        }
                        for (int u = 0; u < j; ++u) {
                            answer.append('b');
                        }
                        for (int u = 0; u < root[c]; ++u) {
                            answer.append('c');
                        }
                        out.println(answer.toString());
                        return;
                    }
                }
            }
        }

    }

    static class InputReader {
        BufferedReader reader;
        StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (Exception e) {
                    throw new UnknownError();
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;

/**
 *
 * @author Fuad
 */
//1 4 5 6
public class Codeforces {

    static class pair<T1, T2> implements Comparator {

        T1 first;
        T2 second;

        pair(T1 f, T2 s) {
            first = f;
            second = s;
        }

        pair() {

        }

        @Override
        public int compare(Object o1, Object o2) {
            pair<Integer, Integer> p1 = (pair) o1;
            pair<Integer, Integer> p2 = (pair) o2;

            if (p1.first < p2.first) {
                return -1;
            } else if (p2.first < p1.first) {
                return 1;
            } else {
                if (p1.second == p2.second) {
                    return 0;
                }

                return p1.second == 1 ? 1 : -1;
            }
        }

    }

    public static void main(String[] args) throws Exception {
        // TODO code application logic here

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String inp[];
        StringBuilder sol = new StringBuilder();
        int k;

        k = Integer.parseInt(br.readLine());

        int l = 0;
        int acc = 0;
        int freq[] = new int[26];
        for (; l < 26; l++) {
            while (true) {
                char c = (char) ('a' + l);
                if (acc + freq[c - 'a'] <= k) {
                    sol.append(c);
                    acc += freq[c - 'a'];
                    freq[c - 'a']++;
                } else {
                    break;
                }
            }

        }

        System.out.println(sol);

    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Anand Iyer
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int cnt = 0;
            if (n == 0) {
                System.out.println("o");
                System.exit(0);
            }
            int[] arr = new int[26]; //letters
            ArrayList<Integer> tri = new ArrayList<>();
            for (int i = 1; i < 450; i++) {
                tri.add(i * (i + 1) / 2);
            }
            while (n > 0) {
                int ind = 0;
                while (tri.get(ind) <= n) {
                    ind++;
                }
                ind--;
                n -= tri.get(ind);
                arr[cnt] = ind + 2;
                cnt++;
            }
            int x = 0;
            while (arr[x] != 0) {
                for (int i = 0; i < arr[x]; i++) {
                    System.out.print((char) (97 + x));
                }
                x++;
            }
        }

    }

    static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public FastScanner(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());
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Anand Iyer
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int cnt = 0;
            if (n == 0) {
                System.out.println("o");
                System.exit(0);
            }
            int[] arr = new int[26]; //letters
            ArrayList<Integer> tri = new ArrayList<>();
            for (int i = 1; i <= 456; i++) {
                tri.add(i * (i + 1) / 2);
            }
            while (n > 0) {
                int ind = 0;
                while (tri.get(ind) <= n) {
                    ind++;
                }
                ind--;
                n -= tri.get(ind);
                arr[cnt] = ind + 2;
                cnt++;
            }
            int x = 0;
            while (arr[x] != 0) {
                for (int i = 0; i < arr[x]; i++) {
                    System.out.print((char) (97 + x));
                }
                x++;
            }
        }

    }

    static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public FastScanner(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());
        }

    }
}

import java.util.*;
import java.io.*;
import java.math.*;
public final class Solution
{
	static HashSet<Integer> primes = new HashSet<>();
    public static void main(String[] args)
    {
    	 Reader input = new Reader();
         PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
         int n = input.nextInt();
         String result = "ab";
         boolean first = true , second = true;
         int current = 1 , cost = 0;
         while(true)
         {
        	 if(first)
        	 {
        		 if(cost + current <= n )
        		 {
        			 cost += current;
        			 result += "a";
        		 }
        		 else
        			 break;
        		 first = false;
        	 }
        	 else
        	 {
        		 if(cost + current <= n )
        		 {
        			 cost += current;
        			 result += "b";
        		 }
        		 else
        			 break;
        		 first = true;
        		 current++;
        	 }
         }
         current = 1;
         first = true;
         result += "cd";
         while(true)
         {
        	 if(first)
        	 {
        		 if(cost + current <= n )
        		 {
        			 cost += current;
        			 result += "c";
        		 }
        		 else
        			 break;
        		 first = false;
        	 }
        	 else
        	 {
        		 if(cost + current <= n )
        		 {
        			 cost += current;
        			 result += "d";
        		 }
        		 else
        			 break;
        		 first = true;
        		 current++;
        	 }
         }
         current = 1;
         for(int i = cost ; i < n ; i++)
         {
        	 result += "" + (char)('d' + current) + (char)('d' + current);
        	 current++;
         }
         out.println(result);
		 out.close();
    }
    public static class Reader
    {
    	BufferedReader br;
    	StringTokenizer st;
    	public Reader()
    	{
    		br = new BufferedReader(new InputStreamReader(System.in));
    	}
    	public String next()
    	{
    		try
    		{
        		if(st == null || !st.hasMoreTokens())
        			st = new StringTokenizer(br.readLine());
    		}
    		catch(IOException ex)
    		{
    			ex.printStackTrace();
    			System.exit(1);
    		}
    		return st.nextToken();
    	}
    	public int nextInt()
    	{
    		return Integer.parseInt(next());
    	}
    	public double nextDouble()
    	{
    		return Double.parseDouble(next());
    	}
    	public long nextLong()
    	{
    		return Long.parseLong(next());
    	}
    	public String nextLine()
    	{
    		try
    		{
    			return br.readLine();
    		}
    		catch(IOException ex)
    		{
    			ex.printStackTrace();
    			System.exit(1);
    		}
    		return "";
    	}
    }
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.util.regex.*;

public class Main {

    static Scanner input = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    static Reader fastInput = new Reader();

    public static void main(String[] args) throws IOException {
        int k = input.nextInt();
        int[] alph = new int[26];
        int len = 0;
        for (int i = 0; i < 26; i++) {
            int c = (int) ((Math.sqrt(1 + 8 * k) + 1) / 2);
            alph[i] = c;
            len += c;
            k -= c * (c - 1) / 2;
            if (c == 1) {
                break;
            }
        }
        char[] res = new char[len];
        for (int i = 0, cur = 0; i < 26; i++) {
            if (alph[i] == 0) {
                break;
            }
            for (int j = 0; j < alph[i]; j++, cur++) {
                res[cur] = (char) ('a' + i);
            }
        }
        System.out.println(new String(res));
    }

    static class Reader {

        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    break;
                }
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg) {
                return -ret;
            }
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg) {
                return -ret;
            }
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg) {
                return -ret;
            }
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1) {
                buffer[0] = -1;
            }
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead) {
                fillBuffer();
            }
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null) {
                return;
            }
            din.close();
        }
    }
}

import java.io.*;
import java.util.StringTokenizer;

public class R431C {

    FastScanner sc;
    PrintWriter out;

    int needMinCost;

    String getStringWithCostX(int x) {
        if(x == 0) {
            return "a";
        }

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < 26; i++) {
            if (x == 0) { break; }

            int cur = 0;
            // double tmp = cur * (cur + 1) / 2;

            while ( cur * (cur + 1) / 2 <= x) {
                cur++;
            }

            x -= cur * (cur + 1) / 2;

            char c = (char)('a' + i);
            for (int z = 0; z < cur; z++) {
                sb.append(c);
            }

        }

        return sb.toString();
    }

    public void solve()  {
        needMinCost = sc.nextInt();
        System.out.println(getStringWithCostX(needMinCost));
        /*for (int i=0; i<26; i++) {
            int cnt = 1;

            while ((cnt+1) * cnt/2 <= needMinCost) {
                cnt++;
            }

            needMinCost -= cnt*(cnt-1)/2;

            for (int j=0; j<cnt; j++) {
                System.out.printf("%c", 'a' + i);
            }
        }*/

    }

    private void run() {
        //sc = new FastScanner(new File("input.txt"));
        sc = new FastScanner(System.in);
        out = new PrintWriter(System.out);

        solve();
        out.close();
    }

    public static void main(String[] args) {
        new R431C().run();
    }

    private class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

import java.io.*;
import java.util.*;
import java.math.*;
public class A {
	public static void main(String[] args)throws IOException {
		FastIO sc = new FastIO(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int k = sc.nextInt();
		String alph = "abcdefghijklmnopqrstuvwxyz";
		int arr[] = new int[26];
		Arrays.fill(arr, 0);
		int idx = 0;
		while(k>0) {
			int a = 1;
			while((a*a-a)/2<=k) {
				a++;
			}
			a--;
			k-=(a*a-a)/2;
			arr[idx] = a;
			idx++;
		}
		for(int i=0; i<26; ++i) {
			for(int j=0; j<arr[i]; ++j) {
				System.out.print(alph.charAt(i));
			}
		}
		out.close();
	}
	static class FastIO {
		InputStream dis;
		byte[] buffer = new byte[1 << 17];
		int pointer = 0;
		public FastIO(String fileName) throws IOException {
			dis = new FileInputStream(fileName);
		}
		public FastIO(InputStream is) throws IOException {
			dis = is;
		}
		int nextInt() throws IOException {
			int ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}

			return (negative) ? -ret : ret;
		}
		long nextLong() throws IOException {
			long ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}
			return (negative) ? -ret : ret;
		}
		byte nextByte() throws IOException {
			if (pointer == buffer.length) {
				dis.read(buffer, 0, buffer.length);
				pointer = 0;
			}
			return buffer[pointer++];
		}
		String next() throws IOException {
			StringBuffer ret = new StringBuffer();

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			while (b > ' ') {
				ret.appendCodePoint(b);
				b = nextByte();
			}

			return ret.toString();
		}
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Anand Iyer
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int cnt = 0;
            if (n == 0) {
                out.println("a");
                System.exit(0);
            }
            int[] arr = new int[26]; //letters
            ArrayList<Integer> tri = new ArrayList<>();
            for (int i = 1; i <= 456; i++) {
                tri.add(i * (i + 1) / 2);
            }
            while (n > 0) {
                int ind = 0;
                while (tri.get(ind) <= n) {
                    ind++;
                }
                ind--;
                n -= tri.get(ind);
                arr[cnt] = ind + 2;
                cnt++;
            }
            int x = 0;
            while (arr[x] != 0) {
                for (int i = 0; i < arr[x]; i++) {
                    System.out.print((char) (97 + x));
                }
                x++;
            }
        }

    }

    static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public FastScanner(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());
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Anand Iyer
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int cnt = 0;
            if (n == 0) {
                out.println("o");
                System.exit(0);
            }
            int[] arr = new int[26]; //letters
            ArrayList<Integer> tri = new ArrayList<>();
            for (int i = 1; i < 450; i++) {
                tri.add(i * (i + 1) / 2);
            }
            while (n > 0) {
                int ind = 0;
                while (tri.get(ind) <= n) {
                    ind++;
                }
                ind--;
                n -= tri.get(ind);
                arr[cnt] = ind + 2;
                cnt++;
            }
            int x = 0;
            while (arr[x] != 0) {
                for (int i = 0; i < arr[x]; i++) {
                    System.out.print((char) (97 + x));
                }
                x++;
            }
        }

    }

    static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public FastScanner(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());
        }

    }
}

import java.io.*;
import java.util.*;

public class C implements Runnable{
	public static void main (String[] args) {new Thread(null, new C(), "C", 1 << 28).start();}

	public void run() {
		FastScanner fs = new FastScanner();
		PrintWriter out = new PrintWriter(System.out);

		//d = 1 ? cost = n * n-1 / 2
		//0, 1

		ArrayList<Long> list = new ArrayList<>();
		ArrayList<Integer> list2 = new ArrayList<>();
		for(int i = 1; i <= 100000; i++) {
			long x = i;
			list2.add(i);
			x *= i - 1;
			x /= 2;
			list.add(x);
		}

		long k = fs.nextInt();
		int[] f = new int[26];
		int p = 0;
		for(int i = list.size() - 1; i > 0 && k > 0; i--) {
			if(k >= list.get(i)) {
				while(k >= list.get(i)) {
					k -= list.get(i);
					f[p++] = (int)list2.get(i);
				}
			} else {
				continue;
			}
		}

		StringBuilder sb = new StringBuilder();
		for(int i = 0; i < 26; i++) {
			for(int j = 0; j < f[i]; j++) {
				sb.append((char)(i + 'a'));
			}
		}

		out.println(sb);

		//		ArrayList<String> str = new ArrayList<>();
		//		String fill = "aaa";
		//		for(Character c : fill.toCharArray()) {
		//			str.add("" + c);
		//		}
		//
		//		System.out.println(go(str));

		out.close();
	}

	int go (ArrayList<String> str) {
		if(str.size() == 1) return 0;

		int res = 10010010;
		for(int i = 0; i < str.size(); i++) {
			for(int j = i + 1; j < str.size(); j++) {
				ArrayList<String> nlist = new ArrayList<>();
				for(int k = 0; k < str.size(); k++) {
					if(k == i || k == j) continue;
					nlist.add(str.get(k));
				}
				nlist.add(str.get(i) + str.get(j));
				int check = cost(str.get(i), str.get(j))  + go(nlist);
				res = Math.min(res, check);
			}
		}

		return res;

	}

	int cost(String s, String st) {
		int[] f1 = new int[26];
		int[] f2 = new int[26];

		for(Character c : s.toCharArray())
			f1[c-'a'] ++;
		for(Character c : st.toCharArray())
			f2[c-'a'] ++;

		int res = 0;
		for(int i = 0; i < 26; i++) {
			res += f1[i] * f2[i];
		}

		return res;

	}

	void sort (int[] a) {
		int n = a.length;
		for(int i = 0; i < 1000; i++) {
			Random r = new Random();
			int x = r.nextInt(n), y = r.nextInt(n);
			int temp = a[x];
			a[x] = a[y];
			a[y] = temp;
		}
		Arrays.sort(a);
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;
		public FastScanner() {
			try	{
				br = new BufferedReader(new InputStreamReader(System.in));
				//                br = new BufferedReader(new FileReader("testdata.out"));
				st = new StringTokenizer("");
			} catch (Exception e){e.printStackTrace();}
		}
		public String next() {
			if (st.hasMoreTokens())	return st.nextToken();
			try {st = new StringTokenizer(br.readLine());}
			catch (Exception e) {e.printStackTrace();}
			return st.nextToken();
		}
		public int nextInt() {return Integer.parseInt(next());}
		public long nextLong() {return Long.parseLong(next());}
		public double nextDouble() {return Double.parseDouble(next());}

		public String nextLine() {
			String line = "";
			try {line = br.readLine();}
			catch (Exception e) {e.printStackTrace();}
			return line;
		}
		public Integer[] nextIntegerArray(int n) {
			Integer[] a = new Integer[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
		public int[] nextIntArray(int n) {
			int[] a = new int[n];
			for(int i = 0; i < n; i++) a[i] = nextInt();
			return a;
		}
		public char[] nextCharArray() {return nextLine().toCharArray();}
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            long k = in.nextInt();
            for (char ch = 'a'; ch <= 'z'; ch++) {
                long cnt = 1;
                while ((cnt * (cnt + 1)) / 2 <= k) {
                    cnt++;
                }
                k -= (cnt * (cnt + 1)) / 2;
                for (int i = 0; i < cnt; i++) {
                    out.print(ch);
                }

            }
            out.println();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int nextInt() {
            return readInt();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void println() {
            writer.println();
        }

        public void print(char i) {
            writer.print(i);
        }

        public void close() {
            writer.close();
        }

    }
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;

/**
 * Created by shikhar on 01/09/17.
 */
public class TellYourWorld
{
    static String fin = "";
    static int cost(String a, String b)
    {
        int char1[] = new int[26];
        int char2[] = new int[26];
        for(char ch : a.toCharArray())
            char1[ch-'a']++;
        for(char ch : b.toCharArray())
            char2[ch-'a']++;
        int sum = 0;
        for(int i =0; i<26; i++)
            sum+=char1[i]*char2[i];
        return sum;
    }
    static void util(String ans, int k, int val)
    {
      if(val>k) return;
      if(val==k){
          if(fin.length()==0)
          fin = ans;
       return;
      }

        util(ans+ans, k, val+cost(ans,ans));

        if(fin.length()!=0) return;
      for(int i =0; i <26 ; i++)
      {
          char ch = (char)('a'+i);
          util(ans+ch, k, val+cost(ans,""+ch));
      }
    }
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);

        int N = in.nextInt();
        util("a",N,0);
        System.out.println(fin);
    }
}

/**
 * Created by Aminul on 9/1/2017.
 */

import java.io.*;
import java.util.*;

public class C_2 {
    public static HashSet<Integer> set;
    static int index[];
    public static void main(String[] args)throws Exception {
        InputReader in = new InputReader(System.in);
        PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
        preCal();
        int n = in.nextInt();
        int [] res = solve(n); //debug(res);

        char c = 'a';
        for(int i = 0; i < 3; i++, c++){
            int x = index[res[i]];
            if(x > 0) x++;
            //debug(x);
            for(int j = 0; j < x; j++){
                pw.print(c);
            }
        }
        pw.println();

        pw.close();
    }

    static int[] solve(int n){
        for(int j : set){
            for(int k : set){
                if(set.contains(n - j - k)){
                    return new int[]{j, k, n-j-k};
                }
            }
        }
        return null;
    }

    static void preCal(){
        set = new HashSet<>();
        index = new int[(int)1e5+50];
        int sum = 0;
        for(int i = 0; i < 1000; i++){
            sum += i;
            if(sum > (int)1e5) break;
            set.add(sum);
            index[sum] = i;
        }
    }

    static void debug(Object...obj) {
        System.err.println(Arrays.deepToString(obj));
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tokenizer = null;
        }

        public String next()throws Exception {
            while (tokenizer == null || !tokenizer.hasMoreTokens())
                tokenizer = new StringTokenizer(reader.readLine());
            return tokenizer.nextToken();
        }

        public String nextLine()throws Exception {
            String line = null;
            tokenizer = null;
            line =  reader.readLine();
            return line;
        }

        public int nextInt()throws Exception {
            return Integer.parseInt(next());
        }

        public double nextDouble() throws Exception{
            return Double.parseDouble(next());
        }

        public long nextLong()throws Exception {
            return Long.parseLong(next());
        }

    }
}

import java.io.*;
import java.util.*;

public class Main_Round431Div2_C {

	private static Scanner sc;
	private static Printer pr;

	private static void solve() {
		int k = sc.nextInt();

		int[] d = new int[448];
		for (int i = 1; i < 448; i++) {
			d[i] = (i - 1) * i / 2;
//			pr.printf("%d %d\n", i, (i - 1) * i / 2);
		}

		StringBuilder ret = new StringBuilder();
		char c = 'a';
		while (k > 0) {
			for (int i = 448 - 1; i > 0; i--) {
				if (k >= d[i]) {
					k -= d[i];
					for (int j = 0; j < i; j++) {
						ret.append(c);
					}
					c++;
					break;
				}
			}
		}

		pr.println(ret);
	}

	// ---------------------------------------------------
	public static void main(String[] args) {
		sc = new Scanner(System.in);
		pr = new Printer(System.out);

		solve();

		pr.close();
		sc.close();
	}

	@SuppressWarnings("unused")
	private static class Scanner {
		BufferedReader br;

		Scanner (InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
		}

		private boolean isPrintable(int ch) {
			return ch >= '!' && ch <= '~';
		}

		private boolean isCRLF(int ch) {
			return ch == '\n' || ch == '\r' || ch == -1;
		}

		private int nextPrintable() {
			try {
				int ch;
				while (!isPrintable(ch = br.read())) {
					if (ch == -1) {
						throw new NoSuchElementException();
					}
				}

				return ch;
			} catch (IOException e) {
				throw new NoSuchElementException();
			}
		}

		String next() {
			try {
				int ch = nextPrintable();
				StringBuilder sb = new StringBuilder();
				do {
					sb.appendCodePoint(ch);
				} while (isPrintable(ch = br.read()));

				return sb.toString();
			} catch (IOException e) {
				throw new NoSuchElementException();
			}
		}

		int nextInt() {
			try {
				// parseInt from Integer.parseInt()
				boolean negative = false;
				int res = 0;
				int limit = -Integer.MAX_VALUE;
				int radix = 10;

				int fc = nextPrintable();
				if (fc < '0') {
					if (fc == '-') {
						negative = true;
						limit = Integer.MIN_VALUE;
					} else if (fc != '+') {
						throw new NumberFormatException();
					}
					fc = br.read();
				}
				int multmin = limit / radix;

				int ch = fc;
				do {
					int digit = ch - '0';
					if (digit < 0 || digit >= radix) {
						throw new NumberFormatException();
					}
					if (res < multmin) {
						throw new NumberFormatException();
					}
					res *= radix;
					if (res < limit + digit) {
						throw new NumberFormatException();
					}
					res -= digit;

				} while (isPrintable(ch = br.read()));

				return negative ? res : -res;
			} catch (IOException e) {
				throw new NoSuchElementException();
			}
		}

		long nextLong() {
			try {
				// parseLong from Long.parseLong()
				boolean negative = false;
				long res = 0;
				long limit = -Long.MAX_VALUE;
				int radix = 10;

				int fc = nextPrintable();
				if (fc < '0') {
					if (fc == '-') {
						negative = true;
						limit = Long.MIN_VALUE;
					} else if (fc != '+') {
						throw new NumberFormatException();
					}
					fc = br.read();
				}
				long multmin = limit / radix;

				int ch = fc;
				do {
					int digit = ch - '0';
					if (digit < 0 || digit >= radix) {
						throw new NumberFormatException();
					}
					if (res < multmin) {
						throw new NumberFormatException();
					}
					res *= radix;
					if (res < limit + digit) {
						throw new NumberFormatException();
					}
					res -= digit;

				} while (isPrintable(ch = br.read()));

				return negative ? res : -res;
			} catch (IOException e) {
				throw new NoSuchElementException();
			}
		}

		float nextFloat() {
			return Float.parseFloat(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String nextLine() {
			try {
				int ch;
				while (isCRLF(ch = br.read())) {
					if (ch == -1) {
						throw new NoSuchElementException();
					}
				}
				StringBuilder sb = new StringBuilder();
				do {
					sb.appendCodePoint(ch);
				} while (!isCRLF(ch = br.read()));

				return sb.toString();
			} catch (IOException e) {
				throw new NoSuchElementException();
			}
		}

		void close() {
			try {
				br.close();
			} catch (IOException e) {
//				throw new NoSuchElementException();
			}
		}
	}

	private static class Printer extends PrintWriter {
		Printer(PrintStream out) {
			super(out);
		}
	}
}

import java.util.*;
import java.io.*;
/*
TASK: substringcon
LANG: JAVA
 */

public class substringcon{
    static int k;
    static long[] table;
    public static void main(String[] args) throws IOException{
        FastScanner in = new FastScanner(System.in);
        k = in.nextInt();
        StringBuilder a = new StringBuilder(100000);
        table = new long[448];
        for(int i = 2; i < 448;i++){
            table[i] = (i*(i-1)) / 2;
        }
        int count = 0;
        for(int i = 447; i > 2; i--){
            if(table[i] < k){
                k -= table[i];
                for(int j = 0;j < i;j++){a.append((char)('a' + count));}
                count++;
            }
        }
        for(int i = 0;i < k; i++){
            a.append((char)('a' + count));
            a.append((char)('a' + count));
            count++;
        }
        System.out.println(a);
    }
}
class FastScanner{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public FastScanner(InputStream stream) {
        this.stream = stream;
    }
    int read() {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (numChars <= 0) return -1;
        }
        return buf[curChar++];
    }

    boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    boolean isEndline(int c) {
        return c == '\n' || c == '\r' || c == -1;
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double nextDouble() {
        return Double.parseDouble(next());
    }

    public String next() {
        int c = read();
        while (isSpaceChar(c)) c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public String nextLine() {
        int c = read();
        while (isEndline(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = read();
        } while (!isEndline(c));
        return res.toString();
    }
}

import java.util.Scanner;
import java.util.ArrayList;
// import java.util.Arrays;
// import java.util.HashMap;
// import java.util.HashSet;
import java.util.Collections;

public class ans3{
    static int mod = (int)10e8;

    public static int lower(int arr[],int key){
        int low = 0;
        int high = arr.length-1;
        while(low < high){
            int mid = low + (high - low)/2;
            if(arr[mid] >= key){
                high = mid;
            }
            else{
                low = mid+1;
            }
        }
        return arr[low - 1];
    }

    public static int justGreater(int[] arr, int val, int s, int e){
        // Returns the index of first element greater than val.
        // If no such value is present, returns the size of the array.
        if (s >= e){
            return arr[s] <= val ? s+1 : s;
        }
        int mid = (s + e) >> 1;
        if (arr[mid] < val) return justGreater(arr, val, mid+1, e);
        return justGreater(arr, val, s, mid);
    }

    public static int upper(int arr[],int key){
        int low = 0;
        int high = arr.length-1;
        while(low < high){
            int mid = low + (high - low+1)/2;
            if(arr[mid] <= key){
                low = mid;
            }
            else{
                high = mid-1;
            }
        }
        return low;
    }

    public static int lower_bound(ArrayList<Integer> ar,int k)
{
    int s=0;
    int e=ar.size();
    while (s !=e)
    {
        int mid = s+e>>1;
        if(ar.get(mid) == k) return mid + 1;
        if (ar.get(mid) <k)
        {
            s=mid+1;
        }
        else
        {
            e=mid;
        }
    }
    if(s==ar.size())
    {
        return -1;
    }
    return s;
}

    public static void main(String args[]){
        Scanner scn = new Scanner(System.in);

        int k = scn.nextInt();

        int si = 0;
        int sum =0;
        ArrayList<Integer> list = new ArrayList<>();
        while(sum <= k){
            sum +=  si;
            list.add(sum);
            si++;
        }
        StringBuilder sb = new StringBuilder();
        if(sum == k){
            for(int i = 0 ; i < si ; i++){
                sb.append('a');
                System.out.println(sb);
                return;
            }
        }

        int c = 0;
        while(k != 0){
            int a = lower_bound(list, k);
            int t = a - 1;
            a = list.get(a - 1);

            k-= a;
            for(int i = 0 ; i < t + 1 ; i++){
                sb.append((char)(c + 97));
            }
            c++;
            // System.out.println(k);
        }

        System.out.println(sb);

    }
}

import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;

public class A {
    static class Node{
        int id;
        long y;
        public Node(int id,long x){
            this.id=id;
            this.y=y;
        }
    }
    //public static PrintWriter pw;
    public static PrintWriter pw = new PrintWriter(System.out);

    public static void solve() throws IOException {
//	pw=new PrintWriter(new FileWriter("C:\\Users\\shree\\Downloads\\small_output_in"));
        FastReader sc = new FastReader();
        long k=sc.L();
        StringBuilder sb=new StringBuilder("");
        int c=0;
        while(k>0 && c<26){
            long n1=1;
            while((n1*(n1-1))/2<k) n1++;
            if((n1*(n1-1))/2!=k) n1--;
            char ch=(char)(c+'a');
            for(int i=1;i<=n1;i++) sb.append(ch);
            c++;
            k-=(n1*(n1-1))/2;
        }
        pw.println(sb);

        pw.close();

    }

    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                try {

                    solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();

    }

    static BufferedReader br;
    static long M = (long) 1e9 + 7;

    static class FastReader {

        StringTokenizer st;

        public FastReader() throws FileNotFoundException {
            //br=new BufferedReader(new FileReader("C:\\Users\\shree\\Downloads\\B-small-practice.in"));
            br = new BufferedReader(new InputStreamReader(System.in));

        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int I() {
            return Integer.parseInt(next());
        }

        long L() {
            return Long.parseLong(next());
        }

        double D() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public boolean hasNext() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                String s = br.readLine();
                if (s == null) {
                    return false;
                }
                st = new StringTokenizer(s);
            }
            return true;
        }

    }
}

        import java.io.*;
        import java.lang.reflect.Array;
        import java.util.*;
        import java.lang.*;
        import static java.lang.Math.*;
        public class main implements Runnable {

            static ArrayList<Integer> adj[];

            static void Check2(int n) {
                adj = new ArrayList[n + 1];
                for (int i = 0; i <= n; i++) {
                    adj[i] = new ArrayList<>();
                }

            }
            static void add(int i, int j)
            {
                adj[i].add(j);
                adj[j].add(i);
            }

            public static void main(String[] args) {
                new Thread(null, new main(), "Check2", 1 << 26).start();// to increse stack size in java
            }
            static long mod = (long) (1e9 + 7);
            public void run() {
                InputReader in = new InputReader(System.in);
                PrintWriter w = new PrintWriter(System.out);

                int co=1;
                char c='a';
                String ans="";
                ans=ans+c;
                int k=in.nextInt();
                while (k>0){

                    if(co>k){

                        k-=co;
                        c++;
                        ans=ans+c;

                    }
                    else{
                        k-=co;
                        ans=ans+c;
                        co++;
                    }

                }
                w.println(ans);

                w.close();
            }

/*            static class cmp implements Comparator<pair>{

                public int compare(pair o1,pair o2){

                    return o1.b<o2.b?-1:o1.b>o2.b?1:0;
                }

            }*/
            static class pair {

              long x,y;
                pair(int a,long b){

                    x=a;
                    y=b;
                }
              /*  public boolean equals(Object obj) {      //  override equals method for object to remove tem from arraylist and sets etc.......
                    if (this == obj)
                        return true;
                    if (obj == null)
                        return false;
                    if (getClass() != obj.getClass())
                        return false;
                    pair other = (pair) obj;
                    if (b!= other.b||a!=other.a)
                        return false;
                    return true;
                }
        */
            }

            static long modinv(long a,long b)
            {
                long p=power(b,mod-2);

                p=a%mod*p%mod;
                p%=mod;

                return p;

            }

            static long power(long x,long y){
                if(y==0)return 1%mod;
                if(y==1)return x%mod;

                long res=1;
                x=x%mod;
                while(y>0){

                    if((y%2)!=0){
                        res=(res*x)%mod;
                    }

                    y=y/2;
                    x=(x*x)%mod;
                }

                return res;

            }
            static  int gcd(int a,int b){

                if(b==0)return a;
                return gcd(b,a%b);
            }

            static  void sev(int a[],int n){

                for(int i=2;i<=n;i++)a[i]=i;
                for(int i=2;i<=n;i++){

                    if(a[i]!=0){
                        for(int j=2*i;j<=n;){

                            a[j]=0;
                            j=j+i;
                        }
                    }

                }

            }

            static class node{

                int y;
                int val;

                node(int a,int b){

                    y=a;
                    val=b;

                }

            }

            static class InputReader
            {
                private InputStream stream;
                private byte[] buf = new byte[1024];
                private int curChar;
                private int numChars;
                private SpaceCharFilter filter;

                public InputReader(InputStream stream)
                {
                    this.stream = stream;
                }

                public int read()
                {
                    if (numChars==-1)
                        throw new InputMismatchException();

                    if (curChar >= numChars)
                    {
                        curChar = 0;
                        try
                        {
                            numChars = stream.read(buf);
                        }
                        catch (IOException e)
                        {
                            throw new InputMismatchException();
                        }

                        if(numChars <= 0)
                            return -1;
                    }
                    return buf[curChar++];
                }

                public String nextLine()
                {
                    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                    String str = "";
                    try
                    {
                        str = br.readLine();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                    return str;
                }
                public int nextInt()
                {
                    int c = read();

                    while(isSpaceChar(c))
                        c = read();

                    int sgn = 1;

                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }

                    int res = 0;
                    do
                    {
                        if(c<'0'||c>'9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    while (!isSpaceChar(c));

                    return res * sgn;
                }

                public long nextLong()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    int sgn = 1;
                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }
                    long res = 0;

                    do
                    {
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    while (!isSpaceChar(c));
                    return res * sgn;
                }

                public double nextDouble()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    int sgn = 1;
                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }
                    double res = 0;
                    while (!isSpaceChar(c) && c != '.')
                    {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    if (c == '.')
                    {
                        c = read();
                        double m = 1;
                        while (!isSpaceChar(c))
                        {
                            if (c == 'e' || c == 'E')
                                return res * Math.pow(10, nextInt());
                            if (c < '0' || c > '9')
                                throw new InputMismatchException();
                            m /= 10;
                            res += (c - '0') * m;
                            c = read();
                        }
                    }
                    return res * sgn;
                }

                public String readString()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    StringBuilder res = new StringBuilder();
                    do
                    {
                        res.appendCodePoint(c);
                        c = read();
                    }
                    while (!isSpaceChar(c));

                    return res.toString();
                }

                public boolean isSpaceChar(int c)
                {
                    if (filter != null)
                        return filter.isSpaceChar(c);
                    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
                }

                public String next()
                {
                    return readString();
                }

                public interface SpaceCharFilter
                {
                    public boolean isSpaceChar(int ch);
                }
            }

        }

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class C431 {
	public static void main(String[] args) {
		try (Scanner in = new Scanner(System.in)) {
			int n = in.nextInt();
			if (n == 0) {
				System.out.println("a");
				return;
			}
			List<Integer> result = new ArrayList<>();
			while (n > 0) {
				int binarySearch = binarySearch(n);
				result.add(binarySearch);
				n -= (binarySearch * (binarySearch - 1)) / 2;
			}
			StringBuilder sb = new StringBuilder();
			for (int i = 0; i < result.size(); i++) {
				String c = (char) ('a' + i) + "";
				sb.append(String.join("", Collections.nCopies(result.get(i), c)));
			}
			System.out.println(sb);
		}
	}

	static int binarySearch(int n) {
		int low = 2;
		int high = n;
		while (low < high - 1) {
			int mid = low + (high - low) / 2;
			if (mid * (mid - 1) < 2 * n) {
				low = mid;
			} else if (mid * (mid - 1) > 2 * n) {
				high = mid;
			} else {
				return mid;
			}
		}
		return low;
	}
}

import java.util.*;
import java.io.*;
import java.math.*;
import java.util.regex.*;

public class Main {

    static Scanner input = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
    static Reader fastInput = new Reader();

    public static void main(String[] args) throws IOException {
        int k = input.nextInt();
        int[] alph = new int[26];
        int len = 0;
        for (int i = 0; i < 26 && k != 0; i++) {
            int c = (int) ((Math.sqrt(1 + 8 * k) + 1) / 2);
            alph[i] = c;
            len += c;
            k -= c * (c - 1) / 2;
        }
        char[] res = new char[len];
        for (int i = 0, cur = 0; i < 26; i++) {
            if (alph[i] == 0) {
                break;
            }
            for (int j = 0; j < alph[i]; j++, cur++) {
                res[cur] = (char) ('a' + i);
            }
        }
        System.out.println(new String(res));
    }

    static class Reader {

        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader() {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1) {
                if (c == '\n') {
                    break;
                }
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException {
            int ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (neg) {
                return -ret;
            }
            return ret;
        }

        public long nextLong() throws IOException {
            long ret = 0;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }
            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');
            if (neg) {
                return -ret;
            }
            return ret;
        }

        public double nextDouble() throws IOException {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ') {
                c = read();
            }
            boolean neg = (c == '-');
            if (neg) {
                c = read();
            }

            do {
                ret = ret * 10 + c - '0';
            } while ((c = read()) >= '0' && c <= '9');

            if (c == '.') {
                while ((c = read()) >= '0' && c <= '9') {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg) {
                return -ret;
            }
            return ret;
        }

        private void fillBuffer() throws IOException {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1) {
                buffer[0] = -1;
            }
        }

        private byte read() throws IOException {
            if (bufferPointer == bytesRead) {
                fillBuffer();
            }
            return buffer[bufferPointer++];
        }

        public void close() throws IOException {
            if (din == null) {
                return;
            }
            din.close();
        }
    }
}

import java.util.Scanner;

public class ProblemC {

	public static long[] cost=new long[1001];

	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();

		for (int i=0; i<1000; i++) {
			calcCost(i);
		}
		StringBuilder sb=new StringBuilder("");
		char l='a';
		while (n>0) {
			int k=0;
			while (calcCost(k)<=n) {
				k++;
			}
			k--;
			n-=calcCost(k);
			for (int i=0; i<k; i++) {
				sb.append(""+l);
			}
			l++;
			//System.out.println(n);
		}
		System.out.print(sb);
	}

	public static long calcCost(int i) {
		return i*(i-1)/2;
	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Wolfgang Beyer
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int k = in.nextInt();

            char c = 'a';
            while (k > 0) {
                int n = 2;
                while ((n * (n - 1)) / 2 <= k) n++;
                n--;
                for (int i = 0; i < n; i++) {
                    out.print(c);
                }
                c++;
                k -= (n * (n - 1)) / 2;
            }
        }

    }

    static class InputReader {
        private static BufferedReader in;
        private static StringTokenizer tok;

        public InputReader(InputStream in) {
            this.in = new BufferedReader(new InputStreamReader(in));
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public String next() {
            try {
                while (tok == null || !tok.hasMoreTokens()) {
                    tok = new StringTokenizer(in.readLine());
                    //tok = new StringTokenizer(in.readLine(), ", \t\n\r\f"); //adds commas as delimeter
                }
            } catch (IOException ex) {
                System.err.println("An IOException was caught :" + ex.getMessage());
            }
            return tok.nextToken();
        }

    }
}

/*
 * Author Ayub Subhaniya
 * Institute DA-IICT
 */

import java.io.*;
import java.math.*;
import java.util.*;

public class Codeforces429C
{

	InputStream in;
	PrintWriter out;

	int MAX=1000;
	void solve()
	{
		int k=ni();
		int sum[]=new int[MAX];
		sum[0]=0;
		for (int i=1;i<MAX;i++)
			sum[i]=sum[i-1]+i;

		int cnt[]=new int[26];
		int j=MAX-1;
		for (int i=0;i<26&&k>0;i++)
		{
			//tr(j);
			for (;j>0;j--)
			{
				if (sum[j]<=k)
				{
					cnt[i]=j+1;
					k-=sum[j];
					//tr(j+" "+sum[j]+" "+k);
					break;
				}
			}
		}
		for (int i=0;i<26;i++)
			for (int l=1;l<=cnt[i];l++)
				out.print((char)('a'+i));
	}

	void run() throws Exception
	{
		String INPUT = "C:/Users/ayubs/Desktop/input.txt";
		in = oj ? System.in : new FileInputStream(INPUT);
		out = new PrintWriter(System.out);

		long s = System.currentTimeMillis();
		solve();
		out.flush();
		tr(System.currentTimeMillis() - s + "ms");

	}
	public static void main(String[] args) throws Exception
	{
		new Codeforces429C().run();
	}

	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;

	private int readByte()
	{
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf)
		{
			ptrbuf = 0;
			try
			{
				lenbuf = in.read(inbuf);
			}
			catch (IOException e)
			{
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}

	private boolean inSpaceChar(int c)
	{
		return !(c >= 33 && c <= 126);
	}

	private int skip()
	{
		int b;
		while ((b = readByte()) != -1 && inSpaceChar(b))
			;
		return b;
	}

	private double nd()
	{
		return Double.parseDouble(ns());
	}

	private char nc()
	{
		return (char) skip();
	}

	private String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(inSpaceChar(b)))
		{ // when nextLine, (inSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(inSpaceChar(b)))
		{
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for (int i = 0; i < n; i++)
			map[i] = ns(m);
		return map;
	}

	private int[] na(int n)
	{
		int[] a = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = ni();
		return a;
	}

	private int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}
			else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-')
		{
			minus = true;
			b = readByte();
		}

		while (true)
		{
			if (b >= '0' && b <= '9')
			{
				num = num * 10 + (b - '0');
			}
			else
			{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private boolean oj = System.getProperty("ONLINE_JUDGE") != null;

	private void tr(Object... o)
	{
		if (!oj)
			System.out.println(Arrays.deepToString(o));
	}

}

import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Codeforces849C {
	private static final int LIMIT = 100000;
	public static void main(String[] args) throws IOException {
		BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
		int k = Integer.parseInt(f.readLine());
		ArrayList<Integer> triangles = new ArrayList<>();
		triangles.add(0);
		int last = 0;
		int counter = 1;
		while(last < LIMIT) {
			last += counter;
			triangles.add(last);
			counter++;
		}
		ArrayList<Integer> sol = new ArrayList<>();
		int tail = triangles.size() - 1;
		while(k != 0) {
			while(triangles.get(tail) > k) {
				tail--;
			}
			k -= triangles.get(tail);
			sol.add(tail + 1);
		}
		StringBuffer s = new StringBuffer("");
		char curr = 'a';
		for(int i = 0; i < sol.size(); i++) {
			int count = sol.get(i);
			for(int j = 0; j < count; j++) {
				s.append(curr);
			}
			curr++;
		}
		System.out.println(s.toString());
	}
}

import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws IOException {

        new Main().go();
    }

    PrintWriter out;
    Reader in;
    BufferedReader br;

    Main() throws IOException {

        try {

            //br = new BufferedReader( new FileReader("input.txt") );
            in = new Reader("input.txt");
            out = new PrintWriter( new BufferedWriter(new FileWriter("output.txt")) );
        }
        catch (Exception e) {

            //br = new BufferedReader( new InputStreamReader( System.in ) );
            in = new Reader();
            out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
        }
    }

    void go() throws IOException {

        int t = 1;
        while (t > 0) {
            solve();
            //out.println();
            t--;
        }

        out.flush();
        out.close();
    }

    int inf = 2000000000;
    int mod = 1000000007;
    double eps = 0.00000001;

    int n;
    int m;

    //ArrayList<Integer>[] g = new ArrayList[200010];

    void solve() throws IOException {

        int n = in.nextInt();

        if (n == 0) {

            out.println('a');
            return;
        }

        int a = 'a';

        int st = 1 << 16;

        while (n > 0) {

            if (st <= n) {
                for (int i = 0; i <= st; i++)
                    out.print((char)a);
                n -= st;
                a++;
            }

            st = st >> 1;
        }

    }

    int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a%b);
    }

    class Pair implements Comparable<Pair>{

        int a;
        int b;

        Pair(int a, int b) {

            this.a = a;
            this.b = b;
        }

        public int compareTo(Pair p) {

            if (a > p.a) return 1;
            if (a < p.a) return -1;
            if (b > p.b) return 1;
            if (b < p.b) return -1;
            return 0;
        }
    }

    class Item {

        int a;
        int b;
        int c;

        Item(int a, int b, int c) {
            this.a = a;
            this.b = b;
            this.c = c;
        }

    }

    class Reader {

        BufferedReader  br;
        StringTokenizer tok;

        Reader(String file) throws IOException {
            br = new BufferedReader( new FileReader(file) );
        }

        Reader() throws IOException {
            br = new BufferedReader( new InputStreamReader(System.in) );
        }

        String next() throws IOException {

            while (tok == null || !tok.hasMoreElements())
                tok = new StringTokenizer(br.readLine());
            return tok.nextToken();
        }

        int nextInt() throws NumberFormatException, IOException {
            return Integer.valueOf(next());
        }

        long nextLong() throws NumberFormatException, IOException {
            return Long.valueOf(next());
        }

        double nextDouble() throws NumberFormatException, IOException {
            return Double.valueOf(next());
        }

        String nextLine() throws IOException {
            return br.readLine();
        }

    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Abhilash
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int k = in.nextInt();
            StringBuilder sb = new StringBuilder();
            int idx = 0;
            String alphabets = "abcdefghijklmnopqrst";
            while (k > 0) {
                int x = (int) Math.ceil(Math.sqrt(2 * k));
                if (x * x - x > 2 * k)
                    x -= 1;
                char c = alphabets.charAt(idx);
                for (int i = 0; i < x; i++)
                    sb.append(c);
                idx += 1;
                k -= (x * x - x) / 2;
            }
            out.println(sb.toString());
        }

    }

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

    }
}

import java.math.BigInteger;
import java.util.StringTokenizer;
import java.util.*;
import java.io.*;
public class Wtf {
    public static void main(String[] args) throws IOException {
        Ifmo ifmo = new Ifmo();
    }
}

class Ifmo {
    ArrayList<Integer> Graph[];
    int n, l, m, primes, timer;
    char[][] field;
    ArrayList<FUCKINGVERTEX> Ribs;
    int[][] roofs, ans, up;
    Vertex[][] highes;
    ArrayList<Integer> fin;
    static int cur;
    int[] p, size, tin, tout;
    boolean[] used;
    int logn;
    int[][] pref;
    int[][] longest;
    int[][][] dp = new int[31][31][51];
    ArrayList<Integer>[] tree, bit;
    Ifmo() throws IOException {
        FScanner fs = new FScanner(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        int k = fs.nextInt();
        int[] mas = new int[100000];
        mas[1] = 0;
        mas[2] = 1;
        mas[3] = 3;
        int size = 0;
        for (int i = 4; i<=100000; i++) {
            if (i%2 == 0) {
                mas[i] = i/2*i/2+2*mas[i/2];
            } else mas[i] = i/2*(i/2+1) + mas[i/2] + mas[i/2+1];
            if (mas[i] >100000)
            {mas[i] = 0; size = i-1;break;}
        }
        int g = size;
        ArrayList<Character> ans = new ArrayList<>();
        char f = 'a';
        int left = 'z'-'a'+1;
        while (k !=0) {
            g = 2;
            while (mas[g]*left<k)
                g++;
            k-=mas[g];
            for (int i = 0; i<g; i++)
                ans.add(f);
            f++;
        }
        for (char x : ans)
            System.out.print(x);
        pw.close();
    }

    private void dfs1(int v, int p) {
        used[v] = true;
        if (v !=0) {
            longest[v][0] = gcd(longest[p][0], size[v]);
        }
        for (int i = 0; i<tree[v].size(); i++) {
            if (!used[tree[v].get(i)])
                dfs1(tree[v].get(i), v);
        }
    }

    void dfs_combo(int cur, int it,  int[] p, int[] q) {
        used[cur] = true;
        if (q[cur] == -1 || q[cur] == p[cur]);
    }

    void dfs(int cur, int[] mas, HashMap<Integer, Integer> numofv, HashMap<Integer, HashSet<Integer>> fullis, HashSet<Integer> currents, ArrayList<Integer>[] bin) {
        used[cur] = true;
        if (bin[mas[cur]].size() == 0)
            primes++;
        else {
            currents.add(mas[cur]);
            for (int i = 0; i<bin[cur].size(); i+=2) {
                int val = bin[cur].get(i);
                int how = bin[cur].get(i+1);
                if (numofv.containsKey(val)) {

                }
            }
        }

    }

    boolean upper(int a, int b) {
        return tin[a]<=tin[b] && tout[a]>=tout[b];
    }

    int lca(int a, int b) {
        if (upper(a, b)) return a;
        if (upper(b, a)) return b;
        for (int i = logn-1; i>=0; i--) {
            if (!upper(up[a][i], b))
                a = up[a][i];
        }
        return up[a][0];
    }

    int log_2(int g) {
        int s = 1;
        int ans = 0;
        while (g>=s)
        {
            ans++;
            s*=2;
        }
        return ans;
    }

    int dsu_get(int v) {
        return p[v] == v? v : (p[v] = dsu_get(p[v]));
    }

    void dsu_unit(int a, int b) { // a or dsu_get(a)? what's your choice?
        if (a!=b) {
            if (size[b]>size[a])
            {
                int q = a;
                a = b;
                b = q;
            }
            p[b] = a;
            size[a]+=size[b];
        }
    }
    int gcd (int a, int b) {
        if (b == 0)
            return a;
        else
            return gcd (b, a % b);
    }
}

class forStr {
    int a, b, size;
    forStr(int a1, int b1, int size1) {
        a = a1;
        b = b1;
        size = size1;
    }
}
class Pair implements Comparable<Pair> {
    int x, y;
    Pair(int x1, int y1) {
        x = x1;
        y = y1;
    }

    @Override
    public int compareTo(Pair o) {
        return Integer.compare(x, o.x);
    }
}

class Lines implements Comparable<Lines> {
    int pos;
    boolean start;
    Lines(int x, boolean f) {
        pos = x;
        start = f;
    }

    @Override
    public int compareTo(Lines o) {
       return Integer.compare(pos, o.pos);
    }
}

class Vertex implements Comparable<Vertex> {
    int a, b, c;
    Vertex(int a1, int b1, int c1) {
        a = a1;
        b = b1;
        c = c1;
    }

    @Override
    public int compareTo(Vertex o) {
        return Integer.compare(a, o.a);
    }
}

class FUCKINGVERTEX implements Comparable<FUCKINGVERTEX> {
    int a, b, c, d;
    FUCKINGVERTEX(int a1, int b1, int c1, int d1) {
        a = a1;
        b = b1;
        c = c1;
        d = d1;
    }

    @Override
    public int compareTo(FUCKINGVERTEX o) {
        return Integer.compare(a, o.a);
    }
}
class FScanner {
    StringTokenizer st;
    BufferedReader reader;
    FScanner(InputStreamReader isr) throws IOException {
        reader = new BufferedReader(isr);
    }

    String nextLine() throws IOException {
        return reader.readLine();
    }

    String nextToken() throws IOException{
        while (st == null || !st.hasMoreTokens()) {
            String s = reader.readLine();
            if (s == null)
                return null;
            st = new StringTokenizer(s);
        }
        return st.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    char nextChar() throws IOException {
        return (char) reader.read();
    }
}

import java.util.*;
import java.awt.Point;
import java.io.*;

public class C{
	public static void main(String[] args) {
		FastScannerC sc = new FastScannerC(System.in);

		int N = sc.nextInt();

		StringBuilder sb = new StringBuilder();

		if(N < 100000){
			for(int i = 0 ; i <= N ; i++){
				sb.append('s');
			}
		}
		else{
			for(int i = 0 ; i < N ; i++){
				sb.append('s');
			}
		}

		System.out.println(sb.toString());

	}

}

class FastScannerC{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastScannerC(InputStream stream)
    {
        this.stream = stream;
    }

    public int read()
    {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars)
        {
            curChar = 0;
            try
            {
                numChars = stream.read(buf);
            } catch (IOException e)
            {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-')
        {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do
        {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String next()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do
        {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public String nextLine()
    {
        int c = read();
        StringBuilder res = new StringBuilder();
        do
        {
            res.appendCodePoint(c);
            c = read();
        } while (!isLineEndChar(c));
        return res.toString();
    }

    public double nextDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        double res = 0;
        while (!isSpaceChar(c) && c != '.') {
            if (c == 'e' || c == 'E')
                return res * Math.pow(10, nextInt());
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        }
        if (c == '.') {
            c = read();
            double m = 1;
            while (!isSpaceChar(c)) {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                m /= 10;
                res += (c - '0') * m;
                c = read();
            }
        }
        return res * sgn;
    }

    public long nextLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public boolean isLineEndChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == '\n' || c == '\r' || c == -1;
    }

    public interface SpaceCharFilter
    {
        public boolean isSpaceChar(int ch);
    }
}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class CF431C {
	static List<Integer> ans = new ArrayList<>();

	static void rec(int n) {
		if (n != 0) {
			int max = max(n);
			ans.add(max);
			rec(n - (max * max + max) / 2);
		}
	}

	static int max(int n) {
		for (int i = 0; i < n + 2; i++)
			if (n - (i * (i + 1)) / 2 < 0)
				return i - 1;
		return 0;
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt(), ch = 'a';
		rec(n);
		StringBuilder sb = new StringBuilder();
		for (int i : ans) {
			for (int j = 0; j <= i; j++)
				sb.append((char) ch);
			ch++;
		}
		System.out.println(n == 0 ? 0 : sb);
	}
}

import java.io.*;
import java.util.*;
import java.util.Map.*;

/**
 * Ariana Herbst, 9/1/2017
 */

public class cfs431C {

    public static void main(String[] args) {
        StringBuilder ans = new StringBuilder();
        FastScanner sc = new FastScanner();
        int k = sc.nextInt();
        ArrayList<Integer> numsToUse = new ArrayList<Integer>();
        numsToUse.add(0);
        numsToUse.add(0);
        int curr = 1;
        int dx = 2;
        while (curr < k) {
            numsToUse.add(curr);
            curr += dx;
            dx++;
        }
        Map<Integer, Integer> count = new HashMap<Integer, Integer>();
        int index = 0;
        int i = numsToUse.size()-1;
        while (k != 0) {
            if (numsToUse.get(i) <= k) {
                k -= numsToUse.get(i);
                count.put(index, i);
                index++;
            } else {
                i--;
            }
        }
        for (Entry<Integer, Integer> entry : count.entrySet()) {
            for (int j = 0; j < entry.getValue(); j++) {
                ans.append((char)('a' + entry.getKey()));
            }
        }
        System.out.println(ans);
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }

        public FastScanner() {
            this(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String readNextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        int[] readIntArray(int n) {
            int[] a = new int[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextInt();
            }
            return a;
        }

        long[] readLongArray(int n) {
            long[] a = new long[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextLong();
            }
            return a;
        }
    }

}

import java.util.Scanner;
public class A{
   static int c =0,j=0;
   static char x='a',y='b';
    public static void main(String[] args)throws Exception {
    int T =0 ;
    Scanner in = new Scanner (System.in);
    T=in.nextInt();

      in.close();
    int count=0;
    String str="";
        for (int i = 0; i <= T+1; i++) {
            if(T==0){System.out.println("ab");
                break;}
            else if (count==T){
                System.out.println(str);
                break;}
            else if ((count+(i*2))<=T){
            count=count+i*2;
            str=str+"ab";}
            else if ((count+(i))<=T){
            count=count+i;
            str=str+"a";}
            else {
            j=0;c=0;
            x=(char)(y+2);
            ++y;
         //   System.out.println(x +""+y);
            str=str+find(T-count);
                count=c+count;
            }

        }

    }

    public static String find (int n){

        String s;
    if (n==0)return"";
    else if ((c+j*2)<=n){
            c=c+j*2;
            j++;
            s=x+""+y+""+find(n-c);
            return s;}
    else if ((c+j)<=n){
            c=c+j;
            j++;
            s=""+x+""+find(n-c);
            return s;}

    else return s=find(n-c);
  }
}

/*
From beginning till end, this message has been waiting to be conveyed.

For a given unordered multiset of n lowercase English letters ("multi" means that a letter may appear more than once), we treat all letters as strings of length 1, and repeat the following operation n - 1 times:

    Remove any two elements s and t from the set, and add their concatenation s + t to the set.

The cost of such operation is defined to be , where f(s, c) denotes the number of times character c appears in string s.

Given a non-negative integer k, construct any valid non-empty set of no more than 100 000 letters, such that the minimum accumulative cost of the whole process is exactly k. It can be shown that a solution always exists.
Input

The first and only line of input contains a non-negative integer k (0 ≤ k ≤ 100 000) — the required minimum cost.
Output

Output a non-empty string of no more than 100 000 lowercase English letters — any multiset satisfying the requirements, concatenated to be a string.

Note that the printed string doesn't need to be the final concatenated string. It only needs to represent an unordered multiset of letters.

Note

For the multiset {'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b'}, one of the ways to complete the process is as follows:

    {"ab", "a", "b", "a", "b", "a", "b"}, with a cost of 0;
    {"aba", "b", "a", "b", "a", "b"}, with a cost of 1;
    {"abab", "a", "b", "a", "b"}, with a cost of 1;
    {"abab", "ab", "a", "b"}, with a cost of 0;
    {"abab", "aba", "b"}, with a cost of 1;
    {"abab", "abab"}, with a cost of 1;
    {"abababab"}, with a cost of 8.

The total cost is 12, and it can be proved to be the minimum cost of the process.
*/

import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {
	private static FastScanner sc = new FastScanner();

	public static void main(String[] args) {
		int[] sums = new int[500];
		for(int i=2; i<500; i++) {
			sums[i] = sums[i-1] + (i-1);
		}

		int k = sc.nextInt();
		char c = 'a';
		String s = "";
		while(k > 0) {
			int i = 1;
			for(; i<500; i++) {
				if(sums[i] > k) {
					i--;
					break;
				}
			}

			k -= sums[i];
			for(int j=0; j<i; j++) {
				s += c;
			}
			c++;
		}

		System.out.println(s);
	}

	static class FastScanner {
        private final InputStream in = System.in;
        private final byte[] buffer = new byte[1024];
        private int ptr = 0;
        private int buflen = 0;
        private boolean hasNextByte() {
            if(ptr < buflen) {
                return true;
            } else {
                ptr = 0;
                try {
                    buflen = in.read(buffer);
                } catch(IOException e) {
                    e.printStackTrace();
                }
                if(buflen <= 0) {
                    return false;
                }
            }
            return true;
        }
        private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
        private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
        private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
        public boolean hasNext() { skipUnprintable(); return hasNextByte();}
        public String next() {
            if (!hasNext()) throw new NoSuchElementException();
            StringBuilder sb = new StringBuilder();
            int b = readByte();
            while(isPrintableChar(b)) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public int nextInt(){
            return Integer.parseInt(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    }
}

import java.util.Scanner;

public class ProblemC {

	public static long[] cost=new long[10001];
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();

		for (int i=0; i<10000; i++) {
			calcCost(i);
			//System.err.println(cost[i]);
		}
		StringBuilder sb=new StringBuilder("");
		char l='a';
		while (n>0) {
			int k=0;
			while (cost[k]<=n) {
				k++;
			}
			k--;
			n-=cost[k];
			for (int i=0; i<k; i++) {
				sb.append(""+l);
			}
			l++;
			//System.out.println(n);
		}
		System.out.println(sb);
	}

	public static long calcCost(int i) {
		if (cost[i]!=0) {
			return cost[i];
		}
		if (i<2) {
			return 0;
		}
		int firstHalf=i/2;

		return cost[i]=2*calcCost(firstHalf)+firstHalf*firstHalf+(i%2==0?0:i);
	}

}

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class CF431C {
	static List<Integer> ans = new ArrayList<>();

	static void rec(int n) {
		if (n != 0) {
			int max = max(n);
			ans.add(max);
			rec(n - (max * max + max) / 2);
		}
	}

	static int max(int n) {
		for (int i = 0;; i++)
			if (n - (i * i + i) / 2 < 0)
				return i - 1;
	}

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt(), c = 'a';
		rec(n);
		StringBuilder sb = new StringBuilder();
		for (int i : ans) {
			for (int j = 0; j <= i; j++)
				sb.append((char) c);
			c++;
		}
		System.out.println(n == 0 ? '0' : sb);
	}
}

        import java.io.*;
        import java.lang.reflect.Array;
        import java.util.*;
        import java.lang.*;
        import static java.lang.Math.*;
        public class main implements Runnable {

            static ArrayList<Integer> adj[];

            static void Check2(int n) {
                adj = new ArrayList[n + 1];
                for (int i = 0; i <= n; i++) {
                    adj[i] = new ArrayList<>();
                }

            }
            static void add(int i, int j)
            {
                adj[i].add(j);
                adj[j].add(i);
            }

            public static void main(String[] args) {
                new Thread(null, new main(), "Check2", 1 << 26).start();// to increse stack size in java
            }
            static long mod = (long) (1e9 + 7);
            public void run() {
                InputReader in = new InputReader(System.in);
                PrintWriter w = new PrintWriter(System.out);

                int co=1;
                char c='a';
                String ans="";
                ans=ans+c;
                int k=in.nextInt();
                while (k>0){

                    if(co>k){

                        k--;
                        co=1;

                        c++;
                        ans=ans+c;

                    }
                    else{
                        k-=co;
                        ans=ans+c;
                        co++;
                    }

                }
                w.println(ans);

                w.close();
            }

/*            static class cmp implements Comparator<pair>{

                public int compare(pair o1,pair o2){

                    return o1.b<o2.b?-1:o1.b>o2.b?1:0;
                }

            }*/
            static class pair {

              long x,y;
                pair(int a,long b){

                    x=a;
                    y=b;
                }
              /*  public boolean equals(Object obj) {      //  override equals method for object to remove tem from arraylist and sets etc.......
                    if (this == obj)
                        return true;
                    if (obj == null)
                        return false;
                    if (getClass() != obj.getClass())
                        return false;
                    pair other = (pair) obj;
                    if (b!= other.b||a!=other.a)
                        return false;
                    return true;
                }
        */
            }

            static long modinv(long a,long b)
            {
                long p=power(b,mod-2);

                p=a%mod*p%mod;
                p%=mod;

                return p;

            }

            static long power(long x,long y){
                if(y==0)return 1%mod;
                if(y==1)return x%mod;

                long res=1;
                x=x%mod;
                while(y>0){

                    if((y%2)!=0){
                        res=(res*x)%mod;
                    }

                    y=y/2;
                    x=(x*x)%mod;
                }

                return res;

            }
            static  int gcd(int a,int b){

                if(b==0)return a;
                return gcd(b,a%b);
            }

            static  void sev(int a[],int n){

                for(int i=2;i<=n;i++)a[i]=i;
                for(int i=2;i<=n;i++){

                    if(a[i]!=0){
                        for(int j=2*i;j<=n;){

                            a[j]=0;
                            j=j+i;
                        }
                    }

                }

            }

            static class node{

                int y;
                int val;

                node(int a,int b){

                    y=a;
                    val=b;

                }

            }

            static class InputReader
            {
                private InputStream stream;
                private byte[] buf = new byte[1024];
                private int curChar;
                private int numChars;
                private SpaceCharFilter filter;

                public InputReader(InputStream stream)
                {
                    this.stream = stream;
                }

                public int read()
                {
                    if (numChars==-1)
                        throw new InputMismatchException();

                    if (curChar >= numChars)
                    {
                        curChar = 0;
                        try
                        {
                            numChars = stream.read(buf);
                        }
                        catch (IOException e)
                        {
                            throw new InputMismatchException();
                        }

                        if(numChars <= 0)
                            return -1;
                    }
                    return buf[curChar++];
                }

                public String nextLine()
                {
                    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                    String str = "";
                    try
                    {
                        str = br.readLine();
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                    return str;
                }
                public int nextInt()
                {
                    int c = read();

                    while(isSpaceChar(c))
                        c = read();

                    int sgn = 1;

                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }

                    int res = 0;
                    do
                    {
                        if(c<'0'||c>'9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    while (!isSpaceChar(c));

                    return res * sgn;
                }

                public long nextLong()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    int sgn = 1;
                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }
                    long res = 0;

                    do
                    {
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    while (!isSpaceChar(c));
                    return res * sgn;
                }

                public double nextDouble()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    int sgn = 1;
                    if (c == '-')
                    {
                        sgn = -1;
                        c = read();
                    }
                    double res = 0;
                    while (!isSpaceChar(c) && c != '.')
                    {
                        if (c == 'e' || c == 'E')
                            return res * Math.pow(10, nextInt());
                        if (c < '0' || c > '9')
                            throw new InputMismatchException();
                        res *= 10;
                        res += c - '0';
                        c = read();
                    }
                    if (c == '.')
                    {
                        c = read();
                        double m = 1;
                        while (!isSpaceChar(c))
                        {
                            if (c == 'e' || c == 'E')
                                return res * Math.pow(10, nextInt());
                            if (c < '0' || c > '9')
                                throw new InputMismatchException();
                            m /= 10;
                            res += (c - '0') * m;
                            c = read();
                        }
                    }
                    return res * sgn;
                }

                public String readString()
                {
                    int c = read();
                    while (isSpaceChar(c))
                        c = read();
                    StringBuilder res = new StringBuilder();
                    do
                    {
                        res.appendCodePoint(c);
                        c = read();
                    }
                    while (!isSpaceChar(c));

                    return res.toString();
                }

                public boolean isSpaceChar(int c)
                {
                    if (filter != null)
                        return filter.isSpaceChar(c);
                    return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
                }

                public String next()
                {
                    return readString();
                }

                public interface SpaceCharFilter
                {
                    public boolean isSpaceChar(int ch);
                }
            }

        }

import java.io.*;
import java.util.*;
import java.math.*;
public class A {
	public static void main(String[] args)throws IOException {
		FastIO sc = new FastIO(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int k = sc.nextInt();
		String alph = "abcdefghijklmnopqrstuvwxyz";
		int arr[] = new int[26];
		Arrays.fill(arr, 0);
		int idx = 0;
		while(k>0) {
			int a = 1;
			while((a*a-a)/2<=k) {
				a++;
			}
			a--;
			k-=(a*a-a)/2;
			arr[idx] = a;
			idx++;
		}
		for(int i=0; i<26; ++i) {
			for(int j=0; j<arr[i]; ++j) {
				System.out.print(alph.charAt(i));
			}
		}
		out.close();
	}
	static class FastIO {
		InputStream dis;
		byte[] buffer = new byte[1 << 17];
		int pointer = 0;
		public FastIO(String fileName) throws IOException {
			dis = new FileInputStream(fileName);
		}
		public FastIO(InputStream is) throws IOException {
			dis = is;
		}
		int nextInt() throws IOException {
			int ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}

			return (negative) ? -ret : ret;
		}
		long nextLong() throws IOException {
			long ret = 0;

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			boolean negative = false;
			if (b == '-') {
				negative = true;
				b = nextByte();
			}
			while (b >= '0' && b <= '9') {
				ret = 10 * ret + b - '0';
				b = nextByte();
			}
			return (negative) ? -ret : ret;
		}
		byte nextByte() throws IOException {
			if (pointer == buffer.length) {
				dis.read(buffer, 0, buffer.length);
				pointer = 0;
			}
			return buffer[pointer++];
		}
		String next() throws IOException {
			StringBuffer ret = new StringBuffer();

			byte b;
			do {
				b = nextByte();
			} while (b <= ' ');
			while (b > ' ') {
				ret.appendCodePoint(b);
				b = nextByte();
			}

			return ret.toString();
		}
	}
}

import java.util.Scanner;
public class A{
   static int c =0,j=0;
   static char x='a',y='b';
    public static void main(String[] args)throws Exception {
    int T =0 ;
    Scanner in = new Scanner (System.in);
    T=in.nextInt();

      in.close();
    int count=0;
    String str="";
        for (int i = 0; i <= T+1; i++) {
            if(T==0){System.out.println("ab");
                break;}
            else if (count==T){
                System.out.println(str);
                break;}
            else if ((count+(i*2))<=T){
            count=count+i*2;
            str=str+"ab";}
            else if ((count+(i))<=T){
            count=count+i;
            str=str+"a";}
            else {
            j=0;c=0;
            x=(char) (y+2);
            ++y;
            str=str+find(T-count);
                count=c+count;
            }

        }

    }

    public static String find (int n){

        String s;
    if (n==0)return"";
    else if ((c+j*2)<=n){
            c=c+j*2;
            j++;
            s=x+y+find(n-c);
            return s;}
    else if ((c+j)<=n){
            c=c+j;
            j++;
            s=x+find(n-c);
            return s;}

    else return s=find(n-c);
  }
}

/*
From beginning till end, this message has been waiting to be conveyed.

For a given unordered multiset of n lowercase English letters ("multi" means that a letter may appear more than once), we treat all letters as strings of length 1, and repeat the following operation n - 1 times:

    Remove any two elements s and t from the set, and add their concatenation s + t to the set.

The cost of such operation is defined to be , where f(s, c) denotes the number of times character c appears in string s.

Given a non-negative integer k, construct any valid non-empty set of no more than 100 000 letters, such that the minimum accumulative cost of the whole process is exactly k. It can be shown that a solution always exists.
Input

The first and only line of input contains a non-negative integer k (0 ≤ k ≤ 100 000) — the required minimum cost.
Output

Output a non-empty string of no more than 100 000 lowercase English letters — any multiset satisfying the requirements, concatenated to be a string.

Note that the printed string doesn't need to be the final concatenated string. It only needs to represent an unordered multiset of letters.

Note

For the multiset {'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b'}, one of the ways to complete the process is as follows:

    {"ab", "a", "b", "a", "b", "a", "b"}, with a cost of 0;
    {"aba", "b", "a", "b", "a", "b"}, with a cost of 1;
    {"abab", "a", "b", "a", "b"}, with a cost of 1;
    {"abab", "ab", "a", "b"}, with a cost of 0;
    {"abab", "aba", "b"}, with a cost of 1;
    {"abab", "abab"}, with a cost of 1;
    {"abababab"}, with a cost of 8.

The total cost is 12, and it can be proved to be the minimum cost of the process.
*/

import java.util.Scanner;

public class a {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		StringBuilder sb = new StringBuilder();
		int ptr = 10000;
		char letter = 'a';
		while(n > 0) {
			if(ptr*(ptr-1)/2 > n) {
				ptr--;
				continue;
			}
			for(int i=0;i<ptr;i++) {
				sb.append(letter);
			}
			letter++;
			n -= ptr*(ptr-1)/2;
		}
		System.out.println(sb);
	}
}

import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import java.io.*;

public class Main {
    double eps = 0.0000001;

    public class point {
        int t, d, p;

        point(int a, int b, int c) {
            t = a;
            d = b;
            p = c;
        }
    }

    public void solve() throws IOException {
        int k = nextInt();
        char t = 'a';
        while (k > 0) {
            int z = (int) Math.sqrt(k);
            while (z * (z + 1) / 2 <= k) {
                z++;
            }
            for(int i = 0; i < z; i++){
                out.print(t);
            }
            k -= z * (z - 1) / 2;
            t++;
        }
    }

    BufferedReader br;
    StringTokenizer sc;
    PrintWriter out;

    public String nextToken() throws IOException {
        while (sc == null || !sc.hasMoreTokens()) {
            try {
                sc = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return sc.nextToken();
    }

    public boolean hasNext() throws IOException {
        while (sc == null || !sc.hasMoreTokens()) {
            try {
                sc = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return false;
            }
        }
        return true;
    }

    public Integer nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    public Long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    public Double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    public static void main(String[] args) throws IOException {
        try {
            Locale.setDefault(Locale.US);
        } catch (Exception e) {
        }
        new Main().run();
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
//            br = new BufferedReader(new FileReader("shooting.in"));
//            out = new PrintWriter(new File("shooting.out"));
            solve();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
}

import java.io.*;
import java.util.*;

public class Main {
	public static void main(String[] args) throws Exception {
		new Main().solve();
	}

	private void solve() throws Exception {
		reader = new BufferedReader(new InputStreamReader(System.in));

		k = Integer.parseInt(reader.readLine());

		reader.close();

		int code = 97;
		while (k > 0) {

			int c = (1 + (int)Math.sqrt(1 + 8 * k)) / 2;
			k -= (c * (c - 1)) / 2;

			for (int j = 0; j < c; ++j) {
				sb.append(Character.toString((char)code));
			}

			code++;
		}

		System.out.println(sb);
	}

	private BufferedReader reader;
	private int k;
	private StringBuilder sb = new StringBuilder();
}

import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;

import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int k = in.nextInt();
        if (k == 0) {
            System.out.println("a");
        } else {
            for (char i = 'a'; i <= 'z'; ++i) {
                int n = 0;
                while (n * (n + 1) / 2 < k) {
                    ++n;
                    System.out.print(i);
                }
                --n;
                k -= n * (n + 1) / 2;
            }
        }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author @Sandip_Jana
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            String res = "";
            char ch = 'a';
            while (n > 0) {
                int start = 1;
                int take = 0;
                while (true) {
                    long ok = (start * 1L * (start - 1)) / 2;
                    if (ok <= n) {
                        take = start;
                        ++start;
                    } else
                        break;
                }
                for (int i = 1; i <= take; i++) res += (ch);
                n -= ((take * 1L * (take - 1)) / 2);
                ch++;
            }
            out.println(res);
        }

    }
}

public class A {

	public A () {
		int Y = 10000;
		long [] Z = new long [Y+1]; Z[1] = 0;
		for (int i : rep(1, Y))
			Z[i+1] = Z[i] + i;

		int K = sc.nextInt(); char s = 'a';
		StringBuffer res = new StringBuffer();

		if (K == 1)
			exit('z');

		for (int j : sep(2, Y))
			while (K >= Z[j]) {
				for (@SuppressWarnings("unused") int i : rep(j))
					res.append(s);
				++s; K -= Z[j];
			}

		exit(res);
	}

	private static int [] rep(int N) { return rep(0, N); }
	private static int [] rep(int S, int T) { if (T <= S) return new int [0]; int [] res = new int [T-S]; for (int i = S; i < T; ++i) res[i-S] = i; return res; }
	private static int [] sep(int S, int T) { if (T <= S) return new int [0]; int [] res = new int [T-S]; for (int i = S; i < T; ++i) res[T-1-i] = i; return res; }
	////////////////////////////////////////////////////////////////////////////////////
	private final static IOUtils.MyScanner sc = new IOUtils.MyScanner();
	private static void exit (Object o, Object ... A) { IOUtils.print(o, A); IOUtils.exit(); }
	private static class IOUtils {
		public static class MyScanner {
			public String next() { newLine(); return line[index++]; }
			public int nextInt() { return Integer.parseInt(next()); }
			//////////////////////////////////////////////
			private boolean eol() { return index == line.length; }
			private String readLine() {
				try {
					return r.readLine();
				} catch (Exception e) {
					throw new Error (e);
				}
			}
			private final java.io.BufferedReader r;
			private MyScanner () { this(new java.io.BufferedReader(new java.io.InputStreamReader(System.in))); }
			private MyScanner (java.io.BufferedReader r) {
				try {
					this.r = r;
					while (!r.ready())
						Thread.sleep(1);
					start();
				} catch (Exception e) {
					throw new Error(e);
				}
			}
			private String [] line;
			private int index;
			private void newLine() {
				if (line == null || eol()) {
					line = split(readLine());
					index = 0;
				}
			}
			private String [] split(String s) { return s.length() > 0 ? s.split(" ") : new String [0]; }
		}
		private static String build(Object o, Object ... A) { return buildDelim(" ", o, A); }
		private static String buildDelim(String delim, Object o, Object ... A) {
			StringBuilder b = new StringBuilder();
			append(b, o, delim);
			for (Object p : A)
				append(b, p, delim);
			return b.substring(delim.length());
		}
		//////////////////////////////////////////////////////////////////////////////////
		private static void start() { if (t == 0) t = millis(); }
		private static void append(StringBuilder b, Object o, String delim) {
			if (o.getClass().isArray()) {
				int len = java.lang.reflect.Array.getLength(o);
				for (int i = 0; i < len; ++i)
					append(b, java.lang.reflect.Array.get(o, i), delim);
			} else if (o instanceof Iterable<?>)
				for (Object p : (Iterable<?>) o)
					append(b, p, delim);
			else {
				if (o instanceof Double)
					o = new java.text.DecimalFormat("#.############").format(o);
				b.append(delim).append(o);
			}
		}
		private static java.io.PrintWriter pw = new java.io.PrintWriter(System.out);
		private static void print(Object o, Object ... A) { pw.println(build(o, A)); }
		private static void err(Object o, Object ... A) { System.err.println(build(o, A)); }
		private static void exit() {
			IOUtils.pw.close();
			System.out.flush();
			err("------------------");
			err(IOUtils.time());
			System.exit(0);
		}
		private static long t;
		private static long millis() { return System.currentTimeMillis(); }
		private static String time() { return "Time: " + (millis() - t) / 1000.0; }
	}
	public static void main (String[] args) { new A(); IOUtils.exit(); }
}

import java.io.*;
import java.util.*;

public class A {

	static InputStream is;

	public static void main(String[] args) throws IOException {
		is = System.in;
		int k = ni();
		long[] costs =new long[100001];
		for(int i =2; i < costs.length; i++){
			costs[i] = costs[i-1]+i-1;
		}
		StringBuilder ans = new StringBuilder();

		char at = 'a';

		while(k > 0){
			int amount = 2;
			while(costs[amount] <= k) amount++;
			amount--;
			k -= costs[amount];
			while(amount-->0){
				ans.append(at);
			}
			at++;
		}
		System.out.println(ans);

	}

	private static byte[] inbuf = new byte[1024];
	public static int lenbuf = 0, ptrbuf = 0;

	private static int readByte()
	{
		if(lenbuf == -1)throw new InputMismatchException();
		if(ptrbuf >= lenbuf){
			ptrbuf = 0;
			try { lenbuf = is.read(inbuf); } catch (IOException e) { throw new InputMismatchException(); }
			if(lenbuf <= 0)return -1;
		}
		return inbuf[ptrbuf++];
	}

	private static boolean isSpaceChar(int c) { return !(c >= 33 && c <= 126); }
	private static int skip() { int b; while((b = readByte()) != -1 && isSpaceChar(b)); return b; }

	private static double nd() { return Double.parseDouble(ns()); }
	private static char nc() { return (char)skip(); }

	private static String ns()
	{
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while(!(isSpaceChar(b))){ // when nextLine, (isSpaceChar(b) && b != ' ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	private static char[] ns(int n)
	{
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while(p < n && !(isSpaceChar(b))){
			buf[p++] = (char)b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}

	private static char[][] nm(int n, int m)
	{
		char[][] map = new char[n][];
		for(int i = 0;i < n;i++)map[i] = ns(m);
		return map;
	}

	private static int[] na(int n)
	{
		int[] a = new int[n];
		for(int i = 0;i < n;i++)a[i] = ni();
		return a;
	}

	private static int ni()
	{
		int num = 0, b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

	private static long nl()
	{
		long num = 0;
		int b;
		boolean minus = false;
		while((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'));
		if(b == '-'){
			minus = true;
			b = readByte();
		}

		while(true){
			if(b >= '0' && b <= '9'){
				num = num * 10 + (b - '0');
			}else{
				return minus ? -num : num;
			}
			b = readByte();
		}
	}

}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Solution {
    static MyScanner sc;
    private static PrintWriter out;
    static long M2 = 1_000_000_000L + 7;

    public static void main(String[] s) throws Exception {
        StringBuilder stringBuilder = new StringBuilder();
//        stringBuilder.append("100000 1000000000 10001 100000 ");
//        for (int i = 1; i < 100000; i++) {
//            stringBuilder.append(" 10000 100000 ");
//        }
        if (stringBuilder.length() == 0) {
            sc = new MyScanner(System.in);
        } else {
            sc = new MyScanner(new BufferedReader(new StringReader(stringBuilder.toString())));
        }

        out = new PrintWriter(new OutputStreamWriter(System.out));
        initData();
        solve();
        out.flush();
    }

    private static void initData() {

    }

    private static void solve() throws IOException {
        int n = sc.nextInt();
        char l = 'a';
        while (n > 0) {
            int s = 2;
            while (n >= (s + 1) * (s) / 2) {
                s++;
            }
            for (int i = 0; i < s; i++) {
                out.print(l);
            }
            l++;
            n -= s * (s - 1) / 2;
        }

    }

    private static void solveT() throws IOException {
        int t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    private static long gcd(long l, long l1) {
        if (l > l1) return gcd(l1, l);
        if (l == 0) return l1;
        return gcd(l1 % l, l);
    }

    private static long pow(long a, long b, long m) {
        if (b == 0) return 1;
        if (b == 1) return a;
        long pp = pow(a, b / 2, m);
        pp *= pp;
        pp %= m;
        return (pp * (b % 2 == 0 ? 1 : a)) % m;
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        MyScanner(BufferedReader br) {
            this.br = br;
        }

        public MyScanner(InputStream in) {
            this(new BufferedReader(new InputStreamReader(in)));
        }

        void findToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        String next() {
            findToken();
            return st.nextToken();
        }

        Integer[] nab(int n) {
            Integer[] k = new Integer[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        int[] na(int n) {
            int[] k = new int[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        long[] nl(int n) {
            long[] k = new long[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.nextLong();
            }
            return k;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        int fi() {
            String t = next();
            int cur = 0;
            boolean n = t.charAt(0) == '-';
            for (int a = n ? 1 : 0; a < t.length(); a++) {
                cur = cur * 10 + t.charAt(a) - '0';
            }
            return n ? -cur : cur;
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }

}

import java.io.*;
import java.util.*;

public class Main {
    static FastScanner in;
    static PrintWriter out;
    static final int MOD = 1000000007;

    public static void main(String[] args) throws IOException {
        //        Scanner in = new Scanner(new File("input.txt"));
        //        Scanner in = new Scanner(System.in);
        //        System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream("output.txt")), true));
        out = new PrintWriter(System.out);
        in = new FastScanner(System.in);
        //        in = new FastScanner("input.txt");
        long k = in.nextLong();
        long f[] = new long[100001];
        TreeMap<Long, Integer> map = new TreeMap<Long, Integer>();
        for (int i = 0; i <= 100000; i++) {
            f[i] = i * (i - 1) / 2;
            map.put(f[i], i);
        }
        StringBuilder sb = new StringBuilder();
        char c = 'a';
        while (k != 0) {
            long key = map.floorKey(k);
            for (int i = 0; i < map.get(key); i++) {
                sb.append(c);
            }
            c++;
            k -= key;
        }
        out.println(sb.toString());
        out.close();
    }
}

class Pair {
    public double first; //first member of pair
    public double second; //second member of pair

    public Pair(double first, double second) {
        this.first = first;
        this.second = second;
    }

    public Pair() {

    }

    @Override
    public boolean equals(Object o) {
        if (this == o)
            return true;
        if (!(o instanceof Pair))
            return false;
        Pair p = (Pair) o;
        return first == p.first && second == p.second;
    }

    @Override
    public int hashCode() {
        int result = (int) first;
        result = 31 * result + (int) second;
        return result;
    }
}

class FastScanner {

    BufferedReader br;
    StringTokenizer tokenizer;

    FastScanner(String fileName) throws FileNotFoundException {
        this(new FileInputStream(new File(fileName)));
    }

    FastScanner(InputStream is) {
        br = new BufferedReader(new InputStreamReader(is));
    }

    String nextLine() throws IOException {
        tokenizer = null;
        return br.readLine();
    }

    String next() throws IOException {
        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
            String line = br.readLine();
            if (line == null) {
                return null;
            }
            tokenizer = new StringTokenizer(line);
        }
        return tokenizer.nextToken();
    }

    int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    long nextLong() throws IOException {
        return Long.parseLong(next());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }

    char nextChar() throws IOException {
        return next().charAt(0);
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int k = in.nextInt();
            for (char i = 'a'; i <= 'z' && k != 0; i++) {
                int low = 1;
                int high = 1000;
                while (low < high) {
                    int mid = (low + high + 1) >> 1;
                    if (((mid) * (mid - 1)) / 2 <= k) {
                        low = mid;
                    } else {
                        high = mid - 1;
                    }
                }
                k -= (low * (low - 1)) / 2;
                for (int j = 0; j < low; j++) {
                    out.print(i);
                }
            }
        }

    }

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

    }
}

import java.io.*;
import java.util.*;

public class C {

    public static void main(String[] args) {
        	Scanner in = new Scanner(System.in);
	    	PrintWriter out = new PrintWriter(System.out);
			int k = in.nextInt();
            int[] kol = new int[500];
            int dob = 1;
            for (int i = 1 ; i < 500 ; i++) {
                kol[i] = kol[i - 1] + dob;
                dob += 1;
            }
            if (k == 0) {
                out.println("a");
                return;
            }
            char letter = 'a';
            StringBuilder sb = new StringBuilder("");
            while (k > 0) {
                int i = 0;
                while (i < 500 && kol[i] <= k) i += 1;
                i -= 1;
                k -= kol[i];
                for (int j = 0 ; j <= i ; j++) sb.append(letter);
                letter += 1;
            }
            out.println(sb.toString());
			out.close();
    }
}

import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Random;
import java.util.StringTokenizer;

public class letsgooo implements Runnable {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new Thread(null, new letsgooo(), ":)", 1 << 28).start();
	}

	static FS in;
	static int mod = (int) 1e9 + 7;
	static int[] dx = new int[] { -1, 0, 0, 1 };
	static int[] dy = new int[] { 0, -1, 1, 0 };

	@Override
	public void run() {
		// TODO Auto-generated method stub
		try {
			in = new FS(System.in);
			PrintWriter out = new PrintWriter(System.out);
			long k = in.nextLong();
				boolean found = false;
				for (long a = 0; a < 100000&&!found; a++) {
					if (k - answer(a) < 0)
						break;
					for (long b = 0; b<=a&&b < 100000&&!found; b++) {
						if (k - answer(a) - answer(b) < 0)
							break;
						for (long c = 0; c<=b&&c < 100000&&!found; c++) {
							if (k - answer(a) - answer(b) - answer(c) < 0)
								break;
							if (k == answer(a) + answer(b) + answer(c)) {
								found=true;
								StringBuilder sb = new StringBuilder();
								for(int i = 0; i < a; i++) {
									sb.append("a");
								}
								for(int i = 0; i < b; i++) {
									sb.append("b");
								}
								for(int i =0 ;i < c; i++) {
									sb.append("c");
								}
								System.out.println(sb.toString());
								return;
							}
						}
					}
				}
			out.close();
		} catch (Exception e) {
			throw e;
		}
	}

	public long answer(long x) {
		return (x * (x - 1)) / 2;
	}

	HashMap<Integer, Integer> min = new HashMap<Integer, Integer>();

	public int solve(int k) {
		int orik = k;
		if (min.containsKey(k))
			return min.get(k);
		int ans = Integer.MAX_VALUE / 3;
		for (int i = 1; i < 100000; i++) {
			k -= i;
			if (k < 0)
				break;
			ans = Math.min(ans, solve(k) + 1);
			if (k == 0) {
				ans = Math.min(ans, k);
				break;
			}
		}
		min.put(orik, ans);
		return ans;
	}

	private static class Trie {
		Trie[] sub;
		int count = 0;
		String val;

		public Trie() {
			sub = new Trie[2];
		}

		public void add(String s) {
			count++;
			if (s == null || s.equals(""))
				return;
			// System.out.println("Adding "+s);
			int i = s.charAt(0) - '0';
			if (sub[i] == null) {
				sub[i] = new Trie();
				sub[i].val = "" + s.charAt(0);
			}
			sub[i].add(s.substring(1));
		}

		public String findminxor(String alt) {
			if (alt == null || alt.equals(""))
				return "";
			int i = alt.charAt(0) - '0';
			if (sub[i] == null) {
				// fix this?
				return alt;
			}
			if (sub[i].count < Math.pow(2, alt.length() - 1)) {
				return i + "" + sub[i].findminxor(alt.substring(1));
			} else {
				if (sub[i ^ 1] == null) {
					return (i ^ 1) + alt.substring(1);
				}
				return (i ^ 1) + sub[i ^ 1].findminxor(alt.substring(1));
			}
		}
	}

	private static int[] cxor(int[] given) {
		int[] ans = new int[given.length + 1];
		for (int i = 1; i < ans.length; i++) {
			ans[i] = given[i - 1] ^ ans[i - 1];
		}
		return ans;
	}

	private static int circularqueryxor(int[] cxor, int x1, int x2) {
		// no rotate needed
		if (x2 < cxor.length)
			return querycxor(cxor, x1, x2);
		int ans = 0;
		// 1 to end
		ans = querycxor(cxor, x1 % (cxor.length - 1), cxor.length - 1);
		x1 += cxor.length - 1 - (x1 % (cxor.length - 1));
		int diff = x2 - x1;
		int iterations = diff / (cxor.length - 1);
		// wraparound
		if (iterations % 2 == 1) {
			ans ^= querycxor(cxor, 0, cxor.length - 1);
		}
		// start to 2
		ans ^= querycxor(cxor, 0, x2 % (cxor.length - 1));
		return ans;
	}

	private static int querycxor(int[] cxor, int x1, int x2) {
		return cxor[x2] ^ cxor[x1];
	}

	private static double[][][] csum(double[][][] given) {
		double[][][] ans = new double[given.length + 1][given[0].length + 1][given[0][0].length + 1];
		for (int i = 1; i < ans.length; i++) {
			for (int j = 1; j < ans[i].length; j++) {
				for (int k = 1; k < ans[i][j].length; k++) {
					ans[i][j][k] = given[i - 1][j - 1][k - 1] + ans[i - 1][j][k] + ans[i][j - 1][k] + ans[i][j][k - 1]
							- ans[i][j - 1][k - 1] - ans[i - 1][j][k - 1] - ans[i - 1][j - 1][k]
							+ ans[i - 1][j - 1][k - 1];
					// System.out.println(i+" "+j+" "+k+" "+ans[i][j][k]+"
					// "+given[i-1][j-1][k-1]);
				}
			}
		}
		return ans;
	}

	private static double querycsum(double[][][] csum, int x1, int y1, int z1, int x2, int y2, int z2) {
		if (x1 > x2 || y1 > y2 || z1 > z2)
			return 0;
		if (x1 < 0)
			x1 = 0;
		if (y1 < 0)
			y1 = 0;
		if (z1 < 0)
			z1 = 0;
		if (x2 < 0)
			x2 = 0;
		if (y2 < 0)
			y2 = 0;
		if (z2 < 0)
			z2 = 0;
		if (x1 >= csum.length)
			x1 = csum.length - 1;
		if (y1 >= csum[0].length)
			y1 = csum[0].length - 1;
		if (z1 >= csum[0][0].length)
			z1 = csum[0][0].length - 1;
		if (x2 >= csum.length)
			x2 = csum.length - 1;
		if (y2 >= csum[0].length)
			y2 = csum[0].length - 1;
		if (z2 >= csum[0][0].length)
			z2 = csum[0][0].length - 1;
		double inclusion = csum[x2][y2][z2];
		double exclusion = csum[x1][y2][z2] + csum[x2][y1][z2] + csum[x2][y2][z1];
		double innerinclusion = csum[x2][y1][z1] + csum[x1][y2][z1] + csum[x1][y1][z2];
		double innerexclusion = csum[x1][y1][z1];
		// System.out.println("("+x1+", "+y1+", "+z1+") -> ("+(x2-1)+",
		// "+(y2-1)+", "+(z2-1)+") = "+(inclusion - exclusion + innerinclusion -
		// innerexclusion));
		// System.out.println(inclusion+" "+exclusion+" "+innerinclusion+"
		// "+innerexclusion);
		return (inclusion - exclusion + innerinclusion - innerexclusion);
	}

	private static class DFA {
		ArrayList<DFANode> nodes;
		ArrayList<DFANode> start;
		ArrayList<DFANode> end;
		int alpha;

		DFA(int count, int alpha, int s, int e) {
			nodes = new ArrayList<DFANode>();
			this.alpha = alpha;
			for (int i = 0; i < count; i++) {
				nodes.add(new DFANode());
				nodes.get(nodes.size() - 1).idx = nodes.size() - 1;
			}
			start = new ArrayList<DFANode>();
			start.add(nodes.get(s));
			end = new ArrayList<DFANode>();
			end.add(nodes.get(e));
		}

		public void AddEdge(int s, int f, int letter) {
			nodes.get(s).transition[letter] = nodes.get(f);
		}

		public void Trim() {
			HashSet<DFANode> valid = new HashSet<DFANode>();
			valid.addAll(nodes);
			for (DFANode n : nodes) {
				for (int i = 0; i < n.transition.length; i++) {
					if (!valid.contains(n.transition[i]))
						n.transition[i] = null;
				}
			}
		}

		private class DFANode implements Comparable<DFANode> {
			DFANode[] transition;
			int idx;

			public DFANode() {
				transition = new DFANode[alpha];
			}

			@Override
			public int hashCode() {
				return idx;
			}

			@Override
			public String toString() {
				StringBuilder sb = new StringBuilder();
				sb.append(idx + ": <");
				for (int i = 0; i < transition.length; i++) {
					if (transition[i] != null) {
						sb.append(i + ":" + transition[i].idx + ",");
					}
				}
				sb.append(">");
				return sb.toString();
			}

			@Override
			public boolean equals(Object obj) {
				return ((DFANode) obj).toString().equals(toString());
			}

			@Override
			public int compareTo(DFANode arg0) {
				// TODO Auto-generated method stub
				return Integer.compare(idx, arg0.idx);
			}

		}

		private void removeUnreachable() {
			HashSet<DFANode> reached = new HashSet<DFANode>();
			ArrayDeque<DFANode> dq = new ArrayDeque<DFANode>();
			dq.addAll(start);
			reached.addAll(start);
			while (!dq.isEmpty()) {
				DFANode cur = dq.poll();
				for (DFANode next : cur.transition) {
					if (next == null)
						continue;
					if (!reached.contains(next)) {
						dq.add(next);
						reached.add(next);
					}
				}
			}
			ArrayList<DFANode> dupe = new ArrayList<DFANode>();
			ArrayList<DFANode> dupend = new ArrayList<DFANode>();
			ArrayList<DFANode> dupstart = new ArrayList<DFANode>();
			for (DFANode d : nodes) {
				if (reached.contains(d)) {
					dupe.add(d);
				}
			}
			for (DFANode d : end) {
				if (reached.contains(d)) {
					dupend.add(d);
				}
			}
			for (DFANode d : start) {
				if (reached.contains(d)) {
					dupstart.add(d);
				}
			}
			nodes = dupe;
			end = dupend;
			start = dupstart;
		}

		private void removeUnproductive() {
			HashSet<DFANode> reached = new HashSet<DFANode>();
			reached.addAll(end);
			boolean news = false;
			do {
				news = false;
				for (DFANode n : nodes) {
					if (reached.contains(n))
						continue;
					for (DFANode nn : n.transition) {
						if (nn == null)
							continue;
						if (reached.contains(nn)) {
							news = true;
							reached.add(n);
						}
					}
				}
			} while (news);
			ArrayList<DFANode> dupe = new ArrayList<DFANode>();
			ArrayList<DFANode> dupend = new ArrayList<DFANode>();
			ArrayList<DFANode> dupstart = new ArrayList<DFANode>();
			for (DFANode d : nodes) {
				if (reached.contains(d)) {
					dupe.add(d);
				}
			}
			for (DFANode d : end) {
				if (reached.contains(d)) {
					dupend.add(d);
				}
			}
			for (DFANode d : start) {
				if (reached.contains(d)) {
					dupstart.add(d);
				}
			}
			nodes = dupe;
			end = dupend;
			start = dupstart;
		}

		private void minimize() {
			number();

			Collections.sort(nodes);
			boolean[][] distinct = new boolean[nodes.size()][nodes.size()];
			for (int i = 0; i < nodes.size(); i++) {
				for (int j = i + 1; j < nodes.size(); j++) {
					boolean hasi = false;
					boolean hasj = false;
					for (DFANode n : end) {
						if (nodes.get(i).equals(n))
							hasi = true;
						if (nodes.get(j).equals(n))
							hasj = true;
					}
					if (hasi != hasj) {
						distinct[i][j] = true;
						distinct[j][i] = true;
					}
				}
			}
			boolean news = false;
			do {
				news = false;
				for (int i = 0; i < nodes.size(); i++) {
					for (int j = 0; j < nodes.size(); j++) {
						if (!distinct[i][j]) {
							for (int a = 0; a < nodes.get(i).transition.length; a++) {
								DFANode alpha = nodes.get(i).transition[a];
								DFANode beta = nodes.get(j).transition[a];
								if (alpha != beta) {
									if (alpha == null || beta == null || distinct[alpha.idx][beta.idx]) {
										distinct[i][j] = true;
										distinct[j][i] = true;
										news = true;
									}
								}
							}
						}
					}
				}
			} while (news);
			ArrayList<DFANode> cop = new ArrayList<DFANode>();
			cop.addAll(nodes);
			for (int i = 0; i < distinct.length; i++) {
				ArrayList<DFANode> needed = new ArrayList<DFANode>();
				needed.add(cop.get(i));
				for (int j = i + 1; j < distinct.length; j++) {
					if (!distinct[i][j]) {
						needed.add(cop.get(j));
					}
				}
				if (needed.size() > 1) {
					merge(needed);
				}
			}
			number();
		}

		@Override
		public String toString() {
			return start.toString() + " " + end.toString() + " " + nodes.toString();
		}

		public void number() {
			removeUnreachable();
			removeUnproductive();
			Trim();
			int num = 0;
			HashSet<DFANode> reached = new HashSet<DFANode>();
			ArrayDeque<DFANode> dq = new ArrayDeque<DFANode>();
			dq.addAll(start);
			reached.addAll(start);
			HashMap<Integer, DFANode> remap = new HashMap<Integer, DFANode>();
			while (!dq.isEmpty()) {
				DFANode cur = dq.poll();
				remap.put(num++, cur);
				for (DFANode next : cur.transition) {
					if (next == null)
						continue;
					if (!reached.contains(next)) {
						dq.add(next);
						reached.add(next);
					}
				}
			}
			for (Integer i : remap.keySet()) {
				remap.get(i).idx = i;
			}
			Collections.sort(nodes);
		}

		public void merge(ArrayList<DFANode> toMerge) {
			HashSet<DFANode> list = new HashSet<DFANode>();
			DFANode twopointoh = toMerge.get(0);
			list.addAll(toMerge);
			nodes.removeAll(list);
			nodes.add(twopointoh);
			if (start.removeAll(toMerge)) {
				start.add(twopointoh);
			}
			if (end.removeAll(toMerge)) {
				end.add(twopointoh);
			}
			for (DFANode n : nodes) {
				for (int i = 0; i < n.transition.length; i++) {
					if (list.contains(n.transition[i])) {
						n.transition[i] = twopointoh;
					}
				}
			}
		}

		@Override
		public boolean equals(Object o) {
			return ((DFA) o).toString().equals(toString());
		}

	}

	private static class RMQ2D {
		int[][][][] rmq;
		int[][] data;

		public RMQ2D(int[][] data) {
			this.data = data;
			int k1 = Integer.numberOfTrailingZeros(Integer.highestOneBit(data.length)) + 3;
			int k2 = Integer.numberOfTrailingZeros(Integer.highestOneBit(data[0].length)) + 3;
			rmq = new int[k1][k2][data.length][data[0].length];
			for (int i = 0; i < data.length; i++) {
				for (int j = 0; j < data[0].length; j++) {
					rmq[0][0][i][j] = data[i][j];
				}
			}
			for (int i = 0; i < k1; i++) {
				for (int j = 0; j < k2; j++) {
					if (i == 0 && j == 0)
						continue;
					for (int x = 0; x + (1 << i) - 1 < data.length; x++) {
						for (int y = 0; y + (1 << j) - 1 < data[0].length; y++) {
							if (j == 0) {
								rmq[i][j][x][y] = Math.min(rmq[i - 1][j][x][y], rmq[i - 1][j][x + (1 << (i - 1))][y]);
							} else {
								rmq[i][j][x][y] = Math.min(rmq[i][j - 1][x][y], rmq[i][j - 1][x][y + (1 << (j - 1))]);
							}
						}
					}
				}
			}
		}

		public int query(int x1, int y1, int x2, int y2) {
			int i = (int) (Math.log(x2 - x1 + 1) / Math.log(2));
			int j = (int) (Math.log(y2 - y1 + 1) / Math.log(2));
			int min = Integer.MAX_VALUE;
			min = Math.min(min, rmq[i][j][x1][y1]);
			min = Math.min(min, rmq[i][j][x2 - (1 << i) + 1][y1]);
			min = Math.min(min, rmq[i][j][x1][y2 - (1 << j) + 1]);
			min = Math.min(min, rmq[i][j][x2 - (1 << i) + 1][y2 - (1 << j) + 1]);
			return min;
		}
	}

	private static void printArray(int[][] arr) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr[i].length; j++) {
				System.out.print(arr[i][j] + " ");
			}
			System.out.println();
		}
	}

	private static Point2D.Double reflectPoint(Point2D.Double p, Line2D.Double line) {
		double dY = line.y2 - line.y1, dX = line.x2 - line.x1;
		Point2D.Double mid = cramer(line, new Line2D.Double(p, new Point2D.Double(p.x - dY, p.y + dX)));
		return new Point2D.Double(2 * mid.x - p.x, 2 * mid.y - p.y);
	}

	private static double angle(Line2D.Double a, Line2D.Double b) {
		return ((Math.atan2(a.y1 - a.y2, a.x1 - a.x2) - Math.atan2(b.y1 - b.y2, b.x1 - b.x2)) % Math.PI + Math.PI)
				% Math.PI;
	}

	private static Point2D.Double cramer(Line2D.Double p, Line2D.Double q) {
		// solves intersection of two line segs.
		// must check that segs ACUTUALLY intersect beforehand

		double dX1 = p.x2 - p.x1, dX2 = q.x2 - q.x1;
		double dY1 = p.y2 - p.y1, dY2 = q.y2 - q.y1;

		double a1 = -dY1, b1 = dX1, c1 = dX1 * p.y1 - dY1 * p.x1;
		double a2 = -dY2, b2 = dX2, c2 = dX2 * q.y1 - dY2 * q.x1;

		double D = a1 * b2 - a2 * b1;
		double Dx = c1 * b2 - c2 * b1;
		double Dy = a1 * c2 - a2 * c1;

		return new Point2D.Double(Dx / D, Dy / D);

	}

	// SegTree RMQ + Range Update
	private static class ST {
		int[] list, st;
		int K;

		public ST(int[] list) {
			this.list = list;
			K = (int) Math.ceil(Math.log(list.length) / Math.log(2.0));
			st = new int[list.length * 4];
			build(0, (1 << K) - 1, 1);
		}

		private int build(int L, int R, int idx) {
			if (L == R) {
				if (L >= list.length)
					return -1;
				return st[idx] = L;
			}
			int mid = L + R >> 1;
			int l = build(L, mid, idx << 1);
			int r = build(mid + 1, R, (idx << 1) + 1);
			if (l != -1 && r != -1)
				return st[idx] = (list[l] <= list[r]) ? l : r;// changesign >=
																// max <= min
			if (l != -1)
				return st[idx] = l;
			if (r != -1)
				return st[idx] = r;
			return st[idx] = -1;
		}

		public int query(int L, int R) {
			return query(L, R, 0, (1 << K) - 1, 1);
		}

		private int query(int L, int R, int tL, int tR, int idx) {
			if (tL >= L && tR <= R)
				return st[idx];
			if (tL < L && tR < L || tL > R && tR > R)
				return -1;
			int mid = tL + tR >> 1;
			int l = query(L, R, tL, mid, idx << 1);
			int r = query(L, R, mid + 1, tR, (idx << 1) + 1);
			if (l != -1 && r != -1)
				return (list[l] <= list[r]) ? l : r;// changesign
			if (l != -1)
				return l;
			if (r != -1)
				return r;
			return -1;
		}

		public int update(int U, int V) {
			return update(U, 0, (1 << K) - 1, 1, V);
		}

		private int update(int U, int tL, int tR, int idx, int V) {
			if (U == tL && tL == tR) {
				list[U] = V;
				return st[idx] = U;
			}
			if (tL < U && tR < U || tL > U && tR > U)
				return st[idx];
			int mid = tL + tR >> 1;
			int l = update(U, tL, mid, idx << 1, V);
			int r = update(U, mid + 1, tR, (idx << 1) + 1, V);
			if (l != -1 && r != -1)
				return st[idx] = (list[l] <= list[r]) ? l : r;// changesign
			if (l != -1)
				return st[idx] = l;
			if (r != -1)
				return st[idx] = r;
			return -1;
		}
	}

	private static class DijkstraEdge implements Comparable<DijkstraEdge> {
		int length;
		int cost;
		int source;
		int destination;

		public DijkstraEdge(int from, int to, int length, int cost) {
			source = from;
			destination = to;
			this.length = length;
			this.cost = cost;
		}

		@Override
		public int compareTo(DijkstraEdge arg0) {
			// TODO Auto-generated method stub
			return Integer.compare(length, arg0.length);
		}
	}

	private static class Event implements Comparable<Event> {
		int x;
		int y;
		int priority;

		public Event(int time, int val, int priority) {
			this.x = time;
			this.y = val;
			this.priority = priority;
		}

		@Override
		public int compareTo(Event o) {
			// TODO Auto-generated method stub
			if (x != o.x)
				return Integer.compare(x, o.x);
			if (y != o.y)
				return Integer.compare(y, o.y);
			return Integer.compare(priority, o.priority);
		}

		@Override
		public boolean equals(Object o) {
			return compareTo((Event) o) == 0;
		}

		@Override
		public String toString() {
			return "(" + x + " , " + y + ", " + priority + ")";
		}

	}

	private static class Lowlink {

		int N, time;
		int[] ord, low;
		boolean[] art;
		ArrayList<Edge>[] adj;

		public Lowlink(ArrayList<Edge>[] adj) {
			this.adj = adj;
			N = adj.length;
		}

		public void start() {
			ord = new int[N];
			low = new int[N];
			art = new boolean[N];

			Arrays.fill(ord, -1);

			for (int i = 0; i < N; i++)
				if (ord[i] == -1)
					dfs(i, -1);
		}

		private int dfs(int u, int parEdge) {

			ord[u] = low[u] = time++;
			int children = 0;

			for (Edge e : adj[u]) {
				int v = e.op(u);
				if (e.id == parEdge)
					continue;
				if (ord[v] == -1) {
					low[u] = Math.min(low[u], dfs(v, e.id));
					if (++children > 1 && parEdge == -1)
						art[u] = true;
					if (parEdge != -1 && low[v] >= ord[u])
						art[u] = true;
					if (low[v] > ord[u])
						e.bridge = true;
				} else
					low[u] = Math.min(low[u], ord[v]);
			}
			return low[u];
		}
	}

	private static class Edge {
		int u, v, id;
		boolean bridge;

		public Edge(int u, int v, int id) {
			this.u = u;
			this.v = v;
			this.id = id;
		}

		public int op(int a) {
			return a == u ? v : u;
		}
	}

	private static class pair implements Comparable<pair> {
		int a;
		int b;

		public pair(int a, int b) {
			this.a = a;
			this.b = b;
		}

		public double dist(pair other) {
			return Math.sqrt((a - other.a) * (a - other.a) + (b - other.b) * (b - other.b));
		}

		@Override
		public int compareTo(pair arg0) {
			// TODO Auto-generated method stub
			if (a != arg0.a)
				return Integer.compare(a, arg0.a);
			return Integer.compare(b, arg0.b);
		}

		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + a;
			result = prime * result + b;
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			pair other = (pair) obj;
			if (a != other.a)
				return false;
			if (b != other.b)
				return false;
			return true;
		}

		@Override
		public String toString() {
			return "(" + a + " , " + b + ")";
		}

	}

	private static class Line {
		double m;
		double b;

		public Line(double m, double b) {
			this.m = m;
			this.b = b;
		}

		@Override
		public int hashCode() {
			final int prime = 31;
			int result = 1;
			long temp;
			temp = Double.doubleToLongBits(b);
			result = prime * result + (int) (temp ^ (temp >>> 32));
			temp = Double.doubleToLongBits(m);
			result = prime * result + (int) (temp ^ (temp >>> 32));
			return result;
		}

		@Override
		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			Line other = (Line) obj;
			if (Double.doubleToLongBits(b) != Double.doubleToLongBits(other.b))
				return false;
			if (Double.doubleToLongBits(m) != Double.doubleToLongBits(other.m))
				return false;
			return true;
		}

	}

	private static class FS {
		BufferedReader br;
		StringTokenizer st;

		public FS(InputStream in) {
			br = new BufferedReader(new InputStreamReader(in));
		}

		String next() {
			while (st == null || !st.hasMoreElements()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (IOException e) {
				e.printStackTrace();
			}
			return str;
		}
	}

	private static class UtilityDinic {
		double eps = 1e-7;
		ArrayList<Edge>[] nodes;
		ArrayList<Double> modifiers;
		ArrayList<Edge> actual;
		ArrayList<Edge> circulatingEdges;
		double[] demand;
		int[] distance;
		boolean[] blocked;
		int source;
		int sink;

		class Edge {
			int from;
			int to;
			double capacity;
			double flow;
			Edge reverse;

			public Edge(int from, int to, double capacity, double flow, Edge reverse) {
				this.from = from;
				this.to = to;
				this.capacity = capacity;
				this.flow = flow;
				this.reverse = reverse;
			}
		}

		public UtilityDinic(int nodes) {
			this.circulatingEdges = new ArrayList<Edge>();
			this.nodes = new ArrayList[nodes];
			this.actual = new ArrayList<Edge>();
			this.modifiers = new ArrayList<Double>();
			for (int i = 0; i < nodes; i++) {
				this.nodes[i] = new ArrayList<Edge>();
			}
			demand = new double[nodes];
		}

		public Edge addEdge(int from, int to, double capacity) {
			// System.out.println(from + "->" + to + " with " + capacity);
			Edge forward = new Edge(from, to, capacity, 0, null);
			Edge reverse = new Edge(to, from, 0, 0, forward);
			forward.reverse = reverse;
			nodes[from].add(forward);
			nodes[to].add(reverse);
			actual.add(forward);
			return forward;
		}

		public Edge addEdge(int from, int to, double capacity, double min) {
			Edge o = addEdge(from, to, capacity - min);
			demand[from] += min;
			demand[to] -= min;
			modifiers.add(min);
			return o;
		}

		public void addCirculatingEdges(int supersource, int supersink) {
			for (int i = 0; i < demand.length; i++) {
				if (Math.abs(demand[i]) < eps)
					continue;
				if (demand[i] < 0) {
					circulatingEdges.add(addEdge(supersource, i, -demand[i]));
				}
				if (demand[i] > 0) {
					circulatingEdges.add(addEdge(i, supersink, demand[i]));
				}
			}
		}

		public double flowX(int source, int sink, double amount) {
			// System.out.println("Sending "+amount+" from "+source+" to
			// "+sink);
			double flow = 0;
			this.source = source;
			this.sink = sink;
			while (bfs()) {
				blocked = new boolean[nodes.length];
				double val = dfs(source, amount - flow);
				flow += val;
				if (flow >= amount)
					break;
			}
			if (circulatingEdges.size() > 0) {
				for (Edge e : circulatingEdges) {
					// System.out.println(e.flow+" / "+e.capacity);
					if (Math.abs(e.flow - e.capacity) > eps) {
						return -1;
					} else {
						if (e.from == source) {
							flow -= e.flow;
						}
					}
				}
			}
			return flow;
		}

		public double flow(int source, int sink) {
			return flowX(source, sink, Double.MAX_VALUE);
		}

		// Lexicographically first flow on a bipartite graph
		// Assumes all left side nodes are added first, then right side nodes,
		// then source and sink
		// Assumes matching left side with lower right side than current
		// matching is better lexicographically
		// Assumes edges are added from top to bottom per node on the left
		public double lexicoFlow(int source, int sink) {
			// generate initial flow graph
			double totalFlow = flow(source, sink);
			for (int i = 0; i < nodes.length - 2; i++) {
				boolean leftside = true;
				for (Edge e : nodes[i]) {
					if (e.to == sink)
						leftside = false;
				}
				if (!leftside)
					break;
				// System.out.println("Testing node "+i);
				for (Edge e : nodes[i]) {
					if (e.to == source || e.from == source || e.to == sink || e.from == sink)
						continue;
					// System.out.println("Testing Edge to "+e.to);
					if (e.flow == 0) {
						e.capacity = 0;
						e.reverse.capacity = 0;
						// System.out.println(e.reverse.flow);
						e.reverse.flow = 0;
						continue;
					}
					if (e.flow < 0)
						continue;
					ForceBlock(e);
				}
			}
			return totalFlow;
		}

		public boolean ForceBlock(Edge e) {
			double cur = e.flow;
			double cap = e.capacity;
			double rcur = e.reverse.flow;
			double rcap = e.reverse.capacity;
			e.capacity = 0;
			e.flow = 0;
			e.reverse.flow = 0;
			e.reverse.capacity = 0;
			double can = flowX(e.from, e.to, cur);
			if (Math.abs(can - cur) < 1e-7) {
				return true;
			} else {
				e.capacity = cap;
				e.flow = cur;
				e.reverse.capacity = rcap;
				e.reverse.flow = rcur;
				return false;
			}
		}

		public boolean bfs() {
			distance = new int[nodes.length];
			Arrays.fill(distance, Integer.MAX_VALUE);
			distance[sink] = 0;
			ArrayDeque<Integer> current = new ArrayDeque<Integer>();
			current.add(sink);
			while (!current.isEmpty()) {
				int cur = current.poll();
				if (distance[cur] >= distance[source])
					break;
				for (Edge e : nodes[cur]) {
					if ((e.reverse.capacity - e.reverse.flow) > eps) {
						if (distance[e.to] > (distance[cur] + 1)) {
							current.add(e.to);
							distance[e.to] = distance[cur] + 1;
						}
					}
				}
			}
			return distance[source] != Integer.MAX_VALUE;
		}

		public double dfs(int pos, double min) {
			if (pos == sink) {
				return min;
			}
			double flow = 0;
			for (Edge e : nodes[pos]) {
				if (blocked[e.to])
					continue;
				if (distance[e.to] != distance[pos] - 1)
					continue;
				if ((e.capacity - e.flow) > eps) {
					double res = dfs(e.to, Math.min(min, e.capacity - e.flow));
					flow += res;
					min -= res;
					e.flow += res;
					e.reverse.flow -= res;
				}
				if (min <= eps)
					break;
			}
			if (min > eps) {
				blocked[pos] = true;
			}
			return flow;
		}

		public void removeEdge(Edge e) {
			// actual.remove(e);
			nodes[e.from].remove(e);
			nodes[e.to].remove(e.reverse);
			// circulatingEdges.remove(e);
		}

		public void removeCirculatingEdges() {
			for (Edge e : circulatingEdges) {
				removeEdge(e);
			}
			circulatingEdges = new ArrayList<Edge>();
		}

		public void addDemand(double demand, int node) {
			this.demand[node] += demand;
		}

		public void drain() {
			for (ArrayList<Edge> al : nodes) {
				for (Edge e : al) {
					e.flow = 0;
				}
			}
		}
	}

	private static class STmine {
		/**
		 * The value we don't care about, use 987654321 for min, and 0 for bit
		 * operations.
		 */
		int ignore = 0;
		/**
		 * The index of the node representing the left subtree of the current node.
		 */
		int[] left;
		/**
		 * The index of the node representing the right subtree of the current node.
		 */
		int[] right;
		/**
		 * The value of the node represented by the index.
		 */
		int[] val;
		/**
		 * The left bound of the range represented by the node at this index.
		 */
		int[] a;
		/**
		 * The right bound of the range represented by the node at this index.
		 */
		int[] b;
		/**
		 * The delta array, representing changes that have yet to be propogated.
		 */
		int[] prop;

		/**
		 * The height of a given node. 0 = leaf.
		 */
		int[] height;

		/**
		 * Initializes a new segment tree, filled with zeros.
		 *
		 * @param n
		 *            The size of the segment tree (zero indexed).
		 */
		STmine(int n) {
			left = new int[4 * n];
			right = new int[4 * n];
			val = new int[4 * n];
			prop = new int[4 * n];
			height = new int[4 * n];
			a = new int[4 * n];
			b = new int[4 * n];
			init(0, 0, n - 1);
		}

		/**
		 * Initializes the Segment Tree, setting up {@link STmine#a}, {@link STmine#b},
		 * {@link STmine#left}, {@link STmine#right}.
		 *
		 * @param at
		 *            The current node
		 * @param l
		 *            The leftmost value of the range represented by this node.
		 * @param r
		 *            The rightmost value of the range represented by this node.
		 * @return The index of the node that was just processed.
		 */
		int init(int at, int l, int r) {
			a[at] = l;
			b[at] = r;
			if (l == r) {
				left[at] = right[at] = -1;
				height[at] = 0;
			} else {
				int mid = l + r >> 1;
				left[at] = init(2 * at + 1, l, mid);
				right[at] = init(2 * at + 2, mid + 1, r);
				height[at] = Math.max(height[left[at]], height[right[at]]) + 1;
			}
			return at++;
		}

		/**
		 *
		 * @param x
		 *            The left value of the range to be queried
		 * @param y
		 *            The right value of the range to be queried
		 * @return The minimum value between x and y.
		 */
		int get(int x, int y) {
			return go(x, y, 0);
		}

		/**
		 * Lazily propogates the value of {@link STmine#prop} to the left and right
		 * children.
		 *
		 * @param at
		 *            The current node.
		 */
		void push(int at) {
			System.out.println("PUSH " + prop[at]);
			if (prop[at] != 0) {
				go3(a[left[at]], b[left[at]], prop[at], left[at]);
				go3(a[right[at]], b[right[at]], prop[at], right[at]);
				prop[at] = 0;
			}
		}

		/**
		 *
		 * @param x
		 *            The left bound of the range to be queried
		 * @param y
		 *            The right bound of the range to be queried
		 * @param at
		 *            The current node
		 * @return The minimum on the range x->y, within the domain of what is
		 *         represented by at
		 */
		int go(int x, int y, int at) {
			if (at == -1 || y < a[at] || x > b[at])
				return ignore;
			if (x <= a[at] && y >= b[at]) {
				push(at);
				System.out.println(prop[at] + " " + val[at]);
				return val[at];
			}
			System.out.println(x + " " + y + " " + a[at] + " " + b[at]);
			push(at);
			return eval(at, go(x, y, left[at]), go(x, y, right[at]));
		}

		/**
		 * Add v to elements x through y
		 *
		 * @param x
		 *            The left index of the range to be added to.
		 * @param y
		 *            The right index of the range to be added to.
		 * @param v
		 *            The value to be added.
		 */
		void add(int x, int y, int v) {
			go3(x, y, v, 0);
		}

		void noLazySet(int x, int y, int v) {
			go2(x, y, v, 0);
		}

		/***
		 * Sets a value and then updates the tree in a non-lazy fashion
		 *
		 * @param x
		 *            The left value of the range being set
		 * @param y
		 *            The right value of the range being set
		 * @param v
		 *            The value to be set to
		 * @param at
		 *            The current node
		 */
		void go2(int x, int y, int v, int at) {
			if (at == -1)
				return;
			if (y < a[at] || x > b[at])
				return;
			x = Math.max(x, a[at]);
			y = Math.min(y, b[at]);
			if (y == b[at] && x == a[at]) {
				val[at] = v;
				return;
			}
			go2(x, y, v, left[at]);
			go2(x, y, v, right[at]);
			val[at] = eval(at, val[left[at]], val[right[at]]);
		}

		/**
		 * Update values and push prop as far as necessary to query x->y.
		 *
		 * @param x
		 *            The left bound of the range to be queried.
		 * @param y
		 *            The right bound of the range to be queried.
		 * @param v
		 *            The current prop value being pushed from parent.
		 * @param at
		 *            The current node.
		 */
		void go3(int x, int y, int v, int at) {
			if (at == -1)
				return;
			if (y < a[at] || x > b[at])
				return;
			x = Math.max(x, a[at]);
			y = Math.min(y, b[at]);
			if (y == b[at] && x == a[at]) {
				val[at] += v;
				prop[at] += v;
				return;
			}
			push(at);
			go3(x, y, v, left[at]);
			go3(x, y, v, right[at]);
			val[at] = eval(at, val[left[at]], val[right[at]]);
		}

		/**
		 * Changes per program, evaluates the new value for a given node given that left
		 * and right are up to date.
		 *
		 * @param at
		 *            The current node.
		 * @param lval
		 *            The value representing the left subtree
		 * @param rval
		 *            The value representing the right subtree
		 */
		int eval(int at, int lval, int rval) {
			// System.out.println("("+height[at]+" "+at+") "+lval+" "+rval);
			System.out.println(at + " " + lval + " " + rval + "!");
			return Math.min(lval, rval);
		}

	}

	private static class AhoCorasick {
		int ALPHA = 26;
		int nodeCount;
		int[][] transition;
		BitSet[] word;

		public void createAhoCorasick(String[] strs) {
			int maxNodes = 1;
			for (String s : strs) {
				maxNodes += s.length();
			}

			int[][] children = new int[ALPHA][maxNodes];
			word = new BitSet[maxNodes];
			for (int i = 0; i < word.length; i++)
				word[i] = new BitSet();
			nodeCount = 1;
			for (int i = 0; i < strs.length; i++) {
				String s = strs[i];
				int node = 0;
				for (char ch : s.toCharArray()) {
					int c = ch - 'a';
					if (children[c][node] == 0) {
						children[c][node] = nodeCount;
						nodeCount++;
					}
					node = children[c][node];
				}
				word[node].set(i);
			}

			transition = new int[ALPHA][nodeCount];

			ArrayDeque<Integer> queue = new ArrayDeque<Integer>();
			queue.add(0);
			queue.add(0);

			while (queue.size() > 0) {
				int node = queue.remove();
				int suffLink = queue.remove();

				word[node].or(word[suffLink]);

				for (int ch = 0; ch < ALPHA; ch++) {
					if (children[ch][node] != 0) {
						transition[ch][node] = children[ch][node];
						queue.add(children[ch][node]);
						queue.add(node == 0 ? 0 : transition[ch][suffLink]);
					} else {
						transition[ch][node] = transition[ch][suffLink];
					}
				}
			}
		}
	}

	private static class NEWMATH {
		static ArrayList<Long> primes;
		static Random r = new Random();

		private static void factorize(long n) {

			primes = new ArrayList<>();
			while (!BigInteger.valueOf(n).isProbablePrime(20)) {
				long rho = rho(n);
				primes.add(rho);
				n /= rho;
			}
			primes.add(n);
		}

		private static long rho(long n) {
			if (n <= 3)
				return -1;
			if ((n & 1) == 0)
				return 2;
			long a = (Math.abs(r.nextLong()) + 2) % 100000, y = (Math.abs(r.nextLong()) + 2) % 100000, x = y, d;
			do {
				x = poly(x, a, n);
				y = poly(poly(y, a, n), a, n);
				d = gcd(n, Math.abs(x - y));
			} while (d == 1);
			return d;
		}

		private static long poly(long x, long a, long n) {
			return (mulmod(x, x, n) + a) % n;
		}

		private static long mulmod(long a, long b, long c) {
			return BigInteger.valueOf(a).multiply(BigInteger.valueOf(b)).mod(BigInteger.valueOf(c)).longValue();
		}

		static long solve(long[] a, long[] m) {
			long A = a[0], M = m[0];
			for (int i = 1; i < a.length; i++) {
				if (A > a[i]) {
					A = A ^ a[i] ^ (a[i] = A);
					M = M ^ m[i] ^ (m[i] = M);
				}
				long gcd = gcd(m[i], M), diff = a[i] - A;
				if (gcd == 0 || diff % gcd != 0)
					return -1;
				long MOD = M * m[i] / gcd;
				A = (modInv(M / gcd, m[i] / gcd) * (diff / gcd) % MOD * M + A) % MOD;
				M = MOD;
			}
			return A;
		}

		private static long modInv(long a, long m) {
			long m0 = m, t, q, x0 = 0, x1 = 1;
			while (a > 1) {
				q = a / (t = m);
				m = a % m;
				a = t;
				x0 = x1 - q * (t = x0);
				x1 = t;
			}
			return (m == 1) ? 0 : (x1 < 0) ? x1 + m0 : x1;
		}

		private static long gcd(long a, long b) {
			return Math.abs(b == 0 ? a : gcd(b, a % b));
		}
	}

	private static class MST {
		static int[] root;
		static int[] rank;
		static int disjoint;

		public MST(int num) {
			root = new int[num];
			rank = new int[num];
			Arrays.fill(root, -1);
			disjoint = num;
		}

		public static int find(int s) {
			if (root[s] != s)
				return root[s] == -1 ? s : (root[s] = find(root[s]));
			return root[s];
		}

		public static void union(int s, int t) {
			int x = find(s);
			int y = find(t);
			if (x != y)
				disjoint--;
			if (rank[x] < rank[y]) {
				root[x] = y;
			}
			if (rank[y] < rank[x]) {
				root[y] = x;
			}
			if (rank[y] == rank[x]) {
				root[y] = x;
				rank[x]++;
			}
		}
	}

	private static class ManachersAlgorithm {

		public static int[] findLongestPalindrome(String s) {
			if (s == null || s.length() == 0)
				return new int[0];

			char[] s2 = addBoundaries(s.toCharArray());
			int[] p = new int[s2.length];
			int c = 0, r = 0; // Here the first element in s2 has been
								// processed.
			int m = 0, n = 0; // The walking indices to compare if two elements
								// are the same
			for (int i = 1; i < s2.length; i++) {
				if (i > r) {
					p[i] = 0;
					m = i - 1;
					n = i + 1;
				} else {
					int i2 = c * 2 - i;
					if (p[i2] < (r - i - 1)) {
						p[i] = p[i2];
						m = -1; // This signals bypassing the while loop below.
					} else {
						p[i] = r - i;
						n = r + 1;
						m = i * 2 - n;
					}
				}
				while (m >= 0 && n < s2.length && s2[m] == s2[n]) {
					p[i]++;
					m--;
					n++;
				}
				if ((i + p[i]) > r) {
					c = i;
					r = i + p[i];
				}
			}
			// System.out.println(Arrays.toString(p));
			int len = 0;
			c = 0;
			for (int i = 1; i < s2.length; i++) {
				if (len < p[i]) {
					len = p[i];
					c = i;
				}
			}
			char[] ss = Arrays.copyOfRange(s2, c - len, c + len + 1);
			return p;
		}

		private static char[] addBoundaries(char[] cs) {
			if (cs == null || cs.length == 0)
				return "||".toCharArray();

			char[] cs2 = new char[cs.length * 2 + 1];
			for (int i = 0; i < (cs2.length - 1); i = i + 2) {
				cs2[i] = '|';
				cs2[i + 1] = cs[i / 2];
			}
			cs2[cs2.length - 1] = '|';
			return cs2;
		}

		private static char[] removeBoundaries(char[] cs) {
			if (cs == null || cs.length < 3)
				return "".toCharArray();

			char[] cs2 = new char[(cs.length - 1) / 2];
			for (int i = 0; i < cs2.length; i++) {
				cs2[i] = cs[i * 2 + 1];
			}
			return cs2;
		}
	}

	static class FFT_Precise {
		static final int maxk = 21, maxn = (1 << maxk) + 1; // maxk ~ log(maxn)
		static double[] ws_r = new double[maxn];
		static double[] ws_i = new double[maxn];
		static int[] dp = new int[maxn];
		static double[] rs_r = new double[maxn];
		static double[] rs_i = new double[maxn];
		static int n, k;
		static int lastk = -1;

		static void fft(boolean rev) {
			if (lastk != k) {
				lastk = k;
				dp[0] = 0;

				for (int i = 1, g = -1; i < n; ++i) {
					if ((i & (i - 1)) == 0) {
						++g;
					}
					dp[i] = dp[i ^ (1 << g)] ^ (1 << (k - 1 - g));
				}

				ws_r[1] = 1;
				ws_i[1] = 0;
				for (int two = 0; two < k - 1; ++two) {
					double alf = Math.PI / n * (1 << (k - 1 - two));
					double cur_r = Math.cos(alf), cur_i = Math.sin(alf);

					int p2 = (1 << two), p3 = p2 * 2;
					for (int j = p2; j < p3; ++j) {
						ws_r[j * 2] = ws_r[j];
						ws_i[j * 2] = ws_i[j];

						// ws[j] * cur
						ws_r[j * 2 + 1] = ws_r[j] * cur_r - ws_i[j] * cur_i;
						ws_i[j * 2 + 1] = ws_r[j] * cur_i + ws_i[j] * cur_r;
					}
				}
			}
			for (int i = 0; i < n; ++i) {
				if (i < dp[i]) {
					double ar = a_r[i];
					double ai = a_i[i];
					a_r[i] = a_r[dp[i]];
					a_i[i] = a_i[dp[i]];
					a_r[dp[i]] = ar;
					a_i[dp[i]] = ai;

				}
			}
			if (rev) {
				for (int i = 0; i < n; ++i) {
					a_i[i] = -a_i[i];
				}
			}
			for (int len = 1; len < n; len <<= 1) {
				for (int i = 0; i < n; i += len) {
					int wit = len;
					for (int it = 0, j = i + len; it < len; ++it, ++i, ++j) {
						double tmp_r = a_r[j] * ws_r[wit] - a_i[j] * ws_i[wit];
						double tmp_i = a_r[j] * ws_i[wit] + a_i[j] * ws_r[wit];
						wit++;
						a_r[j] = a_r[i] - tmp_r;
						a_i[j] = a_i[i] - tmp_i;
						a_r[i] += tmp_r;
						a_i[i] += tmp_i;
						// System.out.printf("%3f %3f\n", a_r[j], a_i[j]);
						// System.out.printf("%3f %3f\n", a_r[i], a_i[i]);
					}
				}
			}
			// System.out.println();
		}

		static double[] a_r = new double[maxn];
		static double[] a_i = new double[maxn];

		static long[] mult(long[] _a, long[] _b) {
			int na = _a.length, nb = _b.length;
			for (k = 0, n = 1; n < na + nb - 1; n <<= 1, ++k)
				;
			ass(n < maxn);
			for (int i = 0; i < n; ++i) {
				a_r[i] = i < na ? _a[i] : 0;
				a_i[i] = i < nb ? _b[i] : 0;
			}
			fft(false);
			a_r[n] = a_r[0];
			a_i[n] = a_i[0];
			double r_i = -1.0d / n / 4.0d;
			for (int i = 0; i <= n - i; ++i) {
				double tmp_r = a_r[i] * a_r[i] - a_i[i] * a_i[i];
				double tmp_i = a_r[i] * a_i[i] * 2.0;
				double tmp2_r = a_r[n - i] * a_r[n - i] - a_i[n - i] * a_i[n - i];
				double tmp2_i = a_r[n - i] * a_i[n - i] * -2.0;
				tmp_r = tmp_r - tmp2_r;
				tmp_i = tmp_i - tmp2_i;
				a_r[i] = -tmp_i * r_i;
				a_i[i] = tmp_r * r_i;

				a_r[n - i] = a_r[i];
				a_i[n - i] = -a_i[i];
			}
			fft(true);
			int res = 0;
			long[] ans = new long[maxn];
			// System.out.println(Arrays.toString(a_r));
			for (int i = 0; i < n; ++i) {
				long val = Math.round(a_r[i]);
				ass(Math.abs(val - a_r[i]) < 1e-1);
				if (val != 0) {
					ass(i < na + nb - 1);
					while (res < i) {
						ans[res++] = 0;
					}
					ans[res++] = val;
				}
			}
			return ans;
		}

		static void ass(boolean f) {
			if (!f)
				System.out.println(1 / 0);
		}
	}

	private static class Sat2 {
		static void dfs1(ArrayList<Integer>[] graph, boolean[] used, ArrayList<Integer> order, int u) {
			used[u] = true;
			for (int v : graph[u]) {
				if (!used[v]) {
					dfs1(graph, used, order, v);
				}
			}
			order.add(u);
		}

		static void dfs2(ArrayList<Integer>[] reverseGraph, int[] comp, int u, int color) {
			comp[u] = color;
			for (int v : reverseGraph[u]) {
				if (comp[v] == -1) {
					dfs2(reverseGraph, comp, v, color);
				}
			}
		}

		public static boolean[] solve2Sat(ArrayList<Integer>[] graph) {
			int n = graph.length;
			boolean[] used = new boolean[n];
			ArrayList<Integer> order = new ArrayList<Integer>();
			for (int i = 0; i < n; i++) {
				if (!used[i]) {
					dfs1(graph, used, order, i);
				}
			}
			ArrayList<Integer>[] reverseGraph = new ArrayList[n];
			for (int i = 0; i < n; i++)
				reverseGraph[i] = new ArrayList<Integer>();
			for (int i = 0; i < n; i++) {
				for (int j : graph[i]) {
					reverseGraph[j].add(i);
				}
			}
			int[] comp = new int[n];
			Arrays.fill(comp, -1);
			for (int i = 0, color = 0; i < n; i++) {
				int u = order.get(n - i - 1);
				if (comp[u] == -1) {
					dfs2(reverseGraph, comp, u, color++);
				}
			}
			for (int i = 0; i < n; i++) {
				if (comp[i] == comp[i ^ 1])
					return null;
			}
			boolean[] res = new boolean[n / 2];
			for (int i = 0; i < n; i += 2)
				res[i / 2] = comp[i] > comp[i ^ 1];
			return res;
		}
	}

}

import java.io.*;
import java.util.*;

public class ProblemA {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		FastScanner input = new FastScanner();

		TreeMap<Integer,Integer> triangular = new TreeMap<Integer, Integer>();

		int sum = 0;
		for(int b = 1; b <= 10000; b++) {
			sum += b;
			triangular.put(sum, b+1);
		}

		int x = input.nextInt();
		int reps = 0;
		StringBuilder  output = new StringBuilder();
		while(x != 0) {
			int lowerKey = triangular.lowerKey(x+1);
			int lowerValue = triangular.get(lowerKey);
			x -= lowerKey;
			for(int q = 0; q < lowerValue; q++) {
				output.append((char) (reps + 'a'));
			}

			reps++;
		}
		System.out.println(output);

	}
	public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;
        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }
        public FastScanner() {
            this(new InputStreamReader(System.in));
        }
        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
        int nextInt() {
            return Integer.parseInt(next());
        }
        long nextLong() {
            return Long.parseLong(next());
        }
        double nextDouble() {
            return Double.parseDouble(next());
        }
        String readNextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        int[] readIntArray(int n) {
            int[] a = new int[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextInt();
            }
            return a;
        }
        long[] readLongArray(int n) {
            long[] a = new long[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextLong();
            }
            return a;
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class C_431 {

	private static int getNearestValue(int k) {
		if (k == 1) return 2;
		int lo = 1;
		int hi = k;
		int mid, val;

		while (lo < hi) {
			mid = (lo + hi + 1)/2;
			val = (mid*(mid - 1))/2;
			if (val > k) {
				hi = mid - 1;
			} else {
				lo = mid;
			}
		}

		return lo;
	}

	private static void generateString(StringBuilder s, char c, int l) {
		for (int i = 0; i < l; i++) {
			s.append(c);
		}
	}

	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader input = new BufferedReader (new InputStreamReader(System.in));

		int n = Integer.parseInt(input.readLine());
		StringBuilder ans = new StringBuilder("");
		int l, iter = 0;
		if (n == 0) ans.append('a');
		while (n != 0) {
			l = getNearestValue(n);
			n -= ((l*(l - 1))/2);
			generateString(ans, (char)('a' + iter), l);
			iter++;
		}
		System.out.println(ans);
		input.close();
	}
}

import java.io.*;
import java.util.*;
public class Main {

	public static void main(String[] args) {
		FastScanner sc=new FastScanner();
		PrintWriter pw=new PrintWriter(System.out);
		while(sc.hasNext()){
			int k=sc.nextInt();
			if(k==0){
				pw.println("ab");
			}else{
				int s=0;
				StringBuilder sb=new StringBuilder();
				while(k>0){
					long start=1;
					long end=k;
					long res=0;
					while(start<=end){
						long mid=(start+end)/2;
						if(mid*(mid+1)/2<=k){
							res=mid;
							start=mid+1;
						}else{
							end=mid-1;
						}
					}
					k-=res*(res+1)/2;
					char q=(char)('a'+s);
					for(int o=1;o<=res;o++){
						sb.append(q);
					}
					s++;
				}
				pw.println(sb.toString());
			}
			pw.flush();
		}

	}
}

class FastScanner {
	BufferedReader br;
	StringTokenizer st;

	public FastScanner() {
		try {
			br = new BufferedReader(new InputStreamReader(System.in),32768);
			st = new StringTokenizer("");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	public boolean hasNext() {
		while (!st.hasMoreTokens()) {
			String line = nextLine();
			if (line == null) {
				return false;
			}
			st = new StringTokenizer(line);
		}
		return true;
	}

	public String next() {
		while(!st.hasMoreTokens()){
			st=new StringTokenizer(nextLine());
		}
		return st.nextToken();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}

	public String nextLine() {
		String line = "";
		try {
			line = br.readLine();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return line;
	}
}

/*
LANG: JAVA
TASK:
*/

import java.io.*;
import java.util.*;
public class cf3
{
	public static void main(String[] args)
	{
		Scanner c = new Scanner(System.in);
		int K = c.nextInt();
		ArrayList<Integer> list = new ArrayList<Integer>();

		while(K>0)
		{
//			System.out.println(K);
			int f = (int) Math.sqrt(2*K);
			if(f*(f+1) <= 2*K)
			{
				list.add(f); K-= (f*f+f)/2;
			}
			else
			{
				list.add(f-1); K-=(f*f-f)/2;
			}
		}
//		System.out.println(list);
		StringBuilder sb = new StringBuilder();
		char ch = 97;
		for(int i=0; i<list.size(); i++)
		{
			for(int j=0; j<list.get(i)+1; j++) sb.append(ch);
			ch++;
		}

		System.out.println(sb);
	}
}

import java.util.Scanner;

public class ProblemC {

	public static long[] cost=new long[1001];

	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();

		for (int i=0; i<1000; i++) {
			calcCost(i);
		}
		StringBuilder sb=new StringBuilder("");
		char l='a';
		while (n>0) {
			int k=0;
			while (calcCost(k)<=n) {
				k++;
			}
			k--;
			n-=calcCost(k);
			for (int i=0; i<k; i++) {
				sb.append(""+l);
			}
			l++;
			//System.out.println(n);
		}
		System.out.print(sb);
	}

	public static long calcCost(int i) {
		return i*(i-1)/2;
	}

}

import java.io.IOException;
import java.io.InputStream;
import java.util.NoSuchElementException;

public class Main {
	private static FastScanner sc = new FastScanner();

	public static void main(String[] args) {
		int[] sums = new int[500];
		for(int i=2; i<500; i++) {
			sums[i] = sums[i-1] + (i-1);
		}

		int k = sc.nextInt();
		char c = 'a';
		String s = "";
		while(k > 0) {
			int i = 1;
			for(; i<500; i++) {
				if(sums[i] > k) {
					i--;
					break;
				}
			}

			k -= sums[i];
			for(int j=0; j<i; j++) {
				s += c;
			}
			c++;
		}

		System.out.println(s);
	}

	static class FastScanner {
        private final InputStream in = System.in;
        private final byte[] buffer = new byte[1024];
        private int ptr = 0;
        private int buflen = 0;
        private boolean hasNextByte() {
            if(ptr < buflen) {
                return true;
            } else {
                ptr = 0;
                try {
                    buflen = in.read(buffer);
                } catch(IOException e) {
                    e.printStackTrace();
                }
                if(buflen <= 0) {
                    return false;
                }
            }
            return true;
        }
        private int readByte() { if (hasNextByte()) return buffer[ptr++]; else return -1;}
        private static boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}
        private void skipUnprintable() { while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++;}
        public boolean hasNext() { skipUnprintable(); return hasNextByte();}
        public String next() {
            if (!hasNext()) throw new NoSuchElementException();
            StringBuilder sb = new StringBuilder();
            int b = readByte();
            while(isPrintableChar(b)) {
                sb.appendCodePoint(b);
                b = readByte();
            }
            return sb.toString();
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public int nextInt(){
            return Integer.parseInt(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
    }
}

import java.io.*;
import java.util.*;

public class MainA {
	static int[] cnt = new int[26];

	public static void main(String[] args) {
		StdIn in = new StdIn();
		int k=in.nextInt();
		recur(k, 500, 0);
	}

	static void recur(int k, int i, int j) {
		if(k==0) {
			for(int l=0; l<26; ++l)
				for(int m=0; m<cnt[l]; ++m)
					System.out.print((char)('a'+l));
			System.exit(0);
		}
		if(j==26)
			return;
		for(; i>1; --i) {
			if(i*(i-1)/2>k)
				continue;
			cnt[j]=i;
			recur(k-i*(i-1)/2, i, j+1);
		}
	}

	interface Input {
		public String next();
		public String nextLine();
		public int nextInt();
		public long nextLong();
		public double nextDouble();
	}
	static class StdIn implements Input {
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;

		public StdIn() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public StdIn(String filename) {
			try{
				din = new DataInputStream(new FileInputStream(filename));
			} catch(Exception e) {
				throw new RuntimeException();
			}
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String next() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == ' ' || c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c=read();
			}
			return s.toString();
		}

		public String nextLine() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c = read();
			}
			return s.toString();
		}

		public int nextInt() {
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
			{
				ret = ret * 10 + c - '0';
			}  while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}

		public int[] readIntArray(int n) {
			int[] ar = new int[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextInt();
			return ar;
		}

		public long nextLong() {
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			}
			while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}

		public long[] readLongArray(int n) {
			long[] ar = new long[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextLong();
			return ar;
		}

		public double nextDouble() {
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();

			do {
				ret = ret * 10 + c - '0';
			}
			while ((c = read()) >= '0' && c <= '9');

			if (c == '.')
			{
				while ((c = read()) >= '0' && c <= '9')
				{
					ret += (c - '0') / (div *= 10);
				}
			}

			if (neg)
				return -ret;
			return ret;
		}

		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}

		private byte read() {
			try{
				if (bufferPointer == bytesRead)
					fillBuffer();
				return buffer[bufferPointer++];
			} catch(IOException e) {
				throw new RuntimeException();
			}
		}

		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}
	}
}

import java.io.*;
import java.util.*;
import java.util.Map.*;

/**
 * Ariana Herbst, 9/1/2017
 */

public class cfs431C {

    public static void main(String[] args) {
        StringBuilder ans = new StringBuilder();
        FastScanner sc = new FastScanner();
        int k = sc.nextInt();
        ArrayList<Integer> numsToUse = new ArrayList<Integer>();
        numsToUse.add(0);
        numsToUse.add(0);
        int curr = 1;
        int dx = 2;
        while (curr < k) {
            numsToUse.add(curr);
            curr += dx;
            dx++;
        }
        Map<Integer, Integer> count = new HashMap<Integer, Integer>();
        int index = 0;
        int i = numsToUse.size()-1;
        while (k != 0) {
            if (numsToUse.get(i) <= k) {
                k -= numsToUse.get(i);
                count.put(index, i);
                index++;
            } else {
                i--;
            }
        }
        for (Entry<Integer, Integer> entry : count.entrySet()) {
            for (int j = 0; j < entry.getValue(); j++) {
                ans.append((char)('a' + entry.getKey()));
            }
        }
        System.out.println(ans);
    }

    public static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }

        public FastScanner() {
            this(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String readNextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        int[] readIntArray(int n) {
            int[] a = new int[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextInt();
            }
            return a;
        }

        long[] readLongArray(int n) {
            long[] a = new long[n];
            for (int idx = 0; idx < n; idx++) {
                a[idx] = nextLong();
            }
            return a;
        }
    }

}

import java.io.*;
import java.util.*;
import java.math.*;
import java.util.concurrent.*;

public final class round_431_c
{
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	static FastScanner sc=new FastScanner(br);
    static PrintWriter out=new PrintWriter(System.out);
	static Random rnd=new Random();

	static int t(int n)
	{
		return (n*(n+1))/2;
	}

	static char[] go(int val1,int val2,int val3)
	{
		char[] res=new char[val1+val2+val3+3];

		int ptr=0;

		for(int i=0;i<=val1;i++)
		{
			res[ptr++]='a';
		}

		for(int j=0;j<=val2;j++)
		{
			res[ptr++]='b';
		}

		for(int k=0;k<=val3;k++)
		{
			res[ptr++]='c';
		}

		return res;
	}

    public static void main(String args[]) throws Exception
    {
		int cost=sc.nextInt();

		if(cost==0)
		{
			out.println("a");
		}

		else
		{
			int val1=-1,val2=-1,val3=-1;

			for(int i=0;i<=100;i++)
			{
				for(int j=0;j<=100;j++)
				{
					for(int k=0;k<=100;k++)
					{
						if(t(i)+t(j)+t(k)==cost)
						{
							val1=i;val2=j;val3=k;break;
						}
					}
				}
			}

		//	System.out.println(val1+" "+val2+" "+val3);

			out.println(new String(go(val1,val2,val3)));
		}

		out.close();
    }
}
class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

	public String next() throws Exception {
		return nextToken().toString();
	}

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}

import java.io.*;
import java.util.StringTokenizer;

/**
 * Created by Katushka on 11.03.2020.
 */
public class FromY2Y {
    static int[] readArray(int size, InputReader in) {
        int[] a = new int[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextInt();
        }
        return a;
    }

    static long[] readLongArray(int size, InputReader in) {
        long[] a = new long[size];
        for (int i = 0; i < size; i++) {
            a[i] = in.nextLong();
        }
        return a;
    }

    public static void main(String[] args) throws FileNotFoundException {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

        int n = in.nextInt();
        long trian = 1;
        long i = 1;
        while (trian * 26 < n) {
            i++;
            trian = i * (i + 1) / 2;
        }
        if (n == 0) {
            out.println('a');
        } else if (trian == 1) {
            StringBuilder str = new StringBuilder();
            for (char ch = 'a'; ch < 'a' + n; ch++) {
                str.append(ch).append(ch);
            }
            out.println(str.toString());
        } else {
            long t = (n / trian);
            long k = n - (trian - 1) * t;
            StringBuilder str = new StringBuilder();
            for (int j = 0; j < i + 1; j++) {
                for (char ch = 'a'; ch < 'a' + (j < 3 ? k : t); ch++) {
                    str.append(ch);
                }
            }
            out.println(str.toString());
        }

        out.close();
    }

    private 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 String nextString() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public char nextChar() {
            return next().charAt(0);
        }
    }
}

import java.io.*;
import java.util.*;
import java.util.Map.Entry;
import java.lang.Math;
import java.math.BigInteger;

public class Problem {

	int INF = -1000 * 1000 * 1000 - 100;
	int counter;
	int[] arr;
	int[] t;

	void solve() throws IOException {
		int n = rI();
		int curChar = 0;
		ArrayList<Character> ansList = new ArrayList<>();
		while(n>0){
			ansList.add((char)('a'+curChar));
			int x = 1;
			int sum = 1 ;
			while(n-sum>=0){
				x++;
				ansList.add((char)('a'+curChar));
				sum += x;
			}
			sum-=x;
			n -= sum;
			curChar++;
		}
		for(char a: ansList){
			out.print(a);
		}
	}

	long get(int r) {
		long sum = 0;
		for (int i = r; i >= 1; i = (i & (i + 1)) - 1) {
			sum += t[i];
		}
		return sum;
	}

	void init() {
		for (int i = 1; i < arr.length; ++i) {
			inc(i, arr[i]);
		}
	}

	void inc(int i, int delta) {
		for (; i < arr.length; i = i | (i + 1)) {
			t[i] += delta;
		}
	}

	public static void main(String[] args) throws IOException {

		new Problem().run();
	}

	boolean isLower(char a) {
		return ((int) a) >= 97 ? true : false;
	}

	BufferedReader in;
	PrintWriter out;
	StringTokenizer tok;
	Random rnd = new Random();
	static final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;

	Problem() throws FileNotFoundException {

		if (ONLINE_JUDGE) {
			in = new BufferedReader(new InputStreamReader(System.in));
			out = new PrintWriter(System.out);
		} else {
			in = new BufferedReader(new FileReader("input.txt"));
			out = new PrintWriter("output.txt");
		}
		tok = new StringTokenizer("");
	}

	long checkBit(long mask, int bit) {
		return (mask >> bit) & 1;
	}

	// ======================================================

	// ======================================================
	void run() throws IOException {
		solve();
		out.close();
	}

	char[] reverseCharArray(char[] arr) {
		char[] ans = new char[arr.length];
		for (int i = 0; i < arr.length; ++i) {
			ans[i] = arr[arr.length - i - 1];
		}
		return ans;
	}

	int sqrt(double m) {
		int l = 0;
		int r = 1000000000 + 9;
		int i = 1000;
		while (r - l > 1) {
			int mid = (r + l) / 2;
			if (mid * mid > m) {
				r = mid;
			} else {
				l = mid;
			}
		}
		return l;
	}

	int countPow(int m, int n) {
		int ans = 0;
		while (m % n == 0 && m > 0) {
			ans++;
			m /= n;
		}
		return ans;
	}

	long binPow(long a, long b) {
		if (b == 0) {
			return 1;
		}
		if (b % 2 == 1) {
			return a * binPow(a, b - 1);
		} else {
			long c = binPow(a, b / 2);
			return c * c;
		}

	}

	int gcd(int a, int b) {
		return b == 0 ? a : gcd(b, a % b);
	}

	long pow(long x, long k) {
		long ans = 1;
		for (int i = 0; i < k; ++i) {
			ans *= x;
		}
		return ans;
	}

	// ////////////////////////////////////////////////////////////////////

	String delimiter = " ";

	String readLine() throws IOException {
		return in.readLine();
	}

	String rS() throws IOException {
		while (!tok.hasMoreTokens()) {
			String nextLine = readLine();
			if (null == nextLine)
				return null;

			tok = new StringTokenizer(nextLine);
		}

		return tok.nextToken(delimiter);
	}

	int rI() throws IOException {
		return Integer.parseInt(rS());
	}

	long rL() throws IOException {
		return Long.parseLong(rS());
	}

	double rD() throws IOException {
		return Double.parseDouble(rS());
	}

	int[] rA(int b) {
		int a[] = new int[b];
		for (int i = 0; i < b; i++) {
			try {
				a[i] = rI();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return a;
	}

	int[] readSortedIntArray(int size) throws IOException {
		Integer[] array = new Integer[size];

		for (int index = 0; index < size; ++index) {
			array[index] = rI();
		}
		Arrays.sort(array);

		int[] sortedArray = new int[size];
		for (int index = 0; index < size; ++index) {
			sortedArray[index] = array[index];
		}

		return sortedArray;
	}

	int[] sortedIntArray(int size, int[] array) throws IOException {
		for (int index = 0; index < size; ++index) {
			array[index] = rI();
		}
		Arrays.sort(array);

		int[] sortedArray = new int[size];
		for (int index = 0; index < size; ++index) {
			sortedArray[index] = array[index];
		}

		return sortedArray;
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.io.PrintStream;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Anand Iyer
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();
            int cnt = 0;
            if (n == 0) {
                out.println("a");
                System.exit(0);
            }
            int[] arr = new int[26]; //letters
            ArrayList<Integer> tri = new ArrayList<>();
            for (int i = 1; i <= 456; i++) {
                tri.add(i * (i + 1) / 2);
            }
            while (n > 0) {
                int ind = 0;
                while (tri.get(ind) <= n) {
                    ind++;
                }
                ind--;
                n -= tri.get(ind);
                arr[cnt] = ind + 2;
                cnt++;
            }
            int x = 0;
            while (arr[x] != 0) {
                for (int i = 0; i < arr[x]; i++) {
                    System.out.print((char) (97 + x));
                }
                x++;
            }
        }

    }

    static class FastScanner {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public FastScanner(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());
        }

    }
}

import java.io.*;
import java.util.*;

public class problem {
    static FastScanner in = new FastScanner();
    static StringBuilder ans = new StringBuilder();
    static int i = 0;
    static String getString(int len, int value) {
        char chars[] = new char[len];
        Arrays.fill(chars, (char) (value + 97));
        return new String(chars);
    }
    static void process(int n) {
        if (n <= 0) return;
        int k = (int) ((Math.sqrt(8 * n + 1) - 1) / 2);
        ans.append(getString(k + 1, i));
        i++;
        process(n - k * (k + 1) / 2);
    }
    static void solve() {
        int n = in.nextInt();
        process(n);
        System.out.println(ans);
    }

    public static void main(String[] args) throws IOException {
        new problem().solve();
    }
}

class FastScanner {
    public static String debug = null;

    private final InputStream in = System.in;
    private int ptr = 0;
    private int buflen = 0;
    private byte[] buffer = new byte[1024];
    private boolean eos = false;

    private boolean hasNextByte() {
        if (ptr < buflen) {
            return true;
        } else {
            ptr = 0;
            try {
                if (debug != null) {
                    buflen = debug.length();
                    buffer = debug.getBytes();
                    debug = "";
                    eos = true;
                } else {
                    buflen = in.read(buffer);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            if (buflen < 0) {
                eos = true;
                return false;
            } else if (buflen == 0) {
                return false;
            }
        }
        return true;
    }

    private int readByte() {
        if (hasNextByte())
            return buffer[ptr++];
        else
            return -1;
    }

    private static boolean isPrintableChar(int c) {
        return 33 <= c && c <= 126;
    }

    private void skipUnprintable() {
        while (hasNextByte() && !isPrintableChar(buffer[ptr]))
            ptr++;
    }

    public boolean isEOS() {
        return this.eos;
    }

    public boolean hasNext() {
        skipUnprintable();
        return hasNextByte();
    }

    public String next() {
        if (!hasNext())
            throw new NoSuchElementException();
        StringBuilder sb = new StringBuilder();
        int b = readByte();
        while (isPrintableChar(b)) {
            sb.appendCodePoint(b);
            b = readByte();
        }
        return sb.toString();
    }

    public long nextLong() {
        if (!hasNext())
            throw new NoSuchElementException();
        long n = 0;
        boolean minus = false;
        int b = readByte();
        if (b == '-') {
            minus = true;
            b = readByte();
        }
        if (b < '0' || '9' < b) {
            throw new NumberFormatException();
        }
        while (true) {
            if ('0' <= b && b <= '9') {
                n *= 10;
                n += b - '0';
            } else if (b == -1 || !isPrintableChar(b)) {
                return minus ? -n : n;
            } else {
                throw new NumberFormatException();
            }
            b = readByte();
        }
    }

    public int nextInt() {
        return (int) nextLong();
    }

    public long[] nextLongList(int n) {
        return nextLongTable(1, n)[0];
    }

    public int[] nextIntList(int n) {
        return nextIntTable(1, n)[0];
    }

    public long[][] nextLongTable(int n, int m) {
        long[][] ret = new long[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ret[i][j] = nextLong();
            }
        }
        return ret;
    }

    public int[][] nextIntTable(int n, int m) {
        int[][] ret = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ret[i][j] = nextInt();
            }
        }
        return ret;
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Marc Magdi
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            int log = (int) (Math.log(n) / Math.log(2));
            int x = n - (int) Math.pow(2, log) - 1;
            StringBuilder stringBuilder = new StringBuilder();
            for (int i = 0; i < x; i++) {
                stringBuilder.append('a');
            }

            for (int i = 0; i < n - x; i++) {
                char c = (char) ('b' + i);
                stringBuilder.append(c).append(c);
            }

            out.println(stringBuilder);
        }

    }
}

import java.util.Scanner;

public class ProblemC {

	public static long[] cost=new long[10001];
	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();

		for (int i=0; i<10000; i++) {
			calcCost(i);
			//System.err.println(cost[i]);
		}
		StringBuilder sb=new StringBuilder("");
		char l='a';
		while (n>0) {
			int k=0;
			while (cost[k]<=n) {
				k++;
			}
			k--;
			n-=cost[k];
			for (int i=0; i<k; i++) {
				sb.append(""+l);
			}
			l++;
			//System.out.println(n);
		}
		System.out.println(sb);
	}

	public static long calcCost(int i) {
		return cost[i]=(i-1l)*(i-2)/2;
	}

}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

public class C431 {
	public static void main(String[] args) {
		try (Scanner in = new Scanner(System.in)) {
			int n = in.nextInt();
			List<Integer> result = new ArrayList<>();
			while (n > 0) {
				int binarySearch = binarySearch(n);
				result.add(binarySearch);
				n -= (binarySearch * (binarySearch - 1)) / 2;
			}
			result.add(1);
			StringBuilder sb = new StringBuilder();
			for (int i = 0; i < result.size(); i++) {
				String c = (char) ('a' + i) + "";
				sb.append(String.join("", Collections.nCopies(result.get(i), c)));
			}
			System.out.println(sb);
		}
	}

	static int binarySearch(int n) {
		int low = 2;
		int high = n;
		while (low < high - 1) {
			int mid = low + (high - low) / 2;
			if (mid * (mid - 1) < 2 * n) {
				low = mid;
			} else if (mid * (mid - 1) > 2 * n) {
				high = mid;
			} else {
				return mid;
			}
		}
		return low;
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author @Sandip_Jana
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, Scanner in, PrintWriter out) {
            int n = in.nextInt();
            String res = "";
            char ch = 'a';
            while (n > 0) {
                int start = 1;
                int take = 0;
                while (true) {
                    long ok = (start * 1L * (start - 1)) / 2;
                    if (ok <= n) {
                        take = start;
                        ++start;
                    } else
                        break;
                }
                for (int i = 1; i <= take; i++) res += (ch);
                n -= ((take * 1L * (take - 1)) / 2);
                ch++;
            }
            out.println(res);
        }

    }
}

import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;
import java.io.*;

public class Main {
    double eps = 0.0000001;

    public class point {
        int t, d, p;

        point(int a, int b, int c) {
            t = a;
            d = b;
            p = c;
        }
    }

    public void solve() throws IOException {
        int k = nextInt();
        char t = 'a';
        while (k > 0) {
            int z = (int) Math.sqrt(k);
            while (z * (z + 1) / 2 <= k) {
                z++;
            }
            for(int i = 0; i < z; i++){
                out.print(t);
            }
            k -= z * (z - 1) / 2;
            t++;
        }
    }

    BufferedReader br;
    StringTokenizer sc;
    PrintWriter out;

    public String nextToken() throws IOException {
        while (sc == null || !sc.hasMoreTokens()) {
            try {
                sc = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return null;
            }
        }
        return sc.nextToken();
    }

    public boolean hasNext() throws IOException {
        while (sc == null || !sc.hasMoreTokens()) {
            try {
                sc = new StringTokenizer(br.readLine());
            } catch (Exception e) {
                return false;
            }
        }
        return true;
    }

    public Integer nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    public Long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    public Double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    public static void main(String[] args) throws IOException {
        try {
            Locale.setDefault(Locale.US);
        } catch (Exception e) {
        }
        new Main().run();
    }

    public void run() {
        try {
            br = new BufferedReader(new InputStreamReader(System.in));
            out = new PrintWriter(System.out);
//            br = new BufferedReader(new FileReader("shooting.in"));
//            out = new PrintWriter(new File("shooting.out"));
            solve();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class Main {

	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[256]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }

	public static void main(String args[])throws IOException{
		Reader in = new Reader();
		Scanner sc = new Scanner(System.in);
		int n = in.nextInt();
		int[] s = new int[451];
		s[1]=1;
		for(int i=2;i<=450;i++)
			s[i]=s[i-1]+i;
		int ch=97;
		while(n>0){
			int num = bin(s,n);
			n-=s[num];
			System.out.print((char)ch);
			for(int i=0;i<num;i++)
				System.out.print((char)ch);
			ch++;
			//System.out.println(n);
		}
		//System.out.println(bin(s,9));
	}
	static int bin(int[] s,int x){
		int l=1;
		int u=s.length-1;
		while(l<=u){
			int mid=(l+u)/2;
			if(s[mid]==x)
				return mid;
			if(s[mid]<x)
				l=mid+1;
			if(s[mid]>x)
				u=mid-1;
		}
		return l-1;
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int[] memo = new int[451];
            for (int i = 1; i <= 450; i++) {
                memo[i] = (i * (i + 1)) / 2;
            }
            int k = in.nextInt();
            char cur = 'a';
            StringBuilder ans = new StringBuilder();
            while (k > 0) {
                int idx = bs(memo, k);
                for (int i = 0; i < idx + 1; i++) ans.append(cur);
                k -= memo[idx];
                cur++;
            }
            out.print(ans.toString());
        }

        private int bs(int[] arr, int x) {
            int l = 1, r = arr.length - 1, m, ans = -1;
            while (l <= r) {
                m = l + (r - l) / 2;
                if (arr[m] <= x) {
                    ans = m;
                    l = m + 1;
                } else {
                    r = m - 1;
                }
            }
            if (ans == -1) throw new RuntimeException();
            return ans;
        }

    }

    static class InputReader {
        private int lenbuf = 0;
        private int ptrbuf = 0;
        private InputStream in;
        private byte[] inbuf = new byte[1024];

        public InputReader(InputStream in) {
            this.in = in;
        }

        private int readByte() {
            if (lenbuf == -1) throw new InputMismatchException();
            if (ptrbuf >= lenbuf) {
                ptrbuf = 0;
                try {
                    lenbuf = in.read(inbuf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (lenbuf <= 0) return -1;
            }
            return inbuf[ptrbuf++];
        }

        public int nextInt() {
            int num = 0, b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;

public class C {

	public static void main(String[] args) {
		try (Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
				PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)))) {
			out.println(solve(in.nextInt()));
		}
	}

	private static String solve(int k) {
		StringBuilder ans = new StringBuilder();
		for (int i = 0; i < 26; i++) {
			int cnt = 1;
			while ((cnt + 1) * cnt / 2 <= k) {
				cnt++;
			}
			k -= cnt * (cnt - 1) / 2;
			for (int j = 0; j < cnt; j++) {
				ans.append('a' + i);
			}
		}
		return ans.toString();
	}

}

import java.util.*;
import java.lang.*;
import java.io.*;
public class Prac{
    static class InputReader {
        private final InputStream stream;
        private final byte[] buf = new byte[8192];
        private int curChar, snumChars;
        public InputReader(InputStream st) {
            this.stream = st;
        }
        public int read() {
            if (snumChars == -1)
                throw new InputMismatchException();
            if (curChar >= snumChars) {
                curChar = 0;
                try {
                    snumChars = stream.read(buf);
                }
                catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (snumChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }
        public int ni() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public long nl() {
            int c = read();
            while (isSpaceChar(c)) {
            c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public int[] nia(int n) {
            int a[] = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = ni();
            }
            return a;
        }
        public String rs() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                    c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }
        public String nextLine() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do {
                res.appendCodePoint(c);
                c = read();
            } while (!isEndOfLine(c));
            return res.toString();
        }
        public boolean isSpaceChar(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        private boolean isEndOfLine(int c) {
            return c == '\n' || c == '\r' || c == -1;
        }
    }
    public static class Key {

        private final int x;
        private final int y;

        public Key(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key key = (Key) o;
            return x == key.x && y == key.y;
        }

        @Override
        public int hashCode() {
            int result = x;
            result = 31 * result + y;
            return result;
        }

    }
    static class Pair{
        int x,y;
        public Pair(int x,int y){
            this.x=x;
            this.y=y;
        }
    }
    static PrintWriter w = new PrintWriter(System.out);
    static long mod=998244353L,mod1=1000000007;

    public static void main(String [] args){
        InputReader sc=new InputReader(System.in);
        int n=sc.ni();
        int cha=-2;
        int i=1;
        ArrayList<Character> ans=new ArrayList<>();
        //ans.add('a');ans.add('b');
        while(n>0){
            i=1;
            cha+=2;
            ans.add((char)(cha+(int)'a'));
            ans.add((char)(1+cha+(int)'a'));
            while(true){
                if(n<i)break;
                if(n>=i){
                    n-=i;
                    ans.add((char)(cha+(int)'a'));
                }
                if(n>=i){
                    n-=i;
                    ans.add((char)(1+cha+(int)'a'));
                }
                i++;

            }

        }
        for(char c:ans)w.print(c);
        w.println();
        w.close();
    }
}

import java.util.*;
import java.awt.Point;
import java.io.*;

public class C{
	public static void main(String[] args) {
		FastScannerC sc = new FastScannerC(System.in);

		int N = sc.nextInt();

		StringBuilder sb = new StringBuilder();

		char c = 'a';

		long sum = 0;

		while(sum < N){

			int currChar = 0;
			sb.append(c);

			while( sum + (currChar + 1) <= N){
				sb.append(c);
				currChar++;
				sum += currChar;
			}
//			System.out.println(sum + " char " + c);
			c = (char) (c + 1);

		}

		System.out.println(sb.toString());

	}

}

class FastScannerC{
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;

    public FastScannerC(InputStream stream)
    {
        this.stream = stream;
    }

    public int read()
    {
        if (numChars == -1)
            throw new InputMismatchException();
        if (curChar >= numChars)
        {
            curChar = 0;
            try
            {
                numChars = stream.read(buf);
            } catch (IOException e)
            {
                throw new InputMismatchException();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int nextInt()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-')
        {
            sgn = -1;
            c = read();
        }
        int res = 0;
        do
        {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public String next()
    {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        StringBuilder res = new StringBuilder();
        do
        {
            res.appendCodePoint(c);
            c = read();
        } while (!isSpaceChar(c));
        return res.toString();
    }

    public String nextLine()
    {
        int c = read();
        StringBuilder res = new StringBuilder();
        do
        {
            res.appendCodePoint(c);
            c = read();
        } while (!isLineEndChar(c));
        return res.toString();
    }

    public double nextDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        double res = 0;
        while (!isSpaceChar(c) && c != '.') {
            if (c == 'e' || c == 'E')
                return res * Math.pow(10, nextInt());
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        }
        if (c == '.') {
            c = read();
            double m = 1;
            while (!isSpaceChar(c)) {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                m /= 10;
                res += (c - '0') * m;
                c = read();
            }
        }
        return res * sgn;
    }

    public long nextLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public boolean isSpaceChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public boolean isLineEndChar(int c)
    {
        if (filter != null)
            return filter.isSpaceChar(c);
        return c == '\n' || c == '\r' || c == -1;
    }

    public interface SpaceCharFilter
    {
        public boolean isSpaceChar(int ch);
    }
}

import java.util.Scanner;

public class a {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		StringBuilder sb = new StringBuilder();
		int ptr = 10000;
		char letter = 'a';
		while(n > 0) {
			if(ptr*(ptr-1)/2 > n) {
				ptr--;
				continue;
			}
			for(int i=0;i<ptr;i++) {
				sb.append(letter);
			}
			letter++;
			n -= ptr*(ptr-1)/2;
		}
		System.out.println(sb);
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.util.InputMismatchException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            long n = in.nextLong();

            long[] t = new long[2000];
            for (int i = 0; i < 2000; i++) {
                t[i] = (long) i * (i - 1) / 2;
            }

            StringBuilder sb = new StringBuilder();
            int idx = 0;
            for (int i = 1999; i >= 3; i--) {
                if (n >= t[i]) {
                    for (int j = 0; j < i; j++) {
                        sb.append((char) ('a' + idx));
                    }
                    idx++;
                    n -= t[i];
                }
            }

            for (int i = 0; i < n; i++) {
                sb.append((char) ('a' + idx));
                sb.append((char) ('a' + idx));
                idx++;
            }

            out.println(sb.toString());
        }

    }

    static class InputReader {
        BufferedReader in;
        StringTokenizer tok;

        public String nextString() {
            while (!tok.hasMoreTokens()) {
                try {
                    tok = new StringTokenizer(in.readLine(), " ");
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
            }
            return tok.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(nextString());
        }

        public InputReader(InputStream inputStream) {
            in = new BufferedReader(new InputStreamReader(inputStream));
            tok = new StringTokenizer("");
        }

    }
}

import java.io.*;
import java.util.*;
import java.math.*;
import java.util.concurrent.*;

public final class round_431_c
{
    static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
	static FastScanner sc=new FastScanner(br);
    static PrintWriter out=new PrintWriter(System.out);
	static Random rnd=new Random();

	static int t(int n)
	{
		return (n*(n+1))/2;
	}

	static char[] go(int val1,int val2,int val3)
	{
		char[] res=new char[val1+val2+val3+3];

		int ptr=0;

		for(int i=0;i<=val1;i++)
		{
			res[ptr++]='a';
		}

		for(int j=0;j<=val2;j++)
		{
			res[ptr++]='b';
		}

		for(int k=0;k<=val3;k++)
		{
			res[ptr++]='c';
		}

		return res;
	}

    public static void main(String args[]) throws Exception
    {
		int cost=sc.nextInt();

		if(cost==0)
		{
			out.println("a");
		}

		else
		{
			int val1=-1,val2=-1,val3=-1;

			for(int i=0;i<=100;i++)
			{
				for(int j=0;j<=100;j++)
				{
					for(int k=0;k<=100;k++)
					{
						if(t(i)+t(j)+t(k)==cost)
						{
							val1=i;val2=j;val3=k;break;
						}
					}
				}
			}

		//	System.out.println(val1+" "+val2+" "+val3);

			out.println(new String(go(val1,val2,val3)));
		}

		out.close();
    }
}
class FastScanner
{
    BufferedReader in;
    StringTokenizer st;

    public FastScanner(BufferedReader in) {
        this.in = in;
    }

    public String nextToken() throws Exception {
        while (st == null || !st.hasMoreTokens()) {
            st = new StringTokenizer(in.readLine());
        }
        return st.nextToken();
    }

	public String next() throws Exception {
		return nextToken().toString();
	}

    public int nextInt() throws Exception {
        return Integer.parseInt(nextToken());
    }

    public long nextLong() throws Exception {
        return Long.parseLong(nextToken());
    }

    public double nextDouble() throws Exception {
        return Double.parseDouble(nextToken());
    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Scanner;

public class C {

	public static void main(String[] args) {
		try (Scanner in = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
				PrintWriter out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)))) {
			out.println(solve(in.nextInt()));
		}
	}

	private static String solve(int k) {
		StringBuilder ans = new StringBuilder();
		for (int i = 0; i < 26; i++) {
			int cnt = 1;
			while ((cnt + 1) * cnt / 2 <= k) {
				cnt++;
			}
			k -= cnt * (cnt - 1) / 2;
			if (cnt > 1) {
				for (int j = 0; j < cnt; j++) {
					ans.append((char) ('a' + i));
				}
			}
		}
		return ans.toString();
	}

}

import java.io.*;
import java.util.*;
public class C {
	public static void main(String[] args)throws Throwable {
		MyScanner sc=new MyScanner();
		PrintWriter pw=new PrintWriter(System.out);

		int k=sc.nextInt();
		StringBuilder sb=new StringBuilder();
		char c='a';
		if(k==0)
			sb.append('a');
		while(k>0){
			int tmp=k*2;
			int root=(int)Math.sqrt(tmp-1);
			k-=(root*(root+1)/2);
			root++;
			while(root-->0)
				sb.append(c);
			c=(char)(c+1);
		}

		pw.println(sb.toString());
		pw.flush();
		pw.close();
	}

	static class MyScanner {
		BufferedReader br;
		StringTokenizer st;
		public MyScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}
		String next() {while (st == null || !st.hasMoreElements()) {
			try {st = new StringTokenizer(br.readLine());}
			catch (IOException e) {e.printStackTrace();}}
		return st.nextToken();}
		int nextInt() {return Integer.parseInt(next());}
		long nextLong() {return Long.parseLong(next());}
		double nextDouble() {return Double.parseDouble(next());}
		String nextLine(){String str = "";
		try {str = br.readLine();}
		catch (IOException e) {e.printStackTrace();}
		return str;}
	}
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Solution {
    static MyScanner sc;
    private static PrintWriter out;
    static long M2 = 1_000_000_000L + 7;

    public static void main(String[] s) throws Exception {
        StringBuilder stringBuilder = new StringBuilder();
//        stringBuilder.append("100000 1000000000 10001 100000 ");
//        for (int i = 1; i < 100000; i++) {
//            stringBuilder.append(" 10000 100000 ");
//        }
        if (stringBuilder.length() == 0) {
            sc = new MyScanner(System.in);
        } else {
            sc = new MyScanner(new BufferedReader(new StringReader(stringBuilder.toString())));
        }

        out = new PrintWriter(new OutputStreamWriter(System.out));
        initData();
        solve();
        out.flush();
    }

    private static void initData() {

    }

    private static void solve() throws IOException {
        int n = sc.nextInt();
        char l = 'a';
        while (n > 0) {
            int s = 1;
            while (n >= (s + 1) * (s) / 2) {
                s++;
            }
            for (int i = 0; i < s; i++) {
                out.print(l);
            }
            l++;
            n -= s * (s - 1) / 2;
        }

    }

    private static void solveT() throws IOException {
        int t = sc.nextInt();
        while (t-- > 0) {
            solve();
        }
    }

    private static long gcd(long l, long l1) {
        if (l > l1) return gcd(l1, l);
        if (l == 0) return l1;
        return gcd(l1 % l, l);
    }

    private static long pow(long a, long b, long m) {
        if (b == 0) return 1;
        if (b == 1) return a;
        long pp = pow(a, b / 2, m);
        pp *= pp;
        pp %= m;
        return (pp * (b % 2 == 0 ? 1 : a)) % m;
    }

    static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        MyScanner(BufferedReader br) {
            this.br = br;
        }

        public MyScanner(InputStream in) {
            this(new BufferedReader(new InputStreamReader(in)));
        }

        void findToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

        String next() {
            findToken();
            return st.nextToken();
        }

        Integer[] nab(int n) {
            Integer[] k = new Integer[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        int[] na(int n) {
            int[] k = new int[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.fi();
            }
            return k;
        }

        long[] nl(int n) {
            long[] k = new long[n];
            for (int i = 0; i < n; i++) {
                k[i] = sc.nextLong();
            }
            return k;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        int fi() {
            String t = next();
            int cur = 0;
            boolean n = t.charAt(0) == '-';
            for (int a = n ? 1 : 0; a < t.length(); a++) {
                cur = cur * 10 + t.charAt(a) - '0';
            }
            return n ? -cur : cur;
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Nathaniel Lahn
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastScanner in = new FastScanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, FastScanner in, PrintWriter out) {
            int n = in.nextInt();

            StringBuilder sb = new StringBuilder();

            char c = 'a';
            while (n > 0) {
                int i;
                for (i = 0; (((long) i) * (i - 1)) / 2 <= n; i++) ;
                i--;
                n -= (i * (i - 1)) / 2;
                for (int j = 0; j < i; j++) {
                    sb.append(c);
                }
                c++;
            }
            out.println(sb);
        }

    }

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(Reader in) {
            br = new BufferedReader(in);
        }

        public FastScanner(InputStream in) {
            this(new InputStreamReader(in));
        }

        public String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.util.*;
import java.math.*;
import java.io.*;
import java.text.*;

public class A {
    static class Node{
        int id;
        long y;
        public Node(int id,long x){
            this.id=id;
            this.y=y;
        }
    }
    //public static PrintWriter pw;
    public static PrintWriter pw = new PrintWriter(System.out);

    public static void solve() throws IOException {
//	pw=new PrintWriter(new FileWriter("C:\\Users\\shree\\Downloads\\small_output_in"));
        FastReader sc = new FastReader();
        int k=sc.I();
        StringBuilder sb=new StringBuilder("");
        int c=0;
        while(k>0 && c<26){
            int n1=1;
            while((n1*(n1-1))/2<k) n1++;
            if((n1*(n1-1))/2!=k) n1--;
            char ch=(char)(c+'a');
            for(int i=1;i<=n1;i++) sb.append(ch);
            c++;
            k-=(n1*(n1-1))/2;
        }
        pw.println(sb);

        pw.close();

    }

    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            public void run() {
                try {

                    solve();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }, "1", 1 << 26).start();

    }

    static BufferedReader br;
    static long M = (long) 1e9 + 7;

    static class FastReader {

        StringTokenizer st;

        public FastReader() throws FileNotFoundException {
            //br=new BufferedReader(new FileReader("C:\\Users\\shree\\Downloads\\B-small-practice.in"));
            br = new BufferedReader(new InputStreamReader(System.in));

        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int I() {
            return Integer.parseInt(next());
        }

        long L() {
            return Long.parseLong(next());
        }

        double D() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }

        public boolean hasNext() throws IOException {
            while (st == null || !st.hasMoreTokens()) {
                String s = br.readLine();
                if (s == null) {
                    return false;
                }
                st = new StringTokenizer(s);
            }
            return true;
        }

    }
}

/**
 * @author: Mehul Raheja
 */

import java.util.*;
import java.io.*;

public class YtoY{

    /*
        Runtime = O()
     */
    static int N, M, K;
    static String s;
    static StringTokenizer st;
    static boolean[][] dp = new boolean[100001][27];
    static int[] d = new int[27];
    static int[] ans = new int[27];

    static boolean DFS(int i, int j){
        if(i == N){
            return true;
        }else if(j == 27){
            return false;
        }

        if(dp[i][j]){
            return false;
        }
        dp[i][j] = true;

        for (int k = 1; k < d.length && d[k] <= N-i; k++) {
            ans[j] = k;
            if(DFS(i + d[k],j+1)){
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        for (int i = 1; i <= 26; i++) {
            d[i] = d[i-1] + (i-1);
        }
        d[0] = 10000000;

        //int[] use = new int[27];

//        for (int i = 1; i <= 26; i++) {
//            for (int j = 1; j <= 100000; j++) {
//                if(N < d[j]){
//                    N -= d[j-1];
//                    System.out.println(N + " " + j);
//
//                   // System.out.println(j);
//                    for (int k = 0; k < j-2; k++) {
//                        System.out.println((char)(i + 96));
//                    }
//                    break;
//                }
//            }
//        }

        DFS(0,1);

        ans[1] = 1;
        //System.out.println(Arrays.toString(ans));
        for (int i = 1; i < ans.length; i++) {
            for (int j = 0; j < ans[i]; j++) {
                System.out.print((char)(i + 96) + "");
            }
        }
        System.out.println("");

    }
}

import java.util.Scanner;

public class ProblemC {

	public static long[] cost=new long[1001];

	public static void main(String[] args) {
		Scanner s=new Scanner(System.in);
		int n=s.nextInt();

		for (int i=0; i<1000; i++) {
			calcCost(i);
		}
		StringBuilder sb=new StringBuilder("");
		char l='a';
		while (n>0) {
			int k=0;
			while (calcCost(k)<=n) {
				k++;
			}
			k--;
			n-=calcCost(k);
			for (int i=0; i<k; i++) {
				sb.append(""+l);
			}
			l++;
			//System.out.println(n);
		}
		System.out.print(sb);
	}

	public static long calcCost(int i) {
		return i*(i-1)/2;
	}

}

import java.util.Scanner;
public class A{
   static int c =0,j=0;
   static char x='a',y='b';
    public static void main(String[] args)throws Exception {
    int T =0 ;
    Scanner in = new Scanner (System.in);
    T=in.nextInt();

      in.close();
    int count=0;
    int i=0;
    String str="";
       while(true) {
            if(T==0){System.out.println("ab");
                break;}
            else if (count==T){
                System.out.println(str);
                break;}
            else if ((count+(i*2))<=T){
            count=count+i*2;
            str=str+"ab";}
            else if ((count+(i))<=T){
            count=count+i;
            str=str+"a";}
            else {
            j=0;c=0;
            x=(char)(y+2);
            ++y;
         //   System.out.println(x +""+y);
            str=str+find(T-count);
                count=c+count;
            }

           i++;
        }

    }

    public static String find (int n){

        String s;
    if (n==0)return"";
    else if ((c+j*2)<=n){
            c=c+j*2;
            j++;
            s=x+""+y+""+find(n-c);
            return s;}
    else if ((c+j)<=n){
            c=c+j;
            j++;
            s=""+x+""+find(n-c);
            return s;}

    else return s=find(n-c);
  }
}

/*
From beginning till end, this message has been waiting to be conveyed.

For a given unordered multiset of n lowercase English letters ("multi" means that a letter may appear more than once), we treat all letters as strings of length 1, and repeat the following operation n - 1 times:

    Remove any two elements s and t from the set, and add their concatenation s + t to the set.

The cost of such operation is defined to be , where f(s, c) denotes the number of times character c appears in string s.

Given a non-negative integer k, construct any valid non-empty set of no more than 100 000 letters, such that the minimum accumulative cost of the whole process is exactly k. It can be shown that a solution always exists.
Input

The first and only line of input contains a non-negative integer k (0 ≤ k ≤ 100 000) — the required minimum cost.
Output

Output a non-empty string of no more than 100 000 lowercase English letters — any multiset satisfying the requirements, concatenated to be a string.

Note that the printed string doesn't need to be the final concatenated string. It only needs to represent an unordered multiset of letters.

Note

For the multiset {'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b'}, one of the ways to complete the process is as follows:

    {"ab", "a", "b", "a", "b", "a", "b"}, with a cost of 0;
    {"aba", "b", "a", "b", "a", "b"}, with a cost of 1;
    {"abab", "a", "b", "a", "b"}, with a cost of 1;
    {"abab", "ab", "a", "b"}, with a cost of 0;
    {"abab", "aba", "b"}, with a cost of 1;
    {"abab", "abab"}, with a cost of 1;
    {"abababab"}, with a cost of 8.

The total cost is 12, and it can be proved to be the minimum cost of the process.
*/

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int k = in.nextInt();
            for (char ch = 'a'; ch <= 'z'; ch++) {
                int cnt = 1;
                while ((cnt * (cnt + 1) / 2 <= k)) {
                    cnt++;
                }
                k -= cnt;
                for (int i = 0; i < cnt; i++) {
                    out.print(ch);
                }

            }
            out.println();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int readInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int nextInt() {
            return readInt();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void println() {
            writer.println();
        }

        public void print(char i) {
            writer.print(i);
        }

        public void close() {
            writer.close();
        }

    }
}