program kryziazodis;
  { 54 u‘davinys }
  const MAX = 40; { maksimalus kry‘ia‘od‘io dydis }
        Z_MAX = 100; { maksimalus ‘od‘i— skai‡ius }
        M_ILG = 10; { maksimalus ‘od‘io ilgis }
        PAV_BYLA = 'PAV.DAT';
        ZOD_BYLA = 'ZOD.DAT';
        REZ_BYLA = 'KRY.REZ';
  type kryz = array [1..MAX, 1..MAX] of char;
       zodynas = array [1..Z_MAX] of record
                                       zod : string [Z_MAX];
                                       ir : boolean; { ar Ťražytas ‘odis }
                                     end;
       kryptys = (hor, vert);
       duomenys = array [1..Z_MAX] { duomenys apie tuž‡ias vietas }
                        of record  { ‘od‘iams Ťražyti }
                             x, y, { pradinio langelio koordinat‚s }
                             ilgis : integer; { Ťražomo ‘od‘io ilgis }
                             kryptis : kryptys; { ‘od‘io kryptis }
                           end;
       numeriai = array [1..Z_MAX] of boolean;

  procedure viena_vieta (var vt : duomenys; var sk : integer;
                         x, y, ilgis : integer; kr : kryptys);
    { Ťražo informacij… apie vien… tuž‡i… viet… }
  begin
    sk := sk + 1;
    vt[sk].x := x;
    vt[sk].y := y;
    vt[sk].ilgis := ilgis;
    vt[sk].kryptis := kr;
  end;

  procedure vietos (k : kryz; m, n : integer;
                    var vt : duomenys; { duomenys apie tuž‡ias vietas }
                    var sk : integer { kiek yra tuž‡i— viet— });
    { surandamos tuž‡ios vietos kry‘ia‘od‘io paveiksle }
    var i, j, ilgis : integer;
  begin
   sk := 0;
   ilgis := 0;
   { rasime tuž‡ias vietas eilut‚se }
   for i := 1 to m do
     for j := 2 to n do
       if (k[i, j] = ' ') { langelis tuž‡ias }
          then ilgis := ilgis + 1
          else if k[i, j - 1] = ' ' { priež tai buvŠs langelis tuž‡ias }
                  then begin
                         if ilgis > 1 { radome tuž‡i… viet… }
                            then viena_vieta (vt, sk, i, j - ilgis, ilgis, hor);
                         ilgis := 0;
                       end;
   { rasime tuž‡ias vietas stulpeliuose }
   for j := 1 to n do
     for i := 2 to m do
       if (k[i, j] = ' ') { langelis tuž‡ias }
          then ilgis := ilgis + 1
          else if k[i - 1, j] = ' ' { aukž‡iau esantis langelis tuž‡ias }
                  then begin
                         if ilgis > 1 { radome tuž‡i… viet… }
                            then viena_vieta (vt, sk, i - ilgis, j, ilgis, vert);
                         ilgis := 0;
                       end

  end;



  procedure spresti (var k : kryz; { kry‘ia‘od‘io paveikslas }
                     m, n : integer; { jo dydis }
                     z : zodynas; { ‘odynas }
                     kiek : integer; { kiek jame ‘od‘i— }
                     var yra : boolean { ar yra sprendinys });
    var vt : duomenys;
        sk, ka, kur : integer;

    procedure trinti (ka, kur : integer; num : numeriai);
      { ižtrina Ťražyt… ‘odŤ iž  kry‘ia‘od‘io }
      var r, i, j, di, dj : integer;
    begin
      i := vt[kur].x;
      j := vt[kur].y;
      di := 0;        { kuria kryptimi trinsime }
      dj := 0;
      if vt[kur].kryptis = hor
         then dj := 1
         else di := 1;
      for r := 1 to length (z[ka].zod) do { ižtriname }
        begin
          if not num[r]
             then k[i, j] := ' ';
           i := i + di;
           j := j + dj;
         end;
      z[ka].ir := false;
    end; { trinti }

    procedure irasyti (ka, kur : integer;
                      var pasiseke : boolean; { ar pasisek‚ Ťražyti }
                      var num : numeriai { kurios raid‚s buvo Ťražytos });
      { Ťražo vien… ‘odŤ Ť kry‘ia‘odŤ }
      var r, i, j, di, dj : integer;
    begin
      pasiseke := true;
      for i := 1 to M_ILG do
        num[i] := false;
      i := vt[kur].x; { nuo žios vietos prad‚sime Ťražin‚ti }
      j := vt[kur].y;
      di := 0;        { kuria kryptimi Ťražin‚sime }
      dj := 0;
      if vt[kur].kryptis = hor
         then dj := 1
         else di := 1;
      for r := 1 to length (z[ka].zod) do
        begin
           if k[i, j] = ' '
              then k[i, j] := z[ka].zod[r]
              else begin
                     if k[i, j] <> z[ka].zod[r]
                        then pasiseke := false;
                        num[r] := true
                    end;
           i := i + di;
           j := j + dj;
        end;
      if pasiseke
         then z[ka].ir := true
         else trinti (ka, kur, num)
    end; { Ťražyti }

    procedure pildyti (ka, kur : integer { kurŤ ‘odŤ kur ražyti });
      { rekursin‚ proced–ra, u‘pildanti kry‘ia‘odŤ }
      var pasiseke : boolean;
          i : integer;
          num : numeriai; { kai Ťražomas naujas ‘odis, ‡ia Ťsimenamos }
                          { vietos, kuriose buvo Ťražytos raid‚s iž kit— }
                          { ‘od‘i— }
    begin
      if kur = 0
         then yra := true { pavyko u‘pildyti }
         else if length (z[ka].zod) = vt[kur].ilgis { jei ‘odŤ galima Ťražyti }
                 then begin { Ťražome ‘odŤ }
                        irasyti (ka, kur, pasiseke, num);
                        if pasiseke { Ťražin‚sime kitus ‘od‘ius }
                           then begin
                                  for i := 1 to kiek do
                                    if not yra and not z[i].ir
                                       { jei ‘odis neŤražytas }
                                       then pildyti (i, kur - 1);
                                   { ižtriname Ťražyt…jŤ ‘odŤ }
                                   if not yra
                                      then trinti (ka, kur, num);
                                 end;
                      end
    end; { pildyti }

  begin { sprŠsti }
    { surandame laisvas vietas kry‘ia‘odyje }
    vietos (k, m, n, vt, sk);
    yra := false; { sprendinio dar nerasta }
    ka := 0; { prad‚sime pildyti nuo pirmo ‘od‘io }
    while (ka <= kiek) and not yra do
      begin
        ka := ka + 1;
        pildyti (ka, sk);
      end;
  end;

  procedure nusk_kryz (var k : kryz; { kryziazodis }
                       var m, n : integer { jo eilu‡i—, stulpeli— skai‡ius });
    { nuskaito kry‘ia‘odŤ }
    var f : text;
        i : integer;
  begin
    assign (f, PAV_BYLA);
    reset (f);
    m := 1; n := 0;
    { perskaitysime pirm…j… eilutŠ }
    { ir su‘inosime stulpeli— skai‡i— }
    while not eoln (f) do
      begin
        n := n + 1;
        read (f, k[m, n]);
      end;
    readln (f);
    while not eof (f) do
      begin
        m := m + 1;
        for i := 1 to n do
          read (f, k[m, i]);
        readln (f);
      end;
  end;

  procedure nusk_zod (var z : zodynas; { ‘odynas }
                      var kiek : integer { kiek jame ‘od‘i— });
    { perskaito ‘odyn… }
    var f : text;
  begin
    assign (f, ZOD_BYLA);
    reset (f);
    kiek := 0;
    while not eof (f) do
      begin
        kiek := kiek + 1;
        readln (f, z[kiek].zod);
        z[kiek].ir := false;
      end;
  end;

  procedure spausdinti (k : kryz; m, n : integer;
                        yra : boolean { ar yra sprendinys });
    { spausdina rezultat… }
    var f : text;
        i, j : integer;
  begin
    assign (f, REZ_BYLA);
    rewrite (f);
    if not yra
       then writeln (f, 'Kry‘ia‘odis sprendinio neturi')
       else for i := 1 to m do
              begin
                for j := 1 to n do
                  write (f, k[i, j]);
                writeln (f);
              end;
    close (f);
  end;

  var k : kryz;
      z : zodynas;
      m, n, kiek : integer;
      yra : boolean;
begin
  nusk_kryz (k, m, n);
  nusk_zod (z, kiek);
  spresti (k, m, n, z, kiek, yra);
  spausdinti (k, m, n, yra);
end.