LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_authentication
int
kmip_encode_authentication(KMIP *ctx, const Authentication *value)
{
    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_AUTHENTICATION, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_credential(ctx, value->credential);
    CHECK_RESULT(ctx, result);
    
    uint8 *curr_index = ctx->index;
    ctx->index = length_index;
    
    result = kmip_encode_length(ctx, curr_index - value_index);
    CHECK_RESULT(ctx, result);

    ctx->index = curr_index;
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x42000c01, %esi       # imm = 0x42000C01
callq 0x60b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1536e
movq -0x10(%rbp), %rdi
leaq 0xfe64(%rip), %rsi      # 0x251bd
movl $0x1f48, %edx           # imm = 0x1F48
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1542f
jmp 0x15370
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x4, %rax
movq %rax, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6070
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x153c6
movq -0x10(%rbp), %rdi
leaq 0xfe09(%rip), %rsi      # 0x251bd
movl $0x1f4e, %edx           # imm = 0x1F4E
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1542f
jmp 0x153c8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
callq 0x6ba0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1541a
movq -0x10(%rbp), %rdi
leaq 0xfdb5(%rip), %rsi      # 0x251bd
movl $0x1f54, %edx           # imm = 0x1F54
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1542f
jmp 0x1541c
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_query_request_payload
int
kmip_encode_query_request_payload(KMIP *ctx, const QueryRequestPayload *value)
{
    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_REQUEST_PAYLOAD, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);

    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;

    if(value->functions != NULL)
    {
        result = kmip_encode_query_functions(ctx, value->functions);
        CHECK_RESULT(ctx, result);
    }

    uint8 *curr_index = ctx->index;
    ctx->index = length_index;

    kmip_encode_int32_be(ctx, curr_index - value_index);

    ctx->index = curr_index;

    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x42007901, %esi       # imm = 0x42007901
callq 0x60b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x15f5e
movq -0x10(%rbp), %rdi
leaq 0xf35a(%rip), %rsi      # 0x252a3
movl $0x20e2, %edx           # imm = 0x20E2
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16005
jmp 0x15f60
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x4, %rax
movq %rax, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x15fc4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6350
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x15fc0
movq -0x10(%rbp), %rdi
leaq 0xf2f5(%rip), %rsi      # 0x252a3
movl $0x20ea, %edx           # imm = 0x20EA
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16005
jmp 0x15fc2
jmp 0x15fc4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
callq 0x60b0
movq -0x38(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_request_message
int
kmip_encode_request_message(KMIP *ctx, const RequestMessage *value)
{
    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_REQUEST_MESSAGE, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_request_header(ctx, value->request_header);
    CHECK_RESULT(ctx, result);
    
    for(size_t i = 0; i < value->batch_count; i++)
    {
        result = kmip_encode_request_batch_item(ctx, &value->batch_items[i]);
        CHECK_RESULT(ctx, result);
    }
    
    uint8 *curr_index = ctx->index;
    ctx->index = length_index;
    
    result = kmip_encode_length(ctx, curr_index - value_index);
    CHECK_RESULT(ctx, result);

    ctx->index = curr_index;
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x42007801, %esi       # imm = 0x42007801
callq 0x60b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x163de
movq -0x10(%rbp), %rdi
leaq 0xee85(%rip), %rsi      # 0x2524e
movl $0x2091, %edx           # imm = 0x2091
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1650c
jmp 0x163e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x4, %rax
movq %rax, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x66c0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x16439
movq -0x10(%rbp), %rdi
leaq 0xee2a(%rip), %rsi      # 0x2524e
movl $0x2097, %edx           # imm = 0x2097
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1650c
jmp 0x1643b
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x164a5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x38(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x6730
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x16493
movq -0x10(%rbp), %rdi
leaq 0xedcd(%rip), %rsi      # 0x2524e
movl $0x209c, %edx           # imm = 0x209C
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1650c
jmp 0x16495
jmp 0x16497
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x16443
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
callq 0x6ba0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x164f7
movq -0x10(%rbp), %rdi
leaq 0xed69(%rip), %rsi      # 0x2524e
movl $0x20a3, %edx           # imm = 0x20A3
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1650c
jmp 0x164f9
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_response_message
int
kmip_encode_response_message(KMIP *ctx, const ResponseMessage *value)
{
    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_RESPONSE_MESSAGE, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_response_header(ctx, value->response_header);
    CHECK_RESULT(ctx, result);
    
    for(size_t i = 0; i < value->batch_count; i++)
    {
        result = kmip_encode_response_batch_item(ctx, &value->batch_items[i]);
        CHECK_RESULT(ctx, result);
    }
    
    uint8 *curr_index = ctx->index;
    ctx->index = length_index;
    
    result = kmip_encode_length(ctx, curr_index - value_index);
    CHECK_RESULT(ctx, result);

    ctx->index = curr_index;
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl $0x42007b01, %esi       # imm = 0x42007B01
callq 0x60b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1656e
movq -0x10(%rbp), %rdi
leaq 0xed11(%rip), %rsi      # 0x2526a
movl $0x20af, %edx           # imm = 0x20AF
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16699
jmp 0x16570
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
addq $0x4, %rax
movq %rax, 0x8(%rcx)
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6a80
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x165c9
movq -0x10(%rbp), %rdi
leaq 0xecb6(%rip), %rsi      # 0x2526a
movl $0x20b5, %edx           # imm = 0x20B5
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16699
jmp 0x165cb
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x16632
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
imulq $0x30, -0x38(%rbp), %rax
addq %rax, %rsi
callq 0x6960
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x16620
movq -0x10(%rbp), %rdi
leaq 0xec5c(%rip), %rsi      # 0x2526a
movl $0x20ba, %edx           # imm = 0x20BA
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16699
jmp 0x16622
jmp 0x16624
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x165d3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rax
subq %rax, %rsi
callq 0x6ba0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x16684
movq -0x10(%rbp), %rdi
leaq 0xebf8(%rip), %rsi      # 0x2526a
movl $0x20c1, %edx           # imm = 0x20C1
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16699
jmp 0x16686
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_query_functions
int
kmip_encode_query_functions(KMIP *ctx, const Functions* value)
{
    CHECK_ENCODE_ARGS(ctx, value);

    int result = 0;

    if(value->function_list != NULL)
    {
        LinkedListItem *curr = value->function_list->head;
        while(curr != NULL)
        {
            result = kmip_encode_enum(ctx, KMIP_TAG_QUERY_FUNCTION, *(int32 *)curr->data);
            CHECK_RESULT(ctx, result);

            curr = curr->next;
        }
    }

    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x166d3
movl $0xffffffef, -0x4(%rbp) # imm = 0xFFFFFFEF
jmp 0x16761
cmpq $0x0, -0x18(%rbp)
jne 0x166e3
movl $0x0, -0x4(%rbp)
jmp 0x16761
jmp 0x166e5
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1675a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x16758
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edx
movl $0x420074, %esi         # imm = 0x420074
callq 0x6770
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x16749
movq -0x10(%rbp), %rdi
leaq 0xeb50(%rip), %rsi      # 0x25287
movl $0x20d5, %edx           # imm = 0x20D5
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x16761
jmp 0x1674b
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x16704
jmp 0x1675a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_int8_be
int
kmip_decode_int8_be(KMIP *ctx, void *value)
{
    CHECK_BUFFER_FULL(ctx, sizeof(int8));
    
    int8 *i = (int8*)value;
    
    *i = 0;
    *i = *ctx->index++;
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jae 0x167c1
movq -0x10(%rbp), %rdi
leaq 0xeb17(%rip), %rsi      # 0x252c5
movl $0x2108, %edx           # imm = 0x2108
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x167f4
jmp 0x167c3
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movb (%rax), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_int32_be
int
kmip_decode_int32_be(KMIP *ctx, void *value)
{
    CHECK_BUFFER_FULL(ctx, sizeof(int32));
    
    int32 *i = (int32*)value;
    
    *i = 0;
    *i |= ((int32)*ctx->index++ << 24);
    *i |= ((int32)*ctx->index++ << 16);
    *i |= ((int32)*ctx->index++ << 8);
    *i |= ((int32)*ctx->index++ << 0);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x4, %rax
jae 0x16854
movq -0x10(%rbp), %rdi
leaq 0xea9b(%rip), %rsi      # 0x252d9
movl $0x2115, %edx           # imm = 0x2115
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x168f3
jmp 0x16856
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %ecx
shll $0x18, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %ecx
shll $0x10, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %ecx
shll $0x0, %ecx
movq -0x20(%rbp), %rax
orl (%rax), %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_int64_be
int
kmip_decode_int64_be(KMIP *ctx, void *value)
{
    CHECK_BUFFER_FULL(ctx, sizeof(int64));
    
    int64 *i = (int64*)value;
    
    *i = 0;
    *i |= ((int64)*ctx->index++ << 56);
    *i |= ((int64)*ctx->index++ << 48);
    *i |= ((int64)*ctx->index++ << 40);
    *i |= ((int64)*ctx->index++ << 32);
    *i |= ((int64)*ctx->index++ << 24);
    *i |= ((int64)*ctx->index++ << 16);
    *i |= ((int64)*ctx->index++ << 8);
    *i |= ((int64)*ctx->index++ << 0);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x8, %rax
jae 0x16954
movq -0x10(%rbp), %rdi
leaq 0xe9b0(%rip), %rsi      # 0x252ee
movl $0x2125, %edx           # imm = 0x2125
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x16aa0
jmp 0x16956
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x38, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x30, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x28, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x20, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x18, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x10, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x8, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, %ecx
shlq $0x0, %rcx
movq -0x20(%rbp), %rax
orq (%rax), %rcx
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_length
int
kmip_decode_length(KMIP *ctx, uint32 *value)
{
    CHECK_BUFFER_FULL(ctx, 4);

    kmip_decode_int32_be(ctx, value);

    if(*value > INT_MAX)
    {
        HANDLE_FAILURE(ctx, KMIP_INVALID_LENGTH);
    }

    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x4, %rax
jae 0x16b01
movq -0x10(%rbp), %rdi
leaq 0xe815(%rip), %rsi      # 0x25303
movl $0x2139, %edx           # imm = 0x2139
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x16b43
jmp 0x16b03
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6b10
movq -0x18(%rbp), %rax
cmpl $0x7fffffff, (%rax)     # imm = 0x7FFFFFFF
jbe 0x16b3c
jmp 0x16b1e
movq -0x10(%rbp), %rdi
leaq 0xe7da(%rip), %rsi      # 0x25303
movl $0x213f, %edx           # imm = 0x213F
callq 0x6f20
movl $0xffffffeb, -0x4(%rbp) # imm = 0xFFFFFFEB
jmp 0x16b43
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_integer
int
kmip_decode_integer(KMIP *ctx, enum tag t, int32 *value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    int32 tag_type = 0;
    uint32 length = 0;
    int32 padding = 0;
    
    kmip_decode_int32_be(ctx, &tag_type);
    CHECK_TAG_TYPE(ctx, tag_type, t, KMIP_TYPE_INTEGER);

    kmip_decode_length(ctx, &length);
    CHECK_LENGTH(ctx, length, 4);
    
    kmip_decode_int32_be(ctx, value);
    
    kmip_decode_int32_be(ctx, &padding);
    CHECK_PADDING(ctx, padding);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jae 0x16ba7
movq -0x10(%rbp), %rdi
leaq 0xe785(%rip), %rsi      # 0x25316
movl $0x2148, %edx           # imm = 0x2148
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x16ca0
jmp 0x16ba9
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x6b10
movl -0x24(%rbp), %eax
sarl $0x8, %eax
cmpl -0x14(%rbp), %eax
je 0x16bf7
movq -0x10(%rbp), %rdi
leaq 0xe735(%rip), %rsi      # 0x25316
movl $0x214f, %edx           # imm = 0x214F
callq 0x6f20
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x16ca0
movl -0x24(%rbp), %eax
andl $0xff, %eax
cmpl $0x2, %eax
je 0x16c22
movq -0x10(%rbp), %rdi
leaq 0xe707(%rip), %rsi      # 0x25316
movl $0x214f, %edx           # imm = 0x214F
callq 0x6f20
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x16ca0
jmp 0x16c24
jmp 0x16c26
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6520
cmpl $0x4, -0x28(%rbp)
je 0x16c57
movq -0x10(%rbp), %rdi
leaq 0xe6d2(%rip), %rsi      # 0x25316
movl $0x2152, %edx           # imm = 0x2152
callq 0x6f20
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x16ca0
jmp 0x16c59
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6b10
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x6b10
cmpl $0x0, -0x2c(%rbp)
je 0x16c97
movq -0x10(%rbp), %rdi
leaq 0xe692(%rip), %rsi      # 0x25316
movl $0x2157, %edx           # imm = 0x2157
callq 0x6f20
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0x16ca0
jmp 0x16c99
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_long
int
kmip_decode_long(KMIP *ctx, enum tag t, int64 *value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    int32 tag_type = 0;
    uint32 length = 0;
    
    kmip_decode_int32_be(ctx, &tag_type);
    CHECK_TAG_TYPE(ctx, tag_type, t, KMIP_TYPE_LONG_INTEGER);

    kmip_decode_length(ctx, &length);
    CHECK_LENGTH(ctx, length, 8);
    
    kmip_decode_int64_be(ctx, value);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jae 0x16d07
movq -0x10(%rbp), %rdi
leaq 0xe639(%rip), %rsi      # 0x2532a
movl $0x215f, %edx           # imm = 0x215F
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x16dc3
jmp 0x16d09
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x6b10
movl -0x24(%rbp), %eax
sarl $0x8, %eax
cmpl -0x14(%rbp), %eax
je 0x16d4d
movq -0x10(%rbp), %rdi
leaq 0xe5f0(%rip), %rsi      # 0x2532a
movl $0x2165, %edx           # imm = 0x2165
callq 0x6f20
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x16dc3
movl -0x24(%rbp), %eax
andl $0xff, %eax
cmpl $0x3, %eax
je 0x16d78
movq -0x10(%rbp), %rdi
leaq 0xe5c5(%rip), %rsi      # 0x2532a
movl $0x2165, %edx           # imm = 0x2165
callq 0x6f20
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x16dc3
jmp 0x16d7a
jmp 0x16d7c
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6520
cmpl $0x8, -0x28(%rbp)
je 0x16dad
movq -0x10(%rbp), %rdi
leaq 0xe590(%rip), %rsi      # 0x2532a
movl $0x2168, %edx           # imm = 0x2168
callq 0x6f20
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x16dc3
jmp 0x16daf
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6920
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_enum
int
kmip_decode_enum(KMIP *ctx, enum tag t, void *value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    int32 tag_type = 0;
    uint32 length = 0;
    int32 *v = (int32*)value;
    int32 padding = 0;
    
    kmip_decode_int32_be(ctx, &tag_type);
    CHECK_TAG_TYPE(ctx, tag_type, t, KMIP_TYPE_ENUMERATION);
    
    kmip_decode_length(ctx, &length);
    CHECK_LENGTH(ctx, length, 4);
    
    kmip_decode_int32_be(ctx, v);
    
    kmip_decode_int32_be(ctx, &padding);
    CHECK_PADDING(ctx, padding);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jae 0x16e27
movq -0x10(%rbp), %rdi
leaq 0xe52a(%rip), %rsi      # 0x2533b
movl $0x2172, %edx           # imm = 0x2172
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x16f28
jmp 0x16e29
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x6b10
movl -0x24(%rbp), %eax
sarl $0x8, %eax
cmpl -0x14(%rbp), %eax
je 0x16e7f
movq -0x10(%rbp), %rdi
leaq 0xe4d2(%rip), %rsi      # 0x2533b
movl $0x217a, %edx           # imm = 0x217A
callq 0x6f20
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x16f28
movl -0x24(%rbp), %eax
andl $0xff, %eax
cmpl $0x5, %eax
je 0x16eaa
movq -0x10(%rbp), %rdi
leaq 0xe4a4(%rip), %rsi      # 0x2533b
movl $0x217a, %edx           # imm = 0x217A
callq 0x6f20
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x16f28
jmp 0x16eac
jmp 0x16eae
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6520
cmpl $0x4, -0x28(%rbp)
je 0x16edf
movq -0x10(%rbp), %rdi
leaq 0xe46f(%rip), %rsi      # 0x2533b
movl $0x217d, %edx           # imm = 0x217D
callq 0x6f20
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x16f28
jmp 0x16ee1
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6b10
movq -0x10(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0x6b10
cmpl $0x0, -0x34(%rbp)
je 0x16f1f
movq -0x10(%rbp), %rdi
leaq 0xe42f(%rip), %rsi      # 0x2533b
movl $0x2182, %edx           # imm = 0x2182
callq 0x6f20
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0x16f28
jmp 0x16f21
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_bool
int
kmip_decode_bool(KMIP *ctx, enum tag t, bool32 *value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    int32 tag_type = 0;
    uint32 length = 0;
    int32 padding = 0;
    
    kmip_decode_int32_be(ctx, &tag_type);
    CHECK_TAG_TYPE(ctx, tag_type, t, KMIP_TYPE_BOOLEAN);
    
    kmip_decode_length(ctx, &length);
    CHECK_LENGTH(ctx, length, 8);
    
    kmip_decode_int32_be(ctx, &padding);
    CHECK_PADDING(ctx, padding);
    
    kmip_decode_int32_be(ctx, value);
    CHECK_BOOLEAN(ctx, *value);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jae 0x16f97
movq -0x10(%rbp), %rdi
leaq 0xe3cb(%rip), %rsi      # 0x2534c
movl $0x218a, %edx           # imm = 0x218A
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x170c5
jmp 0x16f99
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x6b10
movl -0x24(%rbp), %eax
sarl $0x8, %eax
cmpl -0x14(%rbp), %eax
je 0x16fe7
movq -0x10(%rbp), %rdi
leaq 0xe37b(%rip), %rsi      # 0x2534c
movl $0x2191, %edx           # imm = 0x2191
callq 0x6f20
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x170c5
movl -0x24(%rbp), %eax
andl $0xff, %eax
cmpl $0x6, %eax
je 0x17015
movq -0x10(%rbp), %rdi
leaq 0xe34d(%rip), %rsi      # 0x2534c
movl $0x2191, %edx           # imm = 0x2191
callq 0x6f20
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x170c5
jmp 0x17017
jmp 0x17019
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6520
cmpl $0x8, -0x28(%rbp)
je 0x1704a
movq -0x10(%rbp), %rdi
leaq 0xe315(%rip), %rsi      # 0x2534c
movl $0x2194, %edx           # imm = 0x2194
callq 0x6f20
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x170c5
jmp 0x1704c
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x6b10
cmpl $0x0, -0x2c(%rbp)
je 0x1707d
movq -0x10(%rbp), %rdi
leaq 0xe2e2(%rip), %rsi      # 0x2534c
movl $0x2197, %edx           # imm = 0x2197
callq 0x6f20
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0x170c5
jmp 0x1707f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6b10
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
je 0x170bc
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x170bc
movq -0x10(%rbp), %rdi
leaq 0xe2a3(%rip), %rsi      # 0x2534c
movl $0x219a, %edx           # imm = 0x219A
callq 0x6f20
movl $0xfffffff8, -0x4(%rbp) # imm = 0xFFFFFFF8
jmp 0x170c5
jmp 0x170be
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_date_time
int
kmip_decode_date_time(KMIP *ctx, enum tag t, int64 *value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    int32 tag_type = 0;
    uint32 length = 0;
    
    kmip_decode_int32_be(ctx, &tag_type);
    CHECK_TAG_TYPE(ctx, tag_type, t, KMIP_TYPE_DATE_TIME);
    
    kmip_decode_length(ctx, &length);
    CHECK_LENGTH(ctx, length, 8);
    
    kmip_decode_int64_be(ctx, value);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jae 0x17587
movq -0x10(%rbp), %rdi
leaq 0xde1c(%rip), %rsi      # 0x2538d
movl $0x21e8, %edx           # imm = 0x21E8
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x17643
jmp 0x17589
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x6b10
movl -0x24(%rbp), %eax
sarl $0x8, %eax
cmpl -0x14(%rbp), %eax
je 0x175cd
movq -0x10(%rbp), %rdi
leaq 0xddd3(%rip), %rsi      # 0x2538d
movl $0x21ee, %edx           # imm = 0x21EE
callq 0x6f20
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x17643
movl -0x24(%rbp), %eax
andl $0xff, %eax
cmpl $0x9, %eax
je 0x175f8
movq -0x10(%rbp), %rdi
leaq 0xdda8(%rip), %rsi      # 0x2538d
movl $0x21ee, %edx           # imm = 0x21EE
callq 0x6f20
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x17643
jmp 0x175fa
jmp 0x175fc
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6520
cmpl $0x8, -0x28(%rbp)
je 0x1762d
movq -0x10(%rbp), %rdi
leaq 0xdd73(%rip), %rsi      # 0x2538d
movl $0x21f1, %edx           # imm = 0x21F1
callq 0x6f20
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x17643
jmp 0x1762f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6920
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_interval
int
kmip_decode_interval(KMIP *ctx, enum tag t, uint32 *value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    int32 tag_type = 0;
    uint32 length = 0;
    int32 padding = 0;
    
    kmip_decode_int32_be(ctx, &tag_type);
    CHECK_TAG_TYPE(ctx, tag_type, t, KMIP_TYPE_INTERVAL);
    
    kmip_decode_length(ctx, &length);
    CHECK_LENGTH(ctx, length, 4);
    
    kmip_decode_int32_be(ctx, value);
    
    kmip_decode_int32_be(ctx, &padding);
    CHECK_PADDING(ctx, padding);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x10, %rax
jae 0x176a7
movq -0x10(%rbp), %rdi
leaq 0xdd12(%rip), %rsi      # 0x253a3
movl $0x21fb, %edx           # imm = 0x21FB
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x177a0
jmp 0x176a9
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x6b10
movl -0x24(%rbp), %eax
sarl $0x8, %eax
cmpl -0x14(%rbp), %eax
je 0x176f7
movq -0x10(%rbp), %rdi
leaq 0xdcc2(%rip), %rsi      # 0x253a3
movl $0x2202, %edx           # imm = 0x2202
callq 0x6f20
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x177a0
movl -0x24(%rbp), %eax
andl $0xff, %eax
cmpl $0xa, %eax
je 0x17722
movq -0x10(%rbp), %rdi
leaq 0xdc94(%rip), %rsi      # 0x253a3
movl $0x2202, %edx           # imm = 0x2202
callq 0x6f20
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x177a0
jmp 0x17724
jmp 0x17726
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6520
cmpl $0x4, -0x28(%rbp)
je 0x17757
movq -0x10(%rbp), %rdi
leaq 0xdc5f(%rip), %rsi      # 0x253a3
movl $0x2205, %edx           # imm = 0x2205
callq 0x6f20
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x177a0
jmp 0x17759
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6b10
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x6b10
cmpl $0x0, -0x2c(%rbp)
je 0x17797
movq -0x10(%rbp), %rdi
leaq 0xdc1f(%rip), %rsi      # 0x253a3
movl $0x220a, %edx           # imm = 0x220A
callq 0x6f20
movl $0xfffffff9, -0x4(%rbp) # imm = 0xFFFFFFF9
jmp 0x177a0
jmp 0x17799
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_attribute
int
kmip_decode_attribute(KMIP *ctx, Attribute *value)
{
    CHECK_DECODE_ARGS(ctx, value);

    if(ctx->version < KMIP_2_0)
    {
        return(kmip_decode_attribute_v1(ctx, value));
    }
    else
    {
        return(kmip_decode_attribute_v2(ctx, value));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ac5e
cmpq $0x0, -0x18(%rbp)
jne 0x1ac67
movl $0xffffffef, -0x4(%rbp) # imm = 0xFFFFFFEF
jmp 0x1ac95
jmp 0x1ac69
movq -0x10(%rbp), %rax
cmpl $0x5, 0x18(%rax)
jae 0x1ac85
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c70
movl %eax, -0x4(%rbp)
jmp 0x1ac95
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x64c0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_protocol_version
int
kmip_decode_protocol_version(KMIP *ctx, ProtocolVersion *value)
{
    CHECK_BUFFER_FULL(ctx, 40);
    
    int result = 0;
    int32 tag_type = 0;
    uint32 length = 0;
    
    kmip_decode_int32_be(ctx, &tag_type);
    CHECK_TAG_TYPE(ctx, tag_type, KMIP_TAG_PROTOCOL_VERSION, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_LENGTH(ctx, length, 32);
    
    result = kmip_decode_integer(ctx, KMIP_TAG_PROTOCOL_VERSION_MAJOR, &value->major);
    CHECK_RESULT(ctx, result);
    
    result = kmip_decode_integer(ctx, KMIP_TAG_PROTOCOL_VERSION_MINOR, &value->minor);
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
subq %rdx, %rcx
subq %rcx, %rax
cmpq $0x28, %rax
jae 0x1b414
movq -0x10(%rbp), %rdi
leaq 0xa2a3(%rip), %rsi      # 0x256a1
movl $0x24ad, %edx           # imm = 0x24AD
callq 0x6f20
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1b54d
jmp 0x1b416
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6b10
movl -0x20(%rbp), %eax
sarl $0x8, %eax
cmpl $0x420069, %eax         # imm = 0x420069
je 0x1b466
movq -0x10(%rbp), %rdi
leaq 0xa251(%rip), %rsi      # 0x256a1
movl $0x24b4, %edx           # imm = 0x24B4
callq 0x6f20
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x1b54d
movl -0x20(%rbp), %eax
andl $0xff, %eax
cmpl $0x1, %eax
je 0x1b494
movq -0x10(%rbp), %rdi
leaq 0xa223(%rip), %rsi      # 0x256a1
movl $0x24b4, %edx           # imm = 0x24B4
callq 0x6f20
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x1b54d
jmp 0x1b496
jmp 0x1b498
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x6520
cmpl $0x20, -0x24(%rbp)
je 0x1b4cc
movq -0x10(%rbp), %rdi
leaq 0xa1eb(%rip), %rsi      # 0x256a1
movl $0x24b7, %edx           # imm = 0x24B7
callq 0x6f20
movl $0xfffffffa, -0x4(%rbp) # imm = 0xFFFFFFFA
jmp 0x1b54d
jmp 0x1b4ce
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x42006a, %esi         # imm = 0x42006A
callq 0x60e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1b506
movq -0x10(%rbp), %rdi
leaq 0xa1ad(%rip), %rsi      # 0x256a1
movl $0x24ba, %edx           # imm = 0x24BA
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b54d
jmp 0x1b508
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
addq $0x4, %rdx
movl $0x42006b, %esi         # imm = 0x42006B
callq 0x60e0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1b544
movq -0x10(%rbp), %rdi
leaq 0xa16f(%rip), %rsi      # 0x256a1
movl $0x24bd, %edx           # imm = 0x24BD
callq 0x6f20
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1b54d
jmp 0x1b546
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_memset.c
// Function: kmip_base_memset
void *
kmip_base_memset(void *ptr, int value, size_t size)
{
    if(ptr != NULL)
    {
        unsigned char *index = (unsigned char*)ptr;
        for(size_t i = 0; i < size; i++)
        {
            *index++ = (unsigned char)value;
        }
    }
    
    return(ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x23dc6
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x23dc4
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x23d96
jmp 0x23dc6
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: scg_destroy
void scg_destroy(scg_t *g)
{
    if (!g) return;
    if (g->utg_asmg) asmg_destroy(g->utg_asmg);
    if (g->scm_u) free(g->scm_u);
    if (g->idx_u) free(g->idx_u);
    free(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3d25
jmp 0x3d76
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d3d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1f9a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3d55
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3d6d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: scg_meta_clean
void scg_meta_clean(scg_meta_t *meta)
{
    if (!meta) return;
    scg_destroy(meta->scg);
    syncmer_db_destroy(meta->scm_db);
    sr_db_destroy(meta->sr_db);
    scg_ra_v_destroy(meta->ra_db);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3d95
jmp 0x3dc9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3d10
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x13dc0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x13cb0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x25e90
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: add_a_cov
static inline void add_a_cov(kh_u128_t *h, uint128_t v_p, uint64_t c)
{
    int absent;
    khint_t k;
    k = kh_u128_put(h, v_p, &absent);
    if (absent)
        kh_val(h, k) = 0;
    kh_val(h, k) += c;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x3c(%rbp), %rcx
callq 0xde40
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x4710
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x40(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x40(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: scg_is_empty
int scg_is_empty(scg_t *scg)
{
    uint64_t i, n, n_scm;
    syncmer_t *scm;
    scm = scg_a_scm(scg);
    n_scm = scg_n_scm(scg);
    for (i = 0, n = n_scm; i < n; ++i)
        if (scm[i].del) --n_scm;
    return n_scm == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x50e5
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
shrl $0x1f, %eax
cmpl $0x0, %eax
je 0x50d5
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x50d7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x50a5
cmpq $0x0, -0x20(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: scg_update_utg_cov
void scg_update_utg_cov(scg_t *scg)
{
    uint64_t i, n;
    scg_utg_t *s;
    asmg_t *utg_asmg = scg->utg_asmg;
    for (i = 0, n = utg_asmg->n_vtx; i < n; ++i) {
        s = &utg_asmg->vtx[i];
        s->cov = utg_avg_cov(scg, s);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5627
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
leaq (%rcx,%rcx,4), %rcx
leaq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5630
cvttsd2si %xmm0, %rax
movl %eax, %edx
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
andl $0xc0000000, %ecx       # imm = 0xC0000000
orl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x55cb
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/./graph.h
// Function: asmg_clean_consensus
static inline void asmg_clean_consensus(asmg_t *g)
{
    uint64_t i, n;
    for (i = 0, n = g->n_arc; i < n; ++i)
        g->arc[i].ls = 0;
    for (i = 0, n = g->n_vtx; i < n; ++i) {
        if (g->vtx[i].seq) {
            free(g->vtx[i].seq);
            g->vtx[i].seq = 0;
        }
        g->vtx[i].len = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5f70
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5f40
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5ffb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x5fd5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x10(%rbp), %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x5f83
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/./graph.h
// Function: asmg_arc
static inline asmg_arc_t *asmg_arc(asmg_t *g, uint64_t v, uint64_t w)
{
    uint64_t i, n;
    asmg_arc_t *a;

    a = asmg_arc_a(g, v);
    n = asmg_arc_n(g, v);
    for (i = 0; i < n; ++i)
        if (a[i].w == w)
            return &a[i];

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x18(%rbp), %rdx
imulq $0x30, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x701e
movq -0x38(%rbp), %rax
imulq $0x30, -0x28(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x700e
movq -0x38(%rbp), %rax
imulq $0x30, -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x7026
jmp 0x7010
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6fdc
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: process_mergeable_unitigs
void process_mergeable_unitigs(scg_t *g)
{
    // postprocessing for mergeable utgs
    asmg_t *utg_asmg;

    // make utgs from the unitig graph
    utg_asmg = asmg_unitigging(g->utg_asmg);

    // update utg
    asmg_destroy(g->utg_asmg);
    g->utg_asmg = utg_asmg;

    scg_scm_utg_index(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x220a0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1f9a0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
callq 0x4760
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/./graph.h
// Function: asmg_arc_n1
static inline uint64_t asmg_arc_n1(asmg_t *g, uint64_t v)
{
    uint64_t i, n, n1;
    asmg_arc_t *a;

    a = asmg_arc_a(g, v);
    n = asmg_arc_n(g, v);
    n1 = n;
    for (i = 0; i < n; ++i)
        if (a[i].del)
            --n1;

    return n1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x10(%rbp), %rdx
imulq $0x30, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x97d0
movq -0x30(%rbp), %rax
imulq $0x30, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x97c0
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x97c2
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9790
movq -0x28(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)