poszukiwanie lemura, które działa

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <time.h>
pthread_mutex_t blokada = PTHREAD_MUTEX_INITIALIZER;

const int n=1000;
char bufor[1000];
char lemurowy_bufor[1000];
int buf_poczatek=0;
int buf_dlugosc=0;
int pocz=0;
int dlug=0;
int koniec=0;

int push(char x)
{
    if(buf_dlugosc>=n)
                return -5;
        //bufor pelny

        buf_dlugosc++;
        bufor[(buf_dlugosc+buf_poczatek-1)%n]=x;
        return 0;
}

char pop()
{
        char x = 'e';
        if(buf_dlugosc > 0)
        {
        x = bufor[buf_poczatek];
        buf_poczatek= (buf_poczatek+1)%n;
        buf_dlugosc-=1;
        }
        return x;
}

int lemurowy_push(char x)
{
        if(dlug>=n)
                return -5;
        //bufor pelny
        lemurowy_bufor[(dlug+pocz)%n]=x;
        dlug+=1;

        return 0;
}

char lemurowy_pop()
{
        char x = 'e';
        if(dlug>0)
        {
        x = lemurowy_bufor[pocz];
        pocz=(pocz+1)%n;
        dlug-=1;
        }
        else
        {
                printf("lemurowy bufor pusty\n");
        }
        return x;
}

void *hodowlaLemurow(void *arg) {
        char litera;
        char poszukiwana = 'L';
        printf("hodowla lemurów wystartowała\n");
        while(1)
        {
                if(koniec==1)
                        break;

                if(buf_dlugosc>=1000)
                {
                        //printf("nie ma miejsca na lemury\n");
                }
                else
                {
                        //generujemy jakiekolwiek litery;
                        litera=(rand()%26)+65;
                        //printf("generuje litere %c\n", litera);
                        pthread_mutex_lock(&blokada);
                        push(litera);
                        pthread_mutex_unlock(&blokada);
                }

                //sleep(20);
                //puszukiwanie lemura w buforze 2
                if(dlug>=5)
                {
                //printf("ilosc liter w lemurowym buforze wystarczajaca do rozpoczecia poszukiwan \n");
                pthread_mutex_lock(&blokada);
                litera = lemurowy_pop();
                printf("%c", litera);
                pthread_mutex_unlock(&blokada);

                switch(litera)
                {
                        case 'L':
                        {
                                if(poszukiwana == 'L')
                                        poszukiwana = 'E';
                                else
                                        poszukiwana = 'L';
                                break;
                        }
                        case 'E':
                        {
                                if(poszukiwana == 'E')
                                        poszukiwana = 'M';
                                else
                                        poszukiwana = 'L';
                                break;
                        }
                        case 'M':
                        {
                                if(poszukiwana == 'M')
                                        poszukiwana = 'U';
                                else
                                        poszukiwana = 'L';
                                break;
                        }
                        case 'U':
                        {
                                if(poszukiwana == 'U')
                                        poszukiwana = 'R';
                                else
                                        poszukiwana = 'L';
                                break;
                        }
                        case 'R':
                        {
                                if(poszukiwana == 'R')
                                {
                                    koniec=1;
                                        printf("\nOMG!!!\nLEMUR ODNALEZIONY!!\n");
                                }
                                else
                                        poszukiwana = 'L';
                                break;
                        }
                }
                }
                //else
                        //printf("malo lemurow\n");

        }
        printf("kończę z produkcją bo LEMUR odnaleziony\n");
        pthread_exit(NULL);
}

void *przepisywaczLemurow(void *arg)
{
        char litera;
        printf("przepisywacz lemurow zostal uruchomiony\n");
        //przepisywanie bufora na lemurowy_bufor
        while(1)
        {
        if(koniec == 1)
                break;

        pthread_mutex_lock(&blokada);
        if(buf_dlugosc>0)
        {
        litera = pop();

        if(litera == 'L' || litera == 'E' || litera == 'M' || litera == 'U' || litera == 'R')
        {
                        lemurowy_push(litera);
        }
        }
        pthread_mutex_unlock(&blokada);


        }

        printf("przepisywanie zakonczone, LEMUR odnaleziony\n");
        pthread_exit(NULL);
}

int main(void) {
        printf("poszukiwacz lemurów, wersja nieskończonosc\n");
        pthread_t hodowla;
        pthread_t przepisywacz;
        srand(time(NULL));

  //if ( pthread_create( &hodowla, NULL, hodowlaLemurow, NULL) ) {
  //      printf("błąd przy tworzeniu wątku\n.");
  //      abort();
  //}

   // if ( pthread_create( &poszukiwacz, NULL, poszukiwaczLemurow, NULL) ) {
   //     printf("błąd przy tworzeniu wątku\n.");
    //    abort();

        pthread_create( &hodowla, NULL, hodowlaLemurow, NULL);
        //sleep(1);
        pthread_create( &przepisywacz, NULL, przepisywaczLemurow, NULL);
        pthread_join(hodowla, NULL);
        pthread_join(przepisywacz, NULL);

  return 0;
  }