vimref

    .file   "nomorelizing.c"
    .intel_syntax noprefix
    .text
    .globl  solve
    .type   solve, @function
solve:
    push    %rbp
    mov %rbp, %rsp
        mov       %r12, -24(%rbp)
        mov       %rbx, -32(%rbp)
        mov       %r14, -40(%rbp)
        mov       %r15, -48(%rbp)
        # -> передача параметров из регистра на стек
    ##mov   QWORD PTR -24(%rbp), %rdi # a
    ##mov   QWORD PTR -32(%rbp), %rsi # b
    ##mov   DWORD PTR -36(%rbp), %edx # n
        mov       %rdx, %r12
    ##mov   DWORD PTR -40(%rbp), %ecx # x
        mov       %ecx, %ebx
        # <- передача параметров из регистра на стек
    ##mov   DWORD PTR -8(%rbp), 0 # счетчик j
        xor       %r14, %r14
    ##mov   DWORD PTR -4(%rbp), 0 # счетчик i
        xor       %r15, %r15
    jmp .L2
        # -> for loop
.L4:
        # -> if a(i) % x == 0
    lea 0(0+%r15*4), %rdx         # получаем смещение от начала массива а до нужного элемента в байтах
    mov  (%rdi+%rdx), %eax       # кладем в еах значение нужного элемента
    cdq                              # расширяем до 64 битов
    idiv    %ebx                     # получаем остаток (в %edx)
    test    %edx, %edx                # проверяем на равенство нулю
    jne .L3
        # {
    lea  0(0+%r15*4), %rdx        # получаем байтовое смещение
    lea  (%rdx+%rdi), %rcx         # получаем в %rcx адрес элемента a(i)
    mov  %r14, %rax               # кладем в %rax счетчик j
    lea  1(%rax), %r14            # кладем в %r14 j+1
    lea  0(0+%rax*4+%rsi), %rdx    # в %rdx получаем адрес элемента b(j)
    mov  (%rcx), %eax   # кладем в еах значение элемента a(i)
    mov  %eax, (%rdx)   # кладем в b(j) значение элемента a(i)
        # }
.L3:    # <- if
    inc %r15                     # инкрементируем i
.L2:
    cmp %r12, %r15
    jl  .L4
        # <- for loop
    mov  %r14, %rax               # в %rax возвращаем размер массива b
        mov       -24(%rbp), %r12
        mov       -32(%rbp), %rbx
        mov       -40(%rbp), %r14
        mov       -48(%rbp), %r15
    pop %rbp
    ret
    .size   solve, .-solve
    .section    .rodata
.LC0:
    .string "%d%d"
.LC1:
    .string "%d"
.LC2:
    .string "%d "
    .text
    .globl  main
    .type   main, @function
main:
    push    %rbp
    mov %rsp, %rbp
    sub 48, %rsp            # выделяем память на стеке для мейн
        # -> scanf
    lea  -40(%rbp), %rdx     # 3 аргумент для scanf (%rdx) - адрес второй переменной которую надо считать (x)
    lea  -44(%rbp), %rsi     # 2 аргумент (%rsi) - адрес первой переменной значение которой нужно считать (n)
    lea  .LC0(rip), %rdi    # 1 аргумент (%rdi) - форматная строка (%d%d)
    mov 0, %eax
    call    __isoc99_scanf@PLT
        # <- scanf
        # -> malloc a
    mov  -44(%rbp), %edi# кладем в %rdi n
    sal  2, %rdi                 # с помощью побитового сдвига умножаем его на 4 (размер целочисленного типа данных, определенный компилятором)
    call    malloc@PLT
    ##mov   QWORD PTR -24(%rbp), %rax # в %rax возвращается указатель на выделенный блок памяти
        mov       %rax, %r12# вместо памяти сохраняем указатель на выделенную под массив а память в регистр %r12
        # <- malloc
        # -> malloc b
    mov  -44(%rbp), %edi# кладем в %rax n
    sal  2, %rdi                 # с помощью побитового сдвига умножаем его на 4 (размер целочисленного типа данных, определенный компилятором)
    call    malloc@PLT
    ##mov   QWORD PTR -16(%rbp), %rax # в %rax возвращается указатель на выделенный блок памяти
        mov       %rax, %r13
        # <- malloc

        # -> for loop
    ##mov   DWORD PTR -36(%rbp), 0 # по адресу %rbp-36 - счетчик для цикла for
        xor      %rbx, %rbx # вместо памяти используем для счетчика цикла регистр %rbx
    jmp .L7
.L8:
        # -> scanf a(i)
    lea  0(0+%rbx*4), %rdx# записываем в %rdx байтовое смещение от начала массива а, полученное с помощью умножения счетчика (%rax) на 4 (размер int)
    lea  (%r12+%rdx), %rsi      # получаем в %rsi адрес элемента a(i)
    lea  .LC1(rip), %rdi# 1 аргумент - форматная строка
    mov 0, %eax
    call    __isoc99_scanf@PLT
        # <- scanf a(i)
    inc     %rbx # увеличиваем счетчик
.L7:
    cmp  -44(%rbp), %ebx
    jl  .L8
        # <- for loop
        # -> solve(a,b,n,x)
    mov  -40(%rbp), %ecx# число x
    mov  -44(%rbp), %edx# размер массивов
    mov  %r13, %rsi# массив b
    mov  %r12, %rdi# массив а
    call    solve
    ##mov   DWORD PTR -28(%rbp), %eax # возвращается количество элементов кратных х
        mov       %rax, %r14# вместо памяти сохраняем в регистр возвращаемое количество элементов кратных числу х
        # <- solve(a,b,n,x)
        # -> for loop
    ##mov   DWORD PTR -32(%rbp), 0
        xor      %r15, %r15 # счетчик цикла
    jmp .L9
.L10:
    lea  0(0+%r15*4), %rdx
    lea (%r13+%rdx), %rsi
    mov  (%esi), %esi            # 2-й аргумент - значение которое мы выводим
    lea  .LC2(rip), %rdi         # 1-й аргумент - форматная строка
    mov 0, %eax
    call    printf@PLT
    inc     %r15
.L9:
    cmp %r14, %r15
    jl  .L10
        # <- for loop
    xor      %eax, %eax
    leave
    ret
    .size   main, .-main
    .ident  "GCC: (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0"
    .section    .note.GNU-stack,"",@progbits