const
  MAXN = 50;
  MAXM = 50;          //это просто максимальные значения n и m

var
  n, m, i, j, max, max_i: int64;               //int64 - тип данных, можешь заменить на integer
  arr: array [1..MAXN, 1..MAXM] of int64;      //массив для входных данных
  firstIndex: array [1..MAXM] of int64;        //запоминаем индексы
  dp: array [1..MAXM] of int64;                //массив для подсчета динамики
  last: array [1..MAXM] of int64;             //массив для возврата по динамике

procedure qsort(k, a, b: int64);              //можешь заменить на свою сортировку
var
  c, d, e, x: int64;

begin
  if a < b then begin
    x := arr[k, a + random(b - a)];
    d := a;
    e := b;
    while d <= e do begin
      while arr[k, d] < x do inc(d);
      while arr[k, e] > x do dec(e);
      if d <= e then begin
        c := arr[k, d];
        arr[k, d] := arr[k, e];
        arr[k, e] := c;
        inc(d);
        dec(e);
      end;
    end;
    qsort(k, a, e);
    qsort(k, d, b);
  end;
end;

function check(k, p: int64): boolean;
var
  i: int64;

begin
  for i := 1 to n do begin
    if (arr[k, i] > arr[p, i]) then begin
      check := false;                                  //проверка, что один лежит внутри другого
      exit;
    end;
  end;
  check := true;
end;

function getV(k: int64): int64;
var
  i, ans: int64;

begin
  ans := 1;
  for i := 1 to n do                             //подсчет площади параллелепипеда
    ans *= arr[k, i];
  getV := ans;
end;

procedure swapArr(k, p: int64);
var
  i: int64;

begin
  for i := 1 to n do
    swap(arr[k, i], arr[p, i]);                              //процедура для обмена местами двух массивов
end;

procedure qsort1(a, b: int64);              //к сожалению, это не с++, чтобы писать два сорта в две строки
var
  d, e, x: int64;

begin
  if a < b then begin
    x := a + random(b - a);                        //random(b - a) - случайное число от 0 до b - a
    d := a;
    e := b;
    while d <= e do begin
      while getV(d) < getV(x) do inc(d);
      while getV(e) > getV(x) do dec(e);
      if d <= e then begin
        swapArr(d, e);                                       //функция выше
        swap(firstIndex[d], firstIndex[e]);                  //обмен элементов местами
        inc(d);
        dec(e);
      end;
    end;
    qsort1(a, e);
    qsort1(d, b);
  end;
end;

begin
  readln(n, m);
  for i := 1 to m do
    for j := 1 to n do
      read(arr[i, j]);               //ввод данных

  for i := 1 to m do begin
    qsort(i, 1, n);               //сортировка сторон по возрастанию длинн сторон
    firstIndex[i] := i;
  end;

  qsort1(1, m);
  for i := 1 to m do begin         //я точно не хочу это писать так, чтобы прога работала быстрее, особенно на паскале, особенно сейчас
    max := 0;
    for j := 1 to i - 1 do begin
      if ((check(j, i)) and (dp[j] > max)) then begin
        max := dp[j];                                    //поиск даибольшей возрастающей строки
        max_i := j;
      end;
    end;
    dp[i] := max + 1;
    if (max > 0) then last[i] := max_i
    else last[i] := -1;
  end;

  max := 0;
  for i := 1 to m do begin
    if (dp[i] > max) then  begin
      max := dp[i];                                       //поиск лучше возрастающей последовательности
      max_i := i;
    end;
  end;

  writeln('максимальное количество прямоугольников - ', max);        //вывод
  writeln('номера прямоугольников:');
  while (last[max_i] > -1) do begin
    writeln(firstIndex[max_i]);                                   //возврат по динамике
    max_i := last[max_i];
  end;
  writeln(firstIndex[max_i]);
end.