const MaxN = 1000; { maximalni delka textu }

var
 A: array [1..MaxN] of char; { pole pro ulozeni textu }
 N: Integer; { delka textu }
 G: array [1..MaxN] of Integer; { pole pro ulozeni vysledku, G[h] obsahuje }
     { identifikator skupiny useku, do ktere patri usek zacinajici na pozici h }
 I,J,K,L: Integer; { pomocne promenne }
 Max: Integer; { maximalni delka shodneho useku }
 Current: Integer; { aktualni delka shodneho useku }

begin
 N := 0;
 while not eof do { precteni textu ze standardniho vstupu }
  begin
   N := N + 1;
   if N > MaxN then Halt(1); { kdyby nas chtel nekdo zmast, tak se kousnem }
   if eoln then begin A[N] := ' '; readln end { konce radku nahradime mezerama }
    else read(A[N])
  end;

 { nejdrive pouze najdeme delku nejdelsiho opakujiciho se useku }

 Max := 0;
 for J := 1 to N - 1 do { pro vsechny mozne posuny }
  begin
   Current := 0;
   for I := 1 to N - J do { prohledej text }
    if A[I] = A[I + J] then
      begin
       Current := Current + 1;
       if Current > Max then Max := Current
      end
     else Current := 0;
  end;

 if Max = 0 then
   begin writeln('Neexistuje zadny opakujici se usek.'); exit end;

 for I := 1 to N do G[I] := 0; { vynulovani pole s vysledky }
  { G[I] = 0 -> usek nepatri do zadne skupiny }

 for J := 1 to N - 1 do { jeste jednou na ostro }
  begin
   Current := 0;
   for I := 1 to N - J do
    if A[I] = A[I + J] then
      begin
       Current := Current + 1;
       if Current = Max then { nasli jsme dvojici }
         begin
          if G[I - Max + 1] = 0 then
            if G[I + J - Max + 1] = 0 then
              begin { ani jeden usek zatim nepatri do zadne skupiny }
               G[I - Max + 1] := I - Max + 1; { zalozime jim tedy novou }
               G[I + J - Max + 1] := I - Max + 1;
              end
             else
              { prvni usek dame skupiny jako druheho }
              G[I - Max + 1] := G[I + J - Max + 1]
           else
            if G[I + J - Max + 1] = 0 then
              { druhy blok dame do skupine prvniho }
              G[I + J - Max + 1] := G[I - Max + 1]
             else
              begin
               K := G[I + J - Max + 1];
               { skupinu prvniho bloku pridame ke skupine druhe pouze, kdyz se lisi! }
               if K <> G[I - Max + 1] then
                 for L := 1 to N do
                  if G[L] = K then G[L] := G[I - Max + 1];
              end;
         end;
      end
     else Current := 0;
  end;

 { vypsani vysledku }

 writeln('Maximalni delka opakujicich se useku je ', Max);
 writeln('Pozice opakujicich se useku:');
 for I := 1 to N do
  if G[I] > 0 then
    begin
     write(I);
     for J := I + 1 to N do
      if G[I] = G[J] then
        begin write(' - ', J); G[J] := 0 end;
     writeln;
     G[I] := 0;
    end;
end.