function annotations = findDeccelerations(analysedSignal,lowBorderDist,upBorderDist,lowLength,upLength,amplitudaKonca)
    % Glowna funkcja algorytmu wykrywania spadkow RS. Funkcja znajduje w
    % sygnale wejsciowym spadki w sygnale, ktorych dlugosc jest zawarta w
    % przedziale <lowLength,upLength>, oraz amplituda poczatku sygnalu
    % zawiera sie w procentowym przedziale <lowBorderDist,upBorderDist> 
    % dystrybucji  wszystkich wartosci amplitud w calym sygnale. Przez
    % spadek rozumiemy tutaj ciag monotonicznie malejacych wartosci.
    % Dopuszczalne jest zlamanie monotonicznosci dla jednej probki (taki
    % zadzior na sygnale spowodowany szumem).
    %
    % WEJSCIE:
    % analysedSignal - odtrendowiony sygnal wejsciowy, niekoniecznie EKG
    % lowBorderDist  - dolna granica przedzialu, w ktorym znajdzie sie
    %                  amplituda poczatku spadku ( zakres od 0 do 1 )
    % upBorderDist   - gorna granica przedzialu, w ktorym znajdzie sie
    %                  amplituda poczatku spadku ( zakres od 0 do 1 )
    % upBorderDist   - gorna granica przedzialu dopuszczalnych dlugosci 
    %                  spadkow, wyrazona w probkach
    % lowLength      - gorna granica przedzialu dopuszczalnych dlugosci 
    %                  spadkow, wyrazona w probkach
    % amplitudaKonca        - parametr  oznacza wymuszenie koniecznosci przejscia
    %                  wyszukanego spadku przez ta wskazana wartosc.
    % WYJSCIE:
    % annotations    - posortowana tablica polozen poczatkow kazdego z 
    %                  wykrytych ciagow spadkow, wyrazona w probkach
    
    
    
    N=size(analysedSignal,1);                                               % N - dlugosc analizowanego sygnalu
    sortowane = sort(abs(analysedSignal));                                  % sortuje rosnaco wartosci bezwzgledne wszystkich wartosci wystepujacych w sygnale, 

    prog1 = sortowane(round(size(sortowane,1)*lowBorderDist));              % obliczam wartosc liczbowa, ktora odpowiada (lowBorderDist*100) procentom dystrybucji wszystkich wartosci w sygnale
    if(upBorderDist == 1)                                                   % jesli granica gorna ampltudy wynosi 100%, upewnij sie, ze liczbowo bedzie wieksza od maksymalnej amplitudy w sygnale, 
        prog2 = max(sortowane) + 1.0;                                       % tak by nie bylo ograniczenia z gory na amplitude poczatku spadku
    else
        prog2 = sortowane(round(size(sortowane,1)*upBorderDist));           % jesli granica gorna amplitudy < 100% dystrybucji wartosci amplitud - oblicz ja
    end
    prog3 = prog1/30;                                                       % prog 3 - maksymalna wysokosc dopuszczalnego "zadzioru" w sygnale ( o tyle 1 probka w sygnale moze odbiegac od monotonicznosci)
    
    ECGdiffs=diff(analysedSignal);                                          % ciag roznic pomiedzy sasiednimi probkami ("pochodna dyksretna")
    
    % glowna czesc algorytmu - najlepiej to sobie rozrysowac
    SplitPositions=[];                                                      % SplitPositions - na razie pusta tablica, w ktorej bedziemy zawierac polozenia probek nie nalezacych do ciagu spadku; tzw."probki graniczne"
    
    i = 1;                                                                  % iterator glownej petli do podzialu 
    while ( i < size(ECGdiffs,1)-1 )                                        % idziemy, od 1 probki, po wszystkich probkach sygnalu - 1
        if ECGdiffs(i,1) <= 0 && ECGdiffs(i+1,1) <= 0                       % jesli roznica pomiedzy aktualna probka i+1 a probka i jest ujemna, oraz probka i+2 a probka i+1 jest ujemna - nie zapisuj probki jako "granicznej"
            i=i+1;
            
        elseif ECGdiffs(i,1) <= 0 && ECGdiffs(i+1,1) <= prog3               % jesli roznica pomiedzy aktualna probka i+1 a probka i jest ujemna, oraz roznica miedzy probkami i+2 a probka i+1 jest mniejsza niz prog 3 - wejdz w ifa
            if ECGdiffs(i+2,1) >0                                           % jesli roznica pomiedzy  probka i+3 a probka i+2 jest dodatnia, to spadek sie skonczyl, wiec zapisujemy polozenie i+1 jako "graniczne",          
                SplitPositions(end+1,1)=i+1;                                % zapisujemy polozenie i+1 jako "graniczne" do tablicy  SplitPositions i przechodzimy do nastepnej probki, do nastepnej eqolucji petli while
                i=i+1;
            else                                                            % a jesli roznica pomiedzy  probka i+3 a probka i+2 jest ujemna, to byl zadzior i wciaz jestesmy wewnatrz spadku, mozemy przejsc o 2 probki do przodu
                i=i+2;
            end
        else                                                                % jeslizaden z w/w warunkow nie zadzialal - nie jestesmy wewnatrz spadku, zapisujemy polozenie i+1 jako "graniczne"
            SplitPositions(end+1,1)=i+1;
            
            i=i+1;    %!!!!!!!!!!                                           % przechodzimy do nastepnej probki, do nastepnej eqolucji petli while
        end   
    end
    
    % w tym momencie, w SplitPositions mamy polozenia wszystkich probek,
    % ktore nie znajduja sie wewnatrz spadku, posortowane rosnaco. Teraz,
    % jesli odejmiemy od siebie sasiednie elementy tablicy SplitPositions,
    % otrzymamy tablice dlugosci spadkow w sygnale (brak spadku jest
    % rownoznaczny z dlugoscia = 1)
    
    
    piki = [];                                                              % piki - tu bedziemy przetrzymywac polozenia poczatkow spadkow o okreslonych parametrach (czyli np. polozen pikow R)
    RSlength = [];
    Rposition = [];
    if isempty(SplitPositions)~=1                                           % jesli w ogole w sygnale byly spadki ,to...
        dlugoscipochodow = diff(SplitPositions);                            % oblicz tablice dlugosci spadkow w sygnale nazwana "dlugoscipochodow"
        for j=1:size(dlugoscipochodow,1)-1                                  % petla po tablicy z dlugosciami spadkow. Wez  element...
            if lowLength <= dlugoscipochodow(j,1) &&...                     % jesli dana dlugosc spadku jest >= od lowLength, i ...
               upLength  >= dlugoscipochodow(j,1) &&...                     %       dana dlugosc spadku jest <= od upLength, i ...
               prog1 <= analysedSignal(SplitPositions(j),1) &&...           %       amplituda poczatku spadku jest >= prog1 ...
               analysedSignal(SplitPositions(j+1)-1,1) <= amplitudaKonca &&... %    amplituda probki z  konca spadku jest <= amplitudaKonca ...
               prog2 >= analysedSignal(SplitPositions(j),1)                 %      amplituda poczatku spadku jest <= prog2 
%                      MAXneighbour=0;                                        %  to.
%                      if(SplitPositions(j)-20>=1 &&SplitPositions(j)+20 <= N)       
%                            for iterRR=SplitPositions(j)-20:SplitPositions(j)-5
%                              if  abs(analysedSignal(iterRR))>MAXneighbour
%                                  MAXneighbour= max(abs(analysedSignal(iterRR)));
%                              end
%                            end
%                            for iterRR=SplitPositions(j)+5:SplitPositions(j)+20
%                              if  abs(analysedSignal(iterRR))>MAXneighbour
%                                  MAXneighbour= max(abs(analysedSignal(iterRR)));
%                              end
%                            end
%                      end
%                      if(MAXneighbour>prog2)
%                      else
                        RSlength(end+1,1) = dlugoscipochodow(j,1);           % wykryj i zapisz dlugosci spadkow 
                        piki(end+1,1) = SplitPositions(j);                  % oznacz oficjalnie poczatek spadku jako zgodny z warunkami i wstaw jego polozenie wyrazone w probkach do tablicy piki.
                        Rposition(end+1,1) = analysedSignal(SplitPositions(j),1); 
                        %end
            end  
        end
    end
    annotations=piki;                                                       % wypisz znalezione poczatki spadkow na wyjscie.
    length = RSlength;
end