LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x27, %rax
ja 0x11996
leaq 0x67b9(%rip), %rsi      # 0x1813d
movq %rbx, %rdi
movl $0x24ad, %edx           # imm = 0x24AD
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x11a14
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x24b4, %edx           # imm = 0x24B4
cmpl $0x42006900, %ecx       # imm = 0x42006900
jne 0x119fe
cmpb $0x1, %al
jne 0x11a02
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
cmpl $0x20, (%r15)
jne 0x11a21
movq %rbx, %rdi
movl $0x42006a, %esi         # imm = 0x42006A
movq %r14, %rdx
callq 0x60d0
testl %eax, %eax
je 0x11a2b
movl %eax, %ebp
movl $0x24ba, %edx           # imm = 0x24BA
jmp 0x11a05
pushq $-0x4
jmp 0x11a04
pushq $-0x5
popq %rbp
leaq 0x6731(%rip), %rsi      # 0x1813d
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x6
popq %rbp
movl $0x24b7, %edx           # imm = 0x24B7
jmp 0x11a05
addq $0x4, %r14
movq %rbx, %rdi
movl $0x42006b, %esi         # imm = 0x42006B
movq %r14, %rdx
callq 0x60d0
testl %eax, %eax
je 0x11a4c
movl %eax, %ebp
movl $0x24bd, %edx           # imm = 0x24BD
jmp 0x11a05
xorl %ebp, %ebp
jmp 0x11a14
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_transparent_symmetric_key
int
kmip_decode_transparent_symmetric_key(KMIP *ctx, TransparentSymmetricKey *value)
{
    CHECK_BUFFER_FULL(ctx, 8);
    
    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_KEY_MATERIAL, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_BUFFER_FULL(ctx, length);
    
    value->key = ctx->calloc_func(ctx->state, 1, sizeof(ByteString));
    CHECK_NEW_MEMORY(ctx, value->key, sizeof(ByteString), "Key byte string");
    
    result = kmip_decode_byte_string(ctx, KMIP_TAG_KEY, value->key);
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x11a84
leaq 0x66e8(%rip), %rsi      # 0x1815a
movq %rbx, %rdi
movl $0x24c5, %edx           # imm = 0x24C5
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x11afc
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x24cc, %edx           # imm = 0x24CC
cmpl $0x42004300, %ecx       # imm = 0x42004300
jne 0x11ae6
cmpb $0x1, %al
jne 0x11aea
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl (%r15), %ecx
cmpq %rcx, %rax
jae 0x11b09
pushq $-0x2
popq %rbp
movl $0x24cf, %edx           # imm = 0x24CF
jmp 0x11aed
pushq $-0x4
jmp 0x11aec
pushq $-0x5
popq %rbp
leaq 0x6666(%rip), %rsi      # 0x1815a
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x11b41
movq %rbx, %rdi
movl $0x42003f, %esi         # imm = 0x42003F
movq %rax, %rdx
callq 0x6d60
testl %eax, %eax
je 0x11b5d
movl %eax, %ebp
movl $0x24d5, %edx           # imm = 0x24D5
jmp 0x11aed
leaq 0x6638(%rip), %rdx      # 0x18180
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x24d2, %edx           # imm = 0x24D2
jmp 0x11aed
xorl %ebp, %ebp
jmp 0x11afc
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_symmetric_key
int
kmip_decode_symmetric_key(KMIP *ctx, SymmetricKey *value)
{
    CHECK_BUFFER_FULL(ctx, 8);
    
    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_SYMMETRIC_KEY, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_BUFFER_FULL(ctx, length);
    
    value->key_block = ctx->calloc_func(ctx->state, 1, sizeof(KeyBlock));
    CHECK_NEW_MEMORY(ctx, value->key_block, sizeof(KeyBlock), "KeyBlock structure");
    
    result = kmip_decode_key_block(ctx, value->key_block);
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x12787
leaq 0x5d17(%rip), %rsi      # 0x1848c
movq %rbx, %rdi
movl $0x26c9, %edx           # imm = 0x26C9
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x127ff
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x26d0, %edx           # imm = 0x26D0
cmpl $0x42008f00, %ecx       # imm = 0x42008F00
jne 0x127e9
cmpb $0x1, %al
jne 0x127ed
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl (%r15), %ecx
cmpq %rcx, %rax
jae 0x1280c
pushq $-0x2
popq %rbp
movl $0x26d3, %edx           # imm = 0x26D3
jmp 0x127f0
pushq $-0x4
jmp 0x127ef
pushq $-0x5
popq %rbp
leaq 0x5c95(%rip), %rsi      # 0x1848c
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x28
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x1283f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6510
testl %eax, %eax
je 0x1285b
movl %eax, %ebp
movl $0x26d9, %edx           # imm = 0x26D9
jmp 0x127f0
leaq 0x5c60(%rip), %rdx      # 0x184a6
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x26d6, %edx           # imm = 0x26D6
jmp 0x127f0
xorl %ebp, %ebp
jmp 0x127ff
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_public_key
int
kmip_decode_public_key(KMIP *ctx, PublicKey *value)
{
    CHECK_BUFFER_FULL(ctx, 8);
    
    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_PUBLIC_KEY, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_BUFFER_FULL(ctx, length);
    
    value->key_block = ctx->calloc_func(ctx->state, 1, sizeof(KeyBlock));
    CHECK_NEW_MEMORY(ctx, value->key_block, sizeof(KeyBlock), "KeyBlock structure");
    
    result = kmip_decode_key_block(ctx, value->key_block);
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x12893
leaq 0x5c38(%rip), %rsi      # 0x184b9
movq %rbx, %rdi
movl $0x26e1, %edx           # imm = 0x26E1
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x1290b
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x26e8, %edx           # imm = 0x26E8
cmpl $0x42006d00, %ecx       # imm = 0x42006D00
jne 0x128f5
cmpb $0x1, %al
jne 0x128f9
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl (%r15), %ecx
cmpq %rcx, %rax
jae 0x12918
pushq $-0x2
popq %rbp
movl $0x26eb, %edx           # imm = 0x26EB
jmp 0x128fc
pushq $-0x4
jmp 0x128fb
pushq $-0x5
popq %rbp
leaq 0x5bb6(%rip), %rsi      # 0x184b9
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x28
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x1294b
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6510
testl %eax, %eax
je 0x12967
movl %eax, %ebp
movl $0x26f1, %edx           # imm = 0x26F1
jmp 0x128fc
leaq 0x5b54(%rip), %rdx      # 0x184a6
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x26ee, %edx           # imm = 0x26EE
jmp 0x128fc
xorl %ebp, %ebp
jmp 0x1290b
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_private_key
int
kmip_decode_private_key(KMIP *ctx, PrivateKey *value)
{
    CHECK_BUFFER_FULL(ctx, 8);
    
    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_PRIVATE_KEY, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_BUFFER_FULL(ctx, length);
    
    value->key_block = ctx->calloc_func(ctx->state, 1, sizeof(KeyBlock));
    CHECK_NEW_MEMORY(ctx, value->key_block, sizeof(KeyBlock), "KeyBlock structure");
    
    result = kmip_decode_key_block(ctx, value->key_block);
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x1299f
leaq 0x5b43(%rip), %rsi      # 0x184d0
movq %rbx, %rdi
movl $0x26f9, %edx           # imm = 0x26F9
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x12a17
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x2700, %edx           # imm = 0x2700
cmpl $0x42006400, %ecx       # imm = 0x42006400
jne 0x12a01
cmpb $0x1, %al
jne 0x12a05
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl (%r15), %ecx
cmpq %rcx, %rax
jae 0x12a24
pushq $-0x2
popq %rbp
movl $0x2703, %edx           # imm = 0x2703
jmp 0x12a08
pushq $-0x4
jmp 0x12a07
pushq $-0x5
popq %rbp
leaq 0x5ac1(%rip), %rsi      # 0x184d0
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x28
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x12a57
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6510
testl %eax, %eax
je 0x12a73
movl %eax, %ebp
movl $0x2709, %edx           # imm = 0x2709
jmp 0x12a08
leaq 0x5a48(%rip), %rdx      # 0x184a6
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2706, %edx           # imm = 0x2706
jmp 0x12a08
xorl %ebp, %ebp
jmp 0x12a17
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_destroy_request_payload
int
kmip_decode_destroy_request_payload(KMIP *ctx, DestroyRequestPayload *value)
{
    CHECK_BUFFER_FULL(ctx, 8);
    
    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_REQUEST_PAYLOAD, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_BUFFER_FULL(ctx, length);
    
    if(kmip_is_tag_next(ctx, KMIP_TAG_UNIQUE_IDENTIFIER))
    {
        value->unique_identifier = ctx->calloc_func(ctx->state, 1, sizeof(TextString));
        CHECK_NEW_MEMORY(ctx, value->unique_identifier, sizeof(TextString), "UniqueIdentifier text string");
        result = kmip_decode_text_string(ctx, KMIP_TAG_UNIQUE_IDENTIFIER, value->unique_identifier);
        CHECK_RESULT(ctx, result);
    }
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x1382b
leaq 0x4e66(%rip), %rsi      # 0x1867f
movq %rbx, %rdi
movl $0x2839, %edx           # imm = 0x2839
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x138a3
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x2840, %edx           # imm = 0x2840
cmpl $0x42007900, %ecx       # imm = 0x42007900
jne 0x1388d
cmpb $0x1, %al
jne 0x13891
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl (%r15), %ecx
cmpq %rcx, %rax
jae 0x138b0
pushq $-0x2
popq %rbp
movl $0x2843, %edx           # imm = 0x2843
jmp 0x13894
pushq $-0x4
jmp 0x13893
pushq $-0x5
popq %rbp
leaq 0x4de4(%rip), %rsi      # 0x1867f
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x420094, %esi         # imm = 0x420094
callq 0x62d0
xorl %ebp, %ebp
testl %eax, %eax
je 0x138a3
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x138fb
movq %rbx, %rdi
movl $0x420094, %esi         # imm = 0x420094
movq %rax, %rdx
callq 0x6560
testl %eax, %eax
je 0x138a3
movl $0x284a, %edx           # imm = 0x284A
movl %eax, %ebp
jmp 0x13894
leaq 0x4617(%rip), %rdx      # 0x17f19
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2848, %edx           # imm = 0x2848
jmp 0x13894
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_destroy_response_payload
int
kmip_decode_destroy_response_payload(KMIP *ctx, DestroyResponsePayload *value)
{
    CHECK_BUFFER_FULL(ctx, 8);
    
    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_RESPONSE_PAYLOAD, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_BUFFER_FULL(ctx, length);
    
    value->unique_identifier = ctx->calloc_func(ctx->state, 1, sizeof(TextString));
    CHECK_NEW_MEMORY(ctx, value->unique_identifier, sizeof(TextString), "UniqueIdentifier text string");
    
    result = kmip_decode_text_string(ctx, KMIP_TAG_UNIQUE_IDENTIFIER, value->unique_identifier);
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x1394e
leaq 0x4d67(%rip), %rsi      # 0x186a3
movq %rbx, %rdi
movl $0x2853, %edx           # imm = 0x2853
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x139c6
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x285a, %edx           # imm = 0x285A
cmpl $0x42007c00, %ecx       # imm = 0x42007C00
jne 0x139b0
cmpb $0x1, %al
jne 0x139b4
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl (%r15), %ecx
cmpq %rcx, %rax
jae 0x139d3
pushq $-0x2
popq %rbp
movl $0x285d, %edx           # imm = 0x285D
jmp 0x139b7
pushq $-0x4
jmp 0x139b6
pushq $-0x5
popq %rbp
leaq 0x4ce5(%rip), %rsi      # 0x186a3
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x13a0b
movq %rbx, %rdi
movl $0x420094, %esi         # imm = 0x420094
movq %rax, %rdx
callq 0x6560
testl %eax, %eax
je 0x13a27
movl %eax, %ebp
movl $0x2863, %edx           # imm = 0x2863
jmp 0x139b7
leaq 0x4507(%rip), %rdx      # 0x17f19
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2860, %edx           # imm = 0x2860
jmp 0x139b7
xorl %ebp, %ebp
jmp 0x139c6
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_query_request_payload
int
kmip_decode_query_request_payload(KMIP *ctx, QueryRequestPayload *value)
{
    CHECK_DECODE_ARGS(ctx, value);
    CHECK_BUFFER_FULL(ctx, 8);

    int result = 0;
    int32 tag_type = 0;
    uint32 length = 0;

    result = kmip_decode_int32_be(ctx, &tag_type);
    CHECK_RESULT(ctx, result);
    CHECK_TAG_TYPE(ctx, tag_type, KMIP_TAG_QUERY_FUNCTION, KMIP_TYPE_STRUCTURE);

    result = kmip_decode_int32_be(ctx, &length);
    CHECK_RESULT(ctx, result);
    CHECK_BUFFER_FULL(ctx, length);

    if(kmip_is_tag_next(ctx, KMIP_TAG_QUERY_FUNCTION))
    {
        value->functions = ctx->calloc_func(ctx->state, 1, sizeof(Functions));
        CHECK_NEW_MEMORY(ctx, value->functions, sizeof(Functions), "Functions");

        result = kmip_decode_query_functions(ctx, value->functions);
        CHECK_RESULT(ctx, result);
    }

    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x13d86
pushq $-0x11
jmp 0x13db0
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x13db3
leaq 0x4eef(%rip), %rsi      # 0x18c90
movq %rbx, %rdi
movl $0x2b50, %edx           # imm = 0x2B50
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x13e25
movq %rsi, %r14
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
andl $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x6a80
testl %eax, %eax
je 0x13dd8
movl %eax, %ebp
movl $0x2b57, %edx           # imm = 0x2B57
jmp 0x13e16
movl 0xc(%rsp), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x2b58, %edx           # imm = 0x2B58
cmpl $0x42007400, %ecx       # imm = 0x42007400
jne 0x13e0f
cmpb $0x1, %al
jne 0x13e13
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6a80
testl %eax, %eax
je 0x13e30
movl %eax, %ebp
movl $0x2b5b, %edx           # imm = 0x2B5B
jmp 0x13e16
pushq $-0x4
jmp 0x13e15
pushq $-0x5
popq %rbp
leaq 0x4e73(%rip), %rsi      # 0x18c90
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl 0x8(%rsp), %ecx
cmpq %rcx, %rax
jae 0x13e4e
pushq $-0x2
popq %rbp
movl $0x2b5c, %edx           # imm = 0x2B5C
jmp 0x13e16
movq %rbx, %rdi
movl $0x420074, %esi         # imm = 0x420074
callq 0x62d0
xorl %ebp, %ebp
testl %eax, %eax
je 0x13e25
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x8
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x13e94
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6c30
testl %eax, %eax
je 0x13e25
movl $0x2b64, %edx           # imm = 0x2B64
movl %eax, %ebp
jmp 0x13e16
leaq 0x4e17(%rip), %rdx      # 0x18cb2
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b61, %edx           # imm = 0x2B61
jmp 0x13e16
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_nonce
int
kmip_decode_nonce(KMIP *ctx, Nonce *value)
{
    CHECK_BUFFER_FULL(ctx, 8);
    
    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_NONCE, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_BUFFER_FULL(ctx, length);
    
    value->nonce_id = ctx->calloc_func(ctx->state, 1, sizeof(ByteString));
    CHECK_NEW_MEMORY(ctx, value->nonce_id, sizeof(ByteString), "NonceID byte string");
    
    result = kmip_decode_byte_string(ctx, KMIP_TAG_NONCE_ID, value->nonce_id);
    CHECK_RESULT(ctx, result);
    
    value->nonce_value = ctx->calloc_func(ctx->state, 1, sizeof(ByteString));
    CHECK_NEW_MEMORY(ctx, value->nonce_value, sizeof(ByteString), "NonceValue byte string");
    
    result = kmip_decode_byte_string(ctx, KMIP_TAG_NONCE_VALUE, value->nonce_value);
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x14615
leaq 0x425c(%rip), %rsi      # 0x1885e
movq %rbx, %rdi
movl $0x2918, %edx           # imm = 0x2918
callq 0x6e80
pushq $-0x2
popq %r15
jmp 0x14691
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x291f, %ebp           # imm = 0x291F
cmpl $0x4200c800, %ecx       # imm = 0x4200C800
jne 0x14678
cmpb $0x1, %al
jne 0x1467c
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl (%r15), %ecx
cmpq %rcx, %rax
jae 0x1469f
pushq $-0x2
popq %r15
movl $0x2922, %ebp           # imm = 0x2922
jmp 0x14680
pushq $-0x4
jmp 0x1467e
pushq $-0x5
popq %r15
leaq 0x41d7(%rip), %rsi      # 0x1885e
movq %rbx, %rdi
movl %ebp, %edx
callq 0x6e80
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x146d8
movq %rbx, %rdi
movl $0x4200c9, %esi         # imm = 0x4200C9
movq %rax, %rdx
callq 0x6d60
testl %eax, %eax
je 0x146f3
movl %eax, %r15d
movl $0x2928, %ebp           # imm = 0x2928
jmp 0x14680
movl $0x2925, %ebp           # imm = 0x2925
leaq 0x418c(%rip), %rdx      # 0x18870
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
jmp 0x1467e
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq *0x868(%rbx)
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x14730
movq %rbx, %rdi
movl $0x4200ca, %esi         # imm = 0x4200CA
movq %rax, %rdx
callq 0x6d60
testl %eax, %eax
je 0x1473e
movl %eax, %r15d
movl $0x292e, %ebp           # imm = 0x292E
jmp 0x14680
movl $0x292b, %ebp           # imm = 0x292B
leaq 0x4148(%rip), %rdx      # 0x18884
jmp 0x146e4
xorl %r15d, %r15d
jmp 0x14691
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_credential_value
int
kmip_decode_credential_value(KMIP *ctx, enum credential_type type, void **value)
{
    int result = 0;
    
    switch(type)
    {
        case KMIP_CRED_USERNAME_AND_PASSWORD:
        *value = ctx->calloc_func(ctx->state, 1, sizeof(UsernamePasswordCredential));
        CHECK_NEW_MEMORY(ctx, *value, sizeof(UsernamePasswordCredential), "UsernamePasswordCredential structure");
        result = kmip_decode_username_password_credential(ctx, (UsernamePasswordCredential *)*value);
        break;
        
        case KMIP_CRED_DEVICE:
        *value = ctx->calloc_func(ctx->state, 1, sizeof(DeviceCredential));
        CHECK_NEW_MEMORY(ctx, *value, sizeof(DeviceCredential), "DeviceCredential structure");
        result = kmip_decode_device_credential(ctx, (DeviceCredential *)*value);
        break;
        
        case KMIP_CRED_ATTESTATION:
        *value = ctx->calloc_func(ctx->state, 1, sizeof(AttestationCredential));
        CHECK_NEW_MEMORY(ctx, *value, sizeof(AttestationCredential), "AttestationCredential structure");
        result = kmip_decode_attestation_credential(ctx, (AttestationCredential*)*value);
        break;
        
        default:
        kmip_push_error_frame(ctx, __func__, __LINE__);
        return(KMIP_NOT_IMPLEMENTED);
        break;
    }
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
cmpl $0x3, %esi
je 0x14e8f
cmpl $0x2, %esi
je 0x14e67
cmpl $0x1, %esi
jne 0x14ed4
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x14f36
movq %rbx, %rdi
movq %rax, %rsi
callq 0x66f0
jmp 0x14eb5
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x30
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x14ef0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6730
jmp 0x14eb5
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x20
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x14f13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x67a0
movl %eax, %ebp
testl %eax, %eax
je 0x14eec
leaq 0x3b7a(%rip), %rsi      # 0x18a3c
movq %rbx, %rdi
movl $0x29e8, %edx           # imm = 0x29E8
callq 0x6e80
jmp 0x14f5f
leaq 0x3b61(%rip), %rsi      # 0x18a3c
movq %rbx, %rdi
movl $0x29e4, %edx           # imm = 0x29E4
callq 0x6e80
pushq $-0x1
jmp 0x14f5e
xorl %ebp, %ebp
jmp 0x14f5f
leaq 0x3b62(%rip), %rdx      # 0x18a59
pushq $0x30
popq %rsi
movq %rbx, %rdi
callq 0x6c40
leaq 0x3b33(%rip), %rsi      # 0x18a3c
movq %rbx, %rdi
movl $0x29d9, %edx           # imm = 0x29D9
jmp 0x14f57
leaq 0x3b5a(%rip), %rdx      # 0x18a74
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x6c40
leaq 0x3b10(%rip), %rsi      # 0x18a3c
movq %rbx, %rdi
movl $0x29df, %edx           # imm = 0x29DF
jmp 0x14f57
leaq 0x3ada(%rip), %rdx      # 0x18a17
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6c40
leaq 0x3aed(%rip), %rsi      # 0x18a3c
movq %rbx, %rdi
movl $0x29d3, %edx           # imm = 0x29D3
callq 0x6e80
pushq $-0xc
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_credential
int
kmip_decode_credential(KMIP *ctx, Credential *value)
{
    CHECK_BUFFER_FULL(ctx, 8);
    
    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_CREDENTIAL, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_BUFFER_FULL(ctx, length);
    
    result = kmip_decode_enum(ctx, KMIP_TAG_CREDENTIAL_TYPE, &value->credential_type);
    CHECK_RESULT(ctx, result);
    CHECK_ENUM(ctx, KMIP_TAG_CREDENTIAL_TYPE, value->credential_type);
    
    result = kmip_decode_credential_value(ctx, value->credential_type, &value->credential_value);
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x14f9a
leaq 0x3b0c(%rip), %rsi      # 0x18a94
movq %rbx, %rdi
movl $0x29f0, %edx           # imm = 0x29F0
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x15012
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x29f7, %edx           # imm = 0x29F7
cmpl $0x42002300, %ecx       # imm = 0x42002300
jne 0x14ffc
cmpb $0x1, %al
jne 0x15000
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl (%r15), %ecx
cmpq %rcx, %rax
jae 0x1501f
pushq $-0x2
popq %rbp
movl $0x29fa, %edx           # imm = 0x29FA
jmp 0x15003
pushq $-0x4
jmp 0x15002
pushq $-0x5
popq %rbp
leaq 0x3a8a(%rip), %rsi      # 0x18a94
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x420024, %esi         # imm = 0x420024
movq %r14, %rdx
callq 0x6b70
testl %eax, %eax
je 0x1503c
movl %eax, %ebp
movl $0x29fd, %edx           # imm = 0x29FD
jmp 0x15003
movl 0x18(%rbx), %edi
movl (%r14), %r15d
movl $0x420024, %esi         # imm = 0x420024
movl %r15d, %edx
callq 0x6370
testl %eax, %eax
je 0x1506e
movl %eax, %ebp
movq %rbx, %rdi
movl $0x420024, %esi         # imm = 0x420024
movl %r15d, %edx
movl %eax, %ecx
callq 0x6120
movl $0x29fe, %edx           # imm = 0x29FE
jmp 0x15003
addq $0x8, %r14
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x6bc0
testl %eax, %eax
je 0x15090
movl %eax, %ebp
movl $0x2a01, %edx           # imm = 0x2A01
jmp 0x15003
xorl %ebp, %ebp
jmp 0x15012
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_authentication
int
kmip_decode_authentication(KMIP *ctx, Authentication *value)
{
    CHECK_BUFFER_FULL(ctx, 8);
    
    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_AUTHENTICATION, KMIP_TYPE_STRUCTURE);
    
    kmip_decode_length(ctx, &length);
    CHECK_BUFFER_FULL(ctx, length);
    
    value->credential = ctx->calloc_func(ctx->state, 1, sizeof(Credential));
    CHECK_NEW_MEMORY(ctx, value->credential, sizeof(Credential), "Credential structure");
    
    result = kmip_decode_credential(ctx, value->credential);
    CHECK_RESULT(ctx, result);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x7, %rax
ja 0x150cb
leaq 0x39f2(%rip), %rsi      # 0x18aab
movq %rbx, %rdi
movl $0x2a09, %edx           # imm = 0x2A09
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0x15143
movq %rsi, %r14
leaq 0x4(%rsp), %r15
andl $0x0, (%r15)
andl $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6a80
movl (%r15), %eax
movl %eax, %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl $0x2a10, %edx           # imm = 0x2A10
cmpl $0x42000c00, %ecx       # imm = 0x42000C00
jne 0x1512d
cmpb $0x1, %al
jne 0x15131
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x64d0
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq (%rbx), %rax
movl (%r15), %ecx
cmpq %rcx, %rax
jae 0x15150
pushq $-0x2
popq %rbp
movl $0x2a13, %edx           # imm = 0x2A13
jmp 0x15134
pushq $-0x4
jmp 0x15133
pushq $-0x5
popq %rbp
leaq 0x3970(%rip), %rsi      # 0x18aab
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x15183
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6e00
testl %eax, %eax
je 0x1519f
movl %eax, %ebp
movl $0x2a19, %edx           # imm = 0x2A19
jmp 0x15134
leaq 0x389d(%rip), %rdx      # 0x18a27
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2a16, %edx           # imm = 0x2A16
jmp 0x15134
xorl %ebp, %ebp
jmp 0x15143
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_query_functions
int
kmip_decode_query_functions(KMIP *ctx, Functions* value)
{
    int result = 0;
    uint32 tag = kmip_peek_tag(ctx);

    value->function_list = ctx->calloc_func(ctx->state, 1, sizeof(LinkedList));
    CHECK_NEW_MEMORY(ctx, value->function_list, sizeof(LinkedList), "LinkedList");

    while(tag == KMIP_TAG_QUERY_FUNCTION)
    {
        LinkedListItem *item = ctx->calloc_func(ctx->state, 1, sizeof(LinkedListItem));
        CHECK_NEW_MEMORY(ctx, item, sizeof(LinkedListItem), "LinkedListItem");
        kmip_linked_list_enqueue(value->function_list, item);

        item->data = ctx->calloc_func(ctx->state, 1, sizeof(int32));
        CHECK_NEW_MEMORY(ctx, item->data, sizeof(int32), "Query Function");

        result = kmip_decode_enum(ctx, KMIP_TAG_QUERY_FUNCTION, (int32 *)item->data);
        CHECK_RESULT(ctx, result);

        tag = kmip_peek_tag(ctx);
    }

    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x69b0
movl %eax, %ebp
movq 0x890(%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x15e9a
pushq $0x1
popq %r15
pushq $0x18
popq %r12
pushq $0x4
popq %r13
cmpl $0x420074, %ebp         # imm = 0x420074
jne 0x15eb6
movq 0x890(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x868(%rbx)
testq %rax, %rax
je 0x15eba
movq %rax, %rbp
movq (%r14), %rdi
movq %rax, %rsi
callq 0x6770
movq 0x890(%rbx), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x868(%rbx)
movq %rax, 0x10(%rbp)
testq %rax, %rax
je 0x15ed6
movq %rbx, %rdi
movl $0x420074, %esi         # imm = 0x420074
movq %rax, %rdx
callq 0x6b70
testl %eax, %eax
jne 0x15ef2
movq %rbx, %rdi
callq 0x69b0
movl %eax, %ebp
jmp 0x15e30
leaq 0x2004(%rip), %rdx      # 0x17ea5
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b38, %edx           # imm = 0x2B38
jmp 0x15ef9
xorl %ebp, %ebp
jmp 0x15f08
leaq 0x1fef(%rip), %rdx      # 0x17eb0
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b3d, %edx           # imm = 0x2B3D
jmp 0x15ef9
leaq 0x2da4(%rip), %rdx      # 0x18c81
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b41, %edx           # imm = 0x2B41
jmp 0x15ef9
movl %eax, %ebp
movl $0x2b44, %edx           # imm = 0x2B44
leaq 0x2d65(%rip), %rsi      # 0x18c65
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_operations
int
kmip_decode_operations(KMIP *ctx, Operations *value)
{
    int result = 0;

    value->operation_list = ctx->calloc_func(ctx->state, 1, sizeof(LinkedList));
    CHECK_NEW_MEMORY(ctx, value->operation_list, sizeof(LinkedList), "LinkedList");

    uint32 tag = kmip_peek_tag(ctx);
    while(tag == KMIP_TAG_OPERATION)
    {
        LinkedListItem *item = ctx->calloc_func(ctx->state, 1, sizeof(LinkedListItem));
        CHECK_NEW_MEMORY(ctx, item, sizeof(LinkedListItem), "LinkedListItem");
        kmip_linked_list_enqueue(value->operation_list, item);

        item->data = ctx->calloc_func(ctx->state, 1, sizeof(int32));
        CHECK_NEW_MEMORY(ctx, item->data, sizeof(int32), "Operation");


        result = kmip_decode_enum(ctx, KMIP_TAG_OPERATION, (int32 *)item->data);
        CHECK_RESULT(ctx, result);

        tag = kmip_peek_tag(ctx);
    }

    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x890(%rdi), %rdi
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x15fbf
pushq $0x1
popq %r15
pushq $0x18
popq %r12
pushq $0x4
popq %r13
movq %rbx, %rdi
callq 0x69b0
cmpl $0x42005c, %eax         # imm = 0x42005C
jne 0x15fdb
movq 0x890(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x868(%rbx)
testq %rax, %rax
je 0x15fdf
movq %rax, %rbp
movq (%r14), %rdi
movq %rax, %rsi
callq 0x6770
movq 0x890(%rbx), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x868(%rbx)
movq %rax, 0x10(%rbp)
testq %rax, %rax
je 0x15ffb
movq %rbx, %rdi
movl $0x42005c, %esi         # imm = 0x42005C
movq %rax, %rdx
callq 0x6b70
testl %eax, %eax
je 0x15f51
movl %eax, %ebp
movl $0x2b7f, %edx           # imm = 0x2B7F
jmp 0x16015
leaq 0x1edf(%rip), %rdx      # 0x17ea5
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b71, %edx           # imm = 0x2B71
jmp 0x16015
xorl %ebp, %ebp
jmp 0x16024
leaq 0x1eca(%rip), %rdx      # 0x17eb0
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b77, %edx           # imm = 0x2B77
jmp 0x16015
leaq 0x2cd1(%rip), %rdx      # 0x18cd3
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b7b, %edx           # imm = 0x2B7B
leaq 0x2ca0(%rip), %rsi      # 0x18cbc
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_object_types
int
kmip_decode_object_types(KMIP *ctx, ObjectTypes *value)
{
    int result = 0;

    value->object_list = ctx->calloc_func(ctx->state, 1, sizeof(LinkedList));
    CHECK_NEW_MEMORY(ctx, value->object_list, sizeof(LinkedList), "LinkedList");

    uint32 tag = kmip_peek_tag(ctx);
    while(tag == KMIP_TAG_OBJECT_TYPE)
    {
        LinkedListItem *item = ctx->calloc_func(ctx->state, 1, sizeof(LinkedListItem));
        CHECK_NEW_MEMORY(ctx, item, sizeof(LinkedListItem), "LinkedListItem");
        kmip_linked_list_enqueue(value->object_list, item);

        item->data = ctx->calloc_func(ctx->state, 1, sizeof(int32));
        CHECK_NEW_MEMORY(ctx, item->data, sizeof(int32), "Object");

        result = kmip_decode_enum(ctx, KMIP_TAG_OBJECT_TYPE, (int32 *)item->data);
        CHECK_RESULT(ctx, result);

        tag = kmip_peek_tag(ctx);
    }

    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x890(%rdi), %rdi
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x160db
pushq $0x1
popq %r15
pushq $0x18
popq %r12
pushq $0x4
popq %r13
movq %rbx, %rdi
callq 0x69b0
cmpl $0x420057, %eax         # imm = 0x420057
jne 0x160f7
movq 0x890(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x868(%rbx)
testq %rax, %rax
je 0x160fb
movq %rax, %rbp
movq (%r14), %rdi
movq %rax, %rsi
callq 0x6770
movq 0x890(%rbx), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x868(%rbx)
movq %rax, 0x10(%rbp)
testq %rax, %rax
je 0x16117
movq %rbx, %rdi
movl $0x420057, %esi         # imm = 0x420057
movq %rax, %rdx
callq 0x6b70
testl %eax, %eax
je 0x1606d
movl %eax, %ebp
movl $0x2b9a, %edx           # imm = 0x2B9A
jmp 0x16131
leaq 0x1dc3(%rip), %rdx      # 0x17ea5
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b8d, %edx           # imm = 0x2B8D
jmp 0x16131
xorl %ebp, %ebp
jmp 0x16140
leaq 0x1dae(%rip), %rdx      # 0x17eb0
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b93, %edx           # imm = 0x2B93
jmp 0x16131
leaq 0x2bd8(%rip), %rdx      # 0x18cf6
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2b97, %edx           # imm = 0x2B97
leaq 0x2ba5(%rip), %rsi      # 0x18cdd
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_decode_alternative_endpoints
int
kmip_decode_alternative_endpoints(KMIP *ctx, AltEndpoints* value)
{
    int result = 0;

    value->endpoint_list = ctx->calloc_func(ctx->state, 1, sizeof(LinkedList));
    CHECK_NEW_MEMORY(ctx, value->endpoint_list, sizeof(LinkedList), "LinkedList");

    uint32 tag = kmip_peek_tag(ctx);
    while(tag == KMIP_TAG_ALTERNATE_FAILOVER_ENDPOINTS)
    {
        LinkedListItem *item = ctx->calloc_func(ctx->state, 1, sizeof(LinkedListItem));
        CHECK_NEW_MEMORY(ctx, item, sizeof(LinkedListItem), "LinkedListItem");
        kmip_linked_list_enqueue(value->endpoint_list, item);

        item->data = ctx->calloc_func(ctx->state, 1, sizeof(TextString));
        CHECK_NEW_MEMORY(ctx, item->data, sizeof(TextString), "Endpoint text string");

        result = kmip_decode_text_string(ctx, KMIP_TAG_ALTERNATE_FAILOVER_ENDPOINTS, item->data);
        CHECK_RESULT(ctx, result);

        tag = kmip_peek_tag(ctx);
    }

    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x890(%rdi), %rdi
pushq $0x1
popq %rsi
pushq $0x18
popq %rdx
callq *0x868(%rbx)
movq %rax, (%r14)
testq %rax, %rax
je 0x161f7
pushq $0x1
popq %r15
pushq $0x18
popq %r12
pushq $0x10
popq %r13
movq %rbx, %rdi
callq 0x69b0
cmpl $0x420135, %eax         # imm = 0x420135
jne 0x16213
movq 0x890(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x868(%rbx)
testq %rax, %rax
je 0x16217
movq %rax, %rbp
movq (%r14), %rdi
movq %rax, %rsi
callq 0x6770
movq 0x890(%rbx), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq *0x868(%rbx)
movq %rax, 0x10(%rbp)
testq %rax, %rax
je 0x16233
movq %rbx, %rdi
movl $0x420135, %esi         # imm = 0x420135
movq %rax, %rdx
callq 0x6560
testl %eax, %eax
je 0x16189
movl %eax, %ebp
movl $0x2bb5, %edx           # imm = 0x2BB5
jmp 0x1624d
leaq 0x1ca7(%rip), %rdx      # 0x17ea5
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2ba8, %edx           # imm = 0x2BA8
jmp 0x1624d
xorl %ebp, %ebp
jmp 0x1625c
leaq 0x1c92(%rip), %rdx      # 0x17eb0
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2bae, %edx           # imm = 0x2BAE
jmp 0x1624d
leaq 0x2ae5(%rip), %rdx      # 0x18d1f
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x6c40
pushq $-0xc
popq %rbp
movl $0x2bb2, %edx           # imm = 0x2BB2
leaq 0x2aa9(%rip), %rsi      # 0x18cfd
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x38e5
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3884
movq 0x10(%rbx), %rdi
callq 0xbab5
movq 0x18(%rbx), %rdi
callq 0xba3c
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x151dc
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq 0xc(%rsp), %r15
movq %r15, %rcx
callq 0x9aa9
movl %eax, %eax
imulq $0x18, %rax, %rax
cmpl $0x0, (%r15)
movq 0x10(%r14), %rcx
leaq 0x10(%rcx,%rax), %rdx
je 0x3d2c
andq $0x0, (%rdx)
xorl %edx, %edx
jmp 0x3d2f
movq (%rdx), %rdx
addq %rbx, %rdx
movq %rdx, 0x10(%rcx,%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq (%rdi), %rcx
movq (%rcx), %rax
movq 0x10(%rcx), %rcx
addq $0x10, %rcx
movq %rax, %rdx
subq $0x1, %rax
jb 0x42bd
movl (%rcx), %esi
sarl $0x1f, %esi
movslq %esi, %rsi
addq %rsi, %rdx
addq $0x20, %rcx
jmp 0x42a6
xorl %eax, %eax
testq %rdx, %rdx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/c-zhou[P]oatk/syncasm.c
// Function: scg_stat
void scg_stat(scg_t *scg, FILE *fo, uint64_t *stats)
{
    uint64_t i, n, n_scm, u_scm, n_utg, n_arc;
    syncmer_t *scm;
    asmg_t *utg_asmg;

    scm = scg_a_scm(scg);
    u_scm = scg_n_scm(scg);
    utg_asmg = scg->utg_asmg;
    n_utg = utg_asmg->n_vtx;
    n_arc = utg_asmg->n_arc;

    n_scm = 0;
    for (i = 0, n = u_scm; i < n; ++i)
        if (scm[i].del)
            --u_scm;
    for (i = 0, n = n_arc; i < n; ++i)
        if (utg_asmg->arc[i].del)
            --n_arc;
    for (i = 0, n = n_utg; i < n; ++i) {
        if (utg_asmg->vtx[i].del)
            --n_utg;
        else
            n_scm += utg_asmg->vtx[i].n;
    }

    if (fo != 0) {
        fprintf(fo, "[M::%s] number unitigs  : %lu\n", __func__, n_utg);
        fprintf(fo, "[M::%s] number syncmers : %lu\n", __func__, n_scm);
        fprintf(fo, "[M::%s] number arcs     : %lu\n", __func__, n_arc);
    }

    if (stats != 0) {
        stats[0] = n_scm;
        stats[1] = u_scm;
        stats[2] = n_utg;
        stats[3] = n_arc;
    }

    return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbp
movq %rsi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
movq (%rcx), %rsi
movq 0x10(%rcx), %rdi
movq (%rax), %rcx
movq 0x18(%rax), %rdx
addq $0x10, %rdi
movq %rsi, %r14
subq $0x1, %rsi
jb 0x430c
movl (%rdi), %r8d
sarl $0x1f, %r8d
movslq %r8d, %r8
addq %r8, %r14
addq $0x20, %rdi
jmp 0x42f3
pushq $0x20
popq %rsi
movq %rdx, %r15
subq $0x1, %rdx
jb 0x4330
movq 0x28(%rax), %rdi
movl (%rdi,%rsi), %edi
addl %edi, %edi
sarl $0x1f, %edi
movslq %edi, %rdi
addq %rdi, %r15
addq $0x30, %rsi
jmp 0x4312
pushq $0x20
popq %rdx
xorl %r12d, %r12d
movq %rcx, %r13
subq $0x1, %rcx
jb 0x435a
movq 0x10(%rax), %rsi
testb $0x40, 0x3(%rsi,%rdx)
jne 0x4351
addq -0x20(%rsi,%rdx), %r12
jmp 0x4354
decq %r13
addq $0x28, %rdx
jmp 0x4339
testq %rbx, %rbx
je 0x43b0
leaq 0x154ea(%rip), %rsi     # 0x19850
leaq 0x15502(%rip), %rdx     # 0x1986f
movq %rbx, %rdi
movq %r13, %rcx
xorl %eax, %eax
callq 0x2280
leaq 0x154f7(%rip), %rsi     # 0x19878
movq %rbx, %rdi
leaq 0x154e4(%rip), %rdx     # 0x1986f
movq %r12, %rcx
xorl %eax, %eax
callq 0x2280
leaq 0x154fb(%rip), %rsi     # 0x19897
movq %rbx, %rdi
leaq 0x154c9(%rip), %rdx     # 0x1986f
movq %r15, %rcx
xorl %eax, %eax
callq 0x2280
testq %rbp, %rbp
je 0x43c5
movq %r12, (%rbp)
movq %r14, 0x8(%rbp)
movq %r13, 0x10(%rbp)
movq %r15, 0x18(%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq (%r14), %r15
xorl %r12d, %r12d
movl $0xc0000000, %ebp       # imm = 0xC0000000
subq $0x1, %r15
jb 0x45e5
movq 0x10(%r14), %r13
leaq (%r12,%r13), %rsi
movq %rbx, %rdi
callq 0x45f4
cvttsd2si %xmm0, %rax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl 0x20(%r13,%r12), %ecx
andl %ebp, %ecx
orl %eax, %ecx
movl %ecx, 0x20(%r13,%r12)
addq $0x28, %r12
jmp 0x45b1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq