.type decrl @function
decrl:
    pushq   %rbp
    movq    %rsp, %rbp
    movq    16(%rbp), %rsi
    movq    24(%rbp), %rcx
    movq    $-1, %rdi
    stc
start:
    incq    %rdi
    sbbq    $0, (%rsi, %rdi, 8)
    jc  start
    movq    %rbp, %rsp
    popq    %rbp
    ret


.type sqrint @function
sqrint:
    push    %rbp
    mov %rsp, %rbp
    andq    %rax, %rax      # Sprawdzamy czy rax = 0
    jz  endf                # Jeśli tak do kończymy zwracając 0
    movq    %rax, %rdx      # Parametr n do rdx
    movq    $0, %rax        # Licznik / wynik
    movq    $1, %rbx        # Aktualna liczba nieparzysta
start:
    subq    %rbx, %rdx      # Odejmujemy aktualną nieparzystą
    jb  endf                # Jeśli wynik mniejszy od 0 to kończymy
    incq    %rax            # Inkremementacja licznika
    addq    $2, %rbx        # Kolejna liczba nieparzysta
    jmp start               # Zapętlenie
endf:
    mov %rbp, %rsp
    pop %rbp
    ret


.type fibonac @function
fibonac:
    pushq   %rbp
    movq    %rsp, %rbp
    movq    16(%rbp), %rcx
    movq    $0, %rbx            # F(0)
    movq    $1, %rax            # F(1)
    decq    %rcx                # Dekrementacja rcx
    jz  endf                    # Jeśli rcx = 0 to zwróć 1
    jns start                   # Jeśli rcx > 0 to skocz do pętli
    decq    %rax                # Jeśli rcx < 0 to zwróć 0
    jmp endf                    # I skocz na koniec
start:
    addq    %rax, %rbx          # F(n + 1) = F(n - 1) + F(n)
    xchgq   %rax, %rbx          # F(n - 1) <-> F(n)
    loop    start               # Pętla
endf:
    movq    %rax, 16(%rbp)      # Umieszczenie wyniku na stosie
    movq    %rbp, %rsp
    popq    %rbp
    ret


.type inverseb @function
inverseb:
    push    %rbp
    movq    %rsp, %rbp
    movq    16(%rbp), %rbx          # Adres liczby
    movq    24(%rbp), %rcx          # Parametr N

    movb    (%rbx), %al             # Kopia najbardziej znaczącego bajtu liczby w al
    andb    %al, %al                # Test
    jns endf                        # Jeśli SF = 0 (liczba dodatnia) to skocz na koniec
    stc                             # Ustaw CF = 1
negate:
    notq    -8(%rbx, %rcx, 8)       # (%rbx, %rcx, 8) wskazuje na przestrzeń ZA liczbą,
                                    # dlatego cofamy się o 8 bajtów do 8 najmniej znaczących bajtów liczby
    adcq    $0, -8(%rbx, %rcx, 8)   # Dodajemy 1 / przeniesienie
    loop    negate                  # Zapętlamy według rcx

endf:
    movq    %rbp, %rsp
    popq    %rbp
    ret


.type inversel @function
inversel:
    push    %rbp
    movq    %rsp, %rbp
    movq    16(%rbp), %rbx          # Adres liczby
    movq    24(%rbp), %rcx          # Parametr N

    movq    -8(%rbx, %rcx, 8), %rax     # Kopia najbardziej znaczącej części liczby
    andq    %rax, %rax              # Test
    jns endf                        # Jeśli SF = 0 (liczba dodatnia) to skocz na koniec
    movq    $0, %rdx                # Licznik
    stc                             # Ustaw CF = 1
negate:
    notq    (%rbx, %rdx, 8)         # Negujemy nastepne 64 bity
    adcq    $0, (%rbx, %rdx, 8)     # Dodajemy 1 / przeniesienie
    incq    %rdx
    loop    negate                  # Zapętlamy według rcx
endf:
    movq    %rbp, %rsp
    popq    %rbp
    ret


.type gcd @function
gcd:
    pushq   %rbp
    movq    %rsp, %rbp
    movq    16(%rbp), %rax          # Liczba a
    movq    24(%rbp), %rbx          # Liczba b
start:
    andq    %rbx, %rbx          # Sprawadzmy czy b = 0
    jz  endf                    # Jeśli tak to skok na koniec
    movq    $0, %rdx            # 0 do rdx do dzielenia
    divq    %rbx                # Dzielimy rax / rbx
    movq    %rdx, %rax          # Reszta do rax
    xchgq   %rax, %rbx          # Wymiana rax <-> rbx
    jmp start                   # Pętla
endf:
    movq    %rbp, %rsp
    popq    %rbp
    ret


OFFSET = 'z' - 'a' + 1
.type cezar @function
cezar:
    pushq   %rbp
    movq    %rsp, %rbp
    movq    16(%rbp), %rsi          # Adres ciągu
    movq    24(%rbp), %rdx          # Klucz
    subq    $'a', %rdx              # Klucz -> liczba
    movq    $-1, %rcx               # Licznik na -1
start:
    incq    %rcx                    # Inkrementacja licznika
    movb    (%rsi, %rcx, 1), %bl    # Kolejny znak
    cmpb    $'\n', %bl              # Jeśli znak nowej linii
    je  endf                        # To zakończ
    cmpb    $' ', %bl               # Jeśli spacja
    je  start                       # To skocz do kolejnej iteracji
    orb $0x20, %bl                  # Wymuś małe litery
    addq    %rdx, %rbx              # Dodaj klucz do znaku
    cmpq    $'z', %rbx              # Jeśli otzrymany znak mieści się w zakresie
    jle save                        # Skocz do końca iteracji
    subq    $OFFSET, %rbx           # W przeciwnym razie odejmij offset
save:
    movb    %bl, (%rsi, %rcx, 1)    # Wpisz zaszyfrowany znak do pamięci
    jmp start                       # Zapętl
endf:
    movq    %rbp, %rsp
    popq    %rbp
    ret


.type atoix @function
atoix:
    pushq   %rbp
    movq    %rsp, %rbp
    movq    16(%rbp), %rsi
    movq    24(%rbp), %rcx
    movq    $0, %rax            # 0 do rax
    movq    $10, %rdi           # 10 do rdi do mnożenia
start:
    movb    (%rsi), %bl         # Kolejny bajt do bl
    subb    $'0', %bl           # Konwersja ASCII -> cyfra
    mulq    %rdi                # Mnożenie rax * 10
    addq    %rbx, %rax          # Dodanie cyfry do rax
    incq    %rsi                # Przesunięcie adresu na kolejny bajt
    loop    start               # Pętla
    movq    %rbp, %rsp
    popq    %rbp
    ret


.type max2 @function
max2:
    pushq   %rbp
    movq    %rsp, %rbp
    movq    16(%rbp), %rsi
    movq    24(%rbp), %rcx
    decq    %rcx                # Wykonujemy n - 1 porównań
    movq    %rsi, %rax          # Adres największej liczby (na początku przyjmujemy pierwszą)
    movq    8(%rsi), %rdx       # Wyższa część aktualnie największe liczby
    movq    (%rsi), %rbx        # Niższa część aktualnie największej liczby
start:
    addq    $16, %rsi           # Przesuwamy wskaźnik na następną liczbę
    cmpq    8(%rsi), %rdx       # Porównujemy wyższą część aktualnej liczby z największą
    jl  bigger                  # Jeśli większa to skok
    je  equal                   # Jeśli równa to porównaj niższą część
    jmp repeat                  # Jeśli mniejsza to następna liczba
equal:
    cmpq    (%rsi), %rbx        # Porównujemy niższą część aktualnej liczby z największą
    jl  bigger                  # Jeśli większa to skok
    jmp repeat                  # Jeśli mniejsza bądź równa to następna liczba
bigger:
    movq    8(%rsi), %rdx       # Zapisz wyższą część aktualnej liczby jako największą
    movq    (%rsi), %rbx        # Zapisz niższą część aktualnej liczby jako największą
    movq    %rsi, %rax          # Zapisz adres aktualnej liczby
repeat:
    loop    start               # Zapętl według rcx
    movq    %rax, %rbx          # wynik w rbx (polecenie)
    movq    %rbp, %rsp
    popq    %rbp
    ret