LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdx, %rdx
je 0x97aa
movq (%rdx), %rax
testq %rax, %rax
je 0x97aa
movq 0x10(%rax), %rdx
movq %rdx, (%rsi)
movl %ecx, %ecx
xorl %edx, %edx
movq (%rax), %rax
testq %rax, %rax
je 0x97aa
cmpq %rcx, %rdx
jae 0x97aa
movq 0x10(%rax), %rsi
movl (%rsi), %esi
movl %esi, (%rdi,%rdx,4)
incq %rdx
jmp 0x978f
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x1
popq %rcx
cmpq %rsi, %rdi
je 0x9a24
testq %rdi, %rdi
sete %dl
testq %rsi, %rsi
sete %r8b
xorl %eax, %eax
orb %dl, %r8b
jne 0x9a23
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x9a23
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0x9a24
testq %rdi, %rdi
sete %r8b
testq %rsi, %rsi
sete %r9b
orb %r8b, %r9b
jne 0x9a23
xorl %r8d, %r8d
xorl %eax, %eax
cmpq %r8, %rdx
je 0x9a24
movb (%rdi,%r8), %r9b
leaq 0x1(%r8), %r10
cmpb (%rsi,%r8), %r9b
movq %r10, %r8
je 0x9a0d
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x1
popq %rcx
cmpq %rsi, %rdi
je 0x9a87
testq %rdi, %rdi
sete %dl
testq %rsi, %rsi
sete %r8b
xorl %eax, %eax
orb %dl, %r8b
jne 0x9a86
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0x9a86
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0x9a87
testq %rdi, %rdi
sete %r8b
testq %rsi, %rsi
sete %r9b
orb %r8b, %r9b
jne 0x9a86
xorl %r8d, %r8d
xorl %eax, %eax
cmpq %r8, %rdx
je 0x9a87
movb (%rdi,%r8), %r9b
leaq 0x1(%r8), %r10
cmpb (%rsi,%r8), %r9b
movq %r10, %r8
je 0x9a70
retq
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
cmpq %rsi, %rdi
je 0x9ace
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x9ad1
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x9ad1
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0x9ace
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9ad1
callq 0x64a0
testl %eax, %eax
je 0x9ad1
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_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 %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0x9c40
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x9c43
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0x9c1a
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9c43
callq 0x64a0
testl %eax, %eax
je 0x9c43
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0x9c40
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9c43
callq 0x64a0
testl %eax, %eax
je 0x9c43
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_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 %r15
pushq %r14
pushq %rbx
pushq $0x1
popq %rbx
cmpq %rsi, %rdi
je 0x9da7
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9da5
movq (%rdi), %r14
movq (%rsi), %r15
cmpq %r15, %r14
je 0x9da7
testq %r14, %r14
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x9da5
movq 0x10(%r14), %rax
cmpq 0x10(%r15), %rax
jne 0x9da5
movq (%r14), %r14
movq (%r15), %r15
testq %r14, %r14
je 0x9da0
testq %r15, %r15
je 0x9da0
cmpq %r15, %r14
je 0x9d78
movq 0x10(%r14), %rdi
movq 0x10(%r15), %rsi
callq 0x6150
testl %eax, %eax
jne 0x9d78
jmp 0x9da5
cmpq %r15, %r14
je 0x9da7
xorl %ebx, %ebx
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_compare_template_attribute
int
kmip_compare_template_attribute(const TemplateAttribute *a, const TemplateAttribute *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->name_count != b->name_count)
        {
            return(KMIP_FALSE);
        }
        
        if(a->attribute_count != b->attribute_count)
        {
            return(KMIP_FALSE);
        }
        
        if(a->names != b->names)
        {
            if((a->names == NULL) || (b->names == NULL))
            {
                return(KMIP_FALSE);
            }
            
            for(size_t i = 0; i < a->name_count; i++)
            {
                if(kmip_compare_name(&a->names[i], &b->names[i]) == 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
cmpq %rsi, %rdi
je 0x9e7a
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9e78
movq 0x8(%r15), %r13
cmpq 0x8(%r14), %r13
jne 0x9e78
movq 0x18(%r15), %rax
movq %rax, (%rsp)
cmpq 0x18(%r14), %rax
jne 0x9e78
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0x9e38
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9e78
incq %r13
decq %r13
je 0x9e38
leaq 0x10(%rdi), %rbp
leaq 0x10(%rsi), %r12
callq 0x6ba0
movq %r12, %rsi
movq %rbp, %rdi
testl %eax, %eax
jne 0x9e1a
jmp 0x9e78
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
cmpq %rsi, %rdi
je 0x9e7a
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9e78
movq (%rsp), %r12
incq %r12
decq %r12
je 0x9e7a
leaq 0x10(%rdi), %r14
leaq 0x10(%rsi), %r15
callq 0x6150
movq %r15, %rsi
movq %r14, %rdi
testl %eax, %eax
jne 0x9e5c
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip.c
// Function: kmip_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 %rbx
cmpq %rsi, %rdi
je 0x9ef0
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x9ef3
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0x9ef0
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9ef3
callq 0x6400
testl %eax, %eax
je 0x9ef3
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_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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
cmpq %rdx, %rsi
je 0x9fea
movq %rdx, %r15
movq %rsi, %r14
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x9fe8
movq (%r14), %rcx
movq (%r15), %rax
cmpq %rax, %rcx
je 0x9fa8
testq %rcx, %rcx
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0x9fe8
movq %r14, %rsi
movq %r15, %rdx
callq 0x6200
testl %eax, %eax
je 0x9fe8
movq 0x8(%r14), %rdi
movq 0x8(%r15), %rsi
cmpq %rsi, %rdi
je 0x9fea
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x9fe8
movq 0x10(%r14), %r14
incq %r14
decq %r14
je 0x9fea
leaq 0x10(%rdi), %r15
leaq 0x10(%rsi), %r12
callq 0x6150
movq %r12, %rsi
movq %r15, %rdi
testl %eax, %eax
jne 0x9fcc
xorl %ebx, %ebx
movl %ebx, %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_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 %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xa064
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa067
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0xa03e
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa067
callq 0x64a0
testl %eax, %eax
je 0xa067
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xa064
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa067
callq 0x6280
testl %eax, %eax
je 0xa067
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_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 %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xa0db
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa0de
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0xa0b5
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa0de
callq 0x64a0
testl %eax, %eax
je 0xa0de
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xa0db
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa0de
callq 0x6280
testl %eax, %eax
je 0xa0de
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_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 %rbx
cmpq %rsi, %rdi
je 0xa2d6
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa2d9
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0xa2d6
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa2d9
callq 0x61a0
testl %eax, %eax
je 0xa2d9
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_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 %rbx
cmpq %rsi, %rdi
je 0xa319
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa31c
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0xa319
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa31c
callq 0x61a0
testl %eax, %eax
je 0xa31c
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_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 %rbx
cmpq %rsi, %rdi
je 0xa35c
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa35f
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0xa35c
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa35f
callq 0x61a0
testl %eax, %eax
je 0xa35f
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_create_request_payload
int
kmip_compare_create_request_payload(const CreateRequestPayload *a, const CreateRequestPayload *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->object_type != b->object_type)
        {
            return(KMIP_FALSE);
        }
        
        if(a->template_attribute != b->template_attribute)
        {
            if((a->template_attribute == NULL) || (b->template_attribute == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_template_attribute(a->template_attribute, b->template_attribute) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }

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

            if(kmip_compare_attributes(a->attributes, b->attributes) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }

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

            if(kmip_compare_protection_storage_masks(a->protection_storage_masks, b->protection_storage_masks) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xa4f1
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa4f4
movl (%r15), %eax
cmpl (%r14), %eax
jne 0xa4f4
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xa4a5
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa4f4
callq 0x6d80
testl %eax, %eax
je 0xa4f4
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
cmpq %rsi, %rdi
je 0xa4cb
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa4f4
callq 0x6930
testl %eax, %eax
je 0xa4f4
movq 0x18(%r15), %rdi
movq 0x18(%r14), %rsi
cmpq %rsi, %rdi
je 0xa4f1
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa4f4
callq 0x6db0
testl %eax, %eax
je 0xa4f4
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_compare_create_response_payload
int
kmip_compare_create_response_payload(const CreateResponsePayload *a, const CreateResponsePayload *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->object_type != b->object_type)
        {
            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->template_attribute != b->template_attribute)
        {
            if((a->template_attribute == NULL) || (b->template_attribute == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_template_attribute(a->template_attribute, b->template_attribute) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xa572
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa575
movl (%r15), %eax
cmpl (%r14), %eax
jne 0xa575
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xa54c
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa575
callq 0x64a0
testl %eax, %eax
je 0xa575
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
cmpq %rsi, %rdi
je 0xa572
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa575
callq 0x6d80
testl %eax, %eax
je 0xa575
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_compare_get_request_payload
int
kmip_compare_get_request_payload(const GetRequestPayload *a, const GetRequestPayload *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->key_format_type != b->key_format_type)
        {
            return(KMIP_FALSE);
        }
        
        if(a->key_compression_type != b->key_compression_type)
        {
            return(KMIP_FALSE);
        }
        
        if(a->key_wrap_type != b->key_wrap_type)
        {
            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->key_wrapping_spec != b->key_wrapping_spec)
        {
            if((a->key_wrapping_spec == NULL) || (b->key_wrapping_spec == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_key_wrapping_specification(a->key_wrapping_spec, b->key_wrapping_spec) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xa60b
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa60e
movl 0x8(%r15), %eax
cmpl 0x8(%r14), %eax
jne 0xa60e
movl 0xc(%r15), %eax
cmpl 0xc(%r14), %eax
jne 0xa60e
movl 0x18(%r15), %eax
cmpl 0x18(%r14), %eax
jne 0xa60e
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0xa5e5
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa60e
callq 0x64a0
testl %eax, %eax
je 0xa60e
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
cmpq %rsi, %rdi
je 0xa60b
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa60e
callq 0x6df0
testl %eax, %eax
je 0xa60e
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_compare_destroy_request_payload
int
kmip_compare_destroy_request_payload(const DestroyRequestPayload *a, const DestroyRequestPayload *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);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbx
cmpq %rsi, %rdi
je 0xa6e7
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa6ea
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0xa6e7
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa6ea
callq 0x64a0
testl %eax, %eax
je 0xa6ea
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_destroy_response_payload
int
kmip_compare_destroy_response_payload(const DestroyResponsePayload *a, const DestroyResponsePayload *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);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbx
cmpq %rsi, %rdi
je 0xa72a
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa72d
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0xa72a
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa72d
callq 0x64a0
testl %eax, %eax
je 0xa72d
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_query_request_payload
int
kmip_compare_query_request_payload(const QueryRequestPayload *a, const QueryRequestPayload *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }

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

            if(kmip_compare_query_functions(a->functions, b->functions) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }

    return(KMIP_TRUE);
}

// Assembly:
pushq %rbx
cmpq %rsi, %rdi
je 0xa834
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xa837
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0xa834
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa837
callq 0x6ea0
testl %eax, %eax
je 0xa837
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_query_response_payload
int
kmip_compare_query_response_payload(const QueryResponsePayload *a, const QueryResponsePayload *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }

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

            if(kmip_compare_operations(a->operations, b->operations) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }

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

            if(kmip_compare_objects(a->objects, b->objects) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }

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

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

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

            if(kmip_compare_server_information(a->server_information, b->server_information) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }

    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xaa2c
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xaa2f
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0xa9ba
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xaa2f
callq 0x6480
testl %eax, %eax
je 0xaa2f
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xa9e0
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xaa2f
callq 0x66d0
testl %eax, %eax
je 0xaa2f
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
cmpq %rsi, %rdi
je 0xaa06
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xaa2f
callq 0x64a0
testl %eax, %eax
je 0xaa2f
movq 0x18(%r15), %rdi
movq 0x18(%r14), %rsi
cmpq %rsi, %rdi
je 0xaa2c
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xaa2f
callq 0x61d0
testl %eax, %eax
je 0xaa2f
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_compare_nonce
int
kmip_compare_nonce(const Nonce *a, const Nonce *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->nonce_id != b->nonce_id)
        {
            if((a->nonce_id == NULL) || (b->nonce_id == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_byte_string(a->nonce_id, b->nonce_id) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
        
        if(a->nonce_value != b->nonce_value)
        {
            if((a->nonce_value == NULL) || (b->nonce_value == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_byte_string(a->nonce_value, b->nonce_value) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xaaa3
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xaaa6
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0xaa7d
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xaaa6
callq 0x6400
testl %eax, %eax
je 0xaaa6
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xaaa3
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xaaa6
callq 0x6400
testl %eax, %eax
je 0xaaa6
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_compare_username_password_credential
int
kmip_compare_username_password_credential(const UsernamePasswordCredential *a, const UsernamePasswordCredential *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->username != b->username)
        {
            if((a->username == NULL) || (b->username == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_text_string(a->username, b->username) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
        
        if(a->password != b->password)
        {
            if((a->password == NULL) || (b->password == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_text_string(a->password, b->password) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xab1a
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xab1d
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0xaaf4
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xab1d
callq 0x64a0
testl %eax, %eax
je 0xab1d
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xab1a
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xab1d
callq 0x64a0
testl %eax, %eax
je 0xab1d
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_compare_attestation_credential
int
kmip_compare_attestation_credential(const AttestationCredential *a, const AttestationCredential *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->attestation_type != b->attestation_type)
        {
            return(KMIP_FALSE);
        }
        
        if(a->nonce != b->nonce)
        {
            if((a->nonce == NULL) || (b->nonce == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_nonce(a->nonce, b->nonce) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
        
        if(a->attestation_measurement != b->attestation_measurement)
        {
            if((a->attestation_measurement == NULL) || (b->attestation_measurement == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_byte_string(a->attestation_measurement, b->attestation_measurement) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
        
        if(a->attestation_assertion != b->attestation_assertion)
        {
            if((a->attestation_assertion == NULL) || (b->attestation_assertion == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_byte_string(a->attestation_assertion, b->attestation_assertion) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq %rsi, %rdi
je 0xacec
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xacef
movl 0x8(%r15), %eax
cmpl 0x8(%r14), %eax
jne 0xacef
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0xaca0
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xacef
callq 0x6550
testl %eax, %eax
je 0xacef
movq 0x10(%r15), %rdi
movq 0x10(%r14), %rsi
cmpq %rsi, %rdi
je 0xacc6
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xacef
callq 0x6400
testl %eax, %eax
je 0xacef
movq 0x18(%r15), %rdi
movq 0x18(%r14), %rsi
cmpq %rsi, %rdi
je 0xacec
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xacef
callq 0x6400
testl %eax, %eax
je 0xacef
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_compare_credential
int
kmip_compare_credential(const Credential *a, const Credential *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->credential_type != b->credential_type)
        {
            return(KMIP_FALSE);
        }
        
        if(a->credential_value != b->credential_value)
        {
            if((a->credential_value == NULL) || (b->credential_value == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_credential_value(a->credential_type, (void**)&a->credential_value, (void**)&b->credential_value) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
cmpq %rsi, %rdi
je 0xadb2
movq %rdi, %rsi
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xadb5
movl (%rsi), %edi
cmpl (%rdx), %edi
jne 0xadb5
movq 0x8(%rsi), %rcx
movq 0x8(%rdx), %rax
cmpq %rax, %rcx
je 0xadb2
testq %rcx, %rcx
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0xadb5
addq $0x8, %rsi
addq $0x8, %rdx
callq 0x6330
testl %eax, %eax
je 0xadb5
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_authentication
int
kmip_compare_authentication(const Authentication *a, const Authentication *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->credential != b->credential)
        {
            if((a->credential == NULL) || (b->credential == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_credential(a->credential, b->credential) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %rbx
cmpq %rsi, %rdi
je 0xadf5
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0xadf8
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpq %rsi, %rdi
je 0xadf5
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xadf8
callq 0x6910
testl %eax, %eax
je 0xadf8
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_request_message
int
kmip_compare_request_message(const RequestMessage *a, const RequestMessage *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->batch_count != b->batch_count)
        {
            return(KMIP_FALSE);
        }
        
        if(a->request_header != b->request_header)
        {
            if((a->request_header == NULL) || (b->request_header == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_request_header(a->request_header, b->request_header) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
        
        if(a->batch_items != b->batch_items)
        {
            if((a->batch_items == NULL) || (b->batch_items == NULL))
            {
                return(KMIP_FALSE);
            }
            
            for(size_t i = 0; i < a->batch_count; i++)
            {
                if(kmip_compare_request_batch_item(&a->batch_items[i], &b->batch_items[i]) == KMIP_FALSE)
                {
                    return(KMIP_FALSE);
                }
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
cmpq %rsi, %rdi
je 0xb181
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xb17f
movq 0x10(%r15), %r12
cmpq 0x10(%r14), %r12
jne 0xb17f
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0xb143
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xb17f
callq 0x64f0
testl %eax, %eax
je 0xb17f
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xb181
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xb17f
incq %r12
decq %r12
je 0xb181
leaq 0x20(%rdi), %r14
leaq 0x20(%rsi), %r15
callq 0x6110
movq %r15, %rsi
movq %r14, %rdi
testl %eax, %eax
jne 0xb163
xorl %ebx, %ebx
movl %ebx, %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_compare_response_message
int
kmip_compare_response_message(const ResponseMessage *a, const ResponseMessage *b)
{
    if(a != b)
    {
        if((a == NULL) || (b == NULL))
        {
            return(KMIP_FALSE);
        }
        
        if(a->batch_count != b->batch_count)
        {
            return(KMIP_FALSE);
        }
        
        if(a->response_header != b->response_header)
        {
            if((a->response_header == NULL) || (b->response_header == NULL))
            {
                return(KMIP_FALSE);
            }
            
            if(kmip_compare_response_header(a->response_header, b->response_header) == KMIP_FALSE)
            {
                return(KMIP_FALSE);
            }
        }
        
        if(a->batch_items != b->batch_items)
        {
            if((a->batch_items == NULL) || (b->batch_items == NULL))
            {
                return(KMIP_FALSE);
            }
            
            for(size_t i = 0; i < a->batch_count; i++)
            {
                if(kmip_compare_response_batch_item(&a->batch_items[i], &b->batch_items[i]) == KMIP_FALSE)
                {
                    return(KMIP_FALSE);
                }
            }
        }
    }
    
    return(KMIP_TRUE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $0x1
popq %rbx
cmpq %rsi, %rdi
je 0xb225
movq %rsi, %r14
movq %rdi, %r15
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xb223
movq 0x10(%r15), %r12
cmpq 0x10(%r14), %r12
jne 0xb223
movq (%r15), %rdi
movq (%r14), %rsi
cmpq %rsi, %rdi
je 0xb1e7
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xb223
callq 0x63a0
testl %eax, %eax
je 0xb223
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
cmpq %rsi, %rdi
je 0xb225
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xb223
incq %r12
decq %r12
je 0xb225
leaq 0x30(%rdi), %r14
leaq 0x30(%rsi), %r15
callq 0x6da0
movq %r15, %rsi
movq %r14, %rdi
testl %eax, %eax
jne 0xb207
xorl %ebx, %ebx
movl %ebx, %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_compare_linklist_items_textstring
int
kmip_compare_linklist_items_textstring(const LinkedListItem *a_item, const LinkedListItem *b_item)
{
    while((a_item != NULL) && (b_item != NULL))
    {
        if(a_item != b_item)
        {
            TextString *a_data = (TextString *)a_item->data;
            TextString *b_data = (TextString *)b_item->data;
            if(kmip_compare_text_string(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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %r14, %r14
je 0xb2a4
testq %rbx, %rbx
je 0xb2a4
cmpq %rbx, %r14
je 0xb29c
movq 0x10(%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x64a0
testl %eax, %eax
je 0xb2ae
movq (%r14), %r14
movq (%rbx), %rbx
jmp 0xb27c
xorl %eax, %eax
cmpq %rbx, %r14
sete %al
jmp 0xb2b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq