var

  N: Longint;

  Count: Longint;

  I: Longint;

 

procedure PrintSet(X: Longint);

var P: Integer;

begin

  write('{ ');

  P := N;

  while X <> 0 do

  begin

    if X mod 2 = 1 then write(P, ' ');

    Dec(P);

    X := X div 2;

  end;

  writeln('}');

end;

 

begin

  N := 5;

  Count := 1 shl N; { 2^N }

  for I := 0 to Count - 1 do

    PrintSet(I);

end.

function IntToStr(X: Longint): String;

var S: string;

begin

  Str(X, S);

  IntToStr := S;

end;

 

procedure PrintSet(N: Integer; S: string);

begin

  if (N = 0) then writeln('{ ', S, '}')

  else

  begin

    PrintSet(N - 1, S + ' ' + IntToStr(N));

    PrintSet(N - 1, S);

  end;

end;

 

begin

  PrintSet(5, '');

end.

const maxN = 100; { Максимальное число элементов в множестве }

var

  Bits: Array[1 .. maxN] Of Byte; { Массив битов }

  N: Longint;

  I: Longint;

begin

  ReadLn(N); { Считываем, какого размера множество }

  For I := 1 To N + 1 Do Bits[I] := 0; { Сначала у нас пустое подмножество }

  While (Bits[N + 1] = 0) Do { Пока не все множество состоит из 1 }

  Begin

    Write('{ '); { Выводим текущее подмножество }

    For I := 1 To N Do

      If Bits[I] = 1 Then Write(I, ' ');

    Writeln('}');

    I := 1; { Ищем следующее подмножество }

    While (Bits[I] = 1) Do

    Begin

      Bits[I]:=0;

      Inc(I);

    End;

    Bits[I]:=1;

  End;

End.

const maxN = 10; { Максимальная длина перестановки }

var

  Mas: Array[1 .. maxN] Of Byte; { Массив с перестановкой }

  N: Longint;

  I, J, K: Longint;

 

Procedure WritePerm; { Вывод перестановки на экран }

var I: Longint;

begin

  For I := 1 To N Do Write(Mas[I], ' ');

  Writeln;

end;

 

Procedure _Swap(I, K: Longint); { Меняет два элемента с индексами I и K }

var X: Byte;

begin

  X := Mas[I];

  Mas[I] := Mas[K];

  Mas[K] := X;

end;

 

begin

  ReadLn(N);

  For I := 1 To N Do Mas[I] := I; { Заполняем массив числами от 1 до N }

  While True Do

  Begin

    WritePerm; { Готова перестановка }

    I := N; { Проверяем с конца }

    While (I > 0) And (Mas[I] >= Mas[I + 1]) Do Dec(I); { Пока числа расположены в возрастающем порядке, продолжаем }

    If I = 0 Then Break; { Все числа расположены в возрастающем порядке, значит, все перестановки получены }

    For J := I + 1 To N Do { Ищем самое правое число, больше найденного }

      If (Mas[J] > Mas[I]) Then K := J;

    _Swap(I, K); { Меняем их }

    Inc(I);

    J := N;

    While (I < J) Do { Переворачиваем хвост перестановки }

    Begin

      _Swap(I, J);

      Inc(I);

      Dec(J);

    End;

  End;

end.

Const MaxN = 10; { Сколько цифр }

Type SMaxN = String[MaxN];

 

Procedure Permulate(N: Longint; S: SMaxN); { Сама процедура }

Var

  I: Longint;

  TmpS: SMaxN;

Begin

  If (N = MaxN) Then { Добавили последнюю цифру }

  Begin

    Writeln(S); { Новая перестановка в переменной S }

    Exit;

  End;

  For I := 0 To N Do { Добавляем еще по одной цифре(N) в каждое место }

  Begin

    TmpS:=S;

    Insert(Chr(Ord(N) + Ord('0')) ,TmpS, I + 1);

    Permulate(N + 1, TmpS); { Переход от шага N к шагу N+1 }

  End;

End;

 

Begin

  Permulate(0, '');

End.

Const MaxN = 100; { Максимальное число элементов в множестве }

 

Var

  Mas: Array[1 .. MaxN] Of Longint; { Текущее сочетание }

  N, M: Longint;

  I, J: Longint;

 

Procedure WriteComp; { Печать текущего сочетания }

Var I: Longint;

Begin

  For I := 1 To M Do Write(Mas[I], ' ');

  Writeln;

End;

 

Begin

  ReadLn(N, M);

  For I := 1 To M Do Mas[I]:=I; { Заполняем сочетание числами от 1 до M }

  While (True) Do

  Begin

    WriteComp; { Выводим сочетание }

    I := M;

    While (I > 0) And (Mas[I] = N - M + I) Do Dec(I); { Пока все правые  числа -  последние }

    If I = 0 Then Break; { Если все числа - последние, то все сочетания сгенерированы }

    Inc(Mas[I]); { Увеличиваем на 1 найденный не последний элемент }

    For J := I + 1 To M Do Mas[J]:=Mas[J - 1] + 1; { Переносим хвост }

  End;

End.