LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_credential_type_enum
void
kmip_print_credential_type_enum(FILE *f, enum credential_type value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_CRED_USERNAME_AND_PASSWORD:
        fprintf(f, "Username and Password");
        break;
        
        case KMIP_CRED_DEVICE:
        fprintf(f, "Device");
        break;
        
        case KMIP_CRED_ATTESTATION:
        fprintf(f, "Attestation");
        break;

        case KMIP_CRED_ONE_TIME_PASSWORD:
        fprintf(f, "One Time Password");
        break;

        case KMIP_CRED_HASHED_PASSWORD:
        fprintf(f, "Hashed Password");
        break;

        case KMIP_CRED_TICKET:
        fprintf(f, "Ticket");
        break;

        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x22adc
movq -0x8(%rbp), %rdi
leaq 0xd786(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x22b8e
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x22b7c
movq -0x18(%rbp), %rax
leaq 0xb641(%rip), %rcx      # 0x2e13c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0xca49(%rip), %rsi      # 0x2f558
movb $0x0, %al
callq 0x21d0
jmp 0x22b8e
movq -0x8(%rbp), %rdi
leaq 0xca4b(%rip), %rsi      # 0x2f56e
movb $0x0, %al
callq 0x21d0
jmp 0x22b8e
movq -0x8(%rbp), %rdi
leaq 0xca3e(%rip), %rsi      # 0x2f575
movb $0x0, %al
callq 0x21d0
jmp 0x22b8e
movq -0x8(%rbp), %rdi
leaq 0xca36(%rip), %rsi      # 0x2f581
movb $0x0, %al
callq 0x21d0
jmp 0x22b8e
movq -0x8(%rbp), %rdi
leaq 0xd68e(%rip), %rsi      # 0x301ed
movb $0x0, %al
callq 0x21d0
jmp 0x22b8e
movq -0x8(%rbp), %rdi
leaq 0xbd6f(%rip), %rsi      # 0x2e8e2
movb $0x0, %al
callq 0x21d0
jmp 0x22b8e
movq -0x8(%rbp), %rdi
leaq 0xd7d4(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_protection_storage_masks
void
kmip_print_protection_storage_masks(FILE *f, int indent, ProtectionStorageMasks *value)
{
    fprintf(f, "%*sProtection Storage Masks @ %p\n", indent, "", (void *)value);

    if(value != NULL &&
       value->masks != NULL)
    {
        fprintf(f, "%*sMasks: %zu\n", indent + 2, "", value->masks->size);
        LinkedListItem *curr = value->masks->head;
        size_t count = 1;
        while(curr != NULL)
        {
            fprintf(f, "%*sMask: %zu", indent + 4, "", count);
            int32 mask = *(int32 *)curr->data;
            kmip_print_protection_storage_mask_enum(f, indent + 6, mask);

            curr = curr->next;
            count++;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xc5b0(%rip), %rsi      # 0x2f805
leaq 0x8199(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x23320
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x23320
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %r8
leaq 0xc58f(%rip), %rsi      # 0x2f827
leaq 0x8156(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2331e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x4, %edx
movq -0x28(%rbp), %r8
leaq 0xc55e(%rip), %rsi      # 0x2f836
leaq 0x8116(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x6, %esi
movl -0x2c(%rbp), %edx
callq 0x22fc0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x232bc
jmp 0x23320
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_integer
void
kmip_print_integer(FILE *f, int32 value)
{
    switch(value)
    {
        case KMIP_UNSET:
        fprintf(f, "-");
        break;
        
        default:
        fprintf(f, "%d", value);
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
subl $-0x1, %eax
jne 0x2335d
jmp 0x23349
movq -0x8(%rbp), %rdi
leaq 0xcf02(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x23372
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0xc4d8(%rip), %rsi      # 0x2f843
movb $0x0, %al
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_bool
void
kmip_print_bool(FILE *f, int32 value)
{
    switch(value)
    {
        case KMIP_TRUE:
        fprintf(f, "True");
        break;
        
        case KMIP_FALSE:
        fprintf(f, "False");
        break;
        
        default:
        fprintf(f, "-");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x233b9
jmp 0x2339b
movl -0x10(%rbp), %eax
subl $0x1, %eax
jne 0x233cd
jmp 0x233a5
movq -0x8(%rbp), %rdi
leaq 0xc496(%rip), %rsi      # 0x2f846
movb $0x0, %al
callq 0x21d0
jmp 0x233df
movq -0x8(%rbp), %rdi
leaq 0xc487(%rip), %rsi      # 0x2f84b
movb $0x0, %al
callq 0x21d0
jmp 0x233df
movq -0x8(%rbp), %rdi
leaq 0xce7e(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_text_string
void
kmip_print_text_string(FILE *f, int indent, const char *name, TextString *value)
{
    fprintf(f, "%*s%s @ %p\n", indent, "", name, (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sValue: %.*s\n", indent + 2, "", (int)value->size, value->value);
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0xc434(%rip), %rsi      # 0x2f851
leaq 0x7fd1(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x20(%rbp)
je 0x23463
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %r8d
movq -0x20(%rbp), %rax
movq (%rax), %r9
leaq 0xc408(%rip), %rsi      # 0x2f85d
leaq 0x7f99(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_byte_string
void
kmip_print_byte_string(FILE *f, int indent, const char *name, ByteString *value)
{
    fprintf(f, "%*s%s @ %p\n", indent, "", name, (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sValue:", indent + 2, "");
        for(size_t i = 0; i < value->size; i++)
        {
            if(i % 16 == 0)
            {
                fprintf(f, "\n%*s0x", indent + 4, "");
            }
            fprintf(f, "%02X", value->value[i]);
        }
        fprintf(f, "\n");
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0xc3b4(%rip), %rsi      # 0x2f851
leaq 0x7f51(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x20(%rbp)
je 0x23559
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xc3a6(%rip), %rsi      # 0x2f86d
leaq 0x7f27(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x23547
movq -0x28(%rbp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x23518
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x4, %edx
leaq 0xc36d(%rip), %rsi      # 0x2f877
leaq 0x7ee4(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0xad5a(%rip), %rsi      # 0x2e28c
movb $0x0, %al
callq 0x21d0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x234dd
movq -0x8(%rbp), %rdi
leaq 0x7ea2(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_date_time
void
kmip_print_date_time(FILE *f, int64 value)
{
    if(value <= KMIP_UNSET)
    {
        fprintf(f, "-");
    }
    else
    {
        /* NOTE: This cast is only problematic if the current year is 2038+
        *  AND time_t is equivalent to an int32 data type. If these conditions
        *  are true, the cast will overflow and the time value will appear to
        *  be set in 1901+.
        *
        *  No system should be using 32-bit time in 2038. If this impacts you,
        *  upgrade your system.
        */
        time_t t = (time_t)value;

        /* NOTE: The data pointed to by utc_time may change if gmtime is
        *  called again before utc_time is used.
        */
        struct tm *utc_time = gmtime(&t);
        fprintf(f, "%s", asctime(utc_time));
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
jg 0x2358b
movq -0x8(%rbp), %rdi
leaq 0xccd4(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x235c6
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2110
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2090
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x896f(%rip), %rsi      # 0x2bf2e
movb $0x0, %al
callq 0x21d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_protocol_version
void
kmip_print_protocol_version(FILE *f, int indent, ProtocolVersion *value)
{
    fprintf(f, "%*sProtocol Version @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sMajor: %d\n", indent + 2, "", value->major);
        fprintf(f, "%*sMinor: %d\n", indent + 2, "", value->minor);
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xc289(%rip), %rsi      # 0x2f87e
leaq 0x7df9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x23657
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movl (%rax), %r8d
leaq 0xc276(%rip), %rsi      # 0x2f898
leaq 0x7dcc(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %r8d
leaq 0xc25d(%rip), %rsi      # 0x2f8a6
leaq 0x7da5(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_name
void
kmip_print_name(FILE *f, int indent, Name *value)
{
    fprintf(f, "%*sName @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        kmip_print_text_string(f, indent + 2, "Name Value", value->value);
        
        fprintf(f, "%*sName Type: ", indent + 2, "");
        kmip_print_name_type_enum(f, value->type);
        fprintf(f, "\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xc22f(%rip), %rsi      # 0x2f8b4
leaq 0x7d69(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x236f8
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0xc210(%rip), %rdx      # 0x2f8c2
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xc205(%rip), %rsi      # 0x2f8cd
leaq 0x7d26(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x21b90
movq -0x8(%rbp), %rdi
leaq 0x7d03(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_nonce
void
kmip_print_nonce(FILE *f, int indent, Nonce *value)
{
    fprintf(f, "%*sNonce @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        kmip_print_byte_string(f, indent + 2, "Nonce ID", value->nonce_id);
        kmip_print_byte_string(f, indent + 2, "Nonce Value", value->nonce_value);
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xc1b7(%rip), %rsi      # 0x2f8dc
leaq 0x7cc9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x23775
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0xc199(%rip), %rdx      # 0x2f8eb
callq 0x23470
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xc184(%rip), %rdx      # 0x2f8f4
callq 0x23470
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_application_specific_information
void
kmip_print_application_specific_information(FILE *f, int indent, ApplicationSpecificInformation *value)
{
    fprintf(f, "%*sApplication Specific Information @ %p\n", indent, "", (void *)value);

    if(value != NULL)
    {
        kmip_print_text_string(f, indent + 2, "Application Namespace", value->application_namespace);
        kmip_print_text_string(f, indent + 2, "Application Data", value->application_data);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xc15b(%rip), %rsi      # 0x2f900
leaq 0x7c49(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x237f5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0xc158(%rip), %rdx      # 0x2f92a
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xc150(%rip), %rdx      # 0x2f940
callq 0x233f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_encryption_key_information
void
kmip_print_encryption_key_information(FILE *f, int indent, EncryptionKeyInformation *value)
{
    fprintf(f, "%*sEncryption Key Information @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        kmip_print_text_string(f, indent + 2, "Unique Identifier", value->unique_identifier);
        
        kmip_print_cryptographic_parameters(f, indent + 2, value->cryptographic_parameters);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xbe1a(%rip), %rsi      # 0x2faff
leaq 0x7709(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x23d2e
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x8348(%rip), %rdx      # 0x2c05a
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x23800
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_mac_signature_key_information
void
kmip_print_mac_signature_key_information(FILE *f, int indent, MACSignatureKeyInformation *value)
{
    fprintf(f, "%*sMAC/Signature Key Information @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        kmip_print_text_string(f, indent + 2, "Unique Identifier", value->unique_identifier);
        
        kmip_print_cryptographic_parameters(f, indent + 2, value->cryptographic_parameters);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xbdbe(%rip), %rsi      # 0x2fb23
leaq 0x7689(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x23dae
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x82c8(%rip), %rdx      # 0x2c05a
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x23800
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_key_wrapping_data
void
kmip_print_key_wrapping_data(FILE *f, int indent, KeyWrappingData *value)
{
    fprintf(f, "%*sKey Wrapping Data @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sWrapping Method: ", indent + 2, "");
        kmip_print_wrapping_method_enum(f, value->wrapping_method);
        fprintf(f, "\n");
        
        kmip_print_encryption_key_information(f, indent + 2, value->encryption_key_info);
        
        kmip_print_mac_signature_key_information(f, indent + 2, value->mac_signature_key_info);
        
        kmip_print_byte_string(f, indent + 2, "MAC/Signature", value->mac_signature);
        
        kmip_print_byte_string(f, indent + 2, "IV/Counter/Nonce", value->iv_counter_nonce);
        
        fprintf(f, "%*sEncoding Option: ", indent + 2, "");
        kmip_print_encoding_option_enum(f, value->encoding_option);
        fprintf(f, "\n");
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xbd65(%rip), %rsi      # 0x2fb4a
leaq 0x7609(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x23ee9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xbd56(%rip), %rsi      # 0x2fb65
leaq 0x75df(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x228e0
movq -0x8(%rbp), %rdi
leaq 0x75bd(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x23cc0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x23d40
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xbcf5(%rip), %rdx      # 0x2fb7a
callq 0x23470
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0xbce5(%rip), %rdx      # 0x2fb88
callq 0x23470
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xbce0(%rip), %rsi      # 0x2fb99
leaq 0x7535(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x229b0
movq -0x8(%rbp), %rdi
leaq 0x7512(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_attribute
void
kmip_print_attribute(FILE *f, int indent, Attribute *value)
{
    fprintf(f, "%*sAttribute @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sAttribute Name: ", indent + 2, "");
        kmip_print_attribute_type_enum(f, value->type);
        fprintf(f, "\n");
        
        fprintf(f, "%*sAttribute Index: ", indent + 2, "");
        kmip_print_integer(f, value->index);
        fprintf(f, "\n");
        
        kmip_print_attribute_value(f, indent + 2, value->type, value->value);
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xba67(%rip), %rsi      # 0x2fbcc
leaq 0x7289(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x2421c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xba50(%rip), %rsi      # 0x2fbdf
leaq 0x725f(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x21c10
movq -0x8(%rbp), %rdi
leaq 0x723d(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xba24(%rip), %rsi      # 0x2fbf3
leaq 0x721f(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x23330
movq -0x8(%rbp), %rdi
leaq 0x71fc(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x23ef0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_key_material
void
kmip_print_key_material(FILE *f, int indent, enum key_format_type format, void *value)
{
    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:
        kmip_print_byte_string(f, indent, "Key Material", (ByteString *)value);
        break;
        
        default:
        fprintf(f, "%*sUnknown Key Material @ %p\n", indent, "", value);
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %eax
decl %eax
subl $0x5, %eax
ja 0x2426b
jmp 0x24252
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rcx
leaq 0xb9a4(%rip), %rdx      # 0x2fc08
callq 0x23470
jmp 0x2428b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb998(%rip), %rsi      # 0x2fc15
leaq 0x7171(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_key_value
void
kmip_print_key_value(FILE *f, int indent, enum type type, enum key_format_type format, void *value)
{
    switch(type)
    {
        case KMIP_TYPE_BYTE_STRING:
        kmip_print_byte_string(f, indent, "Key Value", (ByteString *)value);
        break;
        
        case KMIP_TYPE_STRUCTURE:
        fprintf(f, "%*sKey Value @ %p\n", indent, "", value);
        
        if(value != NULL)
        {
            KeyValue key_value = *(KeyValue *)value;
            kmip_print_key_material(f, indent + 2, format, key_value.key_material);
            fprintf(f, "%*sAttributes: %zu\n", indent + 2, "", key_value.attribute_count);
            for(size_t i = 0; i < key_value.attribute_count; i++)
            {
                kmip_print_attribute(f, indent + 2, &key_value.attributes[i]);
            }
        }
        break;
        
        default:
        fprintf(f, "%*sUnknown Key Value @ %p\n", indent, "", value);
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x44(%rbp)
subl $0x1, %eax
je 0x242f0
jmp 0x242c6
movl -0x44(%rbp), %eax
subl $0x8, %eax
jne 0x243b1
jmp 0x242d4
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x20(%rbp), %rcx
leaq 0xb94d(%rip), %rdx      # 0x2fc33
callq 0x23470
jmp 0x243d1
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x20(%rbp), %r8
leaq 0xb93b(%rip), %rsi      # 0x2fc3d
leaq 0x70ec(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x20(%rbp)
je 0x243af
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movl -0x14(%rbp), %edx
movq -0x38(%rbp), %rcx
callq 0x24230
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x28(%rbp), %r8
leaq 0xb8ef(%rip), %rsi      # 0x2fc50
leaq 0x708d(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq $0x0, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x243ad
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
callq 0x24140
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x24377
jmp 0x243af
jmp 0x243d1
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x20(%rbp), %r8
leaq 0xb8a1(%rip), %rsi      # 0x2fc64
leaq 0x702b(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_key_block
void
kmip_print_key_block(FILE *f, int indent, KeyBlock *value)
{
    fprintf(f, "%*sKey Block @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sKey Format Type: ", indent + 2, "");
        kmip_print_key_format_type_enum(f, value->key_format_type);
        fprintf(f, "\n");
        
        fprintf(f, "%*sKey Compression Type: ", indent + 2, "");
        kmip_print_key_compression_type_enum(f, value->key_compression_type);
        fprintf(f, "\n");
        
        kmip_print_key_value(f, indent + 2, value->key_value_type, value->key_format_type, value->key_value);
        
        fprintf(f, "%*sCryptographic Algorithm: ", indent + 2, "");
        kmip_print_cryptographic_algorithm_enum(f, value->cryptographic_algorithm);
        fprintf(f, "\n");
        
        fprintf(f, "%*sCryptographic Length: %d\n", indent + 2, "", value->cryptographic_length);
        
        kmip_print_key_wrapping_data(f, indent + 2, value->key_wrapping_data);
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb87a(%rip), %rsi      # 0x2fc7f
leaq 0x6fe9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x24542
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xb863(%rip), %rsi      # 0x2fc92
leaq 0x6fbf(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x212f0
movq -0x8(%rbp), %rdi
leaq 0x6f9d(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xb838(%rip), %rsi      # 0x2fca7
leaq 0x6f7f(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x21560
movq -0x8(%rbp), %rdi
leaq 0x6f5c(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x242a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xb515(%rip), %rsi      # 0x2f9e9
leaq 0x6f1a(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x21620
movq -0x8(%rbp), %rdi
leaq 0x6ef7(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movl 0x18(%rax), %r8d
leaq 0xb7a4(%rip), %rsi      # 0x2fcc1
leaq 0x6ed1(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdx
callq 0x23dc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_symmetric_key
void
kmip_print_symmetric_key(FILE *f, int indent, SymmetricKey *value)
{
    fprintf(f, "%*sSymmetric Key @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        kmip_print_key_block(f, indent + 2, value->key_block);
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb769(%rip), %rsi      # 0x2fcde
leaq 0x6e79(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x245a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x243e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_object
void
kmip_print_object(FILE *f, int indent, enum object_type type, void *value)
{
    switch(type)
    {
        case KMIP_OBJTYPE_SYMMETRIC_KEY:
        kmip_print_symmetric_key(f, indent, (SymmetricKey *)value);
        break;
        
        default:
        fprintf(f, "%*sUnknown Object @ %p\n", indent, "", value);
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %eax
subl $0x2, %eax
jne 0x245e2
jmp 0x245d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x24550
jmp 0x24602
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb701(%rip), %rsi      # 0x2fcf5
leaq 0x6dfa(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_attributes
void
kmip_print_attributes(FILE *f, int indent, Attributes *value)
{
    fprintf(f, "%*sAttributes @ %p\n", indent, "", (void *)value);

    if(value != NULL &&
       value->attribute_list != NULL)
    {
        fprintf(f, "%*sAttributes: %zu\n", indent + 2, "", value->attribute_list->size);
        LinkedListItem *curr = value->attribute_list->head;
        while(curr != NULL)
        {
            Attribute *attribute = (Attribute *)curr->data;
            kmip_print_attribute(f, indent + 4, attribute);

            curr = curr->next;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb6bc(%rip), %rsi      # 0x2fd31
leaq 0x6d79(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x24701
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x24701
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %r8
leaq 0xb5a0(%rip), %rsi      # 0x2fc50
leaq 0x6d3e(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x246ff
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x4, %esi
movq -0x28(%rbp), %rdx
callq 0x24140
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x246cc
jmp 0x24701
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_template_attribute
void
kmip_print_template_attribute(FILE *f, int indent, TemplateAttribute *value)
{
    fprintf(f, "%*sTemplate Attribute @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sNames: %zu\n", indent + 2, "", value->name_count);
        for(size_t i = 0; i < value->name_count; i++)
        {
            kmip_print_name(f, indent + 4, &value->names[i]);
        }
        
        fprintf(f, "%*sAttributes: %zu\n", indent + 2, "", value->attribute_count);
        for(size_t i = 0; i< value->attribute_count; i++)
        {
            kmip_print_attribute(f, indent + 4, &value->attributes[i]);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb610(%rip), %rsi      # 0x2fd45
leaq 0x6cb9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x24829
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0xb5fa(%rip), %rsi      # 0x2fd61
leaq 0x6c87(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x247ba
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x4, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x20(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
callq 0x23660
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2477d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %r8
leaq 0xb47d(%rip), %rsi      # 0x2fc50
leaq 0x6c1b(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x24827
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x4, %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x28(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rdx
callq 0x24140
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x247e9
jmp 0x24829
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_create_request_payload
void
kmip_print_create_request_payload(FILE *f, int indent, CreateRequestPayload *value)
{
    fprintf(f, "%*sCreate Request Payload @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sObject Type: ", indent + 2, "");
        kmip_print_object_type_enum(f, value->object_type);
        fprintf(f, "\n");
        
        kmip_print_template_attribute(f, indent + 2, value->template_attribute);
        kmip_print_attributes(f, indent + 2, value->attributes);
        kmip_print_protection_storage_masks(f, indent + 2, value->protection_storage_masks);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb51b(%rip), %rsi      # 0x2fd70
leaq 0x6b99(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x248f3
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xb511(%rip), %rsi      # 0x2fd90
leaq 0x6b6f(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x211b0
movq -0x8(%rbp), %rdi
leaq 0x6b4d(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x24710
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x24650
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x23230
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_create_response_payload
void
kmip_print_create_response_payload(FILE *f, int indent, CreateResponsePayload *value)
{
    fprintf(f, "%*sCreate Response Payload @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sObject Type: ", indent + 2, "");
        kmip_print_object_type_enum(f, value->object_type);
        fprintf(f, "\n");
        
        kmip_print_text_string(f, indent + 2, "Unique Identifier", value->unique_identifier);
        kmip_print_template_attribute(f, indent + 2, value->template_attribute);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb47c(%rip), %rsi      # 0x2fda1
leaq 0x6ac9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x249af
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xb445(%rip), %rsi      # 0x2fd90
leaq 0x6aa3(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x211b0
movq -0x8(%rbp), %rdi
leaq 0x6a81(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x76c7(%rip), %rdx      # 0x2c05a
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x24710
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_get_request_payload
void
kmip_print_get_request_payload(FILE *f, int indent, GetRequestPayload *value)
{
    fprintf(f, "%*sGet Request Payload @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        kmip_print_text_string(f, indent + 2, "Unique Identifier", value->unique_identifier);
        
        fprintf(f, "%*sKey Format Type: ", indent + 2, "");
        kmip_print_key_format_type_enum(f, value->key_format_type);
        fprintf(f, "\n");
        
        fprintf(f, "%*sKey Wrap Type: ", indent + 2, "");
        kmip_print_key_wrap_type_enum(f, value->key_wrap_type);
        fprintf(f, "\n");
        
        fprintf(f, "%*sKey Compression Type: ", indent + 2, "");
        kmip_print_key_compression_type_enum(f, value->key_compression_type);
        fprintf(f, "\n");
        
        kmip_print_key_wrapping_specification(f, indent + 2, value->key_wrapping_spec);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb3dd(%rip), %rsi      # 0x2fdc2
leaq 0x6a09(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x24af5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x7644(%rip), %rdx      # 0x2c05a
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xb266(%rip), %rsi      # 0x2fc92
leaq 0x69c2(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x212f0
movq -0x8(%rbp), %rdi
leaq 0x699f(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xb372(%rip), %rsi      # 0x2fddf
leaq 0x6981(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x22a30
movq -0x8(%rbp), %rdi
leaq 0x695e(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xb1f9(%rip), %rsi      # 0x2fca7
leaq 0x6940(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x21560
movq -0x8(%rbp), %rdi
leaq 0x691d(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x24610
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_get_response_payload
void
kmip_print_get_response_payload(FILE *f, int indent, GetResponsePayload *value)
{
    fprintf(f, "%*sGet Response Payload @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sObject Type: ", indent + 2, "");
        kmip_print_object_type_enum(f, value->object_type);
        fprintf(f, "\n");
        
        kmip_print_text_string(f, indent + 2, "Unique Identifier", value->unique_identifier);
        kmip_print_object(f, indent + 2, value->object_type, value->object);
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb2cd(%rip), %rsi      # 0x2fdf2
leaq 0x68c9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x24bb5
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xb245(%rip), %rsi      # 0x2fd90
leaq 0x68a3(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x211b0
movq -0x8(%rbp), %rdi
leaq 0x6881(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x74c7(%rip), %rdx      # 0x2c05a
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
callq 0x245b0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_request_payload
void
kmip_print_request_payload(FILE *f, int indent, enum operation type, void *value)
{
    switch(type)
    {
        case KMIP_OP_CREATE:
        kmip_print_create_request_payload(f, indent, value);
        break;
        
        case KMIP_OP_GET:
        kmip_print_get_request_payload(f, indent, (GetRequestPayload *)value);
        break;
        
        case KMIP_OP_DESTROY:
        kmip_print_destroy_request_payload(f, indent, value);
        break;
        
        case KMIP_OP_QUERY:
        kmip_print_query_request_payload(f, indent, value);
        break;

        default:
        fprintf(f, "%*sUnknown Payload @ %p\n", indent, "", value);
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x17, %eax
ja 0x24d02
movq -0x20(%rbp), %rax
leaq 0x94df(%rip), %rcx      # 0x2e190
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x24830
jmp 0x24d22
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x249c0
jmp 0x24d22
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x24bc0
jmp 0x24d22
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x24d30
jmp 0x24d22
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb13f(%rip), %rsi      # 0x2fe53
leaq 0x66da(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_response_payload
void
kmip_print_response_payload(FILE *f, int indent, enum operation type, void *value)
{
    switch(type)
    {
        case KMIP_OP_CREATE:
        kmip_print_create_response_payload(f, indent, value);
        break;
        
        case KMIP_OP_GET:
        kmip_print_get_response_payload(f, indent, (GetResponsePayload *)value);
        break;
        
        case KMIP_OP_DESTROY:
        kmip_print_destroy_response_payload(f, indent, value);
        break;
        
        case KMIP_OP_QUERY:
        kmip_print_query_response_payload(f, indent, value);
        break;

        default:
        fprintf(f, "%*sUnknown Payload @ %p\n", indent, "", value);
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl -0x10(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x17, %eax
ja 0x24e12
movq -0x20(%rbp), %rax
leaq 0x942f(%rip), %rcx      # 0x2e1f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x24900
jmp 0x24e32
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x24b00
jmp 0x24e32
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x24c20
jmp 0x24e32
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x24e40
jmp 0x24e32
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb02f(%rip), %rsi      # 0x2fe53
leaq 0x65ca(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_query_response_payload
void
kmip_print_query_response_payload(FILE* f, int indent, QueryResponsePayload *value)
{
    fprintf(f,"%*sQuery response @ %p\n", indent, "", (void *)value);

    if(value != NULL)
    {
        kmip_print_operations(f,indent, value->operations);
        kmip_print_object_types(f,indent, value->objects);
        kmip_print_text_string(f,indent, "Vendor ID", value->vendor_identification);
        kmip_print_server_information(f,indent, value->server_information);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xb680(%rip), %rsi      # 0x304e5
leaq 0x6589(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x24ed0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x25ee0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x25ff0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xb646(%rip), %rdx      # 0x304fd
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x26210
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)