View difference between Paste ID: YTRYJP6d and CBREc1tR

 .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
-	movq	%rdi, %rax			# Tylko na potrzeby testowania (parametr w rdi)
+	andq	%rax, %rax		# Sprawdzamy czy rax = 0
 	jz	endf				# Jeśli tak do kończymy zwracając 0
-	andq	%rax, %rax			# Sprawdzamy czy rax = 0
+	movq	%rax, %rdx		# Parametr n do rdx
 	movq	$0, %rax		# Licznik / wynik
-	movq	%rax, %rdx			# Parametr n do rdx
+	movq	$1, %rbx		# Aktualna liczba nieparzysta
-	movq	$0, %rax			# Licznik / wynik
+
-	movq	$1, %rbx			# Aktualna liczba nieparzysta
+	subq	%rbx, %rdx		# Odejmujemy aktualną nieparzystą
 	jb	endf				# Jeśli wynik mniejszy od 0 to kończymy
-	subq	%rbx, %rdx			# Odejmujemy aktualną nieparzystą
+	incq	%rax			# Inkremementacja licznika
 	addq	$2, %rbx		# Kolejna liczba nieparzysta
-	incq	%rax				# Inkremementacja licznika
+
-	addq	$2, %rbx			# Kolejna liczba nieparzysta
+
 	mov	%rbp, %rsp
 	pop	%rbp
 	ret
 
 
 .type fibonac @function
 fibonac:
 	pushq	%rbp
 	movq	%rsp, %rbp
 	movq	16(%rbp), %rcx
 	movq	$0, %rbx			# F(0)
-
+
 	decq	%rcx				# Dekrementacja rcx
 	jz	endf					# Jeśli rcx = 0 to zwróć 1
 	jns	start					# Jeśli rcx > 0 to skocz do pętli
-	jz	endf				# Jeśli rcx = 0 to zwróć 1
+
-	jns	start				# Jeśli rcx > 0 to skocz do pętli
+	jmp	endf					# I skocz na koniec
 start:
-	jmp	endf				# I skocz na koniec
+
 	xchgq	%rax, %rbx			# F(n - 1) <-> F(n)
 	loop	start				# Pętla
 endf:
 	movq	%rax, 16(%rbp)		# Umieszczenie wyniku na stosie
 	movq	%rbp, %rsp
-	movq	%rax, 16(%rbp)			# Umieszczenie wyniku na stosie
+
 	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
-	movb	(%rbx), %al			# Kopia najbardziej znaczącego bajtu liczby w al
+	andb	%al, %al				# Test
-	andb	%al, %al			# Test
+	jns	endf						# Jeśli SF = 0 (liczba dodatnia) to skocz na koniec
-	jns	endf				# Jeśli SF = 0 (liczba dodatnia) to skocz na koniec
+	stc								# Ustaw CF = 1
-	stc					# Ustaw CF = 1
+
 	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
-						# dlatego cofamy się o 8 bajtów do 8 najmniej znaczących bajtów liczby
+	adcq	$0, -8(%rbx, %rcx, 8)	# Dodajemy 1 / przeniesienie
-	adcq	$0, -8(%rbx, %rcx, 8)		# Dodajemy 1 / przeniesienie
+	loop	negate					# Zapętlamy według rcx
-	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
+	andq	%rax, %rax				# Test
-	jns	endf				# Jeśli SF = 0 (liczba dodatnia) to skocz na koniec
+	jns	endf						# Jeśli SF = 0 (liczba dodatnia) to skocz na koniec
-	movq	$0, %rdx			# Licznik
+	movq	$0, %rdx				# Licznik
-	stc					# Ustaw CF = 1
+	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
+	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
+	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
+	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
-	subq	$'a', %rdx			# Klucz -> liczba
+
-	movq	$-1, %rcx			# Licznik na -1
+	incq	%rcx					# Inkrementacja licznika
 	movb	(%rsi, %rcx, 1), %bl	# Kolejny znak
-	incq	%rcx				# Inkrementacja licznika
+	cmpb	$'\n', %bl				# Jeśli znak nowej linii
-	movb	(%rsi, %rcx, 1), %bl		# Kolejny znak
+	je	endf						# To zakończ
-	cmpb	$'\n', %bl			# Jeśli znak nowej linii
+	cmpb	$' ', %bl				# Jeśli spacja
-	je	endf				# To zakończ
+	je	start						# To skocz do kolejnej iteracji
-	cmpb	$' ', %bl			# Jeśli spacja
+	orb	$0x20, %bl					# Wymuś małe litery
-	je	start				# To skocz do kolejnej iteracji
+	addq	%rdx, %rbx				# Dodaj klucz do znaku
-	orb	$0x20, %bl			# Wymuś małe litery
+	cmpq	$'z', %rbx				# Jeśli otzrymany znak mieści się w zakresie
-	addq	%rdx, %rbx			# Dodaj klucz do znaku
+	jle	save						# Skocz do końca iteracji
-	cmpq	$'z', %rbx			# Jeśli otzrymany znak mieści się w zakresie
+
-	jle	save				# Skocz do końca iteracji
+
 	movb	%bl, (%rsi, %rcx, 1)	# Wpisz zaszyfrowany znak do pamięci
 	jmp	start						# Zapętl
-	movb	%bl, (%rsi, %rcx, 1)		# Wpisz zaszyfrowany znak do pamięci
+
-	jmp	start				# Zapętl
+
-
+
 	ret
 
 
 .type atoix @function
 atoix:
 	pushq	%rbp
 	movq	%rsp, %rbp
 	movq	16(%rbp), %rsi
 	movq	24(%rbp), %rcx
-	#movq	16(%rbp), %rsi
+
-	#movq	24(%rbp), %rcx
+
-	movq	%rsi, %rcx
+
-	movq	%rdi, %rsi
+
-
+
 	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ę
-	decq	%rcx			# Wykonujemy n - 1 porównań
+
-	movq	%rsi, %rax		# Adres największej liczby (na początku przyjmujemy pierwszą)
+	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:
-	addq	$16, %rsi		# Przesuwamy wskaźnik na następną liczbę
+
 	jl	bigger					# Jeśli większa to skok
-	jl	bigger			# Jeśli większa to skok
+	jmp	repeat					# Jeśli mniejsza bądź równa to następna liczba
-	je	equal			# Jeśli równa to porównaj niższą część
+
-	jmp	repeat			# Jeśli mniejsza to następna liczba
+
 	movq	(%rsi), %rbx		# Zapisz niższą część aktualnej liczby jako największą
 	movq	%rsi, %rax			# Zapisz adres aktualnej liczby
-	jl	bigger			# Jeśli większa to skok
+
-	jmp	repeat			# Jeśli mniejsza bądź równa to następna liczba
+	loop	start				# Zapętl według rcx
 	movq	%rax, %rbx			# wynik w rbx (polecenie)
 	movq	%rbp, %rsp
 	popq	%rbp
-	movq	%rsi, %rax		# Zapisz adres aktualnej liczby
+