.text
	.global	clz
	.type	clz, @function
clz:
    mov $64,%rax
    cmp $0x0,%rdi
# Jesli liczba rowna zero to ma 64 zer w sensie bitow
    je koniec
    mov $0x0,%rax
#Sprawdzamy czy liczba ma z przodu 32 zer
    mov $0xFFFFFFFF00000000,%rsi
    and %rdi,%rsi
    cmp $0,%rsi
    jne pomin32
    add $32,%rax
    shl $32,%rdi
    
#jesli liczba ma 32 zer z przodu to dodamy 32 do wyniku i wykonamy sie na
#pozostalych 32 bitach, przesuwamy wtedy liczbe o 32 w lewo, bo tam sa same zera
#jesli nie to bez dodawania 32 do wyniku wykonujemy algorytm dla 32 starszych 
#bitow, bez przesuniecia. W taki sposob logarytmicznie sprawdzamy ilosc zer

pomin32:
#to samo ale dla 16 bitow z przodu
    mov $0xFFFF000000000000,%rsi
    and %rdi,%rsi
    cmp $0,%rsi
    jne pomin16
    add $16,%rax
    shl $16,%rdi

pomin16:
#to samo ale dla 8 bitow z przodu
    mov $0xFF00000000000000,%rsi
    and %rdi,%rsi
    cmp $0,%rsi
    jne pomin8
    add $8,%rax
    shl $8,%rdi
 
pomin8:
#to samo ale dla 4 bitow z przodu
    mov $0xF000000000000000,%rsi
    and %rdi,%rsi
    cmp $0,%rsi
    jne pomin4
    add $4,%rax
    shl $4,%rdi

pomin4:
#to samo ale dla 2 bitow z przodu
    mov $0xC000000000000000,%rsi
    and %rdi,%rsi
    cmp $0,%rsi
    jne pomin2
    add $2,%rax
    shl $2,%rdi
    
pomin2:
#to samo ale dla 1 bitu z przodu
    mov $0x8000000000000000,%rsi
    and %rdi,%rsi
    cmp $0,%rsi
#tutaj sprawdzilismy czy ostatni bit jest zerem z dwoch niesprawdzonych bitow

    jne koniec
#specjalny przypadek bo dwa ostatnie bity nie moga byc naraz zerami
#inaczej by na samym poczatku algorytm wypisal 64 jako wynik
#w tym przypadku ostatni bit jest zerem wiec przedostatni jest jedynka
    add $1,%rax

#nie ma pomin1,  bo to znaczy ze ostatni bit z pary niesprawdzonych jest 1
#czyli nie ma wiekszego prefiksa

koniec:    
    ret

	.size	clz, .-clz