nml_for6

    .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:
    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 edi, DWORD PTR -44[rbp] # кладем в rdi n
    sal rdi, 2                  # с помощью побитового сдвига умножаем его на 4 (размер целочисленного типа данных, определенный компилятором)
    call    malloc@PLT
    ##mov   QWORD PTR -24[rbp], rax # в rax возвращается указатель на выделенный блок памяти
        mov      r12, rax # вместо памяти сохраняем указатель на выделенную под массив а память в регистр r12
        # <- malloc
        # -> malloc b
    mov edi, DWORD PTR -44[rbp] # кладем в rax n
    sal rdi, 2                  # с помощью побитового сдвига умножаем его на 4 (размер целочисленного типа данных, определенный компилятором)
    call    malloc@PLT
    ##mov   QWORD PTR -16[rbp], rax # в rax возвращается указатель на выделенный блок памяти
        mov      r13, rax
        # <- malloc

        # -> for loop
    ##mov   DWORD PTR -36[rbp], 0 # по адресу rbp-36 - счетчик для цикла for
        xor      rbx, rbx # вместо памяти используем для счетчика цикла регистр rbx
    jmp .L7
.L8:
        # -> scanf a[i]
    lea rdx, 0[0+rbx*4]# записываем в rdx байтовое смещение от начала массива а, полученное с помощью умножения счетчика (rax) на 4 (размер int)
    mov rsi, r12
    add rsi, rdx       # получаем в rsi адрес элемента a[i]
    lea rdi, .LC1[rip] # 1 аргумент - форматная строка
    mov eax, 0
    call    __isoc99_scanf@PLT
        # <- scanf a[i]
    inc     rbx # увеличиваем счетчик
.L7:
    cmp ebx, DWORD PTR -44[rbp]
    jl  .L8
        # <- for loop
        # -> solve(a,b,n,x)
    mov ecx, DWORD PTR -40[rbp] # число x
    mov edx, DWORD PTR -44[rbp] # размер массивов
    mov rsi, r13 # массив b
    mov rdi, r12 # массив а
    call    solve
    ##mov   DWORD PTR -28[rbp], eax # возвращается количество элементов кратных х
        mov      r14, rax # вместо памяти сохраняем в регистр возвращаемое количество элементов кратных числу х
        # <- solve(a,b,n,x)
        # -> for loop
    ##mov   DWORD PTR -32[rbp], 0
        xor      r15, r15 # счетчик цикла
    jmp .L9
.L10:
    lea rdx, 0[0+r15*4]
    mov rsi, r13
    add rsi, rdx
    mov esi, DWORD PTR [esi]    # 2-й аргумент - значение которое мы выводим
    lea rdi, .LC2[rip]          # 1-й аргумент - форматная строка
    mov eax, 0
    call    printf@PLT
    inc     r15
.L9:
    cmp r15, r14
    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