#include <fstream>
#include <vector>

using namespace std;

ifstream cin("submultimi.in");
ofstream cout("submultimi.out");

/* deoarece numerele sunt sterse din domeniu odata ce sunt folosite,
soluția generata este garantata sa nu contina duplicate.
Astfel, atunci cand domeniul ajunge vid, soluția este intotdeauna corecta */
bool check(vector<int> solution) {
    return true;
}

void printSolution(vector<int> &solution) {
    for (int s : solution) {
        cout << s << " ";
    }
    cout << "\n";
}

void back(int start, int k, vector<int> &domain, vector<int> &solution) {
    /* dupa ce am folosit toate elementele din domeniu putem verifica daca
    am gasit o solutie */
    if (solution.size() == k) {
        if(check(solution)) {
            printSolution(solution);
        }
        return;
    }

    /* incercam sa adaugam in solutie toate valorile din domeniu, pe rand */
    for (unsigned int i = start; i < domain.size(); ++i) {
        /* retinem valoarea pe care o scoatem din domeniu ca sa o readaugam dupa
        apelarea recursiva a backtracking-ului */
        int tmp = domain[i];

        /* adaug elementul curent la potentiala solutie */
        solution.push_back(domain[i]);
        /* sterg elementul curent din domeniu ca sa il pot pasa prin referinta
        si sa nu fie nevoie sa creez alt domeniu */
        domain.erase(domain.begin() + i);

        /* apelez recursiv backtracking pe domeniul si solutia modificate */
        back(i, k, domain, solution);

        /* refac domeniul si solutia la modul in care aratau inainte de apelarea
        recursiva a backtracking-ului, adica readaug elementul eliminat in
        domeniu si il sterg din solutie */
        domain.insert(domain.begin() + i, tmp);
        solution.pop_back();
    }
}

int main() {
    int n;
    // Citim n de la tastatura
    cin >> n;

    /* dupa ce am citit n initializam domeniul cu n elemente, numerele de la 1 la n,
    iar solutia este vida initial */
    vector<int> domain(n), solution;
    for (int i = 0; i < n; ++i) {
        domain[i] = i + 1;
    }

    /* apelam backtracking pe domeniul nostru, cautand solutia in vectorul solution */
    for (int i = 1; i <= n; i++)
        back(0, i, domain, solution);

    return 0;
}