{$M 65520,0,655360}
program sveciai_is_Japonijos;
  { 172 u‘davinys }
  { U‘davinys suvestas  Maksimalaus srauto algoritm… }
  const MAX_M = 102; { maksimalus mazg— skai‡ius }
  type lentele1 = array [1..MAX_M] of integer;
       lentele2 = array [1..MAX_M, 1..MAX_M] of integer;
       aibe = set of 1..MAX_M;

  procedure ivesti (var sv: lentele2; var maz, n, m: integer);
  { veda pradinius duomenis }
    var u, v, i, j, sk, jap, viet_nr, jap_nr: integer;
        f: text;
  begin
    assign (f, 'JAPON.DAT');
    reset (f);
    readln (f, n, m);
    { randame mazg— skai‡i— }
    maz := n + m + 2;
    { pradin ir galin mazg… sujungiame su reikiamomis briaunomis }
    for u := 1 to maz do
      for v := 1 to maz do
         if (u = 1) and (v >= 2) and (v <= n + 1) or
            (v = maz) and (u >= n + 2) and (u <= n + m + 1)
            then sv[u, v] := 1
            else sv[u, v] := 0;
    { sujungiame likusius mazgus }
    for i := 1 to n do
      begin
        read (f, sk);
        for j := 1 to sk do
          begin
            read (f, jap);
            viet_nr := i + 1;
            jap_nr := n + 1 + jap;
            sv[viet_nr, jap_nr] := 1;
          end
      end;
    close (f)
  end; { vesti }

  procedure max_srautas (maz: integer; sv: lentele2;
                         var s: lentele2);
  { randa maksimal— sraut… grafe }
    var e, { eil‚ }
        h, bakas: lentele1;  { virž–ni— aukž‡iai ir bakas }
        u, galva, uodega: integer;
        virs: aibe;

    procedure inicializuoti (var h, bakas: lentele1; { aukžtis ir bakas }
                             var s: lentele2 { srautas });
    { inicializuoja h, s, bakas }
      var u, v: integer;
    begin
      for u := 1 to MAX_M do
        begin
          h[u] := 0;
          bakas[u] := 0;
        end;
     for u := 1 to MAX_M do
       for v := 1 to MAX_M do
         begin
           s[u, v] := 0;
           s[v, u] := 0;
         end;
    end; { inicializuoti }

    procedure itraukti_i_eile (u: integer;  var virs: aibe;
                               var e:lentele1; var uodega: integer);
    { traukia  eil‚s pabaig… virž–nŠ u }
    begin
      virs := virs + [u];
      e[uodega] := u;
      if uodega = MAX_M
         then uodega := 1
         else uodega := uodega + 1;
    end; { traukti__eilŠ }

    procedure pasalinti_is_eiles (var galva: integer; var virs: aibe);
    begin
      virs := virs - [u];
      if galva = MAX_M
         then galva := 1
         else galva := galva + 1
    end; { pažalinti_iž_eil‚s }

    procedure pakelti (u: integer; { keliama virž–n‚ }
                       var h: lentele1 { virž–ni— aukž‡iai });
    { padidinamas u aukžtis }
    { vartojami global–s kintamieji maz, s, sv }
      var mini, v: integer;
          galima: boolean;
    begin
      galima := true; { ar galima pakelti virž–nŠ }
      mini := 0;
      for v := 1 to maz do
        if (sv[u, v] - s[u, v] > 0)
           then if (h[u] <= h[v])
                   then begin
                          if mini = 0
                             then mini := v
                             else if h[v] < h[mini]
                                     then mini := v;
                        end
                   else galima := false;
      if galima
         then h[u] := h[mini] + 1
    end; { pakelti }

    function min (x, y: integer): integer;
    begin
      if x < y
         then min := x
         else min := y
    end; { min }

    procedure paleisti (u: integer;
                        var s: lentele2; { srautai }
                        var bakas: lentele1);
    { paleid‘ia virž–n‚s u bake esant sraut… }
    { vartojami global–s kintamieji maz, h, sv, e, uodega }
      var v, kiekis: integer;
    begin
      for v := 1 to maz do
        if (h[v] + 1 = h[u]) and (sv[u, v] - s[u, v] > 0)
           { jei v ‘emesn‚ ir  j… dar galima paleisti sraut… }
           then begin
                  kiekis := min (bakas[u], sv[u, v] - s[u, v]);
                  bakas[u] := bakas[u] - kiekis;
                  s[u, v] := s[u, v] + kiekis;
                  s[v, u] := -s[u, v];
                  bakas[v] := bakas[v] + kiekis;
                  if (bakas[v] > 0) and (v <> 1)
                  then if (v <> maz) and (not (v in virs))
                       then itraukti_i_eile (v, virs, e, uodega);
                end;
    end; { paleisti }

  begin
    inicializuoti (h, bakas, s);
    galva := 1; uodega := 1; { eil‚ tuž‡ia }
    virs := [];
    h[1] := maz; { pradin‚s virž–n‚s aukžtis }
    { paleid‘iame sraut… iž pradin‚s virž–n‚s }
    for u := 1 to maz do
      if sv[1, u] > 0
         then begin
                s[1, u] :=  sv[1, u];
                s[u, 1] := -sv[1, u];
                bakas[u] := sv[1, u];
                if u <> maz
                   then itraukti_i_eile (u, virs, e, uodega);
              end;
    while virs <> [] do
      begin
        u := e[galva];
        pasalinti_is_eiles (galva, virs);
        while bakas[u] > 0 do
          begin
            pakelti (u, h);
            paleisti (u, s, bakas)
          end;
      end;
  end; { max_srautas }

  procedure sutvarkyti (s: lentele2; n, m: integer; var japo: lentele1);
  { pertvarko rezultatus  tinkam… pavidal… }
    var pirmas, i, u, v: integer;
        viet: lentele1;
  begin
    for i := 1 to n do
      viet[i] := 0;
    for i := 1 to m do
      japo[i] := 0;
    { sudarysime japon— bei vietini— moksleivi— apgyvendinimo lenteles }
    for u := 2 to n + 1 do
      for v := n + 2 to n + m + 1 do
         if s[u, v] <> 0
            then begin
                   viet[u-1] := v - (n+1);
                   japo[v - (n+1)] := u - 1;
                 end;
    { rasime pirm…j sve‡io neturint vietin moksleiv }
    pirmas := 1;
    while (viet[pirmas] <> 0) and (pirmas < n) do
      pirmas := pirmas + 1;
    { apgyvendinsime kiekvien… japon— moksleiv }
    for u := 1 to m do
      begin
        if japo[u] = 0 { jei sve‡ias dar neapgyvendintas }
           then begin
                  japo[u] := pirmas; { apgyvendiname j }
                  viet[pirmas] := u;
                  { randame kit… sve‡io neturint vietin moksleiv }
                  while (viet[pirmas] <> 0) and (pirmas < n) do
                    pirmas := pirmas + 1;
                 end;
      end;
  end; { sutvarkyti }

  procedure isvesti (japo: lentele1; m: integer);
     var f: text;
         i: integer;
  begin
    assign (f, 'JAPON.REZ');
    rewrite (f);
    for i := 1 to m do
      writeln (f, japo[i]);
    close (f);
  end; { ižvesti }

  var sv, s: lentele2;
      japo: lentele1;
      maz, n, m: integer;
begin
  ivesti (sv, maz, n, m);
  max_srautas (maz, sv, s);
  sutvarkyti (s, n, m, japo);
  isvesti (japo, m);
end.

