LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_case
elm_ast_val_t *elm_ast_case(int i, elm_ast_val_t **xs) {
    assert(i == 4);
    //assert(((elm_ast_t *)(xs[1]))->tag == ELM_AST_EXPR);
    assert(((elm_ast_t *)(xs[3]))->tag == ELM_AST_CASE);
    
    elm_ast_t *node = elm_ast_new(ELM_AST_CASE, NULL);
    elm_ast_add_child(node, xs[1]);
    
    elm_ast_t *branches = (elm_ast_t *)xs[3];
    for (int x = 0; x < branches->children_num; x++) {
        elm_ast_add_child(node, branches->children[x]);
    } 
    
    free(xs[0]);
    free(xs[2]);
    elm_ast_delete_no_children(xs[3]);
    
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x4(%rbp)
jne 0x1a27
jmp 0x1a46
leaq 0xf736(%rip), %rdi      # 0x11164
leaq 0xf6f7(%rip), %rsi      # 0x1112c
movl $0x88, %edx
leaq 0xf72a(%rip), %rcx      # 0x1116b
callq 0x10a0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
cmpl $0xb, (%rax)
jne 0x1a55
jmp 0x1a74
leaq 0xf742(%rip), %rdi      # 0x1119e
leaq 0xf6c9(%rip), %rsi      # 0x1112c
movl $0x8a, %edx
leaq 0xf6fc(%rip), %rcx      # 0x1116b
callq 0x10a0
movl $0xb, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x14e0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1ada
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1aaa
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x11e0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x11e0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1800
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_branches
elm_ast_val_t *elm_ast_branches(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_CASE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xb, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1b60
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b38
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_branch
elm_ast_val_t *elm_ast_branch(int i, elm_ast_val_t **xs) {
    assert(i == 3);
    assert(((elm_ast_t *)(xs[i - 1]))->tag == ELM_AST_EXPR);

    elm_ast_t *node = elm_ast_new(ELM_AST_BRANCH, NULL);
    elm_ast_add_child(node, xs[0]);
    elm_ast_add_child(node, xs[2]);

    free(xs[1]);
    
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x1b87
jmp 0x1ba6
leaq 0xf63c(%rip), %rdi      # 0x111ca
leaq 0xf597(%rip), %rsi      # 0x1112c
movl $0xa4, %edx
leaq 0xf630(%rip), %rcx      # 0x111d1
callq 0x10a0
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x7, (%rax)
jne 0x1bbe
jmp 0x1bdd
leaq 0xf641(%rip), %rdi      # 0x11206
leaq 0xf560(%rip), %rsi      # 0x1112c
movl $0xa5, %edx
leaq 0xf5f9(%rip), %rcx      # 0x111d1
callq 0x10a0
movl $0xc, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x14e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x14e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_decl
elm_ast_val_t *elm_ast_decl(int i, elm_ast_val_t **xs) {
    assert(i == 3);
    assert(((elm_ast_t *)(xs[0]))->tag == ELM_AST_FUNC);
    assert(((elm_ast_t *)(xs[2]))->tag == ELM_AST_EXPR);

    elm_ast_t *node = elm_ast_new(ELM_AST_DECL, NULL);
    elm_ast_add_child(node, xs[0]);
    elm_ast_add_child(node, xs[2]);

    free(xs[1]);

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x4(%rbp)
jne 0x1c87
jmp 0x1ca6
leaq 0xf53c(%rip), %rdi      # 0x111ca
leaq 0xf497(%rip), %rsi      # 0x1112c
movl $0xb7, %edx
leaq 0xf595(%rip), %rcx      # 0x11236
callq 0x10a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0xf, (%rax)
jne 0x1cb4
jmp 0x1cd3
leaq 0xf5ae(%rip), %rdi      # 0x11269
leaq 0xf46a(%rip), %rsi      # 0x1112c
movl $0xb8, %edx
leaq 0xf568(%rip), %rcx      # 0x11236
callq 0x10a0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x7, (%rax)
jne 0x1ce2
jmp 0x1d01
leaq 0xf5ac(%rip), %rdi      # 0x11295
leaq 0xf43c(%rip), %rsi      # 0x1112c
movl $0xb9, %edx
leaq 0xf53a(%rip), %rcx      # 0x11236
callq 0x10a0
movl $0xe, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x14e0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x14e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11e0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_func
elm_ast_val_t *elm_ast_func(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_FUNC, NULL);

    assert(((elm_ast_t *)(xs[0]))->tag == ELM_AST_VAR);
    assert(((elm_ast_t *)(xs[0]))->contents != NULL);

    node->contents = malloc(sizeof(char) * strlen(((elm_ast_t *)(xs[0]))->contents));
    strcpy(node->contents, ((elm_ast_t *)(xs[0]))->contents);
    elm_ast_delete(xs[0]);

    if (i > 1) {
        for (int x = 1; x < i; x++) {
            elm_ast_add_child(node, xs[x]);
        }
    }

    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xf, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x6, (%rax)
jne 0x1d7f
jmp 0x1d9e
leaq 0xf53b(%rip), %rdi      # 0x112c1
leaq 0xf39f(%rip), %rsi      # 0x1112c
movl $0xc7, %edx
leaq 0xf553(%rip), %rcx      # 0x112ec
callq 0x10a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x1dae
jmp 0x1dcd
leaq 0xf56a(%rip), %rdi      # 0x1131f
leaq 0xf370(%rip), %rsi      # 0x1112c
movl $0xc8, %edx
leaq 0xf524(%rip), %rcx      # 0x112ec
callq 0x10a0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1070
movq %rax, %rdi
shlq $0x0, %rdi
callq 0x1130
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
callq 0x1040
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x1e60
cmpl $0x1, -0x4(%rbp)
jle 0x1e4f
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1e4d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e25
jmp 0x1e4f
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_delete
void elm_ast_delete(elm_ast_t *a) {
    if (a == NULL) { return; }

    for (int i = 0; i < a->children_num; i++) {
        elm_ast_delete(a->children[i]);
    }

    free(a->children);
    free(a->contents);
    free(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1e75
jmp 0x1ecb
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x1ea8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1e60
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e7c
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x11e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11e0
movq -0x8(%rbp), %rdi
callq 0x11e0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_module
elm_ast_val_t *elm_ast_module(int i, elm_ast_val_t **xs) {
    elm_ast_t *node = elm_ast_new(ELM_AST_MODULE, NULL);
    for (int x = 0; x < i; x++) {
        elm_ast_add_child(node, xs[x]);
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x1480
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1f30
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x14e0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1f08
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_traverse_start
elm_ast_trav_t *elm_ast_traverse_start(elm_ast_t *ast, elm_ast_trav_order_t order) {
    elm_ast_trav_t *trav;
    trav = malloc(sizeof(elm_ast_trav_t));
    trav->curr_node = ast;
    trav->parent = NULL;
    trav->curr_child = 0;
    trav->order = order;
    return trav;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x18, %edi
callq 0x1130
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_traverse_next
elm_ast_t *elm_ast_traverse_next(elm_ast_trav_t **trav) {
    elm_ast_trav_t *n_trav, *to_free;
    elm_ast_t *ret = NULL;
    int cchild;

    if(*trav == NULL) return NULL;

    switch((*trav)->order) {
        case ELM_AST_TRAV_ORDER_PRE:
            ret = (*trav)->curr_node;
            
            while(*trav != NULL &&
                    (*trav)->curr_child >= (*trav)->curr_node->children_num)
            {
                to_free = *trav;
                *trav = (*trav)->parent;
                free(to_free);
            }
            
            if(*trav == NULL) {
                break;
            }

            n_trav = malloc(sizeof(elm_ast_trav_t));

            cchild = (*trav)->curr_child;
            n_trav->curr_node = (*trav)->curr_node->children[cchild];
            n_trav->parent = *trav;
            n_trav->curr_child = 0;
            n_trav->order = (*trav)->order;

            (*trav)->curr_child++;
            *trav = n_trav;

            break;
        case ELM_AST_TRAV_ORDER_POST:
            break;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x24db
movq $0x0, -0x8(%rbp)
jmp 0x2603
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x14(%rax), %eax
movl %eax, -0x30(%rbp)
testl %eax, %eax
je 0x24ff
jmp 0x24ee
movl -0x30(%rbp), %eax
subl $0x1, %eax
je 0x25f9
jmp 0x25fb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x31(%rbp)
je 0x2539
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq (%rcx), %rcx
cmpl 0x10(%rcx), %eax
setge %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x2542
jmp 0x256a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x11e0
jmp 0x250d
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x2579
jmp 0x25fb
movl $0x18, %edi
callq 0x1130
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x14(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x25fb
jmp 0x25fb
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/east.c
// Function: elm_ast_traverse_free
void elm_ast_traverse_free(elm_ast_trav_t **trav) {
    elm_ast_trav_t *n_trav;

    while(*trav != NULL) {
        n_trav = (*trav)->parent;
        free(*trav);
        *trav = n_trav;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x264e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x11e0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x261c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_parse
int elm_parse(const char *filename, const char *string, elm_result_t *r) {
    elm_parser_t *p = elm_parser_init();
    mpc_result_t result;
    if (mpc_parse(filename, string, p->Module, &result)) {
        r->output = (elm_ast_t *)result.output;
        elm_parser_cleanup(p);
        return 1;
    } else {
        r->error = elm_error(result.error);  
        elm_parser_cleanup(p);
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x26f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rdx
leaq -0x30(%rbp), %rcx
callq 0x53a0
cmpl $0x0, %eax
je 0x26bb
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x2c70
movl $0x1, -0x4(%rbp)
jmp 0x26de
movq -0x30(%rbp), %rdi
callq 0x2d90
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x2c70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_parser_cleanup
static void elm_parser_cleanup(elm_parser_t *p) {
    mpc_cleanup(17,
            p->Comment,
            p->True,
            p->False,
            p->Number,
            p->Float,
            p->Char,
            p->String,
            p->Literal,
            p->Var,
            p->Value,
            p->Expr,
            p->List,
            p->Tuple,
            p->If,
            p->Case,
            p->Decl,
            p->Module);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x30(%rbp), %rax
movq 0x18(%rax), %r8
movq -0x30(%rbp), %rax
movq 0x20(%rax), %r9
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x30(%rbp), %rdi
movq 0x30(%rdi), %rdi
movq %rdi, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movq 0x38(%rdi), %rdi
movq %rdi, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq 0x48(%rdi), %rdi
movq %rdi, -0x40(%rbp)
movq -0x30(%rbp), %rdi
movq 0x50(%rdi), %r13
movq -0x30(%rbp), %rdi
movq 0x58(%rdi), %r12
movq -0x30(%rbp), %rdi
movq 0x60(%rdi), %r15
movq -0x30(%rbp), %rdi
movq 0x68(%rdi), %r14
movq -0x30(%rbp), %rdi
movq 0x70(%rdi), %rbx
movq -0x30(%rbp), %rdi
movq 0x78(%rdi), %r11
movq -0x30(%rbp), %rdi
movq 0x40(%rdi), %r10
movq -0x30(%rbp), %rdi
movq 0x80(%rdi), %rdi
movq %rdi, -0x38(%rbp)
movl $0x11, %edi
movq %rax, (%rsp)
movq -0x50(%rbp), %rax
movq %rax, 0x8(%rsp)
movq -0x48(%rbp), %rax
movq %rax, 0x10(%rsp)
movq -0x40(%rbp), %rax
movq %rax, 0x18(%rsp)
movq -0x38(%rbp), %rax
movq %r13, 0x20(%rsp)
movq %r12, 0x28(%rsp)
movq %r15, 0x30(%rsp)
movq %r14, 0x38(%rsp)
movq %rbx, 0x40(%rsp)
movq %r11, 0x48(%rsp)
movq %r10, 0x50(%rsp)
movq %rax, 0x58(%rsp)
movb $0x0, %al
callq 0x64d0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_parse_file
int elm_parse_file(const char *filename, FILE *file, elm_result_t *r) {
    elm_parser_t *p = elm_parser_init();
    mpc_result_t result;
    if (mpc_parse_file(filename, file, p->Module, &result)) {
        r->output = (elm_ast_t *)result.output;
        elm_parser_cleanup(p);
        return 1;
    } else {
        r->error = elm_error(result.error);  
        elm_parser_cleanup(p);
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x26f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rdx
leaq -0x30(%rbp), %rcx
callq 0x57b0
cmpl $0x0, %eax
je 0x2e1b
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x2c70
movl $0x1, -0x4(%rbp)
jmp 0x2e3e
movq -0x30(%rbp), %rdi
callq 0x2d90
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x2c70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_parse_pipe
int elm_parse_pipe(const char *filename, FILE *pipe, elm_result_t *r) {
    elm_parser_t *p = elm_parser_init();
    mpc_result_t result;
    if (mpc_parse_pipe(filename, pipe, p->Module, &result)) {
        r->output = (elm_ast_t *)result.output;
        elm_parser_cleanup(p);
        return 1;
    } else {
        r->error = elm_error(result.error);  
        elm_parser_cleanup(p);
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
callq 0x26f0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x80(%rax), %rdx
leaq -0x30(%rbp), %rcx
callq 0x5950
cmpl $0x0, %eax
je 0x2eab
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x2c70
movl $0x1, -0x4(%rbp)
jmp 0x2ece
movq -0x30(%rbp), %rdi
callq 0x2d90
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rdi
callq 0x2c70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_parse_contents
int elm_parse_contents(const char *filename, elm_result_t *r) {
    elm_parser_t *p = elm_parser_init();
    mpc_result_t result;
    if (mpc_parse_contents(filename, p->Module, &result)) {
        r->output = (elm_ast_t *)result.output;
        elm_parser_cleanup(p);
        return 1;
    } else {
        r->error = elm_error(result.error);
        elm_parser_cleanup(p);
        return 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
callq 0x26f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x80(%rax), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5af0
cmpl $0x0, %eax
je 0x2f33
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x2c70
movl $0x1, -0x4(%rbp)
jmp 0x2f56
movq -0x28(%rbp), %rdi
callq 0x2d90
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x2c70
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_list
static mpc_parser_t *elm_list(mpc_parser_t *expr) {
    return mpc_expect(
            mpc_or(2,
                mpc_tok_squares(mpc_many(elm_ast_list, expr), free),
                mpc_tok_squares(mpc_and(2, elm_ast_list_cons, expr, mpc_many(elm_ast_list, mpc_and(2, mpcf_snd_free, mpc_tok(mpc_char(',')), expr, free)), free), free))
            , "list");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x1ad7(%rip), %rdi     # 0x16e0
callq 0x70b0
movq %rax, %rdi
movq 0x13dfa(%rip), %rsi     # 0x16fc0
callq 0x8650
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2c, %edi
callq 0x6980
movq %rax, %rdi
callq 0x8350
movq %rax, %rdx
movq -0x8(%rbp), %rcx
movl $0x2, %edi
leaq 0x51f4(%rip), %rsi      # 0x83f0
movq 0x13dbd(%rip), %r8      # 0x16fc0
movb $0x0, %al
callq 0x7310
movq %rax, %rsi
leaq -0x1b34(%rip), %rdi     # 0x16e0
callq 0x70b0
movq -0x18(%rbp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq -0x1aec(%rip), %rsi     # 0x1740
movq 0x13d8d(%rip), %r8      # 0x16fc0
movb $0x0, %al
callq 0x7310
movq %rax, %rdi
movq 0x13d7c(%rip), %rsi     # 0x16fc0
callq 0x8650
movq -0x10(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
movb $0x0, %al
callq 0x71b0
movq %rax, %rdi
leaq 0xe226(%rip), %rsi      # 0x1148c
callq 0x67b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_tuple
static mpc_parser_t *elm_tuple(mpc_parser_t *expr) {
    return mpc_expect(
            mpc_or(2,
                mpc_tok_parens(mpc_many(elm_ast_tuple, expr), free),
                mpc_tok_parens(mpc_and(2, elm_ast_tuple_cons, expr, mpc_many(elm_ast_tuple, mpc_and(2, mpcf_snd_free, mpc_tok(mpc_char(',')), expr, free)), free), free))
            , "tuple");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x1a57(%rip), %rdi     # 0x1840
callq 0x70b0
movq %rax, %rdi
movq 0x13d1a(%rip), %rsi     # 0x16fc0
callq 0x8590
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x2c, %edi
callq 0x6980
movq %rax, %rdi
callq 0x8350
movq %rax, %rdx
movq -0x8(%rbp), %rcx
movl $0x2, %edi
leaq 0x5114(%rip), %rsi      # 0x83f0
movq 0x13cdd(%rip), %r8      # 0x16fc0
movb $0x0, %al
callq 0x7310
movq %rax, %rsi
leaq -0x1ab4(%rip), %rdi     # 0x1840
callq 0x70b0
movq -0x18(%rbp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq -0x1a6c(%rip), %rsi     # 0x18a0
movq 0x13cad(%rip), %r8      # 0x16fc0
movb $0x0, %al
callq 0x7310
movq %rax, %rdi
movq 0x13c9c(%rip), %rsi     # 0x16fc0
callq 0x8590
movq -0x10(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
movb $0x0, %al
callq 0x71b0
movq %rax, %rdi
leaq 0xe14b(%rip), %rsi      # 0x11491
callq 0x67b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_if
static mpc_parser_t *elm_if(mpc_parser_t *expr) {
    return mpc_and(6, elm_ast_if,
            mpc_sym("if"),
                mpc_tok(expr),
            mpc_sym("then"),
                mpc_tok(expr),
            mpc_sym("else"),
                mpc_tok(expr),
            free, free, free, free, free);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xe124(%rip), %rdi      # 0x11497
callq 0x8390
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8350
movq %rax, -0x28(%rbp)
leaq 0xe18c(%rip), %rdi      # 0x1151c
callq 0x8390
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8350
movq %rax, -0x18(%rbp)
leaq 0xe174(%rip), %rdi      # 0x11521
callq 0x8390
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8350
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x18(%rbp), %r9
movq -0x10(%rbp), %r11
movq %rax, %r10
movl $0x6, %edi
leaq -0x1a82(%rip), %rsi     # 0x1960
movq 0x13bd7(%rip), %rax     # 0x16fc0
movq %r11, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movb $0x0, %al
callq 0x7310
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_case
static mpc_parser_t *elm_case(mpc_parser_t *expr, mpc_parser_t *pattern) {
    return mpc_and(4, elm_ast_case,
            mpc_sym("case"),
                mpc_tok(expr),
            mpc_sym("of"),
                mpc_many1(elm_ast_branches, mpc_tok(elm_case_branch(pattern, expr))),
            free, free, free);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe063(%rip), %rdi      # 0x1149a
callq 0x8390
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8350
movq %rax, -0x20(%rbp)
leaq 0xe0d2(%rip), %rdi      # 0x11526
callq 0x8390
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x39c0
movq %rax, %rdi
callq 0x8350
movq %rax, %rsi
leaq -0x196c(%rip), %rdi     # 0x1b10
callq 0x7100
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %r8
movq %rax, %r9
movl $0x4, %edi
leaq -0x1a8c(%rip), %rsi     # 0x1a10
movq 0x13b1d(%rip), %rax     # 0x16fc0
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x7310
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_module
static mpc_parser_t *elm_module(mpc_parser_t *comment, mpc_parser_t *decl) {
    return mpc_whole(
            mpc_many1(elm_ast_module,
                mpc_or(2,
                    mpc_tok(comment),
                    mpc_tok(decl)
                )
            ), free);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8350
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8350
movq -0x18(%rbp), %rsi
movq %rax, %rdx
movl $0x2, %edi
movb $0x0, %al
callq 0x71b0
movq %rax, %rsi
leaq -0x16e3(%rip), %rdi     # 0x1ee0
callq 0x7100
movq %rax, %rdi
movq 0x139ee(%rip), %rsi     # 0x16fc0
callq 0x8210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_singleline_comment
static mpc_parser_t *elm_singleline_comment(void) {
    return mpc_expect(
            mpc_and(2, mpcf_snd_free,
                    mpc_string("--"),
                    mpc_stripl(mpc_many(mpcf_strfold,
                        mpc_check(mpc_any(), free, is_newline, "end-of-line"))),
                    free),
            "comment");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xde85(%rip), %rdi      # 0x114c4
callq 0x6b60
movq %rax, -0x8(%rbp)
callq 0x6950
movq %rax, %rdi
movq 0x13969(%rip), %rsi     # 0x16fc0
leaq 0x62(%rip), %rdx        # 0x36c0
leaq 0xde62(%rip), %rcx      # 0x114c7
callq 0x6c80
movq %rax, %rsi
leaq 0x40ec(%rip), %rdi      # 0x7760
callq 0x70b0
movq %rax, %rdi
callq 0x8270
movq -0x8(%rbp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x4d5c(%rip), %rsi      # 0x83f0
movq 0x13925(%rip), %r8      # 0x16fc0
movb $0x0, %al
callq 0x7310
movq %rax, %rdi
leaq 0xde10(%rip), %rsi      # 0x114bc
callq 0x67b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: is_newline
static int is_newline(mpc_val_t **xs) {
    char **vs = (char**)xs;
    if (vs[0][0] == '\n') {
        return 0;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x36e8
movl $0x0, -0x4(%rbp)
jmp 0x36ef
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: elm_real
static mpc_parser_t *elm_real(void) {
    /* [+-]?\d+\.\d+([eE][+-]?[0-9]+)? */

    mpc_parser_t *p0, *p1, *p2, *p30, *p31, *p32, *p3;

    p0 = mpc_maybe_lift(mpc_oneof("+-"), mpcf_ctor_str);
    p1 = mpc_digits();
    p2 = mpc_and(2, mpcf_strfold, mpc_char('.'), mpc_digits(), free);
    p30 = mpc_oneof("eE");
    p31 = mpc_maybe_lift(mpc_oneof("+-"), mpcf_ctor_str);
    p32 = mpc_digits();
    p3 = mpc_maybe_lift(mpc_and(3, mpcf_strfold, p30, p31, p32, free, free), mpcf_ctor_str);

    return mpc_expect(mpc_and(4, mpcf_strfold, p0, p1, p2, p3, free, free, free), "real");

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0xdd73(%rip), %rdi      # 0x114e2
callq 0x6a30
movq %rax, %rdi
leaq 0x46d2(%rip), %rsi      # 0x7e50
callq 0x7030
movq %rax, -0x8(%rbp)
callq 0x79b0
movq %rax, -0x10(%rbp)
movl $0x2e, %edi
callq 0x6980
movq %rax, -0x40(%rbp)
callq 0x79b0
movq -0x40(%rbp), %rdx
movq %rax, %rcx
movl $0x2, %edi
leaq 0x3faa(%rip), %rsi      # 0x7760
movq 0x13803(%rip), %r8      # 0x16fc0
movb $0x0, %al
callq 0x7310
movq %rax, -0x18(%rbp)
leaq 0xdd16(%rip), %rdi      # 0x114e5
callq 0x6a30
movq %rax, -0x20(%rbp)
leaq 0xdd03(%rip), %rdi      # 0x114e2
callq 0x6a30
movq %rax, %rdi
leaq 0x4662(%rip), %rsi      # 0x7e50
callq 0x7030
movq %rax, -0x28(%rbp)
callq 0x79b0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x3, %edi
leaq 0x3f48(%rip), %rsi      # 0x7760
movq 0x137a1(%rip), %rax     # 0x16fc0
movq %rax, %r9
movq %rax, (%rsp)
movb $0x0, %al
callq 0x7310
movq %rax, %rdi
leaq 0x4619(%rip), %rsi      # 0x7e50
callq 0x7030
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x38(%rbp), %r9
movl $0x4, %edi
leaq 0x3f04(%rip), %rsi      # 0x7760
movq 0x1375d(%rip), %rax     # 0x16fc0
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq 0x7310
movq %rax, %rdi
leaq 0xdc66(%rip), %rsi      # 0x114e8
callq 0x67b0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/niho[P]elmc/src/eparse.c
// Function: is_unreserved
static int is_unreserved(mpc_val_t **xs) {
    if (strcmp(xs[0], "if") == 0)
        return 0;
    if (strcmp(xs[0], "then") == 0)
        return 0;
    if (strcmp(xs[0], "else") == 0)
        return 0;
    if (strcmp(xs[0], "case") == 0)
        return 0;
    if (strcmp(xs[0], "of") == 0)
        return 0;
    if (strcmp(xs[0], "->") == 0)
        return 0;
    if (strcmp(xs[0], "_") == 0)
        return 0;
    if (strcmp(xs[0], "=") == 0)
        return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xdbed(%rip), %rsi      # 0x11497
callq 0x10e0
cmpl $0x0, %eax
jne 0x38c0
movl $0x0, -0x4(%rbp)
jmp 0x39b7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xdc4e(%rip), %rsi      # 0x1151c
callq 0x10e0
cmpl $0x0, %eax
jne 0x38e4
movl $0x0, -0x4(%rbp)
jmp 0x39b7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xdc2f(%rip), %rsi      # 0x11521
callq 0x10e0
cmpl $0x0, %eax
jne 0x3908
movl $0x0, -0x4(%rbp)
jmp 0x39b7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xdb84(%rip), %rsi      # 0x1149a
callq 0x10e0
cmpl $0x0, %eax
jne 0x392c
movl $0x0, -0x4(%rbp)
jmp 0x39b7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xdbec(%rip), %rsi      # 0x11526
callq 0x10e0
cmpl $0x0, %eax
jne 0x394d
movl $0x0, -0x4(%rbp)
jmp 0x39b7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xdbce(%rip), %rsi      # 0x11529
callq 0x10e0
cmpl $0x0, %eax
jne 0x396e
movl $0x0, -0x4(%rbp)
jmp 0x39b7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xe466(%rip), %rsi      # 0x11de2
callq 0x10e0
cmpl $0x0, %eax
jne 0x398f
movl $0x0, -0x4(%rbp)
jmp 0x39b7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0xdb8f(%rip), %rsi      # 0x1152c
callq 0x10e0
cmpl $0x0, %eax
jne 0x39b0
movl $0x0, -0x4(%rbp)
jmp 0x39b7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/TeaInside[P]teavpn/src/teavpn/main.c
// Function: main
int main(int argc, char **_argv, char **envp)
{
	uint8_t exit_code;
	teavpn_config config;

	argv = _argv;

	if (!argv_parser(&config, argc, _argv, envp)) {
		exit_code = 1;
		goto ret;
	}

	switch (config.type) {
		case teavpn_server_config:
			exit_code = teavpn_tcp_server(&(config.config.server));
			break;
		case teavpn_client_config:
			exit_code = teavpn_tcp_client(&(config.config.client));
			break;
		default:
			printf("Invalid config type\n");
			exit_code = 1;
			break;
	}

	ret:
	return exit_code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movl $0x0, -0x54(%rbp)
movl %edi, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdx, -0x68(%rbp)
movq -0x60(%rbp), %rax
movq %rax, 0xbcf3(%rip)      # 0xe258
movl -0x58(%rbp), %esi
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0x3830
testb $0x1, %al
jne 0x2583
movb $0x1, -0x69(%rbp)
jmp 0x25c9
movl -0x10(%rbp), %eax
movl %eax, -0x70(%rbp)
testl %eax, %eax
je 0x2599
jmp 0x258f
movl -0x70(%rbp), %eax
subl $0x1, %eax
je 0x25a7
jmp 0x25b5
leaq -0x50(%rbp), %rdi
callq 0x55b0
movb %al, -0x69(%rbp)
jmp 0x25c7
leaq -0x50(%rbp), %rdi
callq 0x4120
movb %al, -0x69(%rbp)
jmp 0x25c7
leaq 0x7a48(%rip), %rdi      # 0xa004
movb $0x0, %al
callq 0x2150
movb $0x1, -0x69(%rbp)
jmp 0x25c9
movzbl -0x69(%rbp), %eax
movl %eax, -0x74(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x25ee
movl -0x74(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
callq 0x2100
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TeaInside[P]teavpn/src/teavpn/helpers.c
// Function: escapeshellarg
char *escapeshellarg(char *str)
{
	size_t x, y = 0;
	size_t l = strlen(str);
	char *cmd;

	cmd = (char *)malloc(sizeof(char) * l * 4); // Worst case

#ifdef PHP_WIN32
	cmd[y++] = '"';
#else
	cmd[y++] = '\'';
#endif

	for (x = 0; x < l; x++) {
		switch (str[x]) {
#ifdef PHP_WIN32
		case '"':
		case '%':
		case '!':
			cmd[y++] = ' ';
			break;
#else
		case '\'':
			cmd[y++] = '\'';
			cmd[y++] = '\\';
			cmd[y++] = '\'';
#endif
		/* fall-through */
		default:
			cmd[y++] = str[x];
		}
	}
#ifdef PHP_WIN32
	if (y > 0 && '\\' == cmd[y - 1]) {
		int k = 0, n = y - 1;
		for (; n >= 0 && '\\' == cmd[n]; n--, k++);
		if (k % 2) {
			cmd[y++] = '\\';
		}
	}

	cmd[y++] = '"';
#else
	cmd[y++] = '\'';
#endif
	cmd[y] = '\0';

	return cmd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
shlq $0x0, %rdi
shlq $0x2, %rdi
callq 0x22c0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0x27, (%rax,%rcx)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x26ed
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rax,%rcx), %al
subb $0x27, %al
jne 0x26b9
jmp 0x2674
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0x27, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0x5c, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0x27, (%rax,%rcx)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x26dc
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2655
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb $0x27, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TeaInside[P]teavpn/src/teavpn/helpers.c
// Function: ip_read_conv
uint32_t ip_read_conv(const char *read)
{
	uint32_t ret = 0;
	uint8_t bufptr = 0, i = 0;
	char buf[4] = "\0\0\0";

	while (((*read) != '\0') && ((*read) != '/')) {
		buf[bufptr] = *read;
		read++;
		bufptr++;
		if ((bufptr == 3) || ((*read) == '.')) {
			bufptr = 0;
			ret |= atoi(buf) << i;
			i += 8;
			read++; // skip dot
		}
	}

	if (i < 32) {
		ret |= atoi(buf) << i;
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movb $0x0, -0x1e(%rbp)
leaq -0xc(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x2190
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1f(%rbp)
je 0x2779
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x1f(%rbp)
movb -0x1f(%rbp), %al
testb $0x1, %al
jne 0x2782
jmp 0x27ed
movq -0x18(%rbp), %rax
movb (%rax), %cl
movzbl -0x1d(%rbp), %eax
movb %cl, -0xc(%rbp,%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movb -0x1d(%rbp), %al
addb $0x1, %al
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %eax
cmpl $0x3, %eax
je 0x27b9
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x27e8
movb $0x0, -0x1d(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x2390
movzbl -0x1e(%rbp), %ecx
shll %cl, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movzbl -0x1e(%rbp), %eax
addl $0x8, %eax
movb %al, -0x1e(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2758
movzbl -0x1e(%rbp), %eax
cmpl $0x20, %eax
jge 0x280b
leaq -0xc(%rbp), %rdi
callq 0x2390
movzbl -0x1e(%rbp), %ecx
shll %cl, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0x282c
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
callq 0x2100
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TeaInside[P]teavpn/src/teavpn/cli_arg.c
// Function: argv_parser
bool argv_parser(teavpn_config *config, int argc, char **argv, char **envp)
{
	if (argc == 1) {
		show_help_command(argv[0]);
		return false;
	}

	if (!strcmp(argv[1], "server")) {
		config->type = teavpn_server_config;
		return server_argv_parser(argv[0], &(config->config.server), argc - 1, &(argv[1]), envp);
	} else if (!strcmp(argv[1], "connect")) {
		config->type = teavpn_client_config;
		return client_argv_parser(argv[0], &(config->config.client), argc - 1, &(argv[1]), envp);
	} else if (
		(!strcmp(argv[1], "--help")) || (!strcmp(argv[1], "-h")) || (!strcmp(argv[1], "help"))
	) {
		show_help_command(argv[0]);
	} else {
		printf("Invalid command \"%s\"!\n\nShow usage: %s --help\n", argv[1], argv[0]);
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x3862
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3990
movb $0x0, -0x1(%rbp)
jmp 0x397d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x687f(%rip), %rsi      # 0xa0f0
callq 0x2220
cmpl $0x0, %eax
jne 0x38b2
movq -0x10(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x28(%rbp), %r8
callq 0x3a00
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x397d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x6b53(%rip), %rsi      # 0xa414
callq 0x2220
cmpl $0x0, %eax
jne 0x38ff
movq -0x10(%rbp), %rax
movl $0x1, 0x40(%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
movq -0x28(%rbp), %r8
callq 0x3d30
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x397d
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x67e9(%rip), %rsi      # 0xa0f7
callq 0x2220
cmpl $0x0, %eax
je 0x394a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x67d7(%rip), %rsi      # 0xa0fe
callq 0x2220
cmpl $0x0, %eax
je 0x394a
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x67b9(%rip), %rsi      # 0xa0f9
callq 0x2220
cmpl $0x0, %eax
jne 0x3958
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x3990
jmp 0x3975
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
movq (%rax), %rdx
leaq 0x6793(%rip), %rdi      # 0xa101
movb $0x0, %al
callq 0x2150
jmp 0x3977
jmp 0x3979
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TeaInside[P]teavpn/src/teavpn/cli_arg.c
// Function: show_help_command
static void show_help_command(char *appname)
{
	printf("Usage: %s [command] [options]\n\n", appname);
	printf("Available commands:\n");
	printf("\tserver\t\tMake TeaVPN server.\n");
	printf("\tconnect\t\tConnect to TeaVPN server.\n");
	printf("\nDetailed information: %s [command] --help\n", appname);
	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x6986(%rip), %rdi      # 0xa32d
movb $0x0, %al
callq 0x2150
leaq 0x6998(%rip), %rdi      # 0xa34d
movb $0x0, %al
callq 0x2150
leaq 0x699f(%rip), %rdi      # 0xa362
movb $0x0, %al
callq 0x2150
leaq 0x69af(%rip), %rdi      # 0xa380
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rsi
leaq 0x69c2(%rip), %rdi      # 0xa3a5
movb $0x0, %al
callq 0x2150
movq 0xa5df(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
callq 0x22d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TeaInside[P]teavpn/src/teavpn/cli_arg.c
// Function: show_help_server
static void show_help_server(char *appname)
{
	printf("Usage: %s server [options]\n\n", appname);
	printf("Available options:\n");
	printf("\t--address, -h\t\tSet bind address (default 0.0.0.0).\n");
	printf("\t--port, -p\t\tSet bind port (default 55555).\n");
	printf("\t--threads, -t\t\tSet threads amount (default 8).\n");
	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x61b0(%rip), %rdi      # 0xa217
movb $0x0, %al
callq 0x2150
leaq 0x61bf(%rip), %rdi      # 0xa234
movb $0x0, %al
callq 0x2150
leaq 0x61c5(%rip), %rdi      # 0xa248
movb $0x0, %al
callq 0x2150
leaq 0x61ec(%rip), %rdi      # 0xa27d
movb $0x0, %al
callq 0x2150
leaq 0x620b(%rip), %rdi      # 0xa2aa
movb $0x0, %al
callq 0x2150
movq 0x9f23(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
callq 0x22d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/TeaInside[P]teavpn/src/teavpn/cli_arg.c
// Function: show_help_client
static void show_help_client(char *appname)
{
	printf("Usage: %s connect [options]\n\n", appname);
	printf("Available options:\n");
	printf("\t--address, -h\t\tSet bind address.\n");
	printf("\t--port, -p\t\tSet bind port (default 55555).\n");
	fflush(stdout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x6215(%rip), %rdi      # 0xa2ec
movb $0x0, %al
callq 0x2150
leaq 0x614f(%rip), %rdi      # 0xa234
movb $0x0, %al
callq 0x2150
leaq 0x6217(%rip), %rdi      # 0xa30a
movb $0x0, %al
callq 0x2150
leaq 0x617c(%rip), %rdi      # 0xa27d
movb $0x0, %al
callq 0x2150
movq 0x9ec1(%rip), %rax      # 0xdfd0
movq (%rax), %rdi
callq 0x22d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/TeaInside[P]teavpn/src/teavpn/client/tcp.c
// Function: print_err_sig
static void print_err_sig(uint8_t sig)
{
	switch (sig) {
		case TEAVPN_SIG_AUTH_REJECT:
			debug_log(0, "Invalid username or password");
			break;
		case TEAVPN_SIG_UNKNOWN:
			debug_log(0, "Invalid error (code: TEAVPN_SIG_AUTH_UNKNOWN)");
			break;
		case TEAVPN_SIG_DROP:
			debug_log(0, "Connection dropped!");
			break;
		case TEAVPN_SIG_AUTH_OK:
			debug_log(0, "Success");
			break;
		default:
			debug_log(0, "Unknown signal");
			break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x7, %eax
ja 0x50fa
movq -0x10(%rbp), %rax
leaq 0x5366(%rip), %rcx      # 0xa3d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x93a6(%rip), %rax      # 0xe424
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x5095
leaq 0x5810(%rip), %rdi      # 0xa89e
movb $0x0, %al
callq 0x84c0
jmp 0x511a
leaq 0x9383(%rip), %rax      # 0xe424
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x50b8
leaq 0x580a(%rip), %rdi      # 0xa8bb
movb $0x0, %al
callq 0x84c0
jmp 0x511a
leaq 0x9363(%rip), %rax      # 0xe424
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x50d8
leaq 0x5818(%rip), %rdi      # 0xa8e9
movb $0x0, %al
callq 0x84c0
jmp 0x511a
leaq 0x9343(%rip), %rax      # 0xe424
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x50f8
leaq 0x580c(%rip), %rdi      # 0xa8fd
movb $0x0, %al
callq 0x84c0
jmp 0x511a
leaq 0x9323(%rip), %rax      # 0xe424
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x5118
leaq 0x57f4(%rip), %rdi      # 0xa905
movb $0x0, %al
callq 0x84c0
jmp 0x511a
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/TeaInside[P]teavpn/src/teavpn/server/tcp.c
// Function: enqueue_packet
static void enqueue_packet(uint16_t conn, uint16_t bufchan_index)
{
	while (true) {
		for (register int16_t i = 0; i < QUEUE_AMOUNT; ++i) {
			if (!queues[i].used) {
				queues[i].used = true;
				queues[i].taken = false;
				queues[i].conn_index = conn;
				queues[i].bufchan_index = bufchan_index;
				return;
			}
		}
		debug_log(0, "Packet queue is full");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movw $0x0, -0x6(%rbp)
movswl -0x6(%rbp), %eax
cmpl $0x30, %eax
jge 0x7ccd
movq 0x6728(%rip), %rax      # 0xe368
movswq -0x6(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
testb $0x1, (%rax)
jne 0x7cba
movq 0x6710(%rip), %rax      # 0xe368
movswq -0x6(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x1, (%rax)
movq 0x66fa(%rip), %rax      # 0xe368
movswq -0x6(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movb $0x0, 0x1(%rax)
movw -0x2(%rbp), %cx
movq 0x66df(%rip), %rax      # 0xe368
movswq -0x6(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x10(%rax)
movw -0x4(%rbp), %cx
movq 0x66c4(%rip), %rax      # 0xe368
movswq -0x6(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movw %cx, 0x12(%rax)
addq $0x10, %rsp
popq %rbp
retq
jmp 0x7cbc
movw -0x6(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x6(%rbp)
jmp 0x7c2c
leaq 0x6750(%rip), %rax      # 0xe424
movzbl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x7ceb
leaq 0x2f18(%rip), %rdi      # 0xabfc
movb $0x0, %al
callq 0x84c0
jmp 0x7c26