nml_for5

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

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