LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_specifier_qualifier_node
static SpecifierQualifierNode* create_specifier_qualifier_node(const Vector* vec, int* index) {
    SpecifierQualifierNode* specifier_qualifier_node = calloc(1, sizeof(SpecifierQualifierNode));

    const Token* token = vec->elements[*index];
    if (is_type_specifier(vec, *index)) {
        specifier_qualifier_node->type_specifier_node = create_type_specifier_node(vec, index);
        if (specifier_qualifier_node->type_specifier_node == NULL) {
            error("Failed to create type-specifier node.\n");
            return NULL;
        }
    } 
    else if (token->type == TK_CONST) {
        ++(*index);
        specifier_qualifier_node->is_const = true;
    }
    else {
        error("Invalid token[%d]=\"%s\".\n", *index, decode_token_type(token->type));
        return NULL;
    }

    return specifier_qualifier_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %rbx
movq (%r15), %rdi
movslq (%r14), %rsi
movq (%rdi,%rsi,8), %r12
callq 0x59c5
testb %al, %al
je 0x5d73
movq %r15, %rdi
movq %r14, %rsi
callq 0x59f0
movq %rax, (%rbx)
testq %rax, %rax
jne 0x5da4
leaq 0x41c6(%rip), %rdi      # 0x9f2e
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x86ac
jmp 0x5da4
movl (%r12), %edi
movl (%r14), %ebp
cmpl $0xc, %edi
jne 0x5d8a
incl %ebp
movl %ebp, (%r14)
movb $0x1, 0x8(%rbx)
jmp 0x5da4
callq 0x8681
leaq 0x405a(%rip), %rdi      # 0x9df0
xorl %ebx, %ebx
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x86ac
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_pointer_node
static PointerNode* create_pointer_node(const Vector* vec, int* index) {
    PointerNode* pointer_node = malloc(sizeof(PointerNode));

    pointer_node->count = 1;
    const Token* token = vec->elements[*index];
    if (token->type != TK_ASTER) {
        error("Invalid token[%d]=\"%s\".\n", *index, decode_token_type(token->type));
        return NULL;
    }
    ++(*index);

    token = vec->elements[*index];
    while (token->type == TK_ASTER) {
        ++(pointer_node->count);
        ++(*index);
        token = vec->elements[*index];
    } 
    
    return pointer_node;  
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
movl $0x4, %edi
callq 0x1100
movq %rax, %rbx
movl $0x1, (%rax)
movslq (%r15), %r14
movq (%r12,%r14,8), %rax
movl (%rax), %edi
cmpl $0x1a, %edi
jne 0x5e13
leaq 0x1(%r14), %rax
movl %eax, (%r15)
movq 0x8(%r12,%r14,8), %rcx
cmpl $0x1a, (%rcx)
jne 0x5e2e
leaq (%r12,%rax,8), %rax
addl $0x2, %r14d
movl $0x1, %ecx
movl %r14d, (%r15)
movq (%rax,%rcx,8), %rdx
incq %rcx
incl %r14d
cmpl $0x1a, (%rdx)
je 0x5dfd
movl %ecx, (%rbx)
jmp 0x5e2e
callq 0x8681
leaq 0x3fd1(%rip), %rdi      # 0x9df0
xorl %ebx, %ebx
movl %r14d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x86ac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_conditional_expr_node
static ConditionalExprNode* create_conditional_expr_node(const Vector* vec, int* index) {
    ConditionalExprNode* conditional_expr_node = calloc(1, sizeof(ConditionalExprNode));

    conditional_expr_node->logical_or_expr_node  = create_logical_or_expr_node(vec, index);
    if (conditional_expr_node->logical_or_expr_node == NULL) {
        error("Failed to create logical-or-expression node.\n");
        return NULL;
    }

    const Token* token = vec->elements[*index];
    if (token->type == TK_QUESTION) {
        ++(*index);

        conditional_expr_node->expr_node = create_expr_node(vec, index);
        if (conditional_expr_node->expr_node == NULL) {
            error("Failed to create expression node.\n");
            return NULL;
        }

        token = vec->elements[*index];
        if (token->type != TK_COLON) {
            error("Invalid token[%d]=\"%s\".\n", *index, decode_token_type(token->type));
            return NULL;
        }
        ++(*index);

        conditional_expr_node->conditional_expr_node = create_conditional_expr_node(vec, index);
        if (conditional_expr_node->conditional_expr_node == NULL) {
            error("Failed to create conditional-expression node.\n");
            return NULL;
        }
    }

    return conditional_expr_node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %rbx
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x603d
movq %rax, (%r12)
testq %rax, %rax
je 0x5eda
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rcx
movl (%rcx), %ecx
cmpl $0x37, %ecx
jne 0x5efd
incl %eax
movl %eax, (%r14)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %r13
movq %r12, 0x8(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x603d
movq %rax, (%r13)
testq %rax, %rax
je 0x5eda
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rcx
movl (%rcx), %ecx
movq %r13, %r12
cmpl $0x37, %ecx
je 0x5e95
jmp 0x5f00
leaq 0x421f(%rip), %rdi      # 0xa100
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x86ac
leaq 0x418f(%rip), %rdi      # 0xa080
xorl %eax, %eax
callq 0x86ac
jmp 0x5f7d
movq %r12, %r13
movq %r13, (%rbx)
cmpl $0x2a, %ecx
jne 0x5f7d
incl %eax
movl %eax, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5f8a
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x5f57
movq (%r15), %rax
movslq (%r14), %r12
movq (%rax,%r12,8), %rax
movl (%rax), %edi
cmpl $0x20, %edi
jne 0x5f62
leal 0x1(%r12), %eax
movl %eax, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e3d
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x5f7d
leaq 0x417c(%rip), %rdi      # 0xa0d1
jmp 0x5f5e
leaq 0x4150(%rip), %rdi      # 0xa0ae
xorl %ebx, %ebx
jmp 0x5ef1
callq 0x8681
leaq 0x3e82(%rip), %rdi      # 0x9df0
xorl %ebx, %ebx
movl %r12d, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x86ac
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_expr_node
static ExprNode* create_expr_node(const Vector* vec, int* index) {
    ExprNode* expr_node = calloc(1, sizeof(ExprNode));

    expr_node->assign_expr_node = create_assign_expr_node(vec, index);
    if (expr_node->assign_expr_node == NULL) {
        error("Failed to create assignment-expression node.\n");
        return NULL;
    }

    ExprNode* current = expr_node;
    const Token* token = vec->elements[*index];
    while (token->type == TK_COMMA) {
        ++(*index);

        ExprNode* p_expr_node = calloc(1, sizeof(ExprNode));

        p_expr_node->expr_node        = current;
        p_expr_node->assign_expr_node = create_assign_expr_node(vec, index);
        if (p_expr_node->assign_expr_node == NULL) {
            error("Failed to create assing-expression node.\n");
            return NULL;
        }

        token = vec->elements[*index];
        current = p_expr_node;
    }

    return current;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6bd5
movq %rax, (%r12)
testq %rax, %rax
je 0x6017
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %rcx
cmpl $0x30, (%rcx)
jne 0x602d
leaq 0x4454(%rip), %r15      # 0xa429
incl %eax
movl %eax, (%rbx)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %r13
movq %r12, 0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6bd5
movq %rax, (%r13)
testq %rax, %rax
je 0x601e
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %rcx
cmpl $0x30, (%rcx)
movq %r13, %r12
je 0x5fd5
jmp 0x6030
leaq 0x4390(%rip), %r15      # 0xa3ae
xorl %r13d, %r13d
movq %r15, %rdi
xorl %eax, %eax
callq 0x86ac
jmp 0x6030
movq %r12, %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_logical_and_expr_node
static LogicalAndExprNode* create_logical_and_expr_node(const Vector* vec, int* index) {
    LogicalAndExprNode* logical_and_expr_node = calloc(1, sizeof(LogicalAndExprNode));

    logical_and_expr_node->inclusive_or_expr_node = create_inclusive_or_expr_node(vec, index);
    if (logical_and_expr_node->inclusive_or_expr_node == NULL) {
        error("Failed to create inclusive-or-expression node.\n");
        return NULL;
    }

    const Token* token = vec->elements[*index];
    LogicalAndExprNode* current = logical_and_expr_node;
    while (token->type == TK_LOGAND) {
        ++(*index);

        LogicalAndExprNode* p_logical_and_expr_node = calloc(1, sizeof(LogicalAndExprNode));

        p_logical_and_expr_node->logical_and_expr_node  = current;
        p_logical_and_expr_node->inclusive_or_expr_node = create_inclusive_or_expr_node(vec, index);
        if (p_logical_and_expr_node->inclusive_or_expr_node == NULL) {
            error("Failed to create inclusive-or-expression node.\n");
            return NULL;
        }

        token = vec->elements[*index];
        current = p_logical_and_expr_node;
    }

    return current;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x60e6
movq %rax, (%r15)
testq %rax, %rax
je 0x60c1
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %rcx
cmpl $0x38, (%rcx)
jne 0x60d4
incl %eax
movl %eax, (%rbx)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %r12
movq %r15, 0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x60e6
movq %rax, (%r12)
testq %rax, %rax
je 0x60c1
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %rcx
cmpl $0x38, (%rcx)
movq %r12, %r15
je 0x607f
jmp 0x60d7
leaq 0x4067(%rip), %rdi      # 0xa12f
xorl %r12d, %r12d
xorl %eax, %eax
callq 0x86ac
jmp 0x60d7
movq %r15, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_inclusive_or_expr_node
static InclusiveOrExprNode* create_inclusive_or_expr_node(const Vector* vec, int* index) {
    InclusiveOrExprNode* inclusive_or_expr_node = malloc(sizeof(InclusiveOrExprNode));

    inclusive_or_expr_node->inclusive_or_expr_node = NULL;
    inclusive_or_expr_node->exclusive_or_expr_node = create_exclusive_or_expr_node(vec, index);
    if (inclusive_or_expr_node->exclusive_or_expr_node  == NULL) {
        error("Failed to create exclusive-or-expression node.\n");
        return NULL;
    }

    return inclusive_or_expr_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %edi
callq 0x1100
movq %rax, (%rsp)
movq $0x0, 0x8(%rax)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, 0x10(%rsp)
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, 0x8(%rsp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x625a
movq %rax, 0x8(%r12)
testq %rax, %rax
je 0x61ea
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %r13
movl (%r13), %ecx
addl $-0x33, %ecx
cmpl $0x1, %ecx
ja 0x6231
movq %r12, %rbp
movq %rbp, %rbx
incl %eax
movl %eax, (%r14)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %rbp
movq %rbx, 0x10(%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x625a
movq %rax, 0x8(%rbp)
cmpq $0x0, 0x8(%r12)
je 0x61ea
movl (%r13), %eax
cmpl $0x33, %eax
je 0x61ca
cmpl $0x34, %eax
jne 0x61d2
movl $0x4, %eax
jmp 0x61cf
movl $0x3, %eax
movl %eax, (%rbp)
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %r13
movl (%r13), %ecx
addl $-0x33, %ecx
cmpl $0x2, %ecx
jb 0x6180
jmp 0x6234
leaq 0x3ff1(%rip), %rdi      # 0xa1e2
xorl %eax, %eax
callq 0x86ac
leaq 0x3fb7(%rip), %rdi      # 0xa1b6
xorl %eax, %eax
callq 0x86ac
leaq 0x3f82(%rip), %rdi      # 0xa18f
xorl %eax, %eax
callq 0x86ac
movq (%rsp), %rax
movq $0x0, (%rax)
leaq 0x3f39(%rip), %rdi      # 0xa15f
xorl %eax, %eax
callq 0x86ac
xorl %eax, %eax
jmp 0x624b
movq %r12, %rbp
movq 0x8(%rsp), %rax
movq %rbp, (%rax)
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq (%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_relational_expr_node
static RelationalExprNode* create_relational_expr_node(const Vector* vec, int* index) {
    RelationalExprNode* relational_expr_node = calloc(1, sizeof(RelationalExprNode));

    relational_expr_node->cmp_type             = CMP_NONE;
    relational_expr_node->shift_expr_node      = create_shift_expr(vec, index);
    if (relational_expr_node->shift_expr_node == NULL) {
        error("Failed to create shift-expression node.\n");
        return NULL;
    }
    
    RelationalExprNode* current = relational_expr_node;
    const Token* token = vec->elements[*index];
    while (token->type == TK_LANGLE || token->type == TK_RANGLE || token->type == TK_LE || token->type == TK_GE) {
        ++(*index);
    
        RelationalExprNode* parent = calloc(1, sizeof(EqualityExprNode));

        parent->relational_expr_node = current;
        parent->shift_expr_node      = create_shift_expr(vec, index);
        if (parent->shift_expr_node == NULL) {
            error("Failed to create shif-texpression node.\n");
            return NULL;
        }

        if      (token->type == TK_LANGLE) { parent->cmp_type = CMP_LT; }
        else if (token->type == TK_RANGLE) { parent->cmp_type = CMP_GT; }
        else if (token->type == TK_LE)     { parent->cmp_type = CMP_LE; }
        else if (token->type == TK_GE)     { parent->cmp_type = CMP_GE; }
     
        token = vec->elements[*index];
        current = parent;
    }

    return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x635d
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x633a
movabsq $0x60018000000000, %rbp # imm = 0x60018000000000
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %r12
movl (%r12), %ecx
cmpq $0x36, %rcx
ja 0x634b
btq %rcx, %rbp
jae 0x634b
incl %eax
movl %eax, (%rbx)
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %r13
movq %r15, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x635d
movq %rax, 0x8(%r13)
testq %rax, %rax
je 0x6331
movq %r13, %r15
movl (%r12), %eax
cmpl $0x34, %eax
jg 0x630c
cmpl $0x27, %eax
je 0x631d
cmpl $0x28, %eax
jne 0x629f
movl $0x2, %eax
jmp 0x6329
cmpl $0x35, %eax
je 0x6324
cmpl $0x36, %eax
jne 0x629f
movl $0x6, %eax
jmp 0x6329
movl $0x1, %eax
jmp 0x6329
movl $0x5, %eax
movl %eax, (%r15)
jmp 0x629f
leaq 0x3f01(%rip), %rdi      # 0xa239
jmp 0x6341
leaq 0x3ecf(%rip), %rdi      # 0xa210
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x86ac
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_shift_expr
static ShiftExprNode* create_shift_expr(const Vector* vec, int* index) {
    ShiftExprNode* shift_expr_node = calloc(1, sizeof(ShiftExprNode));

    shift_expr_node->additive_expr_node = create_additive_expr_node(vec, index);
    if (shift_expr_node->additive_expr_node == NULL) {
        error("Failed to additive-expression node.\n");
        return NULL;
    }

    return shift_expr_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x6448
movq %rax, 0x8(%r12)
testq %rax, %rax
je 0x6410
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rbp
movl (%rbp), %ecx
andl $-0x2, %ecx
cmpl $0x18, %ecx
jne 0x6430
incl %eax
movl %eax, (%r14)
movl $0x18, %edi
callq 0x1100
movq %rax, %r13
xorl %eax, %eax
cmpl $0x18, (%rbp)
setne %al
addl $0xb, %eax
movl %eax, (%r13)
movq %r12, 0x10(%r13)
movq %r15, %rdi
movq %r14, %rsi
callq 0x6448
movq %rax, 0x8(%r13)
testq %rax, %rax
je 0x6410
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rbp
movl (%rbp), %ecx
andl $-0x2, %ecx
movq %r13, %r12
cmpl $0x18, %ecx
je 0x63bc
jmp 0x6433
leaq 0x3e70(%rip), %rdi      # 0xa287
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x86ac
leaq 0x3e3b(%rip), %rdi      # 0xa262
xorl %eax, %eax
callq 0x86ac
jmp 0x6436
movq %r12, %r13
movq %r13, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_multiplicative_expr_node
static MultiPlicativeExprNode* create_multiplicative_expr_node(const Vector* vec, int* index) {
    MultiPlicativeExprNode* multiplicative_expr_node = calloc(1, sizeof(MultiPlicativeExprNode));

    multiplicative_expr_node->operator_type  = OP_NONE;
    multiplicative_expr_node->cast_expr_node = create_cast_expr_node(vec, index);
    if (multiplicative_expr_node->cast_expr_node == NULL) {
        error("Failed to create cast-expression node.\n");
        return NULL;
    }

    MultiPlicativeExprNode* current = multiplicative_expr_node;
    const Token* token = vec->elements[*index];
    while (token->type == TK_ASTER || token->type == TK_SLASH || token->type == TK_PER) {
        ++(*index);

        MultiPlicativeExprNode* p_multiplicative_expr_node = malloc(sizeof(MultiPlicativeExprNode));
        p_multiplicative_expr_node->multiplicative_expr_node = current;
        p_multiplicative_expr_node->cast_expr_node           = create_cast_expr_node(vec, index);
        if (p_multiplicative_expr_node->cast_expr_node == NULL) {
            error("Failed to create cast-expression node.\n");
            return NULL;
        }

        if      (token->type == TK_ASTER) { p_multiplicative_expr_node->operator_type = OP_MUL; }
        else if (token->type == TK_SLASH) { p_multiplicative_expr_node->operator_type = OP_DIV; }
        else if (token->type == TK_PER)   { p_multiplicative_expr_node->operator_type = OP_MOD; }

        token = vec->elements[*index];
        current = p_multiplicative_expr_node;
    }

    return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6517
movq %rax, 0x8(%r15)
testq %rax, %rax
je 0x64f4
movl $0x2c000000, %ebp       # imm = 0x2C000000
movq (%r14), %rcx
movslq (%rbx), %rax
movq (%rcx,%rax,8), %r13
movl (%r13), %ecx
cmpl $0x1d, %ecx
ja 0x6505
btl %ecx, %ebp
jae 0x6505
incl %eax
movl %eax, (%rbx)
movl $0x18, %edi
callq 0x1100
movq %rax, %r12
movq %r15, 0x10(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6517
movq %rax, 0x8(%r12)
testq %rax, %rax
je 0x64f4
movq %r12, %r15
movl (%r13), %eax
cmpl $0x1a, %eax
je 0x64ea
cmpl $0x1d, %eax
je 0x64e3
cmpl $0x1b, %eax
jne 0x6484
movl $0xe, %eax
jmp 0x64ef
movl $0xf, %eax
jmp 0x64ef
movl $0xd, %eax
movl %eax, (%r15)
jmp 0x6484
leaq 0x3dbe(%rip), %rdi      # 0xa2b9
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x86ac
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_cast_expr_node
static CastExprNode* create_cast_expr_node(const Vector* vec, int* index) {
    CastExprNode* cast_expr_node = calloc(1, sizeof(CastExprNode));

    cast_expr_node->unary_expr_node = create_unary_expr_node(vec, index);
    if (cast_expr_node->unary_expr_node == NULL) {
        error("Failed to create unary-expression node.\n");
        return NULL;
    }

    return cast_expr_node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %rbx
movq %r15, %rdi
movq %r14, %rsi
callq 0x6560
movq %rax, (%rbx)
testq %rax, %rax
jne 0x6557
leaq 0x3d93(%rip), %rdi      # 0xa2e1
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x86ac
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_param_declaration_node
static ParamDeclarationNode* create_param_declaration_node(const Vector* vec, int* index) {
    ParamDeclarationNode* param_declaration_node = calloc(1, sizeof(ParamDeclarationNode));

    param_declaration_node->decl_spec_nodes          = create_vector();

    while (is_declaration_specifier(vec, *index)) {
        DeclSpecifierNode* decl_spec_node = create_decl_specifier_node(vec, index);
        if (decl_spec_node == NULL) {
            error("Failed to create declaration-specifier node.\n");
            return NULL;
        }

        vector_push_back(param_declaration_node->decl_spec_nodes, decl_spec_node);
    }

    if (is_declarator(vec, *index)) {
        param_declaration_node->declarator_node = create_declarator_node(vec, index); 
    } 

    return param_declaration_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %rbx
xorl %eax, %eax
callq 0x8738
movq %rax, %r12
movq %rax, (%rbx)
movslq (%r14), %rsi
movq (%r15), %rdi
movq (%rdi,%rsi,8), %rax
movl (%rax), %ebp
callq 0x59c5
testb %al, %al
jne 0x6d26
andl $-0x9, %ebp
cmpl $0x4, %ebp
jne 0x6d43
movq %r15, %rdi
movq %r14, %rsi
callq 0x54a9
testq %rax, %rax
je 0x6d6a
movq %r12, %rdi
movq %rax, %rsi
callq 0x876b
jmp 0x6d09
movslq (%r14), %rax
movq (%r15), %rcx
movq (%rcx,%rax,8), %rax
movl (%rax), %eax
cmpl $0x1a, %eax
je 0x6d59
cmpl $0x3, %eax
jne 0x6d7a
movq %r15, %rdi
movq %r14, %rsi
callq 0x5523
movq %rax, 0x8(%rbx)
jmp 0x6d7a
leaq 0x3142(%rip), %rdi      # 0x9eb3
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x86ac
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/parser.c
// Function: create_initializer_node
static InitializerNode* create_initializer_node(const Vector* vec, int* index) {
    InitializerNode* initializer_node = calloc(1, sizeof(InitializerNode));

    const Token* token = vec->elements[*index];
    if (token->type == TK_LBRCKT) {
        ++(*index); 

        initializer_node->initializer_list_node = create_initializer_list_node(vec, index);
        if (initializer_node->initializer_list_node == NULL) {
            error("Failed to create initializer-list node.\n");
            return NULL;
        }

        token = vec->elements[*index];
        if (token->type != TK_RBRCKT) {
            error("Invalid token[%d]=\"%s\".\n", *index, decode_token_type(token->type));
            return NULL;
        }
        ++(*index); 
    }
    else {
        initializer_node->assign_expr_node = create_assign_expr_node(vec, index);
        if (initializer_node->assign_expr_node == NULL) {
            error("Failed to create assignment-expression node.\n");
            return NULL;
        }
    }

    return initializer_node;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x10c0
movq %rax, %rbx
movq (%r15), %rcx
movslq (%r14), %rax
movq (%rcx,%rax,8), %rcx
cmpl $0x23, (%rcx)
jne 0x760e
incl %eax
movl %eax, (%r14)
movl $0x8, %edi
callq 0x1100
movq %rax, %r12
xorl %eax, %eax
callq 0x8738
movq %rax, %r13
movq %rax, (%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x7553
testq %rax, %rax
jne 0x75e2
leaq 0x3103(%rip), %rdi      # 0xa6c3
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x86ac
leaq 0x3117(%rip), %rdi      # 0xa6e7
jmp 0x762a
incl %ebp
movl %ebp, (%r14)
movq %r15, %rdi
movq %r14, %rsi
callq 0x7553
movq %r13, %rdi
movq %rax, %rsi
callq 0x876b
movq (%r15), %rax
movslq (%r14), %rbp
movq (%rax,%rbp,8), %rax
movl (%rax), %edi
cmpl $0x30, %edi
je 0x75d2
movq %r12, 0x8(%rbx)
cmpl $0x24, %edi
jne 0x7633
incl %ebp
movl %ebp, (%r14)
jmp 0x764d
movq %r15, %rdi
movq %r14, %rsi
callq 0x6bd5
movq %rax, (%rbx)
testq %rax, %rax
jne 0x764d
leaq 0x2d86(%rip), %rdi      # 0xa3ae
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x86ac
jmp 0x764d
callq 0x8681
leaq 0x27b1(%rip), %rdi      # 0x9df0
xorl %ebx, %ebx
movl %ebp, %esi
movq %rax, %rdx
xorl %eax, %eax
callq 0x86ac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/util.c
// Function: read_file
char* read_file(const char* file_path) {
    FILE* fp = fopen(file_path, "r");
    if (fp == NULL) {
        return NULL;
    }

    fseek(fp, 0, SEEK_END);
    int fsize = ftell(fp);
    fseek(fp, 0, SEEK_SET);

    char* addr = calloc(fsize, sizeof(char) + 1);
    fread(addr, sizeof(char), fsize, fp);
    fclose(fp);

    return addr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x25bb(%rip), %rsi      # 0xac84
callq 0x1140
testq %rax, %rax
je 0x872c
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1120
movq %rbx, %rdi
callq 0x10f0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x1120
movslq %r14d, %r15
movl $0x2, %esi
movq %r15, %rdi
callq 0x10c0
movq %rax, %r14
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x1080
movq %rbx, %rdi
callq 0x1090
jmp 0x872f
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/util.c
// Function: vector_push_back
void vector_push_back(Vector* vec, void* e) {
    if (vec->size == vec->capacity) {
        vec->capacity *= 2;
        vec->elements = realloc(vec->elements, sizeof(void*) * vec->capacity);
    }

    vec->elements[vec->size] = e;
    ++(vec->size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movq (%rdi), %rax
cmpl 0xc(%rdi), %ecx
jne 0x879a
movslq %ecx, %rsi
addl %ecx, %ecx
movl %ecx, 0xc(%rbx)
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x1130
movq %rax, (%rbx)
movl 0x8(%rbx), %ecx
movslq %ecx, %rcx
movq %r14, (%rax,%rcx,8)
incl %ecx
movl %ecx, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/util.c
// Function: strptrmap_put
void strptrmap_put(StrPtrMap* map, const char* key, void* val) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;
    if (map->entries[index] == NULL) {
        map->entries[index]       = calloc(1, sizeof(StrPtrMapEntry));
        map->entries[index]->key  = strdup(key);
        map->entries[index]->val  = val;
        map->entries[index]->next = NULL;
    }
    else {
        StrPtrMapEntry* current = map->entries[index];
        while (current->next != NULL) {
            current = current->next;
        }
        current->next       = calloc(1, sizeof(StrPtrMapEntry));
        current->next->key  = strdup(key);
        current->next->val  = val;
        current->next->next = NULL;
    }

    ++(map->size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x892d
leaq 0x1(%r15), %rdx
xorl %eax, %eax
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x891d
jmp 0x892f
xorl %eax, %eax
cltd
idivl 0xc(%rbx)
movq (%rbx), %r13
movslq %edx, %r12
movq (%r13,%r12,8), %rax
testq %rax, %rax
je 0x8978
movq %rax, %r13
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x8943
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %r12
movq %rax, 0x10(%r13)
movq %r15, %rdi
callq 0x1190
movq %rax, (%r12)
movq %r14, 0x8(%r12)
jmp 0x89b2
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, (%r13,%r12,8)
movq %r15, %rdi
callq 0x1190
movq (%rbx), %rcx
movq (%rcx,%r12,8), %rdx
movq %rax, (%rdx)
movq (%rcx,%r12,8), %rax
movq %r14, 0x8(%rax)
movq (%rcx,%r12,8), %rax
movq $0x0, 0x10(%rax)
incl 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/util.c
// Function: strptrmap_contains
bool strptrmap_contains(StrPtrMap* map, const char* key) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;

    if (map->entries[index] == NULL) {
        return false;
    }
    else {
        StrPtrMapEntry* current = map->entries[index];
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                return true;
            }
            current = current->next;
        }

        return false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x89e2
leaq 0x1(%rbx), %rdx
xorl %eax, %eax
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x89d2
jmp 0x89e4
xorl %eax, %eax
cltd
idivl 0xc(%rdi)
movq (%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x8a14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10d0
testl %eax, %eax
sete %al
je 0x8a16
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x89f7
jmp 0x8a16
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/util.c
// Function: strptrmap_get
void* strptrmap_get(StrPtrMap* map, const char* key) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;
    if (map->entries[index] == NULL) {
        return NULL;
    }
    else {
        StrPtrMapEntry* current = map->entries[index];
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                return current->val;
            }

            current = current->next;
        }

        return NULL;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x8a42
leaq 0x1(%rbx), %rdx
xorl %eax, %eax
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x8a32
jmp 0x8a44
xorl %eax, %eax
cltd
idivl 0xc(%rdi)
movq (%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r15
xorl %r14d, %r14d
testq %r15, %r15
je 0x8a73
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x10d0
testl %eax, %eax
je 0x8a6f
movq 0x10(%r15), %r15
jmp 0x8a55
movq 0x8(%r15), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/util.c
// Function: strintmap_put
void strintmap_put(StrIntMap* map, const char* key, int val) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;
    if (map->entries[index] == NULL) {
        map->entries[index]       = calloc(1, sizeof(StrIntMapEntry));
        map->entries[index]->key  = strdup(key);
        map->entries[index]->val  = val;
        map->entries[index]->next = NULL;
    }
    else {
        StrIntMapEntry* current = map->entries[index];
        while (current->next != NULL) {
            current = current->next;
        }
        current->next       = calloc(1, sizeof(StrIntMapEntry));
        current->next->key  = strdup(key);
        current->next->val  = val;
        current->next->next = NULL;
    }

    ++(map->size);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x8ae0
leaq 0x1(%r14), %rdx
xorl %eax, %eax
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x8ad0
jmp 0x8ae2
xorl %eax, %eax
cltd
idivl 0xc(%rbx)
movq (%rbx), %r12
movslq %edx, %r15
movq (%r12,%r15,8), %rax
testq %rax, %rax
je 0x8b29
movq %rax, %r12
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x8af5
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, %r15
movq %rax, 0x10(%r12)
movq %r14, %rdi
callq 0x1190
movq %rax, (%r15)
movl %ebp, 0x8(%r15)
jmp 0x8b5d
movl $0x1, %edi
movl $0x18, %esi
callq 0x10c0
movq %rax, (%r12,%r15,8)
movq %r14, %rdi
callq 0x1190
movq (%rbx), %rcx
movq (%rcx,%r15,8), %rdx
movq %rax, (%rdx)
movq (%rcx,%r15,8), %rax
movl %ebp, 0x8(%rax)
movq $0x0, 0x10(%rax)
incl 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/util.c
// Function: strintmap_contains
bool strintmap_contains(StrIntMap* map, const char* key) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;

    if (map->entries[index] == NULL) {
        return false;
    }
    else {
        StrIntMapEntry* current = map->entries[index];
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                return true;
            }
            current = current->next;
        }
        return false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x8b8c
leaq 0x1(%rbx), %rdx
xorl %eax, %eax
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x8b7c
jmp 0x8b8e
xorl %eax, %eax
cltd
idivl 0xc(%rdi)
movq (%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x8bbe
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10d0
testl %eax, %eax
sete %al
je 0x8bc0
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x8ba1
jmp 0x8bc0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/chgzm[P]minic/util.c
// Function: strintmap_get
int strintmap_get(StrIntMap* map, const char* key) {
    const int hash  = calc_hash(key);
    const int index = hash % map->capacity;
    if (map->entries[index] == NULL) {
        fprintf(stderr, "no key=\"%s\"\n", key);
        exit(-1);
    }
    else {
        StrIntMapEntry* current = map->entries[index];
        while (current != NULL) {
            if (strcmp(current->key, key) == 0) {
                return current->val;
            }

            current = current->next;
        }

        fprintf(stderr, "no key=\"%s\"\n", key);
        exit(-1);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rsi), %cl
testb %cl, %cl
je 0x8beb
leaq 0x1(%rbx), %rdx
xorl %eax, %eax
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x8bdb
jmp 0x8bed
xorl %eax, %eax
cltd
idivl 0xc(%rdi)
movq (%rdi), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x8c2c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10d0
testl %eax, %eax
je 0x8c20
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x8c00
movq %rbx, %rdi
callq 0x11e5
movl 0x8(%r14), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x1209
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: format[abi:cxx11](char const*, ...)
string
format(const char* format, ...)
{
    va_list ap;

    size_t buffer_size_bytes = 256;

    string result;

    char* buffer = (char*)malloc(buffer_size_bytes);

    if( buffer == NULL )
        return result;

    bool done = false;

    unsigned int loop_count = 0;

    while(!done)
    {
        va_start(ap, format);

        int return_value = vsnprintf(buffer, buffer_size_bytes, format, ap);

        if( return_value < 0 )
        {
            done = true;
        }
        else if( return_value >= buffer_size_bytes )
        {
            // Realloc and try again.

            buffer_size_bytes = return_value + 1;

            char* new_buffer_ptr = (char*)realloc(buffer, buffer_size_bytes);

            if( new_buffer_ptr == NULL )
            {
                done = true;
            }
            else
            {
                buffer = new_buffer_ptr;
            }
        }
        else
        {
            result = buffer;
            done = true;
        }

        va_end(ap);

        if( ++loop_count > 5 )
            done = true;
    }

    free(buffer);

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, -0xf0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %r8, -0xe0(%rbp)
movq %r9, -0xd8(%rbp)
testb %al, %al
je 0x94a4
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x100, %r12d           # imm = 0x100
movl $0x100, %edi            # imm = 0x100
callq 0x8420
testq %rax, %rax
je 0x9573
movq %rax, %r14
movq %r13, -0x38(%rbp)
movq %rbx, -0x30(%rbp)
xorl %ebx, %ebx
leaq -0x50(%rbp), %r13
leaq -0x100(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x50(%rbp)
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x81e0
testl %eax, %eax
js 0x9567
movl %eax, %ecx
cmpq %rcx, %r12
ja 0x9544
movl %eax, %r12d
incl %r12d
movq %r14, %rdi
movq %r12, %rsi
callq 0x8580
testq %rax, %rax
cmovneq %rax, %r14
cmpl $0x4, %ebx
ja 0x9567
incl %ebx
testq %rax, %rax
jne 0x94e1
jmp 0x9567
movq -0x30(%rbp), %rbx
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0x8170
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x8510
movq %r14, %rdi
callq 0x83e0
movq -0x30(%rbp), %rbx
movq %rbx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0x95a7
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8310
movq %r14, %rdi
callq 0x85f0
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: dirname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string
dirname(const string& path)
{
    size_t pos = path.rfind("/");

    if(pos == std::string::npos)
        return path;
    else if(pos == 0)
        return "/";

    return string(path, 0, pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x16ac6(%rip), %rsi     # 0x20089
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x8450
testq %rax, %rax
je 0x95ff
cmpq $-0x1, %rax
jne 0x9620
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa1e2
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x16a7c(%rip), %rsi     # 0x20089
leaq 0x16a76(%rip), %rdx     # 0x2008a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9f1e
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x80a0
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: realpath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string
realpath(const string& path)
{
    char* real_path = realpath(path.c_str(), NULL);

    string result;

    if(real_path != NULL)
    {
        result = real_path;

        free(real_path);
    }

    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x8120
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
testq %rax, %rax
je 0x9692
movq %rax, %r14
movq %rax, %rdi
callq 0x8170
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x8510
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x83e0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x96b3
movq (%r15), %rsi
incq %rsi
callq 0x8310
movq %r14, %rdi
callq 0x85f0
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/serial/list_ports_linux.cc
// Function: read_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string
read_line(const string& file)
{
    ifstream ifs(file.c_str(), ifstream::in);

    string line;

    if(ifs)
    {
        getline(ifs, line);
    }

    return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq -0x220(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x8630
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x200(%rbp,%rax)
jne 0x9cff
leaq (%rax,%rbp), %rdi
addq $-0x220, %rdi           # imm = 0xFDE0
movl $0xa, %esi
callq 0x82d0
movsbl %al, %edx
leaq -0x220(%rbp), %rdi
movq %rbx, %rsi
callq 0x8650
leaq -0x220(%rbp), %rdi
callq 0x80c0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x9d2f
movq (%r15), %rsi
incq %rsi
callq 0x8310
leaq -0x220(%rbp), %rdi
callq 0x80c0
movq %r14, %rdi
callq 0x85f0
nop
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/serial/serial.cc
// Function: serial::Serial::read(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned long)
size_t
Serial::read (std::vector<uint8_t> &buffer, size_t size)
{
  ScopedReadLock lock(this->pimpl_);
  uint8_t *buffer_ = new uint8_t[size];
  size_t bytes_read = this->pimpl_->read (buffer_, size);
  buffer.insert (buffer.end (), buffer_, buffer_+bytes_read);
  delete[] buffer_;
  return bytes_read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0xddf2
movq %r12, %rdi
callq 0x8040
movq %rax, %r15
movq 0x8(%r13), %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xc778
movq %rax, %r12
movq 0x8(%r14), %rsi
movq %r15, %rcx
addq %rax, %rcx
movq %r14, %rdi
movq %r15, %rdx
callq 0xb4d0
movq %r15, %rdi
callq 0x8410
movq %rbx, %rdi
callq 0xdeac
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xab48
jmp 0xab35
jmp 0xab35
movq %rax, %r14
movq %rbx, %rdi
callq 0xdeac
movq %r14, %rdi
callq 0x85f0
movq %rax, %rdi
callq 0x9ec4
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/serial/serial.cc
// Function: serial::Serial::read(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long)
size_t
Serial::read (std::string &buffer, size_t size)
{
  ScopedReadLock lock(this->pimpl_);
  uint8_t *buffer_ = new uint8_t[size];
  size_t bytes_read = this->pimpl_->read (buffer_, size);
  buffer.append (reinterpret_cast<const char*>(buffer_), bytes_read);
  delete[] buffer_;
  return bytes_read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r13
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0xddf2
movq %r12, %rdi
callq 0x8040
movq %rax, %r15
movq 0x8(%r13), %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xc778
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x8070
movq %r15, %rdi
callq 0x8410
movq %rbx, %rdi
callq 0xdeac
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xabd7
jmp 0xabc4
movq %rax, %r14
movq %rbx, %rdi
callq 0xdeac
movq %r14, %rdi
callq 0x85f0
movq %rax, %rdi
callq 0x9ec4
nop
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/serial/serial.cc
// Function: serial::Serial::readline(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
size_t
Serial::readline (string &buffer, size_t size, string eol)
{
  ScopedReadLock lock(this->pimpl_);
  size_t eol_len = eol.length ();
  uint8_t *buffer_ = static_cast<uint8_t*>
                              (alloca (size * sizeof (uint8_t)));
  size_t read_so_far = 0;
  while (true)
  {
    size_t bytes_read = this->read_ (buffer_ + read_so_far, 1);
    read_so_far += bytes_read;
    if (bytes_read == 0) {
      break; // Timeout occured on reading 1 byte
    }
    if (string (reinterpret_cast<const char*>
         (buffer_ + read_so_far - eol_len), eol_len) == eol) {
      break; // EOL found
    }
    if (read_so_far == size) {
      break; // Reached the maximum read length
    }
  }
  buffer.append(reinterpret_cast<const char*> (buffer_), read_so_far);
  return read_so_far;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, -0x38(%rbp)
movq %rdi, -0x50(%rbp)
movq 0x8(%rdi), %rdi
movq %rdi, -0x30(%rbp)
callq 0xddf2
xorl %r14d, %r14d
xorl %eax, %eax
subq 0x8(%r12), %rax
movq %rax, -0x48(%rbp)
movq %rsp, %rbx
movq %r15, -0x40(%rbp)
leaq 0xf(%r15), %rax
andq $-0x10, %rax
subq %rax, %rbx
movq %rbx, %rsp
leaq (%rbx,%r14), %rsi
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %edx
callq 0xc778
addq %rax, %r14
testq %rax, %rax
je 0xad1e
leaq (%rbx,%r14), %rdx
movq -0x48(%rbp), %rax
leaq (%rdx,%rax), %rsi
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9f1e
movq -0x68(%rbp), %rdx
cmpq 0x8(%r12), %rdx
jne 0xacea
movq -0x70(%rbp), %r13
testq %rdx, %rdx
je 0xacf3
movq (%r12), %rsi
movq %r13, %rdi
callq 0x8320
testl %eax, %eax
sete %r15b
jmp 0xacf6
movq -0x70(%rbp), %r13
xorl %r15d, %r15d
jmp 0xacf6
movb $0x1, %r15b
leaq -0x60(%rbp), %rax
cmpq %rax, %r13
je 0xad0e
movq -0x60(%rbp), %rsi
incq %rsi
movq %r13, %rdi
callq 0x8310
cmpq -0x40(%rbp), %r14
sete %al
orb %r15b, %al
je 0xac87
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x8070
movq -0x30(%rbp), %rdi
callq 0xdeac
movq %r14, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xad62
jmp 0xad4e
jmp 0xad4e
movq %rax, %rbx
movq -0x30(%rbp), %rdi
callq 0xdeac
movq %rbx, %rdi
callq 0x85f0
movq %rax, %rdi
callq 0x9ec4
// File: /workspace/github_c_makefile_star2_O3/patriciogonzalezvivo[P]tprint/include/serial/serial.cc
// Function: serial::Serial::setPort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void
Serial::setPort (const string &port)
{
  ScopedReadLock rlock(this->pimpl_);
  ScopedWriteLock wlock(this->pimpl_);
  bool was_open = pimpl_->isOpen ();
  if (was_open) close();
  pimpl_->setPort (port);
  if (was_open) open ();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0xddf2
movq 0x8(%r15), %r14
movq %r14, %rdi
callq 0xdf66
movq 0x8(%r15), %rdi
callq 0xc44c
movl %eax, %r13d
testb %al, %al
je 0xb20b
movq 0x8(%r15), %rdi
callq 0xbb54
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0xcd0e
testb %r13b, %r13b
je 0xb225
movq 0x8(%r15), %rdi
callq 0xb910
movq %r14, %rdi
callq 0xe024
movq %rbx, %rdi
callq 0xdeac
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb26a
jmp 0xb26a
movq %rax, %r15
jmp 0xb258
movq %rax, %r15
movq %r14, %rdi
callq 0xe024
movq %rbx, %rdi
callq 0xdeac
movq %r15, %rdi
callq 0x85f0
jmp 0xb26a
movq %rax, %rdi
callq 0x9ec4