LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_free_operations
void
kmip_free_operations(KMIP *ctx, Operations *value)
{

    if(value != NULL)
    {
        if(value->operation_list != NULL)
        {
            LinkedListItem *curr = kmip_linked_list_pop(value->operation_list);
            while(curr != NULL)
            {
                ctx->free_func(ctx->state, curr->data);
                curr->data = NULL;
                ctx->free_func(ctx->state, curr);
                curr = kmip_linked_list_pop(value->operation_list);
            }
            ctx->free_func(ctx->state, value->operation_list);
            value->operation_list = NULL;
        }
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb7a6
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb7a4
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6620
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb77a
movq -0x8(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6620
movq %rax, -0x18(%rbp)
jmp 0xb719
movq -0x8(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0xb7a6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_free_objects
void
kmip_free_objects(KMIP *ctx, ObjectTypes* value)
{
    if(value != NULL)
    {
        if(value->object_list != NULL)
        {
            LinkedListItem *curr = kmip_linked_list_pop(value->object_list);
            while(curr != NULL)
            {
                ctx->free_func(ctx->state, curr->data);
                curr->data = NULL;
                ctx->free_func(ctx->state, curr);
                curr = kmip_linked_list_pop(value->object_list);
            }
            ctx->free_func(ctx->state, value->object_list);
            value->object_list = NULL;
        }
    }

    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb876
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xb874
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6620
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb84a
movq -0x8(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x6620
movq %rax, -0x18(%rbp)
jmp 0xb7e9
movq -0x8(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x10(%rbp), %rcx
movq (%rcx), %rsi
callq *%rax
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
jmp 0xb876
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_free_server_information
void
kmip_free_server_information(KMIP* ctx, ServerInformation* value)
{
    kmip_free_text_string(ctx, value->server_name);
    kmip_free_text_string(ctx, value->server_serial_number);
    kmip_free_text_string(ctx, value->server_version);
    kmip_free_text_string(ctx, value->server_load);
    kmip_free_text_string(ctx, value->product_name);
    kmip_free_text_string(ctx, value->build_level);
    kmip_free_text_string(ctx, value->build_date);
    kmip_free_text_string(ctx, value->cluster_info);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x6380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x6380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x6380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x6380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x6380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x6380
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x6380
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_deep_copy_int32
int32 *
kmip_deep_copy_int32(KMIP *ctx, const int32 *value)
{
    if(ctx == NULL || value == NULL)
        return(NULL);

    int32 *copy = ctx->calloc_func(ctx, 1, sizeof(int32));
    if(copy == NULL)
        return(NULL);

    copy = ctx->memcpy_func(ctx->state, copy, value, sizeof(int32));
    return(copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb93e
cmpq $0x0, -0x18(%rbp)
jne 0xb948
movq $0x0, -0x8(%rbp)
jmp 0xb9a9
movq -0x10(%rbp), %rax
movq 0x868(%rax), %rax
movq -0x10(%rbp), %rdi
movl $0x1, %esi
movl $0x4, %edx
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb978
movq $0x0, -0x8(%rbp)
jmp 0xb9a9
movq -0x10(%rbp), %rax
movq 0x880(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x4, %ecx
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_deep_copy_int64
int64 *
kmip_deep_copy_int64(KMIP *ctx, const int64 *value)
{
    if(ctx == NULL || value == NULL)
    {
        return(NULL);
    }

    int64 *copy = ctx->calloc_func(ctx->state, 1, sizeof(int64));
    if(copy == NULL)
    {
        return(NULL);
    }

    copy = ctx->memcpy_func(ctx->state, copy, value, sizeof(int64));
    return(copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb9de
cmpq $0x0, -0x18(%rbp)
jne 0xb9e8
movq $0x0, -0x8(%rbp)
jmp 0xba50
movq -0x10(%rbp), %rax
movq 0x868(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movl $0x1, %esi
movl $0x8, %edx
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xba1f
movq $0x0, -0x8(%rbp)
jmp 0xba50
movq -0x10(%rbp), %rax
movq 0x880(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl $0x8, %ecx
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_deep_copy_text_string
TextString *
kmip_deep_copy_text_string(KMIP *ctx, const TextString *value)
{
    if(ctx == NULL || value == NULL)
        return(NULL);

    TextString *copy = ctx->calloc_func(ctx->state, 1, sizeof(TextString));
    if(copy == NULL)
        return(NULL);

    copy->size = value->size;
    if(value->value != NULL)
    {
        copy->value = ctx->calloc_func(ctx->state, 1, value->size);
        if(copy->value == NULL && value->value != NULL)
        {
            ctx->free_func(ctx->state, copy);
            return(NULL);
        }
        copy->value = ctx->memcpy_func(ctx->state, copy->value, value->value, value->size);
    }
    else
        copy->value = NULL;

    return(copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xba7e
cmpq $0x0, -0x18(%rbp)
jne 0xba8b
movq $0x0, -0x8(%rbp)
jmp 0xbb99
movq -0x10(%rbp), %rax
movq 0x868(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbac5
movq $0x0, -0x8(%rbp)
jmp 0xbb99
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbb86
movq -0x10(%rbp), %rax
movq 0x868(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdx
movl $0x1, %esi
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xbb4c
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbb4c
movq -0x10(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0xbb99
movq -0x10(%rbp), %rax
movq 0x880(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbb91
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_deep_copy_byte_string
ByteString *
kmip_deep_copy_byte_string(KMIP *ctx, const ByteString *value)
{
    if(NULL == ctx || NULL == value)
    {
        return(NULL);
    }

    ByteString *copy = ctx->calloc_func(ctx->state, 1, sizeof(ByteString));
    if(NULL == copy)
    {
        return(NULL);
    }

    copy->size = value->size;
    if(NULL != value->value)
    {
        copy->value = ctx->calloc_func(ctx->state, 1, value->size);
        if(NULL == copy->value)
        {
            ctx->free_func(ctx->state, copy);
            return(NULL);
        }
        copy->value = ctx->memcpy_func(ctx->state, copy->value, value->value, value->size);
    }
    else
    {
        copy->value = NULL;
    }

    return(copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
je 0xbbd0
xorl %eax, %eax
cmpq -0x18(%rbp), %rax
jne 0xbbdd
movq $0x0, -0x8(%rbp)
jmp 0xbce4
movq -0x10(%rbp), %rax
movq 0x868(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq *%rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq -0x20(%rbp), %rax
jne 0xbc18
movq $0x0, -0x8(%rbp)
jmp 0xbce4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0xbcd1
movq -0x10(%rbp), %rax
movq 0x868(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rdx
movl $0x1, %esi
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0xbc97
movq -0x10(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0xbce4
movq -0x10(%rbp), %rax
movq 0x880(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x20(%rbp), %rcx
movq (%rcx), %rsi
movq -0x18(%rbp), %rcx
movq (%rcx), %rdx
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xbcdc
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_deep_copy_name
Name *
kmip_deep_copy_name(KMIP *ctx, const Name *value)
{
    if(ctx == NULL || value == NULL)
        return(NULL);

    Name *copy = ctx->calloc_func(ctx->state, 1, sizeof(Name));
    if(copy == NULL)
        return(NULL);

    copy->type = value->type;
    if(value->value != NULL)
    {
        copy->value = kmip_deep_copy_text_string(ctx, value->value);
        if(copy->value == NULL)
        {
            ctx->free_func(ctx->state, copy);
            return(NULL);
        }
    }
    else
        copy->value = NULL;

    return(copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbd0e
cmpq $0x0, -0x18(%rbp)
jne 0xbd1b
movq $0x0, -0x8(%rbp)
jmp 0xbdc9
movq -0x10(%rbp), %rax
movq 0x868(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xbd52
movq $0x0, -0x8(%rbp)
jmp 0xbdc9
movq -0x18(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xbdb6
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6590
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xbdb4
movq -0x10(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0xbdc9
jmp 0xbdc1
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_deep_copy_application_specific_information
ApplicationSpecificInformation *
kmip_deep_copy_application_specific_information(KMIP *ctx, const ApplicationSpecificInformation *value)
{
    if(ctx == NULL || value == NULL)
    {
        return(NULL);
    }

    ApplicationSpecificInformation *copy = ctx->calloc_func(ctx->state, 1, sizeof(ApplicationSpecificInformation));
    if(copy == NULL)
    {
        return(NULL);
    }

    if(value->application_namespace != NULL)
    {
        copy->application_namespace = kmip_deep_copy_text_string(ctx, value->application_namespace);
        if(copy->application_namespace == NULL)
        {
            ctx->free_func(ctx->state, copy);
            return(NULL);
        }
    }
    else
    {
        copy->application_namespace = NULL;
    }

    if(value->application_data != NULL)
    {
        copy->application_data = kmip_deep_copy_text_string(ctx, value->application_data);
        if(copy->application_data == NULL)
        {
            kmip_free_application_specific_information(ctx, copy);
            ctx->free_func(ctx->state, copy);
            return(NULL);
        }
    }
    else
    {
        copy->application_data = NULL;
    }

    return(copy);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xbfde
cmpq $0x0, -0x18(%rbp)
jne 0xbfeb
movq $0x0, -0x8(%rbp)
jmp 0xc104
movq -0x10(%rbp), %rax
movq 0x868(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movl $0x1, %esi
movl $0x10, %edx
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc025
movq $0x0, -0x8(%rbp)
jmp 0xc104
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc07e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6590
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc07c
movq -0x10(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0xc104
jmp 0xc089
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc0f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6590
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xc0ee
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6d60
movq -0x10(%rbp), %rax
movq 0x878(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x890(%rcx), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0xc104
jmp 0xc0fc
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_copy_textstring
char*
kmip_copy_textstring(char* dest, TextString* src, size_t size)
{
    if(src && src->value != NULL)
    {
        size_t len = KMIP_MIN(size, src->size);
        memcpy(dest, src->value, len);
        dest[len] = 0;
    }
    else
        *dest = 0;

    return dest;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xc433
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc433
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xc3fd
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0xc409
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x6790
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0xc43a
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_copy_operations
void
kmip_copy_operations(int ops[], size_t* ops_size, Operations *value, unsigned max_ops)
{
    if(value != NULL &&
       value->operation_list != NULL)
    {
        *ops_size = value->operation_list->size;

        LinkedListItem *curr = value->operation_list->head;
        size_t idx = 0;
        while(curr != NULL && idx < max_ops )
        {
            ops[idx] = *(int32 *)curr->data;
            curr = curr->next;
            idx++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc4f5
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc4f5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0xc4bc
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xc4c5
jmp 0xc4f3
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc4a0
jmp 0xc4f5
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_copy_objects
void
kmip_copy_objects(int objs[], size_t* objs_size, ObjectTypes *value, unsigned max_objs)
{
    if(value != NULL &&
       value->object_list != NULL)
    {
        *objs_size = value->object_list->size;

        LinkedListItem *curr = value->object_list->head;
        size_t idx = 0;
        while(curr != NULL && idx < max_objs )
        {
            objs[idx] = *(int32 *)curr->data;
            curr = curr->next;
            idx++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc5a5
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc5a5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x31(%rbp)
je 0xc56c
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
cmpq %rcx, %rax
setb %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xc575
jmp 0xc5a3
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc550
jmp 0xc5a5
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_text_string
int
kmip_compare_text_string(const TextString *a, const TextString *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->size != b->size)
        {
            return(KMIP_FALSE);
        }
        
        if(a->value != b->value)
        {
            if((a->value == NULL) || (b->value == NULL))
            {
                return(KMIP_FALSE);
            }
            
            for(size_t i = 0; i < a->size; i++)
            {
                if(a->value[i] != b->value[i])
                {
                    return(KMIP_FALSE);
                }
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xc814
cmpq $0x0, -0x10(%rbp)
je 0xc768
cmpq $0x0, -0x18(%rbp)
jne 0xc774
movl $0x0, -0x4(%rbp)
jmp 0xc81b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xc792
movl $0x0, -0x4(%rbp)
jmp 0xc81b
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xc812
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc7b6
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc7bf
movl $0x0, -0x4(%rbp)
jmp 0xc81b
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xc810
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xc800
movl $0x0, -0x4(%rbp)
jmp 0xc81b
jmp 0xc802
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc7c7
jmp 0xc812
jmp 0xc814
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_byte_string
int
kmip_compare_byte_string(const ByteString *a, const ByteString *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->size != b->size)
        {
            return(KMIP_FALSE);
        }
        
        if(a->value != b->value)
        {
            if((a->value == NULL) || (b->value == NULL))
            {
                return(KMIP_FALSE);
            }
            
            for(size_t i = 0; i < a->size; i++)
            {
                if(a->value[i] != b->value[i])
                {
                    return(KMIP_FALSE);
                }
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xc8f4
cmpq $0x0, -0x10(%rbp)
je 0xc848
cmpq $0x0, -0x18(%rbp)
jne 0xc854
movl $0x0, -0x4(%rbp)
jmp 0xc8fb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xc872
movl $0x0, -0x4(%rbp)
jmp 0xc8fb
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xc8f2
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc896
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc89f
movl $0x0, -0x4(%rbp)
jmp 0xc8fb
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xc8f0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movq -0x20(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0xc8e0
movl $0x0, -0x4(%rbp)
jmp 0xc8fb
jmp 0xc8e2
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xc8a7
jmp 0xc8f2
jmp 0xc8f4
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_name
int
kmip_compare_name(const Name *a, const Name *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->type != b->type)
        {
            return(KMIP_FALSE);
        }
        
        if(a->value != b->value)
        {
            if((a->value == NULL) || (b->value == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_text_string(a->value, b->value) != KMIP_TRUE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xc9a0
cmpq $0x0, -0x10(%rbp)
je 0xc92c
cmpq $0x0, -0x18(%rbp)
jne 0xc935
movl $0x0, -0x4(%rbp)
jmp 0xc9a7
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
je 0xc94e
movl $0x0, -0x4(%rbp)
jmp 0xc9a7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xc99e
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc972
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc97b
movl $0x0, -0x4(%rbp)
jmp 0xc9a7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x64d0
cmpl $0x1, %eax
je 0xc99c
movl $0x0, -0x4(%rbp)
jmp 0xc9a7
jmp 0xc99e
jmp 0xc9a0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_application_specific_information
int
kmip_compare_application_specific_information(const ApplicationSpecificInformation *a, const ApplicationSpecificInformation *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }

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

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

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

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

    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xce83
cmpq $0x0, -0x10(%rbp)
je 0xcdcc
cmpq $0x0, -0x18(%rbp)
jne 0xcdd8
movl $0x0, -0x4(%rbp)
jmp 0xce8a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xce2b
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xcdfc
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xce08
movl $0x0, -0x4(%rbp)
jmp 0xce8a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x64d0
cmpl $0x0, %eax
jne 0xce29
movl $0x0, -0x4(%rbp)
jmp 0xce8a
jmp 0xce2b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xce81
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xce53
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xce5c
movl $0x0, -0x4(%rbp)
jmp 0xce8a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x64d0
cmpl $0x0, %eax
jne 0xce7f
movl $0x0, -0x4(%rbp)
jmp 0xce8a
jmp 0xce81
jmp 0xce83
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_attributes
int
kmip_compare_attributes(const Attributes *a, const Attributes *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }

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

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

            LinkedListItem *a_item = a->attribute_list->head;
            LinkedListItem *b_item = b->attribute_list->head;
            while((a_item != NULL) && (b_item != NULL))
            {
                if(a_item != b_item)
                {
                    Attribute *a_data = (Attribute *)a_item->data;
                    Attribute *b_data = (Attribute *)b_item->data;
                    if(kmip_compare_attribute(a_data, b_data) == KMIP_FALSE)
                    {
                        return(KMIP_FALSE);
                    }
                }

                a_item = a_item->next;
                b_item = b_item->next;
            }

            if(a_item != b_item)
            {
                return(KMIP_FALSE);
            }
        }
    }

    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xd25a
cmpq $0x0, -0x10(%rbp)
je 0xd14c
cmpq $0x0, -0x18(%rbp)
jne 0xd158
movl $0x0, -0x4(%rbp)
jmp 0xd261
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xd258
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd180
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd18c
movl $0x0, -0x4(%rbp)
jmp 0xd261
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x10(%rcx), %rax
je 0xd1b0
movl $0x0, -0x4(%rbp)
jmp 0xd261
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x39(%rbp)
je 0xd1e3
cmpq $0x0, -0x28(%rbp)
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0xd1ec
jmp 0xd243
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xd22b
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6170
cmpl $0x0, %eax
jne 0xd229
movl $0x0, -0x4(%rbp)
jmp 0xd261
jmp 0xd22b
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xd1cc
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xd256
movl $0x0, -0x4(%rbp)
jmp 0xd261
jmp 0xd258
jmp 0xd25a
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_protocol_version
int
kmip_compare_protocol_version(const ProtocolVersion *a, const ProtocolVersion *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->major != b->major)
        {
            return(KMIP_FALSE);
        }
        
        if(a->minor != b->minor)
        {
            return(KMIP_FALSE);
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xd48f
cmpq $0x0, -0x10(%rbp)
je 0xd454
cmpq $0x0, -0x18(%rbp)
jne 0xd45d
movl $0x0, -0x4(%rbp)
jmp 0xd496
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
je 0xd474
movl $0x0, -0x4(%rbp)
jmp 0xd496
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0xd48d
movl $0x0, -0x4(%rbp)
jmp 0xd496
jmp 0xd48f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_transparent_symmetric_key
int
kmip_compare_transparent_symmetric_key(const TransparentSymmetricKey *a, const TransparentSymmetricKey *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->key != b->key)
        {
            if((a->key == NULL) || (b->key == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_byte_string(a->key, b->key) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xd523
cmpq $0x0, -0x10(%rbp)
je 0xd4c8
cmpq $0x0, -0x18(%rbp)
jne 0xd4d1
movl $0x0, -0x4(%rbp)
jmp 0xd52a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xd521
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd4f5
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd4fe
movl $0x0, -0x4(%rbp)
jmp 0xd52a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6430
cmpl $0x0, %eax
jne 0xd51f
movl $0x0, -0x4(%rbp)
jmp 0xd52a
jmp 0xd521
jmp 0xd523
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_key_material
int
kmip_compare_key_material(enum key_format_type format, void **a, void **b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(*a != *b)
        {
            if((*a == NULL) || (*b == NULL))
            {
                return(KMIP_FALSE);
            }
            
            switch(format)
            {
                case KMIP_KEYFORMAT_RAW:
                case KMIP_KEYFORMAT_OPAQUE:
                case KMIP_KEYFORMAT_PKCS1:
                case KMIP_KEYFORMAT_PKCS8:
                case KMIP_KEYFORMAT_X509:
                case KMIP_KEYFORMAT_EC_PRIVATE_KEY:
                if(kmip_compare_byte_string(*a, *b) == KMIP_FALSE)
                {
                    return(KMIP_FALSE);
                }
                break;
                
                case KMIP_KEYFORMAT_TRANS_SYMMETRIC_KEY:
                if(kmip_compare_transparent_symmetric_key(*a, *b) == KMIP_FALSE)
                {
                    return(KMIP_FALSE);
                }
                break;
                
                default:
                /* NOTE (ph) Unsupported types cannot be compared. */
                return(KMIP_FALSE);
                break;
            };
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xd618
cmpq $0x0, -0x10(%rbp)
je 0xd56f
cmpq $0x0, -0x18(%rbp)
jne 0xd57b
movl $0x0, -0x4(%rbp)
jmp 0xd61f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xd616
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd5a3
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd5ac
movl $0x0, -0x4(%rbp)
jmp 0xd61f
movl -0x8(%rbp), %eax
movl %eax, -0x1c(%rbp)
decl %eax
subl $0x6, %eax
jb 0xd5c5
jmp 0xd5bb
movl -0x1c(%rbp), %eax
subl $0x7, %eax
je 0xd5e8
jmp 0xd60b
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6430
cmpl $0x0, %eax
jne 0xd5e6
movl $0x0, -0x4(%rbp)
jmp 0xd61f
jmp 0xd614
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x6160
cmpl $0x0, %eax
jne 0xd609
movl $0x0, -0x4(%rbp)
jmp 0xd61f
jmp 0xd614
movl $0x0, -0x4(%rbp)
jmp 0xd61f
jmp 0xd616
jmp 0xd618
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_key_value
int
kmip_compare_key_value(enum key_format_type format, const KeyValue *a, const KeyValue *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->key_material != b->key_material)
        {
            if((a->key_material == NULL) || (b->key_material == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_key_material(format, (void**)&a->key_material, (void**)&b->key_material) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
        
        if(a->attributes != b->attributes)
        {
            if((a->attributes == NULL) || (b->attributes == NULL))
            {
                return(KMIP_FALSE);
            }
            
            for(size_t i = 0; i < a->attribute_count; i++)
            {
                if(kmip_compare_attribute(&a->attributes[i], &b->attributes[i]) == KMIP_FALSE)
                {
                    return(KMIP_FALSE);
                }
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xd756
cmpq $0x0, -0x10(%rbp)
je 0xd65f
cmpq $0x0, -0x18(%rbp)
jne 0xd66b
movl $0x0, -0x4(%rbp)
jmp 0xd75d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xd6be
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd68f
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd69b
movl $0x0, -0x4(%rbp)
jmp 0xd75d
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x6230
cmpl $0x0, %eax
jne 0xd6bc
movl $0x0, -0x4(%rbp)
jmp 0xd75d
jmp 0xd6be
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xd754
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd6ea
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd6f3
movl $0x0, -0x4(%rbp)
jmp 0xd75d
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0xd752
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rsi
callq 0x6170
cmpl $0x0, %eax
jne 0xd742
movl $0x0, -0x4(%rbp)
jmp 0xd75d
jmp 0xd744
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd6fb
jmp 0xd754
jmp 0xd756
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_encryption_key_information
int
kmip_compare_encryption_key_information(const EncryptionKeyInformation *a, const EncryptionKeyInformation *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->unique_identifier != b->unique_identifier)
        {
            if((a->unique_identifier == NULL) || (b->unique_identifier == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_text_string(a->unique_identifier, b->unique_identifier) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
        
        if(a->cryptographic_parameters != b->cryptographic_parameters)
        {
            if((a->cryptographic_parameters == NULL) ||
               (b->cryptographic_parameters == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_cryptographic_parameters(a->cryptographic_parameters, b->cryptographic_parameters) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xd853
cmpq $0x0, -0x10(%rbp)
je 0xd79c
cmpq $0x0, -0x18(%rbp)
jne 0xd7a8
movl $0x0, -0x4(%rbp)
jmp 0xd85a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xd7fb
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd7cc
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd7d8
movl $0x0, -0x4(%rbp)
jmp 0xd85a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x64d0
cmpl $0x0, %eax
jne 0xd7f9
movl $0x0, -0x4(%rbp)
jmp 0xd85a
jmp 0xd7fb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xd851
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd823
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd82c
movl $0x0, -0x4(%rbp)
jmp 0xd85a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x62b0
cmpl $0x0, %eax
jne 0xd84f
movl $0x0, -0x4(%rbp)
jmp 0xd85a
jmp 0xd851
jmp 0xd853
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_mac_signature_key_information
int
kmip_compare_mac_signature_key_information(const MACSignatureKeyInformation *a, const MACSignatureKeyInformation *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->unique_identifier != b->unique_identifier)
        {
            if((a->unique_identifier == NULL) || (b->unique_identifier == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_text_string(a->unique_identifier, b->unique_identifier) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
        
        if(a->cryptographic_parameters != b->cryptographic_parameters)
        {
            if((a->cryptographic_parameters == NULL) || (b->cryptographic_parameters == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_cryptographic_parameters(a->cryptographic_parameters, b->cryptographic_parameters) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xd953
cmpq $0x0, -0x10(%rbp)
je 0xd89c
cmpq $0x0, -0x18(%rbp)
jne 0xd8a8
movl $0x0, -0x4(%rbp)
jmp 0xd95a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xd8fb
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xd8cc
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xd8d8
movl $0x0, -0x4(%rbp)
jmp 0xd95a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x64d0
cmpl $0x0, %eax
jne 0xd8f9
movl $0x0, -0x4(%rbp)
jmp 0xd95a
jmp 0xd8fb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0xd951
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd923
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd92c
movl $0x0, -0x4(%rbp)
jmp 0xd95a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x62b0
cmpl $0x0, %eax
jne 0xd94f
movl $0x0, -0x4(%rbp)
jmp 0xd95a
jmp 0xd951
jmp 0xd953
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_symmetric_key
int
kmip_compare_symmetric_key(const SymmetricKey *a, const SymmetricKey *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->key_block != b->key_block)
        {
            if((a->key_block == NULL) || (b->key_block == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_key_block(a->key_block, b->key_block) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xddb3
cmpq $0x0, -0x10(%rbp)
je 0xdd58
cmpq $0x0, -0x18(%rbp)
jne 0xdd61
movl $0x0, -0x4(%rbp)
jmp 0xddba
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xddb1
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdd85
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xdd8e
movl $0x0, -0x4(%rbp)
jmp 0xddba
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x61d0
cmpl $0x0, %eax
jne 0xddaf
movl $0x0, -0x4(%rbp)
jmp 0xddba
jmp 0xddb1
jmp 0xddb3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_public_key
int
kmip_compare_public_key(const PublicKey *a, const PublicKey *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->key_block != b->key_block)
        {
            if((a->key_block == NULL) || (b->key_block == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_key_block(a->key_block, b->key_block) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xde53
cmpq $0x0, -0x10(%rbp)
je 0xddf8
cmpq $0x0, -0x18(%rbp)
jne 0xde01
movl $0x0, -0x4(%rbp)
jmp 0xde5a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xde51
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xde25
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xde2e
movl $0x0, -0x4(%rbp)
jmp 0xde5a
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x61d0
cmpl $0x0, %eax
jne 0xde4f
movl $0x0, -0x4(%rbp)
jmp 0xde5a
jmp 0xde51
jmp 0xde53
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_compare_private_key
int
kmip_compare_private_key(const PrivateKey *a, const PrivateKey *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->key_block != b->key_block)
        {
            if((a->key_block == NULL) || (b->key_block == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_key_block(a->key_block, b->key_block) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xdef3
cmpq $0x0, -0x10(%rbp)
je 0xde98
cmpq $0x0, -0x18(%rbp)
jne 0xdea1
movl $0x0, -0x4(%rbp)
jmp 0xdefa
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0xdef1
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xdec5
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xdece
movl $0x0, -0x4(%rbp)
jmp 0xdefa
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
callq 0x61d0
cmpl $0x0, %eax
jne 0xdeef
movl $0x0, -0x4(%rbp)
jmp 0xdefa
jmp 0xdef1
jmp 0xdef3
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)