//package ro.stancalau;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * Created by Sorin on 4/29/2017.
 */
public class prog {

    static Map<Integer, StringBuilder> map = new HashMap<>();
    static Map<String, Integer> numberOf1 = new HashMap<>();
    static Set<StringBuilder> set = new HashSet<>();
    static Set<StringBuilder> all = new HashSet<>();
    static List<String> answer = new ArrayList<>();
    static boolean exit;

    public static void main(final String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int power = 1;
        for (int i = 0; i < n; i++) {
            power = power * 2;
        }

        for (int i = 0; i < power; i++) {
            int bits = Integer.bitCount(i);
            StringBuilder binaryString = new StringBuilder(Integer.toBinaryString(i));
            StringBuilder zeros = new StringBuilder();
            if (binaryString.length() < n) {
                if (!map.containsKey(n - binaryString.length())) {
                    for (int j = 1; j <= n - binaryString.length(); j++) {
                        zeros.insert(0, "0");
                    }
                    map.put((n - binaryString.length()), zeros);
                } else {
                    zeros = map.get(n - binaryString.length());
                }
                binaryString.insert(0, zeros);
            }

            if (bits == 0) {
                answer.add(binaryString.toString());
            } else {
                set.add(binaryString);
                all.add(binaryString);
            }
            numberOf1.put(binaryString.toString(), bits);

        }

        back(1, power);
    }

    static void back(int step, int n) {
        if (step == n) {
            StringBuilder sb = new StringBuilder();
            for (String sol : answer) {
                sb.append(sol).append(System.lineSeparator());
            }
            System.out.println(sb);
            exit = true;
           // System.exit(1);
        } else {
            int nrOf1 = numberOf1.get(answer.get(step - 1));
            //for (Iterator<StringBuilder> it = set.iterator(); it.hasNext();) {
            for (StringBuilder sbb : all) {
                //  StringBuilder sbb = it.next();
                String sb = sbb.toString();
                int nrOf1FromNext = numberOf1.get(sb);
                if (set.contains(sbb)) {
                    if (isOk(answer.get(step - 1), sb)) {
                        // it.remove();
                        set.remove(sbb);
                        answer.add(sb.toString());
                        if (!exit)
                            back(step + 1, n);
                        set.add(sbb);
                        answer.remove(sb.toString());
                    }
                }
            }
        }
    }

    static Map<String, Boolean> ok = new HashMap<>();

    private static boolean isOk(String s, String sb) {
        if (ok.containsKey(s + sb)) {
            return ok.get(s + sb);
        }
        int diff = 0;
        for (int i = 0; i < s.length(); i++) {
            if (sb.charAt(i) != s.charAt(i)) {
                diff++;
            }
        }

        ok.put(s + sb, diff == 1);
        return diff == 1;
    }
}