#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

unsigned int convert(char *hodnota)//funkce, ktera pretypuje N (vstup char a vystup unsigned int
{
unsigned int cislo=0,preteceni=0;
unsigned int i=0;
while(hodnota[i]!='\0')
  {
  if (hodnota[i]<='0' && hodnota[i]>'9') //osetreni, ze N je cislo (osetreni i pro to, ze cilo je kladne)
    {
    return 0;
    }
  hodnota[i]=hodnota[i]-'0';    //zaskani presne hodnoty cisla z nejake ascii hodnoty

  preteceni=cislo;
  cislo=cislo*10;
  cislo=cislo+hodnota[i]; //pokud uz proslo pripocte k 10tinasobku predchoziho cila prave nastene cislo
  i++;
  if(preteceni>cislo)   //doslo k preteceni - jednicka vypadla ven a jede se od nuly
    {
    return 0;       //kdyz vrati nulu - doslo k chybe (zde z duvodu preteceni)
    }
  }
return cislo;
}


/*------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
/*------------------------------------------------------------------------------------------------------------------------------------------------------------------*/


int komprimace(unsigned int N)
{
printf("Komprimace %d \n",N);

char *buffer1 = malloc((N+1) * sizeof(char));//definice bufferu a jejich dynamické alokování

if(buffer1==NULL)
{
return 1;
}

char *buffer2 = malloc((N+1) * sizeof(char));

if (buffer2==NULL)
{
free(buffer1);
return 1;
}
memset(buffer1, 0, (N+1) * sizeof(char));
memset(buffer2, 0, (N+1) * sizeof(char));
printf("memtest probehl vporadku\n");

unsigned int i=0,pocet=1,proslo=0; //vlozeni pomocnych promenych (pocet je promena, do ktere se bude vkladat pocet shodujicich se blokù znakù)
char c=0;







while((c = getchar()) != EOF)
  {
 if (isblank(c)!= 0)
  {
  unsigned int k=0, l=0;
  printf("Je tam mezera\n");
  while(k < N)
      {
      putchar (buffer1[l%N]);
      k++;
      l++;
      while((k>=N) && k < (2 * (N-1)))
        {
        putchar (buffer2[l%N]);
        k++;
    l++;
        }
      }
memset(buffer1, 0, (N+1) * sizeof(char));
memset(buffer2, 0, (N+1) * sizeof(char));
i=0;
  }


    if(i < N)               //prvotní nacteni do bufferu ze vstupu
      {
      buffer1[i%N] = c;
      i++;
      }
      else if(i < 2 * N)
        {
        buffer2[i%N] = c;
        i++;
    printf("prvotni nacteni do bufferu probehlo\n");
        }



while(strcmp(buffer1, buffer2) == '0')        //porovnani buffer (jestli se bloky neopakuji
  {
  printf("Buffery se rovnají\n");
  proslo=1;
  pocet++;                                  //pokud se tovnaji naèti do bufferu 2 dalsi blok znakù a znovu skoc na provnavani
  printf("rovnaji se %d \n",N);
  unsigned int ochrana=0;
  while((c=getchar())!= EOF && ochrana!=N)
    {
    ochrana++;
    i++;
    buffer2[i%N]=c;
    }
  }

if(proslo==1){
 putchar(pocet);
  for (unsigned int misto=0;misto<N;misto++)
    {
    putchar(buffer1[misto%N]);
    }
  proslo=0;
  }

if(buffer2[N-1]!=0)
{
    unsigned int j=0;
    putchar(buffer1[j%N]);

    while(j<(N-1))
      {
      buffer1[j%N]=buffer1[(j+1)%N];
      j++;
      }

    while(j==(N-1))
      {
      buffer1[j%N]=buffer2[(j+1)%N];     // PRESUNUTI PRVNIHO ZNAKU Z BUFFERU2 NA POSLEDNI ZNAK BUFFERU 1
            j++;
      }

    while ((j>(N-1)) && (j<((2*N)-1)))
      {
      buffer2[j%N]=buffer2[(j+1)%N];
      j++;
      }



}
}
return 0;
}




int main(int argc, char *argv[])
{
unsigned int N=(convert(argv[1]));
komprimace(N);
return 0;
}