nml_for6.final

    .file   "nomorelizing.c"
    .intel_syntax noprefix
    .text
    .globl  solve
    .type   solve, @function
solve:
    push    rbp
    mov rbp, rsp
        mov      QWORD PTR -24[rbp], r12
        mov      QWORD PTR -32[rbp], rbx
        mov      QWORD PTR -40[rbp], r14
        mov      QWORD PTR -48[rbp], r15
        # -> передача параметров из регистра на стек
    ##mov   QWORD PTR -24[rbp], rdi # a
    ##mov   QWORD PTR -32[rbp], rsi # b
    ##mov   DWORD PTR -36[rbp], edx # n
        mov      r12, rdx
    ##mov   DWORD PTR -40[rbp], ecx # x
        mov      ebx, ecx
        # <- передача параметров из регистра на стек
    ##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 rdx, 0[0+r15*4]         # получаем смещение от начала массива а до нужного элемента в байтах
    mov eax, DWORD PTR [rdi+rdx]# кладем в еах значение нужного элемента
    cdq                              # расширяем до 64 битов
    idiv    ebx                     # получаем остаток (в edx)
    test    edx, edx                # проверяем на равенство нулю
    jne .L3
        # {
    lea rdx, 0[0+r15*4]         # получаем байтовое смещение
    lea rcx, [rdx+rdi]          # получаем в rcx адрес элемента a[i]
    mov rax, r14                # кладем в rax счетчик j
    lea r14, 1[rax]             # кладем в r14 j+1
    lea rdx, 0[0+rax*4+rsi]     # в rdx получаем адрес элемента b[j]
    mov eax, DWORD PTR [rcx]    # кладем в еах значение элемента a[i]
    mov DWORD PTR [rdx], eax    # кладем в b[j] значение элемента a[i]
        # }
.L3:    # <- if
    inc r15                     # инкрементируем i
.L2:
    cmp r15, r12
    jl  .L4
        # <- for loop
    mov rax, r14                # в rax возвращаем размер массива b
        mov      r12, QWORD PTR -24[rbp]
        mov      rbx, QWORD PTR -32[rbp]
        mov      r14, QWORD PTR -40[rbp]
        mov      r15, QWORD PTR -48[rbp]
    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)
    lea rsi, [r12+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]
    lea rsi, [r13+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