LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_query_functions
int
kmip_compare_query_functions(const Functions* a, const Functions* b)
{
    if(a != b )
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }

        if((a->function_list != b->function_list))
        {
            if((a->function_list == NULL) || (b->function_list == NULL))
            {
                return(KMIP_FALSE);
            }

            if((a->function_list->size != b->function_list->size))
            {
                return(KMIP_FALSE);
            }

            LinkedListItem *a_item = a->function_list->head;
            LinkedListItem *b_item = b->function_list->head;

            if (kmip_compare_linklist_items_int32(a_item, b_item) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }

    return(KMIP_TRUE);
}

// Assembly:
pushq %rbx
cmpq %rsi, %rdi
je 0xb306
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xb309
movq (%rdi), %rax
movq (%rsi), %rcx
cmpq %rcx, %rax
je 0xb306
testq %rax, %rax
sete %dl
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0xb309
movq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jne 0xb309
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0x63e0
testl %eax, %eax
je 0xb309
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_operations
int
kmip_compare_operations(const Operations *a, const Operations *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }

        if((a->operation_list != b->operation_list))
        {
            if((a->operation_list == NULL) || (b->operation_list == NULL))
            {
                return(KMIP_FALSE);
            }

            if((a->operation_list->size != b->operation_list->size))
            {
                return(KMIP_FALSE);
            }

            LinkedListItem *a_item = a->operation_list->head;
            LinkedListItem *b_item = b->operation_list->head;
            if (kmip_compare_linklist_items_int32(a_item, b_item) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }

    return(KMIP_TRUE);
}

// Assembly:
pushq %rbx
cmpq %rsi, %rdi
je 0xb35b
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xb35e
movq (%rdi), %rax
movq (%rsi), %rcx
cmpq %rcx, %rax
je 0xb35b
testq %rax, %rax
sete %dl
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0xb35e
movq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jne 0xb35e
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0x63e0
testl %eax, %eax
je 0xb35e
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_objects
int
kmip_compare_objects(const ObjectTypes *a, const ObjectTypes *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }

        if((a->object_list != b->object_list))
        {
            if((a->object_list == NULL) || (b->object_list == NULL))
            {
                return(KMIP_FALSE);
            }

            if((a->object_list->size != b->object_list->size))
            {
                return(KMIP_FALSE);
            }

            LinkedListItem *a_item = a->object_list->head;
            LinkedListItem *b_item = b->object_list->head;
            if (kmip_compare_linklist_items_int32(a_item, b_item) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }

    return(KMIP_TRUE);
}

// Assembly:
pushq %rbx
cmpq %rsi, %rdi
je 0xb3b0
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xb3b3
movq (%rdi), %rax
movq (%rsi), %rcx
cmpq %rcx, %rax
je 0xb3b0
testq %rax, %rax
sete %dl
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0xb3b3
movq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jne 0xb3b3
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0x63e0
testl %eax, %eax
je 0xb3b3
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_alternative_endpoints
int
kmip_compare_alternative_endpoints(const AltEndpoints* a, const AltEndpoints* b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }

        if((a->endpoint_list != b->endpoint_list))
        {
            if((a->endpoint_list == NULL) || (b->endpoint_list == NULL))
            {
                return(KMIP_FALSE);
            }

            if((a->endpoint_list->size != b->endpoint_list->size))
            {
                return(KMIP_FALSE);
            }

            LinkedListItem *a_item = a->endpoint_list->head;
            LinkedListItem *b_item = b->endpoint_list->head;
            if (kmip_compare_linklist_items_textstring(a_item, b_item) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }

    return(KMIP_TRUE);
}

// Assembly:
pushq %rbx
cmpq %rsi, %rdi
je 0xb405
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xb408
movq (%rdi), %rax
movq (%rsi), %rcx
cmpq %rcx, %rax
je 0xb405
testq %rax, %rax
sete %dl
testq %rcx, %rcx
sete %sil
orb %dl, %sil
jne 0xb408
movq 0x10(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jne 0xb408
movq (%rax), %rdi
movq (%rcx), %rsi
callq 0x6390
testl %eax, %eax
je 0xb408
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_server_information
int
kmip_compare_server_information(const ServerInformation* a, const ServerInformation* b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }

        if(kmip_compare_text_string(a->server_name, b->server_name) == KMIP_FALSE)
        {
            return(KMIP_FALSE);
        }

        if(kmip_compare_text_string(a->server_serial_number, b->server_serial_number) == KMIP_FALSE)
        {
            return(KMIP_FALSE);
        }

        if(kmip_compare_text_string(a->server_version, b->server_version) == KMIP_FALSE)
        {
            return(KMIP_FALSE);
        }

        if(kmip_compare_text_string(a->server_load, b->server_load) == KMIP_FALSE)
        {
            return(KMIP_FALSE);
        }
        if(kmip_compare_text_string(a->product_name, b->product_name) == KMIP_FALSE)
        {
            return(KMIP_FALSE);
        }
        if(kmip_compare_text_string(a->build_level, b->build_level) == KMIP_FALSE)
        {
            return(KMIP_FALSE);
        }
        if(kmip_compare_text_string(a->build_date, b->build_date) == KMIP_FALSE)
        {
            return(KMIP_FALSE);
        }

        if(a->alternative_failover_endpoints != b->alternative_failover_endpoints )
        {
            if(kmip_compare_alternative_endpoints(a->alternative_failover_endpoints, b->alternative_failover_endpoints) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }

//      if(a->vendor_specific != b->vendor_specific )
//      {
//          if(kmip_compare_vendor_specifi(a->vendor_specific, b->vendor_specific) == KMIP_FALSE)
//          {
//              return(KMIP_FALSE);
//          }
//      }

    }

    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xb4c1
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xb4c4
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x64a0
testl %eax, %eax
je 0xb4c4
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
callq 0x64a0
testl %eax, %eax
je 0xb4c4
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
callq 0x64a0
testl %eax, %eax
je 0xb4c4
movq 0x18(%r15), %rdi
movq 0x18(%r14), %rsi
callq 0x64a0
testl %eax, %eax
je 0xb4c4
movq 0x20(%r15), %rdi
movq 0x20(%r14), %rsi
callq 0x64a0
testl %eax, %eax
je 0xb4c4
movq 0x28(%r15), %rdi
movq 0x28(%r14), %rsi
callq 0x64a0
testl %eax, %eax
je 0xb4c4
movq 0x30(%r15), %rdi
movq 0x30(%r14), %rsi
callq 0x64a0
testl %eax, %eax
je 0xb4c4
movq 0x40(%r15), %rdi
movq 0x40(%r14), %rsi
cmpq %rsi, %rdi
je 0xb4c1
callq 0x6050
testl %eax, %eax
je 0xb4c4
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_int32_be
int
kmip_encode_int32_be(KMIP *ctx, int32 value)
{
    CHECK_BUFFER_FULL(ctx, sizeof(int32));

    uint32 v = *(uint32 *)((void *)(&value));

    *ctx->index++ = (uint8)((v & 0xFF000000) >> 24);
    *ctx->index++ = (uint8)((v & 0x00FF0000) >> 16);
    *ctx->index++ = (uint8)((v & 0x0000FF00) >> 8);
    *ctx->index++ = (uint8)((v & 0x000000FF) >> 0);

    return(KMIP_OK);
}

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
subq %rcx, %rdx
addq (%rdi), %rdx
cmpq $0x3, %rdx
ja 0xb532
pushq %rax
leaq 0xc0b1(%rip), %rsi      # 0x175d1
movl $0x180d, %edx           # imm = 0x180D
callq 0x6e80
pushq $-0x2
popq %rax
addq $0x8, %rsp
retq
movl %esi, %eax
movl %esi, %edx
shrl $0x18, %edx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x8(%rdi)
movb %dl, (%rcx)
movl %eax, %ecx
shrl $0x10, %ecx
movq 0x8(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rdi)
movb %cl, (%rdx)
movq 0x8(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movb %ah, (%rcx)
movq 0x8(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movb %al, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_int64_be
int
kmip_encode_int64_be(KMIP *ctx, int64 value)
{
    CHECK_BUFFER_FULL(ctx, sizeof(int64));

    uint64 v = *(uint64 *)((void *)(&value));

    *ctx->index++ = (uint8)((v & 0xFF00000000000000) >> 56);
    *ctx->index++ = (uint8)((v & 0x00FF000000000000) >> 48);
    *ctx->index++ = (uint8)((v & 0x0000FF0000000000) >> 40);
    *ctx->index++ = (uint8)((v & 0x000000FF00000000) >> 32);
    *ctx->index++ = (uint8)((v & 0x00000000FF000000) >> 24);
    *ctx->index++ = (uint8)((v & 0x0000000000FF0000) >> 16);
    *ctx->index++ = (uint8)((v & 0x000000000000FF00) >> 8);
    *ctx->index++ = (uint8)((v & 0x00000000000000FF) >> 0);
    
    return(KMIP_OK);
}

// Assembly:
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdx
subq %rcx, %rdx
addq (%rdi), %rdx
cmpq $0x7, %rdx
ja 0xb5a3
pushq %rax
leaq 0xc055(%rip), %rsi      # 0x175e6
movl $0x181c, %edx           # imm = 0x181C
callq 0x6e80
pushq $-0x2
popq %rax
addq $0x8, %rsp
retq
movq %rsi, %rax
movq %rsi, %rdx
shrq $0x38, %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x8(%rdi)
movb %dl, (%rcx)
movq %rax, %rcx
shrq $0x30, %rcx
movq 0x8(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rdi)
movb %cl, (%rdx)
movq %rax, %rcx
shrq $0x28, %rcx
movq 0x8(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rdi)
movb %cl, (%rdx)
movq %rax, %rcx
shrq $0x20, %rcx
movq 0x8(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rdi)
movb %cl, (%rdx)
movl %eax, %ecx
shrl $0x18, %ecx
movq 0x8(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rdi)
movb %cl, (%rdx)
movl %eax, %ecx
shrl $0x10, %ecx
movq 0x8(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x8(%rdi)
movb %cl, (%rdx)
movq 0x8(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movb %ah, (%rcx)
movq 0x8(%rdi), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rdi)
movb %al, (%rcx)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_integer
int
kmip_encode_integer(KMIP *ctx, enum tag t, int32 value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    kmip_encode_int32_be(ctx, TAG_TYPE(t, KMIP_TYPE_INTEGER));
    kmip_encode_int32_be(ctx, 4);
    kmip_encode_int32_be(ctx, value);
    kmip_encode_int32_be(ctx, 0);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0xf, %rax
ja 0xb66b
leaq 0xbfa2(%rip), %rsi      # 0x175fb
movq %rbx, %rdi
movl $0x182f, %edx           # imm = 0x182F
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0xb69c
movl %edx, %ebp
shll $0x8, %esi
orl $0x2, %esi
movq %rbx, %rdi
callq 0x60a0
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x60a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x60a0
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x60a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_long
int
kmip_encode_long(KMIP *ctx, enum tag t, int64 value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    kmip_encode_int32_be(ctx, TAG_TYPE(t, KMIP_TYPE_LONG_INTEGER));
    kmip_encode_int32_be(ctx, 8);
    kmip_encode_int64_be(ctx, value);
    
    return(KMIP_OK);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0xf, %rax
ja 0xb6d6
leaq 0xbf4b(%rip), %rsi      # 0x1760f
movq %rbx, %rdi
movl $0x183c, %edx           # imm = 0x183C
callq 0x6e80
pushq $-0x2
popq %rax
jmp 0xb6ff
movq %rdx, %r14
shll $0x8, %esi
orl $0x3, %esi
movq %rbx, %rdi
callq 0x60a0
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x60a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6950
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_enum
int
kmip_encode_enum(KMIP *ctx, enum tag t, int32 value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    kmip_encode_int32_be(ctx, TAG_TYPE(t, KMIP_TYPE_ENUMERATION));
    kmip_encode_int32_be(ctx, 4);
    kmip_encode_int32_be(ctx, value);
    kmip_encode_int32_be(ctx, 0);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0xf, %rax
ja 0xb737
leaq 0xbefb(%rip), %rsi      # 0x17620
movq %rbx, %rdi
movl $0x1848, %edx           # imm = 0x1848
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0xb768
movl %edx, %ebp
shll $0x8, %esi
orl $0x5, %esi
movq %rbx, %rdi
callq 0x60a0
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x60a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x60a0
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x60a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_bool
int
kmip_encode_bool(KMIP *ctx, enum tag t, bool32 value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    kmip_encode_int32_be(ctx, TAG_TYPE(t, KMIP_TYPE_BOOLEAN));
    kmip_encode_int32_be(ctx, 8);
    kmip_encode_int32_be(ctx, 0);
    kmip_encode_int32_be(ctx, value);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0xf, %rax
ja 0xb7a3
leaq 0xbea1(%rip), %rsi      # 0x17631
movq %rbx, %rdi
movl $0x1855, %edx           # imm = 0x1855
callq 0x6e80
pushq $-0x2
popq %r14
jmp 0xb7d5
movl %edx, %ebp
shll $0x8, %esi
orl $0x6, %esi
movq %rbx, %rdi
callq 0x60a0
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x60a0
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x60a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x60a0
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_text_string
int
kmip_encode_text_string(KMIP *ctx, enum tag t, const TextString *value)
{
    /* TODO (ph) What if value is NULL? */
    uint8 padding = CALCULATE_PADDING(value->size);
    CHECK_BUFFER_FULL(ctx, 8 + value->size + padding);
    
    kmip_encode_int32_be(ctx, TAG_TYPE(t, KMIP_TYPE_TEXT_STRING));
    kmip_encode_int32_be(ctx, value->size);
    
    for(uint32 i = 0; i < value->size; i++)
    {
        kmip_encode_int8_be(ctx, value->value[i]);
    }
    for(uint8 i = 0; i < padding; i++)
    {
        kmip_encode_int8_be(ctx, 0);
    }
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rax
movl %eax, %r15d
negb %r15b
movq 0x10(%rdi), %rcx
subq 0x8(%rdi), %rcx
addq (%rdi), %rcx
andb $0x7, %r15b
movzbl %r15b, %edx
addq %rdx, %rax
addq $0x8, %rax
cmpq %rax, %rcx
jae 0xb836
leaq 0xbe27(%rip), %rsi      # 0x17642
movq %rbx, %rdi
movl $0x1864, %edx           # imm = 0x1864
callq 0x6e80
pushq $-0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
shll $0x8, %esi
orl $0x7, %esi
movq %rbx, %rdi
callq 0x60a0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x60a0
xorl %eax, %eax
movl %eax, %r12d
cmpq %r12, 0x8(%r14)
jbe 0xb872
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x64e0
leal 0x1(%r12), %eax
jmp 0xb852
xorl %ebp, %ebp
subb $0x1, %r15b
jb 0xb82b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x64e0
jmp 0xb874
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_byte_string
int
kmip_encode_byte_string(KMIP *ctx, enum tag t, const ByteString *value)
{
    uint8 padding = CALCULATE_PADDING(value->size);
    CHECK_BUFFER_FULL(ctx, 8 + value->size + padding);
    
    kmip_encode_int32_be(ctx, TAG_TYPE(t, KMIP_TYPE_BYTE_STRING));
    kmip_encode_int32_be(ctx, value->size);
    
    for(uint32 i = 0; i < value->size; i++)
    {
        kmip_encode_int8_be(ctx, value->value[i]);
    }
    for(uint8 i = 0; i < padding; i++)
    {
        kmip_encode_int8_be(ctx, 0);
    }
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movq 0x8(%rdx), %rax
movl %eax, %r15d
negb %r15b
movq 0x10(%rdi), %rcx
subq 0x8(%rdi), %rcx
addq (%rdi), %rcx
andb $0x7, %r15b
movzbl %r15b, %edx
addq %rdx, %rax
addq $0x8, %rax
cmpq %rax, %rcx
jae 0xb8df
leaq 0xbd96(%rip), %rsi      # 0x1765a
movq %rbx, %rdi
movl $0x1879, %edx           # imm = 0x1879
callq 0x6e80
pushq $-0x2
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
shll $0x8, %esi
orl $0x8, %esi
movq %rbx, %rdi
callq 0x60a0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x60a0
xorl %eax, %eax
movl %eax, %r12d
cmpq %r12, 0x8(%r14)
jbe 0xb91b
movq (%r14), %rax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x64e0
leal 0x1(%r12), %eax
jmp 0xb8fb
xorl %ebp, %ebp
subb $0x1, %r15b
jb 0xb8d4
movq %rbx, %rdi
xorl %esi, %esi
callq 0x64e0
jmp 0xb91d
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_date_time
int
kmip_encode_date_time(KMIP *ctx, enum tag t, int64 value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    kmip_encode_int32_be(ctx, TAG_TYPE(t, KMIP_TYPE_DATE_TIME));
    kmip_encode_int32_be(ctx, 8);
    kmip_encode_int64_be(ctx, value);
    
    return(KMIP_OK);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0xf, %rax
ja 0xb960
leaq 0xbd24(%rip), %rsi      # 0x17672
movq %rbx, %rdi
movl $0x188d, %edx           # imm = 0x188D
callq 0x6e80
pushq $-0x2
popq %rax
jmp 0xb989
movq %rdx, %r14
shll $0x8, %esi
orl $0x9, %esi
movq %rbx, %rdi
callq 0x60a0
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0x60a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6950
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_interval
int
kmip_encode_interval(KMIP *ctx, enum tag t, uint32 value)
{
    CHECK_BUFFER_FULL(ctx, 16);
    
    kmip_encode_int32_be(ctx, TAG_TYPE(t, KMIP_TYPE_INTERVAL));
    kmip_encode_int32_be(ctx, 4);
    kmip_encode_int32_be(ctx, value);
    kmip_encode_int32_be(ctx, 0);
    
    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0xf, %rax
ja 0xb9c1
leaq 0xbcd9(%rip), %rsi      # 0x17688
movq %rbx, %rdi
movl $0x1899, %edx           # imm = 0x1899
callq 0x6e80
pushq $-0x2
popq %rbp
jmp 0xb9f2
movl %edx, %ebp
shll $0x8, %esi
orl $0xa, %esi
movq %rbx, %rdi
callq 0x60a0
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x60a0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x60a0
xorl %ebp, %ebp
movq %rbx, %rdi
xorl %esi, %esi
callq 0x60a0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_length
int
kmip_encode_length(KMIP *ctx, intptr length)
{
    // NOTE: Length is encoded as a signed 32-bit integer but the usage of this
    // function uses the difference between two buffer pointers to determine
    // the length in bytes that should be encoded. See the intptr typedef in
    // the header for type details.
    int result = 0;

    if((length > INT_MAX) || (length < 0))
    {
        HANDLE_FAILURE(ctx, KMIP_INVALID_LENGTH);
    }
    else
    {
        result = kmip_encode_int32_be(ctx, (int32)length);
        CHECK_RESULT(ctx, result);
    }

    return(KMIP_OK);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x7fffffff, %rsi       # imm = 0x7FFFFFFF
jbe 0xba14
pushq $-0x15
popq %rbp
movl $0x18ae, %edx           # imm = 0x18AE
jmp 0xba27
movq %rbx, %rdi
callq 0x60a0
testl %eax, %eax
je 0xba3f
movl %eax, %ebp
movl $0x18b3, %edx           # imm = 0x18B3
leaq 0xbc6f(%rip), %rsi      # 0x1769d
movq %rbx, %rdi
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %ebp, %ebp
jmp 0xba36
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_name
int
kmip_encode_name(KMIP *ctx, const Name *value)
{
    /* TODO (ph) Check for value == NULL? */
    
    int result = 0;
    
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_NAME, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_text_string(ctx, KMIP_TAG_NAME_VALUE, value->value);
    CHECK_RESULT(ctx, result);
    
    result = kmip_encode_enum(ctx, KMIP_TAG_NAME_TYPE, value->type);
    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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x42005301, %esi       # imm = 0x42005301
callq 0x60a0
testl %eax, %eax
je 0xba75
movl %eax, %ebp
leaq 0xbc48(%rip), %rsi      # 0x176b0
movq %rbx, %rdi
movl $0x18c1, %edx           # imm = 0x18C1
jmp 0xbafc
movq 0x8(%rbx), %r12
leaq 0x4(%r12), %r15
movq %r15, 0x8(%rbx)
movq (%r14), %rdx
movq %rbx, %rdi
movl $0x420055, %esi         # imm = 0x420055
callq 0x66a0
testl %eax, %eax
je 0xbaa9
movl %eax, %ebp
leaq 0xbc11(%rip), %rsi      # 0x176b0
movq %rbx, %rdi
movl $0x18c7, %edx           # imm = 0x18C7
jmp 0xbafc
movl 0x8(%r14), %edx
movq %rbx, %rdi
movl $0x420054, %esi         # imm = 0x420054
callq 0x6700
testl %eax, %eax
je 0xbad1
movl %eax, %ebp
leaq 0xbbe9(%rip), %rsi      # 0x176b0
movq %rbx, %rdi
movl $0x18ca, %edx           # imm = 0x18CA
jmp 0xbafc
movq 0x8(%rbx), %r14
movq %r12, 0x8(%rbx)
movq %r14, %rsi
subq %r15, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xbb0c
movl %eax, %ebp
leaq 0xbbbc(%rip), %rsi      # 0x176b0
movq %rbx, %rdi
movl $0x18d0, %edx           # imm = 0x18D0
callq 0x6e80
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0xbb01
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_protection_storage_masks
int
kmip_encode_protection_storage_masks(KMIP *ctx, const ProtectionStorageMasks *value)
{
    CHECK_ENCODE_ARGS(ctx, value);
    CHECK_KMIP_VERSION(ctx, KMIP_2_0);

    int result = 0;

    result = kmip_encode_int32_be(
        ctx,
        TAG_TYPE(KMIP_TAG_PROTECTION_STORAGE_MASKS, KMIP_TYPE_STRUCTURE)
    );
    CHECK_RESULT(ctx, result);

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

    if(value->masks != NULL)
    {
        LinkedListItem *curr = value->masks->head;
        while(curr != NULL)
        {
            result = kmip_encode_integer(ctx, KMIP_TAG_PROTECTION_STORAGE_MASK, *(int32 *)curr->data);
            CHECK_RESULT(ctx, result);

            curr = curr->next;
        }
    }

    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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xbb4f
movq %rsi, %r14
xorl %ebp, %ebp
testq %rsi, %rsi
je 0xbb52
movq %rdi, %rbx
cmpl $0x4, 0x18(%rdi)
ja 0xbb63
leaq 0xbb83(%rip), %rsi      # 0x176c1
movq %rbx, %rdi
movl $0x18db, %edx           # imm = 0x18DB
callq 0x6e80
pushq $-0xb
jmp 0xbb51
pushq $-0x11
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x42015f01, %esi       # imm = 0x42015F01
callq 0x60a0
testl %eax, %eax
je 0xbb90
movl %eax, %r15d
leaq 0xbb43(%rip), %rsi      # 0x176c1
movq %rbx, %rdi
movl $0x18e3, %edx           # imm = 0x18E3
callq 0x6e80
movl %r15d, %ebp
jmp 0xbb52
movq 0x8(%rbx), %rax
movq %rax, (%rsp)
leaq 0x4(%rax), %r15
movq %r15, 0x8(%rbx)
movq (%r14), %r13
movq %r15, %r12
testq %r13, %r13
je 0xbbe3
movq (%r13), %r13
testq %r13, %r13
je 0xbbdf
movq 0x10(%r13), %rax
movl (%rax), %edx
movq %rbx, %rdi
movl $0x42015e, %esi         # imm = 0x42015E
callq 0x63f0
testl %eax, %eax
je 0xbbab
movl %eax, %r14d
leaq 0xbaec(%rip), %rsi      # 0x176c1
movq %rbx, %rdi
movl $0x18ee, %edx           # imm = 0x18EE
jmp 0xbc0f
movq 0x8(%rbx), %r12
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r12, %rsi
subq %r15, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xbc1c
movl %eax, %r14d
leaq 0xbaba(%rip), %rsi      # 0x176c1
movq %rbx, %rdi
movl $0x18f8, %edx           # imm = 0x18F8
callq 0x6e80
movl %r14d, %ebp
jmp 0xbb52
movq %r12, 0x8(%rbx)
jmp 0xbb52
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_attributes
int
kmip_encode_attributes(KMIP *ctx, const Attributes *value)
{
    CHECK_ENCODE_ARGS(ctx, value);
    CHECK_KMIP_VERSION(ctx, KMIP_2_0);

    int result = 0;

    result = kmip_encode_int32_be(
        ctx,
        TAG_TYPE(KMIP_TAG_ATTRIBUTES, KMIP_TYPE_STRUCTURE)
    );
    CHECK_RESULT(ctx, result);

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

    if(value->attribute_list != NULL)
    {
        LinkedListItem *curr = value->attribute_list->head;
        while(curr != NULL)
        {
            Attribute *attribute = (Attribute *)curr->data;
            result = kmip_encode_attribute(ctx, attribute);
            CHECK_RESULT(ctx, result);

            curr = curr->next;
        }
    }

    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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc689
movq %rsi, %r14
xorl %ebp, %ebp
testq %rsi, %rsi
je 0xc68c
movq %rdi, %rbx
cmpl $0x4, 0x18(%rdi)
ja 0xc69d
leaq 0xb1c9(%rip), %rsi      # 0x17841
movq %rbx, %rdi
movl $0x1a9c, %edx           # imm = 0x1A9C
callq 0x6e80
pushq $-0xb
jmp 0xc68b
pushq $-0x11
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movl $0x42012501, %esi       # imm = 0x42012501
callq 0x60a0
testl %eax, %eax
je 0xc6ca
movl %eax, %r15d
leaq 0xb189(%rip), %rsi      # 0x17841
movq %rbx, %rdi
movl $0x1aa4, %edx           # imm = 0x1AA4
callq 0x6e80
movl %r15d, %ebp
jmp 0xc68c
movq 0x8(%rbx), %rax
movq %rax, (%rsp)
leaq 0x4(%rax), %r15
movq %r15, 0x8(%rbx)
movq (%r14), %r13
movq %r15, %r12
testq %r13, %r13
je 0xc716
movq (%r13), %r13
testq %r13, %r13
je 0xc712
movq 0x10(%r13), %rsi
movq %rbx, %rdi
callq 0x6b20
testl %eax, %eax
je 0xc6e5
movl %eax, %r14d
leaq 0xb139(%rip), %rsi      # 0x17841
movq %rbx, %rdi
movl $0x1ab0, %edx           # imm = 0x1AB0
jmp 0xc742
movq 0x8(%rbx), %r12
movq (%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r12, %rsi
subq %r15, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xc74f
movl %eax, %r14d
leaq 0xb107(%rip), %rsi      # 0x17841
movq %rbx, %rdi
movl $0x1aba, %edx           # imm = 0x1ABA
callq 0x6e80
movl %r14d, %ebp
jmp 0xc68c
movq %r12, 0x8(%rbx)
jmp 0xc68c
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_template_attribute
int
kmip_encode_template_attribute(KMIP *ctx, const TemplateAttribute *value)
{
    int result = 0;
    
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_TEMPLATE_ATTRIBUTE, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    for(size_t i = 0; i < value->name_count; i++)
    {
        result = kmip_encode_name(ctx, &value->names[i]);
        CHECK_RESULT(ctx, result);
    }
    
    for(size_t i = 0; i <value->attribute_count; i++)
    {
        result = kmip_encode_attribute(ctx, &value->attributes[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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x42009101, %esi       # imm = 0x42009101
callq 0x60a0
testl %eax, %eax
je 0xc78d
movl %eax, %ebp
leaq 0xb0d8(%rip), %rsi      # 0x17858
movq %rbx, %rdi
movl $0x1ac7, %edx           # imm = 0x1AC7
jmp 0xc83b
movq 0x8(%rbx), %r12
leaq 0x4(%r12), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%rbx)
pushq $-0x1
popq %r13
xorl %esi, %esi
incq %r13
cmpq 0x8(%r14), %r13
jae 0xc7d6
leaq 0x10(%rsi), %r15
addq (%r14), %rsi
movq %rbx, %rdi
callq 0x6180
movq %r15, %rsi
testl %eax, %eax
je 0xc7a4
movl %eax, %ebp
leaq 0xb08c(%rip), %rsi      # 0x17858
movq %rbx, %rdi
movl $0x1acf, %edx           # imm = 0x1ACF
jmp 0xc83b
pushq $-0x1
popq %r13
xorl %esi, %esi
incq %r13
cmpq 0x18(%r14), %r13
jae 0xc80f
leaq 0x10(%rsi), %r15
addq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x6b20
movq %r15, %rsi
testl %eax, %eax
je 0xc7dc
movl %eax, %ebp
leaq 0xb053(%rip), %rsi      # 0x17858
movq %rbx, %rdi
movl $0x1ad5, %edx           # imm = 0x1AD5
jmp 0xc83b
movq 0x8(%rbx), %r14
movq %r12, 0x8(%rbx)
movq %r14, %rsi
subq (%rsp), %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xc851
movl %eax, %ebp
leaq 0xb025(%rip), %rsi      # 0x17858
movq %rbx, %rdi
movl $0x1adc, %edx           # imm = 0x1ADC
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0xc840
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_protocol_version
int
kmip_encode_protocol_version(KMIP *ctx, const ProtocolVersion *value)
{
    CHECK_BUFFER_FULL(ctx, 40);
    
    kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_PROTOCOL_VERSION, KMIP_TYPE_STRUCTURE));
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    kmip_encode_integer(ctx, KMIP_TAG_PROTOCOL_VERSION_MAJOR, value->major);
    kmip_encode_integer(ctx, KMIP_TAG_PROTOCOL_VERSION_MINOR, value->minor);
    
    uint8 *curr_index = ctx->index;
    ctx->index = length_index;
    
    kmip_encode_length(ctx, curr_index - value_index);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq $0x27, %rax
ja 0xc88e
leaq 0xaffb(%rip), %rsi      # 0x17877
movq %rbx, %rdi
movl $0x1ae6, %edx           # imm = 0x1AE6
callq 0x6e80
pushq $-0x2
popq %rax
jmp 0xc8e7
movq %rsi, %r14
movq %rbx, %rdi
movl $0x42006901, %esi       # imm = 0x42006901
callq 0x60a0
movq 0x8(%rbx), %r15
leaq 0x4(%r15), %r12
movq %r12, 0x8(%rbx)
movl (%r14), %edx
movq %rbx, %rdi
movl $0x42006a, %esi         # imm = 0x42006A
callq 0x63f0
movl 0x4(%r14), %edx
movq %rbx, %rdi
movl $0x42006b, %esi         # imm = 0x42006B
callq 0x63f0
movq 0x8(%rbx), %r14
movq %r15, 0x8(%rbx)
movq %r14, %rsi
subq %r12, %rsi
movq %rbx, %rdi
callq 0x6b10
movq %r14, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_encryption_key_information
int
kmip_encode_encryption_key_information(KMIP *ctx, const EncryptionKeyInformation *value)
{
    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_ENCRYPTION_KEY_INFORMATION, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_text_string(ctx, KMIP_TAG_UNIQUE_IDENTIFIER, value->unique_identifier);
    CHECK_RESULT(ctx, result);
    
    if(value->cryptographic_parameters != 0)
    {
        result = kmip_encode_cryptographic_parameters(ctx, value->cryptographic_parameters);
        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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x42003601, %esi       # imm = 0x42003601
callq 0x60a0
testl %eax, %eax
je 0xc922
movl %eax, %ebp
leaq 0xb076(%rip), %rsi      # 0x1798e
movq %rbx, %rdi
movl $0x1bb6, %edx           # imm = 0x1BB6
jmp 0xc954
movq 0x8(%rbx), %r12
leaq 0x4(%r12), %r15
movq %r15, 0x8(%rbx)
movq (%r14), %rdx
movq %rbx, %rdi
movl $0x420094, %esi         # imm = 0x420094
callq 0x66a0
testl %eax, %eax
je 0xc964
movl %eax, %ebp
leaq 0xb042(%rip), %rsi      # 0x1798e
movq %rbx, %rdi
movl $0x1bbc, %edx           # imm = 0x1BBC
callq 0x6e80
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0xc98c
movq %rbx, %rdi
callq 0x6cc0
testl %eax, %eax
je 0xc98c
movl %eax, %ebp
leaq 0xb00c(%rip), %rsi      # 0x1798e
movq %rbx, %rdi
movl $0x1bc1, %edx           # imm = 0x1BC1
jmp 0xc954
movq 0x8(%rbx), %r14
movq %r12, 0x8(%rbx)
movq %r14, %rsi
subq %r15, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xc9b9
movl %eax, %ebp
leaq 0xafdf(%rip), %rsi      # 0x1798e
movq %rbx, %rdi
movl $0x1bc8, %edx           # imm = 0x1BC8
jmp 0xc954
movq %r14, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0xc959
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_mac_signature_key_information
int
kmip_encode_mac_signature_key_information(KMIP *ctx, const MACSignatureKeyInformation *value)
{
    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_MAC_SIGNATURE_KEY_INFORMATION, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_text_string(ctx, KMIP_TAG_UNIQUE_IDENTIFIER, value->unique_identifier);
    CHECK_RESULT(ctx, result);
    
    if(value->cryptographic_parameters != 0)
    {
        result = kmip_encode_cryptographic_parameters(ctx, value->cryptographic_parameters);
        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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x42004e01, %esi       # imm = 0x42004E01
callq 0x60a0
testl %eax, %eax
je 0xc9f0
movl %eax, %ebp
leaq 0xafcf(%rip), %rsi      # 0x179b5
movq %rbx, %rdi
movl $0x1bd4, %edx           # imm = 0x1BD4
jmp 0xca22
movq 0x8(%rbx), %r12
leaq 0x4(%r12), %r15
movq %r15, 0x8(%rbx)
movq (%r14), %rdx
movq %rbx, %rdi
movl $0x420094, %esi         # imm = 0x420094
callq 0x66a0
testl %eax, %eax
je 0xca32
movl %eax, %ebp
leaq 0xaf9b(%rip), %rsi      # 0x179b5
movq %rbx, %rdi
movl $0x1bda, %edx           # imm = 0x1BDA
callq 0x6e80
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r14), %rsi
testq %rsi, %rsi
je 0xca5a
movq %rbx, %rdi
callq 0x6cc0
testl %eax, %eax
je 0xca5a
movl %eax, %ebp
leaq 0xaf65(%rip), %rsi      # 0x179b5
movq %rbx, %rdi
movl $0x1bdf, %edx           # imm = 0x1BDF
jmp 0xca22
movq 0x8(%rbx), %r14
movq %r12, 0x8(%rbx)
movq %r14, %rsi
subq %r15, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xca87
movl %eax, %ebp
leaq 0xaf38(%rip), %rsi      # 0x179b5
movq %rbx, %rdi
movl $0x1be6, %edx           # imm = 0x1BE6
jmp 0xca22
movq %r14, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0xca27
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_transparent_symmetric_key
int
kmip_encode_transparent_symmetric_key(KMIP *ctx, const TransparentSymmetricKey *value)
{
    int result = 0;
    
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_KEY_MATERIAL, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_byte_string(ctx, KMIP_TAG_KEY, value->key);
    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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x42004301, %esi       # imm = 0x42004301
callq 0x60a0
testl %eax, %eax
je 0xcc4b
movl %eax, %ebp
leaq 0xadbc(%rip), %rsi      # 0x179fd
movq %rbx, %rdi
movl $0x1c29, %edx           # imm = 0x1C29
jmp 0xccaa
movq 0x8(%rbx), %r12
leaq 0x4(%r12), %r15
movq %r15, 0x8(%rbx)
movq (%r14), %rdx
movq %rbx, %rdi
movl $0x42003f, %esi         # imm = 0x42003F
callq 0x6cb0
testl %eax, %eax
je 0xcc7f
movl %eax, %ebp
leaq 0xad88(%rip), %rsi      # 0x179fd
movq %rbx, %rdi
movl $0x1c2f, %edx           # imm = 0x1C2F
jmp 0xccaa
movq 0x8(%rbx), %r14
movq %r12, 0x8(%rbx)
movq %r14, %rsi
subq %r15, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xccba
movl %eax, %ebp
leaq 0xad5b(%rip), %rsi      # 0x179fd
movq %rbx, %rdi
movl $0x1c35, %edx           # imm = 0x1C35
callq 0x6e80
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0xccaf
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_key_value
int
kmip_encode_key_value(KMIP *ctx, enum key_format_type format, const KeyValue *value)
{
    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_KEY_VALUE, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_key_material(ctx, format, value->key_material);
    CHECK_RESULT(ctx, result);
    
    for(size_t i = 0; i < value->attribute_count; i++)
    {
        result = kmip_encode_attribute(ctx, &value->attributes[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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
movl $0x42004501, %esi       # imm = 0x42004501
callq 0x60a0
testl %eax, %eax
je 0xcddc
movl %eax, %ebp
leaq 0xac6d(%rip), %rsi      # 0x17a3c
movq %rbx, %rdi
movl $0x1ca5, %edx           # imm = 0x1CA5
jmp 0xce87
movq 0x8(%rbx), %r13
leaq 0x4(%r13), %r12
movq %r12, 0x8(%rbx)
movq (%r14), %rdx
movq %rbx, %rdi
movl %r15d, %esi
callq 0x6380
testl %eax, %eax
je 0xce0d
movl %eax, %ebp
leaq 0xac39(%rip), %rsi      # 0x17a3c
movq %rbx, %rdi
movl $0x1cab, %edx           # imm = 0x1CAB
jmp 0xce87
movq %rbx, (%rsp)
pushq $-0x1
popq %r15
xorl %esi, %esi
incq %r15
cmpq 0x10(%r14), %r15
jae 0xce58
movq %r13, %rbx
movq %r12, %r13
leaq 0x10(%rsi), %r12
addq 0x8(%r14), %rsi
movq (%rsp), %rdi
callq 0x6b20
movq %r12, %rsi
movq %r13, %r12
movq %rbx, %r13
testl %eax, %eax
je 0xce17
movl %eax, %ebp
leaq 0xabef(%rip), %rsi      # 0x17a3c
movq (%rsp), %rdi
movl $0x1cb0, %edx           # imm = 0x1CB0
jmp 0xce87
movq (%rsp), %rbx
movq 0x8(%rbx), %r14
movq %r13, 0x8(%rbx)
movq %r14, %rsi
subq %r12, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xce9d
movl %eax, %ebp
leaq 0xabbd(%rip), %rsi      # 0x17a3c
movq %rbx, %rdi
movl $0x1cb7, %edx           # imm = 0x1CB7
callq 0x6e80
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0xce8c
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_symmetric_key
int
kmip_encode_symmetric_key(KMIP *ctx, const SymmetricKey *value)
{
    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_SYMMETRIC_KEY, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_key_block(ctx, value->key_block);
    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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x42008f01, %esi       # imm = 0x42008F01
callq 0x60a0
testl %eax, %eax
je 0xd076
movl %eax, %ebp
leaq 0xa9fc(%rip), %rsi      # 0x17a68
movq %rbx, %rdi
movl $0x1cfd, %edx           # imm = 0x1CFD
jmp 0xd0d0
movq 0x8(%rbx), %r12
leaq 0x4(%r12), %r15
movq %r15, 0x8(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x6d90
testl %eax, %eax
je 0xd0a5
movl %eax, %ebp
leaq 0xa9cd(%rip), %rsi      # 0x17a68
movq %rbx, %rdi
movl $0x1d03, %edx           # imm = 0x1D03
jmp 0xd0d0
movq 0x8(%rbx), %r14
movq %r12, 0x8(%rbx)
movq %r14, %rsi
subq %r15, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xd0e0
movl %eax, %ebp
leaq 0xa9a0(%rip), %rsi      # 0x17a68
movq %rbx, %rdi
movl $0x1d09, %edx           # imm = 0x1D09
callq 0x6e80
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0xd0d5
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_private_key
int
kmip_encode_private_key(KMIP *ctx, const PrivateKey *value)
{
    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_PRIVATE_KEY, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_key_block(ctx, value->key_block);
    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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x42006401, %esi       # imm = 0x42006401
callq 0x60a0
testl %eax, %eax
je 0xd1b8
movl %eax, %ebp
leaq 0xa8eb(%rip), %rsi      # 0x17a99
movq %rbx, %rdi
movl $0x1d2d, %edx           # imm = 0x1D2D
jmp 0xd212
movq 0x8(%rbx), %r12
leaq 0x4(%r12), %r15
movq %r15, 0x8(%rbx)
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x6d90
testl %eax, %eax
je 0xd1e7
movl %eax, %ebp
leaq 0xa8bc(%rip), %rsi      # 0x17a99
movq %rbx, %rdi
movl $0x1d33, %edx           # imm = 0x1D33
jmp 0xd212
movq 0x8(%rbx), %r14
movq %r12, 0x8(%rbx)
movq %r14, %rsi
subq %r15, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xd222
movl %eax, %ebp
leaq 0xa88f(%rip), %rsi      # 0x17a99
movq %rbx, %rdi
movl $0x1d39, %edx           # imm = 0x1D39
callq 0x6e80
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r14, 0x8(%rbx)
xorl %ebp, %ebp
jmp 0xd217
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_encode_create_response_payload
int
kmip_encode_create_response_payload(KMIP *ctx, const CreateResponsePayload *value)
{
    CHECK_ENCODE_ARGS(ctx, value);

    int result = 0;
    result = kmip_encode_int32_be(ctx, TAG_TYPE(KMIP_TAG_RESPONSE_PAYLOAD, KMIP_TYPE_STRUCTURE));
    CHECK_RESULT(ctx, result);
    
    uint8 *length_index = ctx->index;
    uint8 *value_index = ctx->index += 4;
    
    result = kmip_encode_enum(ctx, KMIP_TAG_OBJECT_TYPE, value->object_type);
    CHECK_RESULT(ctx, result);
    
    result = kmip_encode_text_string(ctx, KMIP_TAG_UNIQUE_IDENTIFIER, value->unique_identifier);
    CHECK_RESULT(ctx, result);

    if(ctx->version < KMIP_2_0)
    {
        if(value->template_attribute != NULL)
        {
            result = kmip_encode_template_attribute(ctx, value->template_attribute);
            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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd638
movq %rsi, %r14
xorl %ebp, %ebp
testq %rsi, %rsi
je 0xd6a0
movq %rdi, %rbx
movl $0x42007c01, %esi       # imm = 0x42007C01
callq 0x60a0
testl %eax, %eax
je 0xd63d
movl %eax, %r15d
leaq 0xa4cd(%rip), %rsi      # 0x17afb
movq %rbx, %rdi
movl $0x1db8, %edx           # imm = 0x1DB8
jmp 0xd698
pushq $-0x11
popq %rbp
jmp 0xd6a0
movq 0x8(%rbx), %r13
leaq 0x4(%r13), %r12
movq %r12, 0x8(%rbx)
movl (%r14), %edx
movq %rbx, %rdi
movl $0x420057, %esi         # imm = 0x420057
callq 0x6700
testl %eax, %eax
je 0xd671
movl %eax, %r15d
leaq 0xa494(%rip), %rsi      # 0x17afb
movq %rbx, %rdi
movl $0x1dbe, %edx           # imm = 0x1DBE
jmp 0xd698
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movl $0x420094, %esi         # imm = 0x420094
callq 0x66a0
testl %eax, %eax
je 0xd6b1
movl %eax, %r15d
leaq 0xa46b(%rip), %rsi      # 0x17afb
movq %rbx, %rdi
movl $0x1dc1, %edx           # imm = 0x1DC1
callq 0x6e80
movl %r15d, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x4, 0x18(%rbx)
ja 0xd6e0
movq 0x10(%r14), %rsi
testq %rsi, %rsi
je 0xd6e0
movq %rbx, %rdi
callq 0x6d30
testl %eax, %eax
je 0xd6e0
movl %eax, %r14d
leaq 0xa425(%rip), %rsi      # 0x17afb
movq %rbx, %rdi
movl $0x1dc8, %edx           # imm = 0x1DC8
jmp 0xd70c
movq 0x8(%rbx), %r15
movq %r13, 0x8(%rbx)
movq %r15, %rsi
subq %r12, %rsi
movq %rbx, %rdi
callq 0x6b10
testl %eax, %eax
je 0xd716
movl %eax, %r14d
leaq 0xa3f7(%rip), %rsi      # 0x17afb
movq %rbx, %rdi
movl $0x1dd0, %edx           # imm = 0x1DD0
callq 0x6e80
movl %r14d, %ebp
jmp 0xd6a0
movq %r15, 0x8(%rbx)
jmp 0xd6a0