Petya loves lucky numbers. We all know that lucky numbers are the positive integers whose decimal representations contain only the lucky digits 4 and 7. For example, numbers 47, 744, 4 are lucky and 5, 17, 467 are not.

Petya recently learned to determine whether a string of lowercase Latin letters is lucky. For each individual letter all its positions in the string are written out in the increasing order. This results in 26 lists of numbers; some of them can be empty. A string is considered lucky if and only if in each list the absolute difference of any two adjacent numbers is a lucky number. 

For example, let's consider string "zbcdzefdzc". The lists of positions of equal letters are:

  * b: 2
  * c: 3, 10
  * d: 4, 8
  * e: 6
  * f: 7
  * z: 1, 5, 9
  * Lists of positions of letters a, g, h, ..., y are empty.



This string is lucky as all differences are lucky numbers. For letters z: 5 - 1 = 4, 9 - 5 = 4, for letters c: 10 - 3 = 7, for letters d: 8 - 4 = 4. 

Note that if some letter occurs only once in a string, it doesn't influence the string's luckiness after building the lists of positions of equal letters. The string where all the letters are distinct is considered lucky.

Find the lexicographically minimal lucky string whose length equals n.

Input

The single line contains a positive integer n (1 ≤ n ≤ 105) — the length of the sought string.

Output

Print on the single line the lexicographically minimal lucky string whose length equals n.

Examples

Input

5


Output

abcda


Input

3


Output

abc

Note

The lexical comparison of strings is performed by the < operator in modern programming languages. String a is lexicographically less than string b if exists such i (1 ≤ i ≤ n), that ai < bi, and for any j (1 ≤ j < i) aj = bj.
import java.io.*;
import java.math.*;
import java.util.*;


public class Main {
    private static int [] lucky;
    private static final int MAX = 100*1000;
    private static char [] out;

    private static boolean isLucky (int x) {
        if (x == 0) return true;
        if (x%10 != 4 && x%10 != 7) return false;
        return isLucky(x/10);
    }
    private static void init(){
        int cnt = 0;
        for (int i = 1;i <= MAX;i++)
            cnt += isLucky(i) ? 1 : 0;
        lucky = new int[cnt];
        cnt = 0;
        for (int i = 1;i <= MAX;i++)
            if (isLucky(i))
                lucky[cnt++] = i;
    }

    public static void main(String[] args) throws Exception{
        IO io = new IO(null,null);
        init();
        int n = io.getNextInt();
        out = new char[n];
        char c = 'a';
        for (int i = 0;i < n;i++) if (out[i] == 0) {
            out[i] = c;
            int k = i;
            while (k < n) {
                boolean found = false;
                for (int j = 0;j < lucky.length && k + lucky[j] < n;j++) {
                    if (out[k + lucky[j]] == 0) {
                        k += lucky[j];
                        out[k] = c;
                        found = true;
                        break;
                    }
                }
                if (!found) break;
            }
            c++;
        }
        io.println(new String(out));
        io.close();
    }
}

class pair implements Comparable<pair>{
    int l,r;
    public pair(int l,int r) {
        this.l = l;
        this.r = r;
    }
    @Override
    public int compareTo(pair o) {
        return  l - o.l;
    }
}

class edge implements Comparable<edge>{
    int fr,to,l,r;
    public edge(int f,int t,int l,int r) {
        this.fr = f;
        this.to = t;
        this.l = l;
        this.r = r;
    }
    @Override
    public int compareTo(edge e) {
        return l - e.l;
    }
    @Override
    public String toString(){
        return "" + fr + "->" + to + " (" + l + ", " + r + ")";
    }
}

class IO{
    private BufferedReader br;
    private StringTokenizer st;
    private PrintWriter writer;
    private String inputFile,outputFile;

    public boolean hasMore() throws IOException{
        if(st != null && st.hasMoreTokens()) return true;
        if(br != null && br.ready()) return true;
        return false;
    }
    public String getNext() throws FileNotFoundException, IOException{
        while(st == null || !st.hasMoreTokens()) st = new StringTokenizer(br.readLine());
        return st.nextToken();
    }

    public String getNextLine() throws FileNotFoundException, IOException{
        return br.readLine().trim();
    }

    public int getNextInt() throws FileNotFoundException, IOException{
        return Integer.parseInt(getNext());
    }
    public long getNextLong() throws FileNotFoundException, IOException{
        return Long.parseLong(getNext());
    }

    public void print(double x,int num_digits) throws  IOException{
        writer.printf("%." + num_digits + "f" ,x);
    }
    public void println(double x,int num_digits) throws  IOException{
        writer.printf("%." + num_digits + "f\n" ,x);
    }
    public void print(Object o) throws  IOException{
        writer.print(o.toString());
    }

    public void println(Object o) throws  IOException{
        writer.println(o.toString());
    }
    public IO(String x,String y) throws FileNotFoundException, IOException{
        inputFile = x;
        outputFile = y;
        if(x != null) br = new BufferedReader(new FileReader(inputFile));
        else br = new BufferedReader(new InputStreamReader(System.in));
        if(y != null) writer = new PrintWriter(new BufferedWriter(new FileWriter(outputFile)));
        else writer = new PrintWriter(new OutputStreamWriter(System.out));
    }

    protected void close() throws IOException{
        br.close();
        writer.close();
    }
    public void outputArr(Object [] A) throws IOException{
        int L = A.length;
        for (int i = 0;i < L;i++) {
            if(i > 0) writer.print(" ");
            writer.print(A[i]);
        }
        writer.print("\n");
    }
}

