%include "io.inc"

section .data
    n dd 31
    k dd 0

section .bss
    a resd 600
    number resb 32

section .text
global CMAIN
CMAIN:
    mov edx, 0
    mov [a], dword 1
    mov esi, 1          ; esi = current_index

    mov eax, 0          ; eax = i

.for_i_eax:
    cmp eax, dword [n]
        jz .stop_for_i_eax

            mov [a + 4 * esi], dword 1          ; a.append(1)
            inc esi

            mov ebx, 0                          ; ebx = j

            .for_j_ebx:
                cmp ebx, eax
                    jz .stop_for_j_ebx

                        mov edi, eax

                        inc eax
                        imul edi

                        mov ecx, 2
                        div ecx
                        add eax, ebx

                        mov ecx, [a + 4 * eax]
                        add ecx, [a + 4 * eax + 4]

                        mov [a + 4 * esi], ecx
                        inc esi

                        mov eax, edi

                    inc ebx
                    jmp .for_j_ebx

            .stop_for_j_ebx:

            mov [a + 4 * esi], dword 1          ; a.append(1)
            inc esi

        inc eax
        jmp .for_i_eax

.stop_for_i_eax:

    mov eax, 0

.print_for_eax:
    cmp eax, dword 100
        jz .stop_print_for_eax

            ;PRINT_UDEC 4, [a + 4 * eax]
            ;PRINT_CHAR ' '

        inc eax
        jmp .print_for_eax

.stop_print_for_eax:

    ;PRINT_STRING "Shalom!"
    GET_UDEC 4, eax
    GET_UDEC 4, k
    ;PRINT_HEX 4, eax
    ;NEWLINE

    mov edi, eax

    mov esi, 0
    mov edx, 0

    mov ecx, 0

.for_number_ecx:
    cmp ecx, dword 32
        jz .stop_for_number_ecx

            mov edx, 0
            rol eax, 1
            mov edi, eax

            mov ebx, 2
            div ebx

            mov [number + esi], dl

            mov eax, edi
            ;PRINT_UDEC 1, [number + esi]
            inc esi

        inc ecx
        jmp .for_number_ecx

.stop_for_number_ecx:

    mov edx, 0
    mov esi, 0                                    ; esi = i
    mov edi, 0                                    ; edi = answer

.for_esi:
    cmp byte [number + esi], 1
        jz .stop_for_esi

        inc esi
        jmp .for_esi

.stop_for_esi:

    ;NEWLINE
    ;PRINT_UDEC 4, esi

    mov edx, 30                                   ; n = 30 - i
    sub edx, esi
    inc edx

    mov ecx, [k]
    inc ecx

    cmp edx, ecx
        jb .return_0
            mov eax, edx
            inc eax
            mul edx
            mov ebx, 2
            div ebx
            add eax, ecx
            mov edi, [a + 4 * eax]
            ;PRINT_STRING "bias = "
            ;PRINT_UDEC 4, eax
            ;NEWLINE
        jmp .after_first

.return_0:
    ;PRINT_STRING "Shalom!"
    mov edi, 0
.after_first:

    ;NEWLINE
    ;PRINT_UDEC 4, edi
    ;mov edx, [a + 4 * ]

    mov esi, 0                                    ; esi = i

    ;NEWLINE
    ;PRINT_STRING "SECOND"
    ;NEWLINE

.for2_esi:
    cmp byte [number + esi], 1
        jz .stop_for2_esi

        inc esi
        jmp .for2_esi

.stop_for2_esi:

    ;PRINT_UDEC 4, esi

    inc esi                                        ; i += 1

    mov ebx, esi                                   ; j = i
    mov ecx, [k]                                   ; ecx = k

 .for_ebx_j:
    cmp ebx, 32
        jz .stop_for_ebx_j

            cmp byte [number + ebx], 0             ; if (number[ebx] == 0):
                jnz .else

                    dec ecx                            ; k -= 1
                    cmp ecx, 0                         ; if (k == 0):
                        jnz .end_of_1if

                            inc edi                        ; answer += 1
                            jmp .stop_for_ebx_j            ; break
            .else:
                mov eax, 32
                sub eax, ebx
                dec eax

                mov esi, ecx
                dec esi
                cmp eax, esi
                    jb .end_of_1if

                mov edx, 0

                mov esi, eax
                inc esi
                mul esi

                mov esi, 2
                div esi

                add eax, ecx
                dec eax

                add edi, [a + 4 * eax]
                ; answer += c(32 - ebx - 1, ecx - 1)
        .end_of_1if:
        inc ebx
        jmp .for_ebx_j

 .stop_for_ebx_j:

    ;NEWLINE
    PRINT_UDEC 4, edi

    xor eax, eax
    ret