############ Euklides

.globl Euklides
.type Euklides, @function
Euklides:
pushl %ebp
movl %esp, %ebp

movl 12(%ebp), %ebx #b
movl 8(%ebp), %eax #a

poczE:
movl $0, %edx #przygotowujemy edx do dzielenia
divl %ebx
movl %ebx, %eax #umieszczamy b w miejsce a
movl %edx, %ebx #reszte z dzielenia wrzucamy do b
cmpl $0, %ebx #jesli reszta z dzielenia rowna zero to mamy wynik
jne poczE

movl %ebp, %esp
popl %ebp
ret


############ Fibonacci


.globl Fibonacci
.type Fibonacci, @function
Fibonacci:

pushl %ebp
movl %esp, %ebp

movl 8(%ebp), %esi #argument ciagu

movl $1, %eax
movl $0, %ebx
cmpl $1, %esi #jesli argument jest jedynka to konczymy
je endF

loop:
movl %eax, %ecx #umieszczamy zapamitujemy wieksza liczbe
addl %ebx, %eax #wyliczamy kolejny wyraz ciagu
movl %ecx, %ebx
dec %esi
cmpl $1, %esi
jne loop


endF:
movl %ebp, %esp
popl %ebp
ret


############ Horner


.globl toInt
.type toInt, @function
toInt:

pushl %ebp
movl %esp, %ebp

movl 8(%ebp), %esi #adres
movl 12(%ebp), %ecx #rozmiar

movl $10, %ebx
movl $0, %eax #suma

poczInt:
mull %ebx #przesuniecie wyniku
movb (%esi), %dl #pobranie aktualnej cyfry
andl $0x0f, %edx #zamiana kodu ASCII na zwykla wartosc liczbowa
addl %edx, %eax #dodanie do wyniku kolejnej cyfry
incl %esi
loop poczInt

movl %ebp, %esp
popl %ebp
ret


############# Cezar

a = 97
z = 122
nl = 10
sp = 32

.globl ceasar
.type ceasar, @function
ceasar:

pushl %ebp
movl %esp, %ebp

movl 8(%ebp), %esi  #adres lancucha
movl 12(%ebp), %ebx #klucz

subb $a, %bl #zmienienie klucza na przesuniecie

loopC:
movb (%esi), %al

cmpb $nl, %al  #jesli nowa linia to konczymy
je endC

cmpb $sp, %al  #jesli spacja to mijamy ja
je next

addb %bl, %al  #przesuwamy litere

cmpb $z, %al #jesli nie przekroczylo z to mozna wstawic
jl put

subb $26, %al #korygujemy znak

put:
movb %al, (%esi)
next:
incl %esi
jmp loopC

endC:
movl %ebp, %esp
popl %ebp
ret


############### Bezwzgledna
#Uwaga! Niesprawdzone dzialanie


.globl abs
.type abs, @function
abs:
pushl %ebp
movl %esp, %ebp

movl 8(%ebp), %esi  #adres pierwszej wartosci
movl 12(%ebp), %ecx #rozmiar

movl $0x80000000, %eax #sprawdz czy liczba wgl jest ujemna
andl (%esi), %eax
jz endA

stc  #ustawienie flagi przeniesienia, wykorzystujemy zaleznosc -X = not(X) + ulp
     #za pierwszym razem doda nam ulp

poczA:
decl %ecx #przesuniecie indeksu
notl (%esi, %ecx, 4)
adcl $0, (%esi, %ecx, 4) #dodaj przeniesienie jesli jest
loop poczA

endA:
movl %ebp, %esp
popl %ebp
ret

################ Przeciwna
#Uwaga! Niesprawdzone zadanie

.globl inverse
.type inverse, @function
inverse:
pushl %ebp
movl %esp, %ebp

movl 8(%ebp), %esi  #adres pierwszej wartosci
movl 12(%ebp), %ecx #rozmiar

stc  #ustawienie flagi przeniesienia, wykorzystujemy zaleznosc -X = not(X) + ulp
     #za pierwszym razem doda nam ulp

poczI:
decl %ecx #przesuniecie indeksu
notl (%esi, %ecx, 4)
adcl $0, (%esi, %ecx, 4) #dodaj przeniesienie jesli jest
loop poczA

endI:
movl %ebp, %esp
popl %ebp
ret


################ Dekrementacja
#Uwaga! Niesprawdzone zadanie

.globl dec
.type idec, @function
dec:
pushl %ebp
movl %esp, %ebp

movl 8(%ebp), %esi  #adres pierwszej wartosci
movl 12(%ebp), %ecx #rozmiar

stc  #za pierwszy razem oddejmie nam jedynke od liczby
poczD:
decl %ecx #przesuniecie indeksu
sbbl $0, (%esi, %ecx, 4) #odejmij przeniesienie jesli jest
loop poczA

endD:
movl %ebp, %esp
popl %ebp
ret

################# NWW
#Uwaga! Niesprawdzone zadanie

.globl NWW
.type NWW, @function
NWW:
pushl %ebp
movl %esp, %ebp

movl 8(%ebp), %eax
movl 12(%ebp), %ebx

loopNWW:  #wyliczenie NWD z Euklidesa
movl $0, %edx
divl %ebx
movl %ebx, %eax
movl %edx, %eax
cmpl $0, %ebx
jne loopNWW

movl %eax, %ecx #zapamietanie NWD
movl 8(%ebp), %eax
mull 12(%ebp) #wyliczenie iloczynu argumentow
divl %ecx #podzielenie przez NWD

movl %ebp, %esp
popl %ebp
ret