LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: SD_add_scope
void SD_add_scope(pSD psd, pAstNode scope) {
    pST pst = malloc(sizeof(ST));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated ST %p\n", __func__, (void*)pst);
#endif
    ST_init(pst, scope, ++(psd->level));
    ST_tree_insert(psd->active, pst);
    psd->active = psd->active->last_child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x50, %edi
callq 0x3130
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
addl $0x1, %edx
movl %edx, 0x10(%rax)
callq 0xc530
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xc770
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: SD_remove_scope
void SD_remove_scope(pSD psd) {
    ST_tree_node* parent = psd->active->parent;
    if(parent != NULL) {
        int pmo = parent->value->max_offset;
        int mo = psd->active->value->max_offset;
        if(mo > pmo) {pmo = mo;}
        parent->value->max_offset = pmo;
    }
    psd->active = parent;
    psd->level--;
    if(parent->parent == NULL) {   // if now root is active
        psd->offset = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xcdb8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movl 0x4c(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jle 0xcdab
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %ecx, 0x4c(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xcde7
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: SD_clear
void SD_clear(pSD psd) {
#ifdef LOG_MEM
    fprintf(stderr, "Called %s(%p)\n", __func__, (void*)psd);
#endif
    ST_tree_destroy(psd->root);
    psd->root = psd->active = NULL;
    psd->level = 0;
    psd->offset = 0;
    psd->first_entry = psd->last_entry = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xc800
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/symbol_table.c
// Function: SD_print_sub
void SD_print_sub(pSD psd, FILE* fp) {
    fprintf(stderr, "%-10s %-12s %-10s %-10s %6s %6s %7s\n",
        "lexeme", "type", "scope", "lines", "level", "width", "offset");
    for(pSTEntry node = psd->first_entry; node != NULL; node = node->next) {
        pSTEntry_print_sub(node, stderr);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0xd151(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x8383(%rip), %rsi      # 0x15234
leaq 0x83a1(%rip), %rdx      # 0x15259
leaq 0x79c7(%rip), %rcx      # 0x14886
leaq 0x839a(%rip), %r8       # 0x15260
leaq 0x8399(%rip), %r9       # 0x15266
leaq 0x8398(%rip), %r11      # 0x1526c
leaq 0x8397(%rip), %r10      # 0x15272
leaq 0x8396(%rip), %rax      # 0x15278
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xcf2b
movq -0x18(%rbp), %rdi
movq 0xd0e3(%rip), %rax      # 0x19ff8
movq (%rax), %rsi
callq 0xbd10
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xcf03
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compiler.c
// Function: add_node_addr_to_SD
AddrNode* add_node_addr_to_SD(pAstNode node, pSD psd, addr_type_t addr_type) {
    AddrNode* anode = malloc(sizeof(AddrNode));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated AddrNode %p\n", __func__, (void*)anode);
#endif
    anode->next = NULL;
    anode->symbol_table = (psd->active)->value;
    anode->id = 0;
    anode->addr_type = addr_type;
    anode->type = node->base.type;
    anode->size = node->base.size;
    anode->line = node->base.line;
    anode->col = node->base.col;
    anode->offset = 0;
    SD_add_addr(psd, anode);
    return anode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x40, %edi
callq 0x3130
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xcb30
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compiler.c
// Function: add_node_var_to_SD
void add_node_var_to_SD(pAstNode node, pSD psd, const char* func_name) {
    pSTEntry entry = malloc(sizeof(STEntry));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated STEntry %p\n", __func__, (void*)entry);
#endif
    entry->func_name = func_name;
    entry->use_line = 0;
    entry->use_col = 0;
    entry->readonly = false;
    entry->next = NULL;
    entry->addr = NULL;
    if(node->base.node_type == ASTN_IDList) {
        entry->lexeme = ((IDListNode*)node)->varname;
    }
    else if(node->base.node_type == ASTN_IDTypeList) {
        entry->lexeme = ((IDTypeListNode*)node)->varname;
    }
    else {
        entry->lexeme = NULL;
    }
    int line = node->base.line, col = node->base.col;
    if(!SD_add_entry(psd, entry, line, col)) {
        free(entry);
#ifdef LOG_MEM
        fprintf(stderr, "%s: Freed STEntry %p\n", __func__, (void*)entry);
#endif
    }
    else {
        entry->addr = add_node_addr_to_SD(node, psd, ADDR_VAR);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x30, %edi
callq 0x3130
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpl $0x7, (%rax)
jne 0xf29e
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xf2c5
movq -0x8(%rbp), %rax
cmpl $0x8, (%rax)
jne 0xf2b8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xf2c3
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0xf2c5
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
movl -0x28(%rbp), %ecx
callq 0xc9e0
testb $0x1, %al
jne 0xf2fb
movq -0x20(%rbp), %rdi
callq 0x3030
jmp 0xf315
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0xf170
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compiler.c
// Function: log_var_set
void log_var_set(pSTEntry entry, int line, int col) {
    if(entry->readonly == true) {
        sprintf(msg, "Cannot modify read-only variable '%s' (declared at line %d, col %d).",
            entry->lexeme, entry->addr->line, entry->addr->col);
        print_error("type", ERROR, -1, line, col, entry->lexeme, "RDONLY_MOD", msg);
    }
    entry->use_line = line;
    entry->use_col = col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xf3ae
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl 0x24(%rax), %r8d
leaq 0x10a88(%rip), %rdi     # 0x1fdf0
leaq 0x5fff(%rip), %rsi      # 0x1536e
movb $0x0, %al
callq 0x3190
movl -0xc(%rbp), %ecx
movl -0x10(%rbp), %r8d
movq -0x8(%rbp), %rax
movq (%rax), %r9
leaq 0x54fb(%rip), %rdi      # 0x14886
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x601a(%rip), %r10      # 0x153b3
leaq 0x10a50(%rip), %rax     # 0x1fdf0
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xba50
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/addr.c
// Function: AddrList_clear
void AddrList_clear(AddrList* al) {
    AddrNode* an = al->first;
    AddrNode* tn2 = NULL;
    for(; an != NULL; an = tn2) {
        tn2 = an->next;
        AddrNode_destroy(an);
    }
    al->first = al->last = NULL;
    al->size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xfdb4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xfd20
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xfd8f
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/addr.c
// Function: AddrList_add
void AddrList_add(AddrList* al, AddrNode* an) {
    if(an != NULL) {
        (al->size)++;
        if(al->first == NULL) {
            al->first = an;
        }
        else {
            al->last->next = an;
        }
        al->last = an;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xfe32
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xfe17
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfe26
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/addr.c
// Function: AddrNode_print
void AddrNode_print(const AddrNode* an, FILE* fp) {
    if(an == NULL) {
        fprintf(fp, "null");
    }
    else {
        fprintf(fp, "AddrNode(%d, %d:%d, %s %s", an->id, an->line, an->col, ADDR_TYPE_STRS[an->addr_type],
            TYPE_STRS[an->type]);
        if(an->size > 0) {
            fprintf(fp, "[%d]", an->size);
        }
        fprintf(fp, ", %d)", an->offset);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xfe6e
movq -0x10(%rbp), %rdi
leaq 0x5cc3(%rip), %rsi      # 0x15b25
movb $0x0, %al
callq 0x3120
jmp 0xfefe
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x24(%rax), %r8d
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, %esi
leaq 0xac68(%rip), %rax      # 0x1ab00
movq (%rax,%rsi,8), %r9
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %esi
leaq 0xad34(%rip), %rax      # 0x1abe0
movq (%rax,%rsi,8), %rax
leaq 0x5c73(%rip), %rsi      # 0x15b2a
movq %rax, (%rsp)
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jle 0xfee5
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edx
leaq 0x526d(%rip), %rsi      # 0x1514b
movb $0x0, %al
callq 0x3120
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %edx
leaq 0x524c(%rip), %rsi      # 0x15143
movb $0x0, %al
callq 0x3120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/addr.c
// Function: AddrList_print
void AddrList_print(const AddrList* al, FILE* fp) {
    AddrNode* an = al->first;
    for(; an != NULL; an = an->next) {
        AddrNode_print(an, fp);
        fprintf(fp, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xff5e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xfe40
movq -0x10(%rbp), %rdi
leaq 0x51e1(%rip), %rsi      # 0x1512b
movb $0x0, %al
callq 0x3120
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xff2b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/type.c
// Function: get_type_width
int get_type_width(valtype_t type, int size) {
    if(size == 0) {
        return TYPE_SIZES[type];
    }
    else {
        return TYPE_SIZES[type] * size;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0xff94
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xac74(%rip), %rax      # 0x1ac00
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rbp)
jmp 0xffaa
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xac60(%rip), %rax      # 0x1ac00
movl (%rax,%rcx,4), %eax
imull -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/type.c
// Function: get_aligned_offset
int get_aligned_offset(int offset, valtype_t type) {
    int align_size = TYPE_ALIGNS[type];
    int t = offset % align_size;
    if(t != 0)
        offset += (align_size - t);
    return offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0xac4a(%rip), %rax      # 0x1ac10
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0xffe8
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/type.c
// Function: get_type_str
void get_type_str(char* str, valtype_t type, int size) {
    if(size == 0)
        sprintf(str, "%s", TYPE_STRS[type]);
    else
        sprintf(str, "%s[%d]", TYPE_STRS[type], size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jne 0x1002c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xabc8(%rip), %rax      # 0x1abe0
movq (%rax,%rcx,8), %rdx
leaq 0x5c75(%rip), %rsi      # 0x15c98
movb $0x0, %al
callq 0x3190
jmp 0x10051
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xaba4(%rip), %rax      # 0x1abe0
movq (%rax,%rcx,8), %rdx
movl -0x10(%rbp), %ecx
leaq 0x50ff(%rip), %rsi      # 0x15149
movb $0x0, %al
callq 0x3190
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_init
void irinstr_init(IRInstr* instr, op_t op) {
    instr->op = op;
    instr->arg1 = NULL;
    instr->arg2 = NULL;
    instr->res = NULL;
    instr->prev = NULL;
    instr->next = NULL;
    instr->label = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x30(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_init2
void irinstr_init2(IRInstr* instr, op_t op, AddrNode* res, AddrNode* arg1, AddrNode* arg2) {
    irinstr_init(instr, op);
    instr->arg1 = arg1;
    instr->arg2 = arg2;
    instr->res = res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x10060
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_new
IRInstr* irinstr_new(op_t op) {
    IRInstr* p = malloc(sizeof(IRInstr));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated IRInstr %p\n", __func__, (void*)p);
#endif
    irinstr_init(p, op);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x38, %edi
callq 0x3130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x10060
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_new2
IRInstr* irinstr_new2(op_t op, AddrNode* res, AddrNode* arg1, AddrNode* arg2) {
    IRInstr* p = malloc(sizeof(IRInstr));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated IRInstr %p\n", __func__, (void*)p);
#endif
    irinstr_init2(p, op, res, arg1, arg2);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x38, %edi
callq 0x3130
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
callq 0x100c0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_new3
IRInstr* irinstr_new3(op_t op, int label) {
    IRInstr* p = malloc(sizeof(IRInstr));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated IRInstr %p\n", __func__, (void*)p);
#endif
    irinstr_init3(p, op, label);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x38, %edi
callq 0x3130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x10120
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_new4
IRInstr* irinstr_new4(op_t op, AddrNode* res, AddrNode* arg1, AddrNode* arg2, int label) {
    IRInstr* p = malloc(sizeof(IRInstr));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated IRInstr %p\n", __func__, (void*)p);
#endif
    irinstr_init4(p, op, res, arg1, arg2, label);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x38, %edi
callq 0x3130
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movl -0x24(%rbp), %r9d
callq 0x10150
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_link
void irinstr_link(IRInstr* i1, IRInstr* i2) {
    if(i1->next != NULL) {
        fprintf(stderr, "%s: i1 (%p) already has a next.\n", __func__, (void*)i1);
    }
    if(i2->prev != NULL) {
        fprintf(stderr, "%s: i2 (%p) already has a prev.\n", __func__, (void*)i2);
    }
    i1->next = i2;
    i2->prev = i1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x102ee
movq 0x9d26(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x5891(%rip), %rsi      # 0x15b71
leaq 0x58ab(%rip), %rdx      # 0x15b92
movb $0x0, %al
callq 0x3120
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1031c
movq 0x9cf8(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rcx
leaq 0x5891(%rip), %rsi      # 0x15b9f
leaq 0x587d(%rip), %rdx      # 0x15b92
movb $0x0, %al
callq 0x3120
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_clear
void irinstr_clear(IRInstr* instr) {
    if(instr->prev != NULL) {
        instr->prev->next = NULL;
    }
    if(instr->next != NULL) {
        instr->next->prev = NULL;
    }
    irinstr_init(instr, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x10367
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x10382
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x10060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_destroy_list
void irinstr_destroy_list(IRInstr* n) {
    IRInstr* p = NULL;
    while(n != NULL) {
        p = n->next;
        irinstr_destroy(n);
        n = p;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1040a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x103a0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x103e4
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/ircode.c
// Function: irinstr_print
void irinstr_print(IRInstr* n, FILE* fp) {
    fprintf(fp, "Instr(op=%s", OP_STRS[n->op]);
    if(n->op == OP_JUMP0 || n->op == OP_JUMP || n->op == OP_LABEL
        || n->op == OP_JG || n->op == OP_JUMP1) {
        fprintf(fp, ", label=%d", n->label);
    }
    if(n->res != NULL) {
        fprintf(fp, ",\n\tres=");
        AddrNode_print(n->res, fp);
    }
    if(n->arg1 != NULL) {
        fprintf(fp, ",\n\targ1=");
        AddrNode_print(n->arg1, fp);
    }
    if(n->arg2 != NULL) {
        fprintf(fp, ",\n\targ2=");
        AddrNode_print(n->arg2, fp);
    }
    fprintf(fp, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0xa6ed(%rip), %rax      # 0x1ab20
movq (%rax,%rcx,8), %rdx
leaq 0x5782(%rip), %rsi      # 0x15bc0
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
cmpl $0x13, (%rax)
je 0x10472
movq -0x8(%rbp), %rax
cmpl $0x10, (%rax)
je 0x10472
movq -0x8(%rbp), %rax
cmpl $0x15, (%rax)
je 0x10472
movq -0x8(%rbp), %rax
cmpl $0x11, (%rax)
je 0x10472
movq -0x8(%rbp), %rax
cmpl $0x14, (%rax)
jne 0x1048b
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x30(%rax), %edx
leaq 0x5748(%rip), %rsi      # 0x15bcc
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x104b9
movq -0x10(%rbp), %rdi
leaq 0x5736(%rip), %rsi      # 0x15bd7
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xfe40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x104e7
movq -0x10(%rbp), %rdi
leaq 0x5710(%rip), %rsi      # 0x15bdf
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xfe40
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10515
movq -0x10(%rbp), %rdi
leaq 0x56eb(%rip), %rsi      # 0x15be8
movb $0x0, %al
callq 0x3120
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xfe40
movq -0x10(%rbp), %rdi
leaq 0x4186(%rip), %rsi      # 0x146a6
movb $0x0, %al
callq 0x3120
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_combine
void CLASSED(combine)(CLASS* plist, CLASS* p1, CLASS* p2) {
    plist->size = p1->size + p2->size;
    if(p1->first == NULL) {
        plist->first = p2->first;
        plist->last = p2->last;
    }
    else if(p2->first == NULL) {
        plist->first = p1->first;
        plist->last = p1->last;
    }
    else {
        TYPED(link)(p1->last, p2->first);
        plist->first = p1->first;
        plist->last = p2->last;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
addl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x105f3
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x10651
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1061d
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1064f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x102b0
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x10651
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_prepend
void CLASSED(prepend)(CLASS* plist, TYPE instr) {
    (plist->size)++;
    if(plist->first == NULL) {
        plist->first = plist->last = instr;
        plist->size = 1;
    }
    else {
        TYPED(link)(instr, plist->first);
        plist->first = instr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x106a7
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x106c2
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x102b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_append
void CLASSED(append)(CLASS* plist, TYPE instr) {
    (plist->size)++;
    if(plist->first == NULL) {
        plist->first = plist->last = instr;
        plist->size = 1;
    }
    else {
        TYPED(link)(plist->last, instr);
        plist->last = instr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x10717
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x10734
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x102b0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_remove
void CLASSED(remove)(CLASS* plist, TYPE elem) {
    (plist->size)--;
    // first manipulate pointers of list
    if(plist->first == NULL) {
        fprintf(stderr, "Cannot remove from empty linked-list.\n");
        plist->first = plist->last = elem;
        plist->size = 0;
    }
    else if(plist->first == elem) {
        if(plist->last == elem) {
            plist->first = plist->last = NULL;
        }
        else {
            plist->first = plist->first->next;
        }
    }
    else if(plist->last == elem) {
        plist->last = plist->last->prev;
    }
    // now detach elem
    TYPE prev = elem->prev;
    TYPE next = elem->next;
    elem->prev = elem->next = NULL;
    if(next != NULL) {
        next->prev = prev;
    }
    if(prev != NULL) {
        prev->next = next;
    }
    TYPED(destroy)(elem);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1079f
movq 0x988a(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
leaq 0x5479(%rip), %rsi      # 0x15bf1
movb $0x0, %al
callq 0x3120
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
jmp 0x1080d
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x107e7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x107d3
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
jmp 0x107e5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1080b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x10809
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1080b
jmp 0x1080d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x10850
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x10863
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rdi
callq 0x103a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/./util/llist.gen.c
// Function: ircode_print
void CLASSED(print)(CLASS* plist, FILE* fp) {
    int i;
    TYPE node = plist->first;
    for(i=0; i<(plist->size); ++i) {
        TYPED(print)(node, fp);
        fprintf(fp, "\n");
        node = node->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x10924
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x10410
movq -0x10(%rbp), %rdi
leaq 0x4825(%rip), %rsi      # 0x1512b
movb $0x0, %al
callq 0x3120
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x108e2
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_init
void x86_instr_init(X86Instr* instr, x86_op_t opcode) {
    memset((void*)instr, 0, sizeof(instr));
    instr->next = instr->prev = NULL;
    instr->arg1[0] = instr->arg2[0] = '\0';
    instr->opcode = opcode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x30d0
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x22(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x4(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_new
X86Instr* x86_instr_new(x86_op_t opcode) {
    X86Instr* p = malloc(sizeof(X86Instr));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated X86Instr %p\n", __func__, (void*)p);
#endif
    x86_instr_init(p, opcode);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x50, %edi
callq 0x3130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0x10930
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_new2
X86Instr* x86_instr_new2(x86_op_t opcode, const char* arg1, const char* arg2) {
    X86Instr* p = malloc(sizeof(X86Instr));
#ifdef LOG_MEM
    fprintf(stderr, "%s: Allocated X86Instr %p\n", __func__, (void*)p);
#endif
    x86_instr_init2(p, opcode, arg1, arg2);
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x50, %edi
callq 0x3130
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x10990
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_link
void x86_instr_link(X86Instr* i1, X86Instr* i2) {
    if(i1->next != NULL) {
        fprintf(stderr, "%s: i1 (%p) already has a next.\n", __func__, (void*)i1);
    }
    if(i2->prev != NULL) {
        fprintf(stderr, "%s: i2 (%p) already has a prev.\n", __func__, (void*)i2);
    }
    i1->next = i2;
    i2->prev = i1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x10a9e
movq 0x9576(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rcx
leaq 0x50e1(%rip), %rsi      # 0x15b71
leaq 0x51e3(%rip), %rdx      # 0x15c7a
movb $0x0, %al
callq 0x3120
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x10acc
movq 0x9548(%rip), %rax      # 0x19ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rcx
leaq 0x50e1(%rip), %rsi      # 0x15b9f
leaq 0x51b5(%rip), %rdx      # 0x15c7a
movb $0x0, %al
callq 0x3120
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_clear
void x86_instr_clear(X86Instr* instr) {
    if(instr->prev != NULL) {
        instr->prev->next = NULL;
    }
    if(instr->next != NULL) {
        instr->next->prev = NULL;
    }
    x86_instr_init(instr, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x10b17
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x10b32
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x10930
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_destroy_list
void x86_instr_destroy_list(X86Instr* n) {
    X86Instr* p = NULL;
    while(n != NULL) {
        p = n->next;
        x86_instr_destroy(n);
        n = p;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x10bba
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x10b50
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10b94
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/x86.c
// Function: x86_instr_print
void x86_instr_print(X86Instr* n, FILE* fp) {
    if(n->opcode == X86_OP_label) {
        fprintf(fp, "%s%s:", X86_INDENT_STR, n->arg1);
    }
    else if(n->arg2[0] != '\0') {
        fprintf(fp, "%s%s %s, %s", X86_INDENT_STR, X86_OP_STRS[n->opcode], n->arg1, n->arg2);
    }
    else if(n->arg1[0] != '\0') {
        fprintf(fp, "%s%s %s", X86_INDENT_STR, X86_OP_STRS[n->opcode], n->arg1);
    }
    else {
        fprintf(fp, "%s%s", X86_INDENT_STR, X86_OP_STRS[n->opcode]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x13, (%rax)
jne 0x10bff
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rcx
addq $0x4, %rcx
leaq 0x509d(%rip), %rsi      # 0x15c89
leaq 0x422f(%rip), %rdx      # 0x14e22
movb $0x0, %al
callq 0x3120
jmp 0x10cbd
movq -0x8(%rbp), %rax
movsbl 0x22(%rax), %eax
cmpl $0x0, %eax
je 0x10c4a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0xa001(%rip), %rax      # 0x1ac20
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %r8
addq $0x4, %r8
movq -0x8(%rbp), %r9
addq $0x22, %r9
leaq 0x5055(%rip), %rsi      # 0x15c8f
leaq 0x41e1(%rip), %rdx      # 0x14e22
movb $0x0, %al
callq 0x3120
jmp 0x10cbb
movq -0x8(%rbp), %rax
movsbl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x10c8d
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x9fb6(%rip), %rax      # 0x1ac20
movq (%rax,%rcx,8), %rcx
movq -0x8(%rbp), %r8
addq $0x4, %r8
leaq 0x501e(%rip), %rsi      # 0x15c9b
leaq 0x419e(%rip), %rdx      # 0x14e22
movb $0x0, %al
callq 0x3120
jmp 0x10cb9
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x9f80(%rip), %rax      # 0x1ac20
movq (%rax,%rcx,8), %rcx
leaq 0x4ff8(%rip), %rsi      # 0x15ca3
leaq 0x4170(%rip), %rdx      # 0x14e22
movb $0x0, %al
callq 0x3120
jmp 0x10cbb
jmp 0x10cbd
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: enable_output
void enable_output(valtype_t type, int size) {
    include_lib_files[0] = true;
    int index = 1;
    if(size > 0) {
        index += 2;
    }
    if(type == TYPE_BOOLEAN) {
        index++;
    }
    include_lib_files[index] = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb $0x1, 0x9c57(%rip)      # 0x1ad38
movl $0x1, -0xc(%rbp)
cmpl $0x0, -0x8(%rbp)
jle 0x110f7
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x11106
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x9c27(%rip), %rax      # 0x1ad38
movb $0x1, (%rax,%rcx)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: enable_input
void enable_input(valtype_t type) {
    include_lib_files[0] = true;
    int index = 5;
    if(type == TYPE_BOOLEAN) {
        index++;
    }
    include_lib_files[index] = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movb $0x1, 0x9c0a(%rip)      # 0x1ad38
movl $0x5, -0x8(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x11144
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x9be9(%rip), %rax      # 0x1ad38
movb $0x1, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: load_index_if_needed
void load_index_if_needed(X86Code* ocode, const AddrNode* an, const char* index_reg) {
    if(an->addr_type == ADDR_ARR && an->index->addr_type == ADDR_VAR) {
        X86Instr* onode = x86_instr_new(X86_OP_mov);
        x86_code_append(ocode, onode);
        strcpy(onode->arg1, index_reg);
        snprintf(onode->arg2, X86_ARG_SIZE, "[%s + %d]", DATA_REG, an->index->offset);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x14(%rax)
jne 0x114d3
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x0, 0x14(%rax)
jne 0x114d3
xorl %edi, %edi
callq 0x109f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10e70
movq -0x20(%rbp), %rdi
addq $0x4, %rdi
movq -0x18(%rbp), %rsi
callq 0x3050
movq -0x20(%rbp), %rdi
addq $0x22, %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x28(%rax), %r8d
movl $0x1e, %esi
leaq 0x49b3(%rip), %rdx      # 0x15e78
leaq 0x48a0(%rip), %rcx      # 0x15d6c
movb $0x0, %al
callq 0x30b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: op_addr_to_reg
void op_addr_to_reg(X86Code* ocode, x86_op_t opcode, int regno, const AddrNode* an) {
    X86Instr* onode = x86_instr_new2(opcode, std_regs[regno][an->type], NULL);
    load_index_if_needed(ocode, an, "si");
    addr_to_x86_arg(an, onode->arg2, false, "rsi");
    x86_code_append(ocode, onode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %edi
movslq -0x10(%rbp), %rax
leaq 0xea1c(%rip), %rsi      # 0x1ff20
imulq $0x28, %rax, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
imulq $0xa, %rax, %rax
addq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x10a20
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x4966(%rip), %rdx      # 0x15e9b
callq 0x11450
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x22, %rsi
xorl %edx, %edx
leaq 0x494b(%rip), %rcx      # 0x15e9a
callq 0x111a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10e70
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: op_reg_to_addr
void op_reg_to_addr(X86Code* ocode, x86_op_t opcode, const AddrNode* an, int regno) {
    X86Instr* onode = x86_instr_new2(opcode, NULL, std_regs[regno][an->type]);
    load_index_if_needed(ocode, an, "di");
    addr_to_x86_arg(an, onode->arg1, false, "rdi");
    x86_code_append(ocode, onode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0xc(%rbp), %edi
movslq -0x1c(%rbp), %rax
leaq 0xe98c(%rip), %rdx      # 0x1ff20
imulq $0x28, %rax, %rax
addq %rax, %rdx
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
imulq $0xa, %rax, %rax
addq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x10a20
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x48da(%rip), %rdx      # 0x15e9f
callq 0x11450
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
xorl %edx, %edx
leaq 0x48bf(%rip), %rcx      # 0x15e9e
callq 0x111a0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10e70
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: op_addr_to_addr
void op_addr_to_addr(X86Code* ocode, x86_op_t opcode, const AddrNode* an1, const AddrNode* an2) {
    if((an1->addr_type == ADDR_CONST) != (an2->addr_type == ADDR_CONST)) {
        X86Instr* onode = x86_instr_new2(opcode, NULL, NULL);
        load_index_if_needed(ocode, an1, "si");
        load_index_if_needed(ocode, an2, "di");
        addr_to_x86_arg(an1, onode->arg1, true, "rsi");
        addr_to_x86_arg(an2, onode->arg2, true, "rdi");
        x86_code_append(ocode, onode);
    }
    else {
        op_addr_to_reg(ocode, X86_OP_mov, 0, an2);
        op_reg_to_addr(ocode, opcode, an1, 0);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x2, 0x14(%rax)
sete %al
andb $0x1, %al
movzbl %al, %eax
movq -0x20(%rbp), %rcx
cmpl $0x2, 0x14(%rcx)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x116c4
movl -0xc(%rbp), %edi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x10a20
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x4839(%rip), %rdx      # 0x15e9b
callq 0x11450
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4829(%rip), %rdx      # 0x15e9f
callq 0x11450
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x4, %rsi
movl $0x1, %edx
leaq 0x4807(%rip), %rcx      # 0x15e9a
callq 0x111a0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x22, %rsi
movl $0x1, %edx
leaq 0x47ee(%rip), %rcx      # 0x15e9e
callq 0x111a0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x10e70
jmp 0x116e7
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rcx
xorl %edx, %edx
movl %edx, %esi
callq 0x114e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq 0x11570
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: op_apply
void op_apply(X86Code* ocode, x86_op_t opcode, const AddrNode* an) {
    X86Instr* onode = x86_instr_new(opcode);
    load_index_if_needed(ocode, an, "si");
    addr_to_x86_arg(an, onode->arg1, true, "rsi");
    x86_code_append(ocode, onode);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edi
callq 0x109f0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x477d(%rip), %rdx      # 0x15e9b
callq 0x11450
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x4, %rsi
movl $0x1, %edx
leaq 0x475f(%rip), %rcx      # 0x15e9a
callq 0x111a0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10e70
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharmaeklavya2[P]cerplag/compile_x86.c
// Function: check_arg
bool check_arg(const AddrNode* an) {
    if(an != NULL && an->type != TYPE_INTEGER && an->type != TYPE_BOOLEAN) {
        print_error("x86_codegen", ERROR, -1, an->line, an->col, TYPE_STRS[an->type],
            "BAD_TYPE", "Bad type of argument");
        return false;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x117da
movq -0x10(%rbp), %rax
cmpl $0x1, 0x18(%rax)
je 0x117da
movq -0x10(%rbp), %rax
cmpl $0x3, 0x18(%rax)
je 0x117da
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rbp), %rax
movl 0x24(%rax), %r8d
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, %edx
leaq 0x943a(%rip), %rax      # 0x1abe0
movq (%rax,%rdx,8), %r9
leaq 0x46f1(%rip), %rdi      # 0x15ea2
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq 0x403a(%rip), %r10      # 0x157f9
leaq 0x46e8(%rip), %rax      # 0x15eae
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0xba50
movb $0x0, -0x1(%rbp)
jmp 0x117de
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)