Пояснения по чужим решениям одного того же задание (почему решения настолько разные)

global string_repeat
extern malloc, memcpy, strlen
section .text
string_repeat:
                push    rbx
                push    rbp
[B]                push    rax
                push    rax[/B]
                push    rsi
                mov     rbx, rdi
                mov     rbp, rsi
                mov     rdi, rsi
                call    strlen
                mov     rbp, rax
                mul     rbx
                lea     rdi, [rax + 1]
                call    malloc
                mov     [rsp + 16], rax
                test    rbx, rbx
                jz      .done
.loop:          mov     rdi, rax
                mov     rsi, [rsp]
                mov     rdx, rbp
                call    memcpy
                add     rax, rbp
                dec     rbx
                jnz     .loop
.done:          mov     byte [rax], 0
                pop     rcx
                pop     rcx
                pop     rax
                pop     rbp
                pop     rbx
                ret

SECTION .text
extern malloc, strlen, memcpy
global string_repeat
 
;  Returns a string repeated arg1 times.
;  Note: Please return a pointer to the new string which was allocated by C's malloc.
;  arg0         = (size_t)      The number of times to repeat.
;  arg1         = (const char*) The original string.
;  return value = (char*)       New string which holds the value of arg0 repeated arg1 times.
string_repeat:
  push rbx  ; = original string
  push r12  ; = number of times to repeat
  push r13  ; = length of the original string
  push r14  ; = output pointer
  push r15  ; = output buffer
  mov rbx, rsi
  mov r12, rdi
  mov rdi, rsi
  call strlen
  mov r13, rax
  mul r12
  inc rax
  mov rdi, rax
  call malloc
  mov r15, rax
  mov r14, rax
  test r12, r12
  jz .end
.loop:
  mov rdi, r14
  mov rsi, rbx
  mov rdx, r13
  call memcpy
  add r14, r13
  dec r12
  jnz .loop
  mov rax, r15
.end:
  mov byte [r14], 0
  pop r15
  pop r14
  pop r13
  pop r12
  pop rbx
  ret

SECTION .text
global string_repeat
extern calloc, strlen, strcat
 
extern puts, putchar
 
;  Returns a string repeated arg1 times.
;  Note: Please return a pointer to the new string which was allocated by C's malloc.
;  arg0         = (size_t)      The number of times to repeat.
;  arg1         = (const char*) The original string.
;  return value = (char*)       New string which holds the value of arg0 repeated arg1 times.
string_repeat:
  cmp rsi, 0
  je zero
  
  push rdi
  push rsi
  add rdi, 48
  call putchar
  pop rsi
  pop rdi
  
  
  push rdi
  push rsi
  mov rdi, rsi
  call puts
  pop rsi
  pop rdi
  cmp rdi, 0
  jne ok1
zero:
  mov rdi, 1
  mov rsi, 1
  call calloc
  ret
ok1:
  cmp byte [rsi], 0
  je zero
  push rdi           ; положили число на стек
  mov rdi, rsi       ; исходная строка в первый аргумент
  call strlen        ; вызвали strlen
  pop rdi            ; прочитали число обратно
                     ; теперь в rax длина исходной строки
  push rax
  
  push rsi           ; положили исходную строку на стек
  push rdi           ; положили число на стек
  mul rdi            ; умножили длину исходной строки на число
                     ; теперь в rax длина ответа
  inc rax            ; теперь в rax длина нольтерм. ответа (, а на стеке число и исходная строка)
  
  mov rdi, rax       ; в первый аргумент длина нольтерм. ответа
  mov rsi, 1         ; во второй аргумент sizeof(char)
  call calloc        ; вызвали calloc
                     ; теперь в rax ответ (, а на стеке число и исходная строка)
  
  pop rbx            ; в rbx число
  pop rsi            ; в rsi исходная строка
  mov rdi, rax       ; в rdi ответ
  pop rcx            ; в rcx длина исходной строки
  push rdi
  
loopp:
  cmp rbx, 0
  jng return         ; если нет, то выходим из цикла
  
  push rdi
  push rcx
  push rsi
  call strcat        ; если да, то вызываем strcat
  pop rsi
  pop rcx
  pop rdi
  add rdi, rcx
  dec rbx            ; --число
  jmp loopp          ; в начало цикла 
  
return:
  pop rdi
  push rdi
  call puts
  pop rdi
  mov rax, rdi
  ret

SECTION .text
global string_repeat
extern malloc
 
;  Returns a string repeated arg1 times.
;  Note: Please return a pointer to the new string which was allocated by C's malloc.
;  arg0         = (size_t)      The number of times to repeat.
;  arg1         = (const char*) The original string.
;  return value = (char*)       New string which holds the value of arg0 repeated arg1 times.
string_repeat:
 
  ; if 'count' is 0 then return address to a null byte
  cmp rdi, 0
  jne .ok
  mov rdi, 1
  call malloc
  mov [rax], byte 0
  ret
  
.ok:
 
  ; calculate length of string
  push rsi 
  call string_length
  pop rsi
  
  ; preserve the registers because they will be
  ; affected by 'malloc' subroutine
  push rdi
  push rcx
  push rsi
  
  ; calculate number of bytes to allocate
  mov rax, rdi
  mul rcx
  mov rdi, rax
  inc rdi
  
  call malloc
  
  ; restore the registers
  pop rsi
  pop rcx
  pop rdi
  
  ; use rbx to loop through the string allocated by malloc
  mov rbx, rax
 
.ok.loop:
  ; save the registers for later
  ; rcx will be affected by 'loop' instruction
  ; rsi will be affected by 'lodsb' instruction
  push rcx
  push rsi
  
  xor rax, rax
  .ok.loop.string:
      ; write the 'str' string to memory
      lodsb
      mov [rbx], al
      inc rbx
      loop .ok.loop.string
      
   ; restore the registers
   pop rsi
   pop rcx
   
   ; do '.ok.loop' as many time as needed
   dec rdi
   jnz .ok.loop
   
   ; put string terminator at the end
   mov [rbx], byte 0
   ; rdx will store the base address of the string allocated by malloc
   ; we move it to rax in order to return from the function
   mov rax, rdx
   
   ret
 
  ret
  
string_length:
  ; loop through the string until we find a null character
  ; at the end we decrement rcx in order to get the length of the
  ; string without the null byte
  xor rcx, rcx
  xor rax, rax
  
.loop:
  lodsb; load byte from rsi
  inc rcx
  test al, al; check for null byte
  jnz .loop
  
  dec rcx; eliminate null byte
  ret