{$M 65520,0,655360}
program gelezinkelio_groteles;

   const PR = 'GROTEL.DAT';
         MAX_N = 16000; { maksimalus teksto ilgis }
         MAX_K = 6000;  { maksimalus pirmojo simbolio pasikartojim— skai‡ius }
   type tekstas = array [1..MAX_N] of char;
        lentele = array [1..MAX_K] of integer;

   { ‘emiau apražyti globalieji kintamieji, kuriuos perskai‡ius
     j— reikžm‚s daugiau nekei‡iamos }
   var n: integer;  { žifro ilgis }
       sif: tekstas; { pats žifras }
       fr: string;  { fragmentas }

   procedure init (var t: tekstas);
     { masyv… t u‘pildome fiktyviais simboliais }
     var i: integer;
   begin
     for i := 1 to n do
       t[i] := chr(1);
   end; { init }

   procedure delioti (e,   { kuri eilut‚ d‚liojama }
                      k: integer; { nagrin‚jamas aukžtis }
          var poz: integer; { nuo kurios žifro raid‚s ražoma }
          var t: tekstas;
          var len: lentele ; { viet—, kur dar galima ražyti fr, lentel‚ }
          var ilg,           { tos lentel‚s ilgis }
              iras: integer { kelios pirmosios raid‚s jau ražytos tekste });
     { sud‚lioje e-osios eilut‚s simbolius }
     var stu, { simbolio, kur dabar ražysime, stulpelis }
         post1, post2: integer;
         pirmas: boolean;
   begin
     if (e = 1) or (e = k)
        then begin  post1 := 2*k - 2;   post2 := 2*k - 2; end
        else begin  post1 := 2*k - 2*e; post2 := 2*e - 2; end;
     pirmas := true; { prad‚sime nuo pirmojo post–mio }
     stu := e; { pirmojo e-sios eil. simbolio stulpelis }
     while stu <= n do
       begin
          t[stu] := sif[poz];
          if sif[poz] = fr[1]  { jei raž‚me pirm… fragmento raidŠ }
            then begin
                   ilg := ilg + 1;
                   len[ilg] := stu;  {  sid‚mime pozicij… }
                   iras := iras + 1; {  gal nuo jos galima ražyti fragment… }
                 end;
          poz := poz + 1;
          if pirmas then stu := stu + post1
                    else stu := stu + post2;
          pirmas := not pirmas;
       end;
   end; { d‚lioti }

   procedure paieska (const t: tekstas; var len: lentele;
                      var ilg: integer; var rasta: boolean);
     { iežko fragmento fr dalinai ižžifruotame tekste t; kartu skai‡iuoja
       keliose vietose yra galimyb‚ rasti fragment… dežifravus tekst…  }
     var i, j, stu: integer;
         gerai, tarpas: boolean;
   begin
     i := 1;  rasta := false;
     while (i <= ilg) and not rasta do
       begin
         stu := len[i];
         if stu > n - length(fr) + 1 { jei fragmentas nebetilps }
            then begin                  { tekste }
                   len[i] := len[ilg];
                   ilg := ilg - 1;
                 end
         else begin { jei fragmentas tilps nuo i-osios pozicijos }
                gerai := true; { nerasta nesutampan‡i— simboli— }
                tarpas := false; { nerasta neražyt— simboli— }
                j := 0;
                while gerai and (j < length(fr)-1) do
                  begin
                    j := j + 1;
                    { ar galima ražyti fragment… nuo i-osios pozicijos }
                    if t[stu+j] = chr (1)     { jei tekstas neu‘pildytas }
                       then tarpas := true    { ten gali b–ti bet koks simbolis }
                       else gerai := t[stu+j] = fr[1+j];
                  end;
                 if gerai
                    then if not tarpas
                            then rasta := true
                            else i := i + 1
                    else begin
                           len[i] := len[ilg];
                           ilg := ilg - 1;
                         end;
              end
       end
   end; { paiežka }

   function aukstis: integer;
     var ilg, poz, e, iras, i, stu, k, pirm: integer;
         rasta: boolean;
         t: tekstas;
         len: lentele;
   begin
     k := 2;     { prad‚sime nuo tokio aukž‡io }
     { suskai‡iuojame kiek kart— tekste sutinkama pirmoji fragmento raid‚ }
     pirm := 0;
     for i := 1 to n do
       if sif[i] = fr[1]
          then pirm := pirm + 1;
     rasta := false;
     while not rasta do
       { tikrina, ar tinkamas aukžtis k }
       begin
         poz := 1;    { prad‚sime nuo pirmojo u‘ifruoto teksto simbolio }
         init (t); { inicializuojamas masyvas t }
         iras := 0;   { kelios pirmosios raid‚s jau ražytos tekste }
         ilg := 0;    { lentel‚ len dar tuž‡ia }
         for e := 1 to k do
           { sudarome e-…j… eilutŠ }
           begin
             delioti (e, k, poz, t, len, ilg, iras);
             paieska (t, len, ilg, rasta);
             if not rasta
                then if (pirm = iras) and (ilg = 0 )
                      { aklaviet‚ - fragmento niekur negalima ražyti }
                      then break;
           end;
         k := k + 1;
       end;
     aukstis := k - 1;
   end; { aukžtis }

   procedure skaityti (var n: integer; var fr: string;
                       var sif: tekstas);
     var f: text;
         i, stu, eil: integer;
         s: string;
   begin
     assign (f, PR);
     reset (f);
     readln (f, n);
     readln (f, fr);
     stu := 1;
     if n mod 100 <> 0
        then eil := n div 100 + 1 { kelias eilutes reikia}
        else eil := n div 100;    { perskaityti }
     for i := 1 to eil do
       begin
         readln (f, s);
         move (s[1], sif[stu], length(s));
         stu := stu + length(s)
       end;
     close (f);
   end; { skaityti }

  var rez: integer;
begin
  skaityti (n, fr, sif);
  rez := aukstis;
  writeln (rez);
end.

