simple bst

;sasm
%include "io.inc"
section .bss
    derevo: resd 1
    k: resd 1
    v: resd 1
    c: resb 1
section .rodata
    T2: db "%d %d", 0
    T1: db "%d", 0
    T3: db "%c", 0
    T4: db "%d %d\n", 0
section .text
CEXTERN scanf
CEXTERN printf
CEXTERN malloc
CEXTERN free
global searchnode
global findmin
global cleanderevo
global addnode
global delnode

searchnode:
    push ebp
    mov ebp, esp
    push ebx
    mov ebx, dword[ebp+8]
    L18:
    cmp ebx, 0
    je L19
        mov eax, dword[ebp+12] ;key
        mov edx, dword[ebx+12] ;derevo->key
        cmp eax, edx
        jle L20
        mov ebx, dword[ebx+4]
        jmp L18
        L20:
        je L21
        mov ebx, dword[ebx]
        jmp L18
        L21:
        mov eax, ebx
        jmp L22
    jmp L18
    L19:
    mov eax, 0
    L22:
    pop ebx
    mov esp, ebp
    pop ebp
    ret

addnode:
    push ebp
    mov ebp, esp
    sub esp, 8
    mov dword[esp], edi
    mov dword[esp+4], esi
    sub esp, 16
    ;код
    mov dword[esp+8], 0
    mov eax, dword[ebp+8]
    mov dword[esp+12], eax
    L10:
    cmp dword[esp+12], 0
    je L11
        mov eax, dword[ebp+12] ;key
        mov edx, dword[esp+12] ;node
        mov edx, dword[edx+12] ;node->key
        cmp eax, edx
        jle L12
            ; key>node->key
            mov eax, dword[esp+12]
            mov dword[esp+8], eax
            mov eax, dword[eax+4]
            mov dword[esp+12], eax
            jmp L10
        L12:
            je L13
            ;key<node->key
            mov eax, dword[esp+12]
            mov dword[esp+8], eax
            mov eax, dword[eax]
            mov dword[esp+12], eax
            jmp L10
        L13:
            ;key == node->key
            mov eax, dword[ebp+16]
            mov edx, dword[esp+12]
            mov dword[edx+16], eax
            jmp L14
    jmp L10
    L11:
    ;
    mov dword[esp], 20
    call malloc
    cmp eax, 0
    je L14
    mov dword[esp+12], eax
    mov edx, dword[ebp+12]
    mov dword[eax+12], edx
    mov edx, dword[ebp+16]
    mov dword[eax+16], edx
    mov edx, dword[esp+8]
    mov dword[eax+8], edx
    mov dword[eax], 0
    mov dword[eax+4], 0
    cmp dword[esp+8], 0
    je L16
    ;сравниваем key, prev->key
    mov eax, dword[ebp+12]
    mov edx, dword[esp+8]
    mov edx, dword[edx+12]
    cmp eax, edx
    jg L17
    mov eax, dword[esp+12]
    mov edx, dword[esp+8]
    mov dword[edx], eax
    jmp L14
    L17:
    mov eax, dword[esp+12]
    mov edx, dword[esp+8]
    mov dword[edx+4], eax
    jmp L14
    L16:
    mov eax, dword[esp+12]
    jmp L15
    L14:
    mov eax, dword[ebp+8]
    L15:
    add esp, 16
    mov edi, dword[esp]
    mov esi, dword[esp+4]
    add esp, 8
    mov esp, ebp
    pop ebp
    ret

findmin:
    push ebp
    mov ebp, esp
    mov eax, dword[ebp+8]
    L8:
    mov edx, dword[eax]
    cmp edx, 0
    je L9
    mov eax, edx
    jmp L8
    L9:
    mov esp, ebp
    pop ebp
    ret

cleanderevo:
    push ebp
    mov ebp, esp
    sub esp, 8
    mov eax, dword[ebp+8]
    cmp eax, 0
    je L5
    mov edx, dword[eax]
    cmp edx, 0
    je L6
    mov dword[esp], edx
    call cleanderevo
    L6:
    mov eax, dword[ebp+8]
    mov edx, dword[eax+4]
    cmp edx, 0
    je L7
    mov dword[esp], edx
    call cleanderevo
    L7:
    mov eax, dword[ebp+8]
    mov dword[esp], eax
    call free
    L5:
    mov esp, ebp
    pop ebp
    ret

delnode:
    push ebp
    mov ebp, esp
    sub esp, 24
    mov eax, dword[ebp+8]
    mov dword[esp], eax
    mov eax, dword[ebp+12]
    mov dword[esp+4], eax
    call searchnode
    mov dword[esp+20], eax
    cmp eax, 0
    jne L23
    mov eax, dword[ebp+8]
    mov esp, ebp
    pop ebp
    ret
    L23:
    ;if (deleting->pravo == NULL && deleting->levo == NULL)
    mov ecx, dword[eax]
    mov edx, dword[eax+4]
    cmp ecx, 0
    jne L24
    cmp edx, 0
    jne L24
        mov edx, dword[eax+8] ;deleting->verx
        cmp edx, 0
        je L25
        mov ecx, dword[edx] ;deleting->verx->levo
        cmp ecx, eax
        jne L26
        mov dword[edx], 0
        mov dword[esp], eax
        call free
        mov eax, dword[ebp+8]
        mov esp, ebp
        pop ebp
        ret
        L26:
        mov dword[edx+4], 0
        mov dword[esp], eax
        call free
        mov eax, dword[ebp+8]
        mov esp, ebp
        pop ebp
        ret
        L25:
        mov dword[esp], eax
        call free
        mov eax, 0
        mov esp, ebp
        pop ebp
        ret
    L24:
    ;if (deleting->pravo && deleting->levo)
    mov eax, dword[esp+20] ;deleting
    mov edx, dword[eax]
    mov ecx, dword[eax+4] ;deleting->pravo
    cmp edx, 0
    je L27
    cmp ecx, 0
    je L27
        mov dword[esp], ecx
        call findmin
        mov dword[esp+16], eax
        mov edx, dword[eax+12] ;nextnode->key
        mov ecx, dword[esp+20] ;deleting
        mov dword[ecx+12], edx
        mov edx, dword[eax+16] ;nextnode->value
        mov dword[ecx+16], edx
        mov eax, dword[esp+16]
        cmp dword[eax+4], 0
        je L28
            ;if (nextnode->pravo)
            mov eax, dword[esp+16]
            mov eax, dword[eax+8] ;nextnode->verx
            mov edx, dword[esp+20] ;deleting
            cmp eax, edx
            jne L29
            ;if (nextnode->verx == deleting)
            mov eax, dword[esp+16] ;nextnode
            mov eax, dword[eax+4] ;nextnode->pravo
            mov dword[edx+4], eax
            mov eax, dword[esp+20] ;deleting
            mov edx, dword[esp+16] ;nextnode
            mov edx, dword[edx+4] ;nextnode->pravo
            mov dword[edx+8], eax
            jmp L30
            L29:
            ;else
            mov eax, dword[esp+16]
            mov eax, dword[eax+8] ;nextnode->verx
            mov edx, dword[esp+16]
            mov edx, dword[edx+4] ;nextnode->pravo
            mov dword[eax], edx
            mov eax, dword[esp+16]
            mov eax, dword[eax+4] ;nextnode->pravo
            mov edx, dword[esp+16]
            mov edx, dword[edx+8] ;nextnode->verx
            mov dword[eax+8], edx
            jmp L30

        L28:
            ;else
            mov eax, dword[esp+16]
            mov eax, dword[eax+8] ;nextnode->verx
            mov edx, dword[esp+20] ;deleting
            cmp eax, edx
            jne L31
                ;if (nextnode->verx == deleting)
                mov dword[edx+4], 0
                jmp L30
            L31:
                ;else
                mov dword[eax], 0
                jmp L30

    L30:
    mov eax, dword[esp+16]
    mov dword[esp], eax
    call free
    mov eax, dword[ebp+8]
    mov esp, ebp
    pop ebp
    ret
    L27:
    mov eax, dword[esp+20] ;deleting
    cmp dword[eax+4], 0
    je L32
    ; if (deleting->pravo)
    cmp dword[eax+8], 0
        ;if (deleting->verx)
        je L33
            mov eax, dword[eax+8]
            mov eax, dword[eax+4]
            cmp eax, dword[esp+20]
            jne L34
            ;if (deleting->verx->pravo == deleting)
            ;deleting->verx->pravo = deleting->pravo;
            mov eax, dword[esp+20]
            mov edx, eax
            mov eax, dword[eax+8]
            mov edx, dword[edx+4]
            mov dword[eax+4], edx
            jmp L35
            L34:
            ;else
            ;deleting->verx->levo = deleting->pravo;
            mov eax, dword[esp+20]
            mov edx, dword[eax+4]
            mov eax, dword[eax+8]
            mov dword[eax], edx
            jmp L35

        L33:
        ;else
        ;derevo = derevo->pravo;
        mov eax, dword[ebp+8]
        mov eax, dword[eax+4]
        mov dword[ebp+8], eax ; хакерство какоето получилось
        mov eax, dword[ebp+8]
        mov dword[eax+8], 0
        jmp L36
    L32:
    ;if (deleting->verx)
    mov eax, dword[esp+20]
    cmp dword[eax+8], 0
    je L39
        ;if (deleting->verx->pravo == deleting)
        mov edx, dword[eax+8]
        mov edx, dword[edx+4]
        cmp eax, edx
        jne L37
            ;deleting->verx->pravo = deleting->levo;
            mov eax, dword[esp+20]
            mov edx, dword[eax]
            mov eax, dword[eax+8]
            mov dword[eax+4], edx
        jmp L38
        L37:
        ;else
            ;deleting->verx->levo = deleting->levo;
            mov eax, dword[esp+20]
            mov edx, dword[eax]
            mov eax, dword[eax+8]
            mov dword[eax], edx
        L38:
        ;deleting->levo->verx = deleting->verx;
        mov eax, dword[esp+20]
        mov edx, dword[eax+8]
        mov eax, dword[eax]
        mov dword[eax+8], edx
        jmp L36
    L39:
    ;else
    ;derevo = derevo->levo;
    mov eax, dword[ebp+8]
    mov eax, dword[eax]
    mov dword[ebp+8], eax
    mov eax, dword[ebp+8]
    mov dword[eax+8], 0
    jmp L36
    L35:
    mov eax, dword[esp+20]
    mov edx, dword[eax+4] ;deleting->pravo
    mov ecx, dword[eax+8] ;deleting->verx
    mov dword[edx+8], ecx ;deleting->pravo->verx = deleting->verx;
    L36:
    mov eax, dword[esp+20]
    mov dword[esp], eax
    call free
    mov eax, dword[ebp+8]
    mov esp, ebp
    pop ebp
    ret

global CMAIN
CMAIN:
    mov ebp, esp; for correct debugging
    pushad
    mov ebp, esp
    add esp, 16
    and esp, -16
    ;
    L1:
    sub esp, 16
    mov dword[esp+4], c
    mov dword[esp], T3
    call scanf
    add esp, 16
    cmp byte[c], 70 ;F
    je L2
    cmp byte[c], 65 ;A
    jne L3
        sub esp, 16
        mov dword[esp], T2
        mov dword[esp+4], k
        mov dword[esp+8], v
        call scanf
        mov eax, dword[derevo]
        mov dword[esp], eax
        mov eax, dword[k]
        mov dword[esp+4], eax
        mov eax, dword[v]
        mov dword[esp+8], eax
        call addnode
        add esp, 16
        mov dword[derevo], eax
    jmp L1
    L3:
    cmp byte[c], 68 ;D
    jne L4
        sub esp, 16
        mov dword[esp], T1
        mov dword[esp+4], k
        call scanf
        mov eax, dword[derevo]
        mov dword[esp], eax
        mov eax, dword[k]
        mov dword[esp+4], eax
        call delnode
        add esp, 16
        mov dword[derevo], eax
    jmp L1
    L4:
    cmp byte[c], 83 ;S
    jne L1
        sub esp, 16
        mov dword[esp], T1
        mov dword[esp+4], k
        call scanf
        mov eax, dword[derevo]
        mov dword[esp], eax
        mov eax, dword[k]
        mov dword[esp+4], eax
        call searchnode
        cmp eax, 0
        je L1
        mov edx, dword[eax+16]
        mov dword[esp+8], edx
        mov edx, dword[eax+12]
        mov dword[esp+4], edx
        mov dword[esp], T4
        call printf
        add esp, 16
    jmp L1
    L2:
    sub esp, 16
    mov eax, dword[derevo]
    mov dword[esp], eax
    call cleanderevo
    add esp, 16
    ;
    mov esp, ebp
    popad
    xor eax, eax
    ret