LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_username_password_credential
void
kmip_print_username_password_credential(FILE *f, int indent, UsernamePasswordCredential *value)
{
    fprintf(f, "%*sUsername/Password Credential @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        kmip_print_text_string(f, indent + 2, "Username", value->username);
        kmip_print_text_string(f, indent + 2, "Password", value->password);
    }
}

// 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 0xaf67(%rip), %rsi      # 0x2fe6c
leaq 0x64e9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x24f55
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0xaf60(%rip), %rdx      # 0x2fe92
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x9a8d(%rip), %rdx      # 0x2e9dd
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_device_credential
void
kmip_print_device_credential(FILE *f, int indent, DeviceCredential *value)
{
    fprintf(f, "%*sDevice Credential @ %p\n", indent, "", (void *)value);

    if(value != NULL)
    {
        kmip_print_text_string(f, indent + 2, "Device Serial Number", value->device_serial_number);
        kmip_print_text_string(f, indent + 2, "Password", value->password);
        kmip_print_text_string(f, indent + 2, "Device Identifier", value->device_identifier);
        kmip_print_text_string(f, indent + 2, "Network Identifier", value->network_identifier);
        kmip_print_text_string(f, indent + 2, "Machine Identifier", value->machine_identifier);
        kmip_print_text_string(f, indent + 2, "Media Identifier", value->media_identifier);
    }
}

// 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 0xaf16(%rip), %rsi      # 0x2fe9b
leaq 0x6469(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x25051
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0xaf00(%rip), %rdx      # 0x2feb6
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x9a09(%rip), %rdx      # 0x2e9dd
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xaed9(%rip), %rdx      # 0x2fecb
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xaecd(%rip), %rdx      # 0x2fedd
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0xaec2(%rip), %rdx      # 0x2fef0
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0xaeb7(%rip), %rdx      # 0x2ff03
callq 0x233f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_attestation_credential
void
kmip_print_attestation_credential(FILE *f, int indent, AttestationCredential *value)
{
    fprintf(f, "%*sAttestation Credential @ %p\n", indent, "", (void *)value);

    if(value != NULL)
    {
        kmip_print_nonce(f, indent + 2, value->nonce);
        fprintf(f, "%*sAttestation Type: ", indent + 2, "");
        kmip_print_attestation_type_enum(f, value->attestation_type);
        fprintf(f, "\n");
        kmip_print_byte_string(f, indent + 2, "Attestation Measurement", value->attestation_measurement);
        kmip_print_byte_string(f, indent + 2, "Attestation Assertion", value->attestation_assertion);
    }
}

// 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 0xae8f(%rip), %rsi      # 0x2ff14
leaq 0x6369(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x25131
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rdx
callq 0x23700
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xae6f(%rip), %rsi      # 0x2ff34
leaq 0x6329(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x20400
movq -0x8(%rbp), %rdi
leaq 0x6306(%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), %rcx
leaq 0xae3c(%rip), %rdx      # 0x2ff4a
callq 0x23470
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xae36(%rip), %rdx      # 0x2ff62
callq 0x23470
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_credential_value
void
kmip_print_credential_value(FILE *f, int indent, enum credential_type type, void *value)
{
    fprintf(f, "%*sCredential Value @ %p\n", indent, "", value);
    
    if(value != NULL)
    {
        switch(type)
        {
            case KMIP_CRED_USERNAME_AND_PASSWORD:
            kmip_print_username_password_credential(f, indent + 2, value);
            break;
            
            case KMIP_CRED_DEVICE:
            kmip_print_device_credential(f, indent + 2, value);
            break;
            
            case KMIP_CRED_ATTESTATION:
            kmip_print_attestation_credential(f, indent + 2, value);
            break;
            
            default:
            fprintf(f, "%*sUnknown Credential @ %p\n", indent + 2, "", 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)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %r8
leaq 0xae10(%rip), %rsi      # 0x2ff78
leaq 0x6286(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x25206
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x1, %eax
je 0x251a2
jmp 0x2518e
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0x251b7
jmp 0x25198
movl -0x1c(%rbp), %eax
subl $0x3, %eax
je 0x251cc
jmp 0x251e1
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rdx
callq 0x24ee0
jmp 0x25204
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rdx
callq 0x24f60
jmp 0x25204
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rdx
callq 0x25060
jmp 0x25204
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %r8
leaq 0xad9c(%rip), %rsi      # 0x2ff92
leaq 0x61f8(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
jmp 0x25206
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_credential
void
kmip_print_credential(FILE *f, int indent, Credential *value)
{
    fprintf(f, "%*sCredential @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sCredential Type: ", indent + 2, "");
        kmip_print_credential_type_enum(f, value->credential_type);
        fprintf(f, "\n");
        
        kmip_print_credential_value(f, indent + 2, value->credential_type, value->credential_value);
    }
}

// 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 0xad79(%rip), %rsi      # 0x2ffae
leaq 0x61b9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x252a7
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xad67(%rip), %rsi      # 0x2ffc2
leaq 0x6193(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x22ab0
movq -0x8(%rbp), %rdi
leaq 0x6171(%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 0x25140
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_request_batch_item
void
kmip_print_request_batch_item(FILE *f, int indent, RequestBatchItem *value)
{
    fprintf(f, "%*sRequest Batch Item @ %p\n", indent, "", (void *)value);
    
    if(value != NULL)
    {
        fprintf(f, "%*sOperation: ", indent + 2, "");
        kmip_print_operation_enum(f, value->operation);
        fprintf(f, "\n");

        fprintf(f, "%*sEphemeral: ", indent + 2, "");
        kmip_print_bool(f, value->ephemeral);
        fprintf(f, "\n");

        kmip_print_byte_string(f, indent + 2, "Unique Batch Item ID", value->unique_batch_item_id);
        kmip_print_request_payload(f, indent + 2, value->operation, value->request_payload);
    }
}

// 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 0xacba(%rip), %rsi      # 0x2ffef
leaq 0x60b9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x2540a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xacac(%rip), %rsi      # 0x3000b
leaq 0x608f(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x20540
movq -0x8(%rbp), %rdi
leaq 0x606d(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
leaq 0xac7b(%rip), %rsi      # 0x3001a
leaq 0x604f(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x23380
movq -0x8(%rbp), %rdi
leaq 0x602c(%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 0xac41(%rip), %rdx      # 0x30029
callq 0x23470
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 0x24c80
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_request_message
void
kmip_print_request_message(FILE *f, RequestMessage *value)
{
    fprintf(f, "Request Message @ %p\n", (void *)value);
    
    if(value != NULL)
    {
        kmip_print_request_header(f, 2, value->request_header);
        fprintf(f, "%*sBatch Items: %zu\n", 2, "", value->batch_count);
        
        for(size_t i = 0; i < value->batch_count; i++)
        {
            kmip_print_request_batch_item(f, 4, &value->batch_items[i]);
        }
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa7ce(%rip), %rsi      # 0x301fd
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x10(%rbp)
je 0x25ac3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x2, %esi
callq 0x25590
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %r8
leaq 0xa7aa(%rip), %rsi      # 0x30213
movl $0x2, %edx
leaq 0x5980(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x25ac1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x18(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdx
movl $0x4, %esi
callq 0x25310
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x25a84
jmp 0x25ac3
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_response_message
void
kmip_print_response_message(FILE *f, ResponseMessage *value)
{
    fprintf(f, "Response Message @ %p\n", (void *)value);
    
    if(value != NULL)
    {
        kmip_print_response_header(f, 2, value->response_header);
        fprintf(f, "  Batch Items: %zu\n", value->batch_count);
        
        for(size_t i = 0; i < value->batch_count; i++)
        {
            kmip_print_response_batch_item(f, 4, &value->batch_items[i]);
        }
    }
    
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0xa739(%rip), %rsi      # 0x30228
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x10(%rbp)
je 0x25b70
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
movl $0x2, %esi
callq 0x25860
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0xa71a(%rip), %rsi      # 0x3023f
movb $0x0, %al
callq 0x21d0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x25b6e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
imulq $0x30, -0x18(%rbp), %rax
addq %rax, %rdx
movl $0x4, %esi
callq 0x25410
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x25b34
jmp 0x25b70
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_query_functions
void
kmip_print_query_functions(FILE* f, int indent, Functions* value)
{
    fprintf(f, "%*sQuery Functions @ %p\n", indent, "", (void *)value);

    if(value != NULL &&
       value->function_list != NULL)
    {
        fprintf(f, "%*sFunctions: %zu\n", indent + 2, "", value->function_list->size);
        LinkedListItem *curr = value->function_list->head;
        size_t count = 1;
        while(curr != NULL)
        {
            fprintf(f, "%*sFunction: %zu: ", indent + 4, "", count);
            int32 func = *(int32 *)curr->data;
            kmip_print_query_function_enum(f, indent + 6, func);
            fprintf(f, "\n");

            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 0xa56e(%rip), %rsi      # 0x30363
leaq 0x55f9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x25ed2
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x25ed2
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %r8
leaq 0xa544(%rip), %rsi      # 0x3037c
leaq 0x55b6(%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 0x25ed0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x4, %edx
movq -0x28(%rbp), %r8
leaq 0xa517(%rip), %rsi      # 0x3038f
leaq 0x5576(%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 0x25b80
movq -0x8(%rbp), %rdi
leaq 0x5544(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x25e5c
jmp 0x25ed2
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_operations
void
kmip_print_operations(FILE* f, int indent, Operations *value)
{
    fprintf(f, "%*sOperations @ %p\n", indent, "", (void *)value);

    if(value != NULL &&
       value->operation_list != NULL)
    {
        fprintf(f, "%*sOperations: %zu\n", indent + 2, "", value->operation_list->size);
        LinkedListItem *curr = value->operation_list->head;
        size_t count = 1;
        while(curr != NULL)
        {
            fprintf(f, "%*sOperation: %zu: ", indent + 4, "", count);
            int32 oper = *(int32 *)curr->data;
            kmip_print_operation_enum(f, oper);
            fprintf(f, "\n");

            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 0xa49d(%rip), %rsi      # 0x303a2
leaq 0x54e9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x25fdc
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x25fdc
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %r8
leaq 0xa46e(%rip), %rsi      # 0x303b6
leaq 0x54a6(%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 0x25fda
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x4, %edx
movq -0x28(%rbp), %r8
leaq 0xa442(%rip), %rsi      # 0x303ca
leaq 0x5466(%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 -0x2c(%rbp), %esi
callq 0x20540
movq -0x8(%rbp), %rdi
leaq 0x543a(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x25f6c
jmp 0x25fdc
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_object_types
void
kmip_print_object_types(FILE* f, int indent, ObjectTypes* value)
{
    fprintf(f, "%*sObjects @ %p\n", indent, "", (void *)value);

    if(value != NULL &&
       value->object_list != NULL )
    {
        fprintf(f, "%*sObjects: %zu\n", indent + 2, "", value->object_list->size);
        LinkedListItem *curr = value->object_list->head;
        size_t count = 1;
        while(curr != NULL)
        {
            fprintf(f, "%*sObject: %zu: ", indent + 4, "", count);
            int32 obj = *(int32 *)curr->data;
            kmip_print_object_type_enum(f, obj);
            fprintf(f, "\n");

            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 0xa3c9(%rip), %rsi      # 0x303de
leaq 0x53d9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x260ec
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x260ec
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %r8
leaq 0xa397(%rip), %rsi      # 0x303ef
leaq 0x5396(%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 0x260ea
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x4, %edx
movq -0x28(%rbp), %r8
leaq 0xa368(%rip), %rsi      # 0x30400
leaq 0x5356(%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 -0x2c(%rbp), %esi
callq 0x211b0
movq -0x8(%rbp), %rdi
leaq 0x532a(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2607c
jmp 0x260ec
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_alternative_endpoints
void
kmip_print_alternative_endpoints(FILE* f, int indent, AltEndpoints* value)
{
    fprintf(f, "%*sAlt Endpointss @ %p\n", indent, "", (void *)value);

    if(value != NULL &&
       value->endpoint_list != NULL )
    {
        fprintf(f, "%*sAlt Endpoints: %zu\n", indent + 2, "", value->endpoint_list->size);
        LinkedListItem *curr = value->endpoint_list->head;
        size_t count = 1;
        while(curr != NULL)
        {
            fprintf(f, "%*sEndpoint: %zu: ", indent + 4, "", count);
            TextString* endpoint = (TextString*)curr->data;
            kmip_print_text_string(f, indent + 2, "Endpoint", endpoint);
            fprintf(f, "\n");

            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 0xa2ec(%rip), %rsi      # 0x30411
leaq 0x52c9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x26209
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x26209
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x2, %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %r8
leaq 0xa2c1(%rip), %rsi      # 0x30429
leaq 0x5286(%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 0x26207
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
addl $0x4, %edx
movq -0x28(%rbp), %r8
leaq 0xa298(%rip), %rsi      # 0x30440
leaq 0x5246(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x30(%rbp), %rcx
leaq 0xa27c(%rip), %rdx      # 0x30453
callq 0x233f0
movq -0x8(%rbp), %rdi
leaq 0x520d(%rip), %rsi      # 0x2b3f4
movb $0x0, %al
callq 0x21d0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2618c
jmp 0x26209
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_server_information
void
kmip_print_server_information(FILE* f, int indent, ServerInformation* value)
{
    fprintf(f,"%*sServer Information @ %p\n", indent, "", (void *)value);

    if(value != NULL)
    {
        kmip_print_text_string(f,indent + 2, "Server Name", value->server_name);
        kmip_print_text_string(f,indent + 2, "Server Serial Number", value->server_serial_number);
        kmip_print_text_string(f,indent + 2, "Server Version", value->server_version);
        kmip_print_text_string(f,indent + 2, "Server Load", value->server_load);
        kmip_print_text_string(f,indent + 2, "Product Name", value->product_name);
        kmip_print_text_string(f,indent + 2, "Build Level", value->build_level);
        kmip_print_text_string(f,indent + 2, "Build Date", value->build_date);
        kmip_print_text_string(f,indent + 2, "Cluster info", value->cluster_info);

        kmip_print_alternative_endpoints(f,indent+2, value->alternative_failover_endpoints);
    }
}

// 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 0xa227(%rip), %rsi      # 0x3045c
leaq 0x51b9(%rip), %rcx      # 0x2b3f5
movb $0x0, %al
callq 0x21d0
cmpq $0x0, -0x18(%rbp)
je 0x26354
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0xa212(%rip), %rdx      # 0x30478
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0xa200(%rip), %rdx      # 0x30484
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0xa1f7(%rip), %rdx      # 0x30499
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
leaq 0xa1e8(%rip), %rdx      # 0x304a8
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
leaq 0xa1d6(%rip), %rdx      # 0x304b4
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
leaq 0xa1c5(%rip), %rdx      # 0x304c1
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
leaq 0xa1b3(%rip), %rdx      # 0x304cd
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
leaq 0xa1a0(%rip), %rdx      # 0x304d8
callq 0x233f0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdx
callq 0x26100
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_bio.c
// Function: kmip_clear_last_result
void kmip_clear_last_result(void)
{
    last_result.operation     = 0;
    last_result.result_status = KMIP_STATUS_SUCCESS;
    last_result.result_reason = 0;
    last_result.result_message[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0xd31e(%rip)      # 0x351fc
movl $0x0, 0xd318(%rip)      # 0x35200
movl $0x0, 0xd312(%rip)      # 0x35204
movb $0x0, 0xd30f(%rip)      # 0x35208
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_bio.c
// Function: kmip_set_last_result
int kmip_set_last_result(ResponseBatchItem* value)
{
    if (value)
    {
        last_result.operation = value->operation;
        last_result.result_status = value->result_status;
        last_result.result_reason = value->result_reason;
        if (value->result_message)
            kmip_copy_textstring(last_result.result_message, value->result_message, sizeof(last_result.result_message));
        else
            last_result.result_message[0] = 0;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x27f6c
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, 0xd2dd(%rip)      # 0x351fc
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, 0xd2d4(%rip)      # 0x35200
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, 0xd2cb(%rip)      # 0x35204
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x27f63
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
leaq 0xd2a9(%rip), %rdi      # 0x351fc
addq $0xc, %rdi
movl $0x80, %edx
callq 0x86b0
jmp 0x27f6a
movb $0x0, 0xd29e(%rip)      # 0x35208
jmp 0x27f6c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/helpers.c
// Function: read_string
char *read_string(const char *file_path, size_t *tlen)
{
	if (file_path == NULL) {
		return NULL;
	}

	int fd = open(file_path, O_RDONLY);

	if (fd == -1) {
		perror("Read file: open");
		return NULL;
	}

	char buf[BUFSIZ], *content = NULL;
	size_t len = sizeof(buf);

	if ((content = calloc(len, sizeof(char))) == NULL) {
		perror("Read file: calloc");
		goto end;
	}

	int nb;
	*tlen = 0;

	while (true) {
		nb = read(fd, buf, sizeof(buf));
		if (nb < 0) {
			perror("Restore tree: read");
			free(content);
			content = NULL;
			goto end;
		} else if (nb == 0) {
			break;
		} else {
			*tlen += nb;
			if (*tlen > len) {
				len *= 2;
				char *rcontent = realloc(content, len * sizeof(char));
				if (rcontent == NULL) {
					perror("Read file: realloc");
					free(content);
					content = NULL;
					goto end;
				} else {
					content = rcontent;
				}
			}
			strncpy(content + (*tlen - nb), buf, nb);
		}
	}

end:
	close(fd);
	return content;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x18a7
movq $0x0, -0x8(%rbp)
jmp 0x1a58
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x1200
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x18d6
leaq 0x7f5(%rip), %rdi       # 0x20b9
callq 0x11e0
movq $0x0, -0x8(%rbp)
jmp 0x1a58
movq $0x0, -0x2028(%rbp)
movq $0x2000, -0x2030(%rbp) # imm = 0x2000
movq -0x2030(%rbp), %rdi
movl $0x1, %esi
callq 0x1190
movq %rax, -0x2028(%rbp)
cmpq $0x0, %rax
jne 0x191b
leaq 0x7b8(%rip), %rdi       # 0x20c9
callq 0x11e0
jmp 0x1a45
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movl -0x1c(%rbp), %edi
leaq -0x2020(%rbp), %rsi
movl $0x2000, %edx           # imm = 0x2000
callq 0x1070
movl %eax, -0x2034(%rbp)
cmpl $0x0, -0x2034(%rbp)
jge 0x1971
leaq 0x78b(%rip), %rdi       # 0x20db
callq 0x11e0
movq -0x2028(%rbp), %rdi
callq 0x10c0
movq $0x0, -0x2028(%rbp)
jmp 0x1a45
cmpl $0x0, -0x2034(%rbp)
jne 0x197f
jmp 0x1a43
movslq -0x2034(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq -0x2030(%rbp), %rax
jbe 0x1a0e
movq -0x2030(%rbp), %rax
shlq %rax
movq %rax, -0x2030(%rbp)
movq -0x2028(%rbp), %rdi
movq -0x2030(%rbp), %rsi
shlq $0x0, %rsi
callq 0x11d0
movq %rax, -0x2040(%rbp)
cmpq $0x0, -0x2040(%rbp)
jne 0x19fe
leaq 0x70e(%rip), %rdi       # 0x20ee
callq 0x11e0
movq -0x2028(%rbp), %rdi
callq 0x10c0
movq $0x0, -0x2028(%rbp)
jmp 0x1a45
movq -0x2040(%rbp), %rax
movq %rax, -0x2028(%rbp)
jmp 0x1a0e
movq -0x2028(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x2034(%rbp), %rcx
subq %rcx, %rax
addq %rax, %rdi
leaq -0x2020(%rbp), %rsi
movslq -0x2034(%rbp), %rdx
callq 0x11a0
jmp 0x1a3e
jmp 0x1926
jmp 0x1a45
movl -0x1c(%rbp), %edi
callq 0x1050
movq -0x2028(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/helpers.c
// Function: copy_string
char *copy_string(char *str, size_t len)
{
	char *cpy = calloc(1, ((len+1) * sizeof(char)));
	if (cpy == NULL) {
		perror("Copy string: calloc");
		return NULL;
	}
	strncpy(cpy, str, len);
	cpy[len] = '\0';
	return cpy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
shlq $0x0, %rsi
movl $0x1, %edi
callq 0x1190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1ab7
leaq 0x659(%rip), %rdi       # 0x2101
callq 0x11e0
movq $0x0, -0x8(%rbp)
jmp 0x1adc
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x11a0
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/helpers.c
// Function: mktempfifo
char *mktempfifo(const char *template)
{
	int tempfd;
	char *runtime_dir = getenv(RUNTIME_DIR_ENV);
	if (runtime_dir == NULL) {
		runtime_dir = "/tmp";
	}

	char *fifo_path = malloc(strlen(runtime_dir)+1+strlen(template)+1);
	if (fifo_path == NULL) {
		return NULL;
	}

	sprintf(fifo_path, "%s/%s", runtime_dir, template);

	if ((tempfd = mkstemp(fifo_path)) == -1) {
		free(fifo_path);
		return NULL;
	}

	close(tempfd);
	unlink(fifo_path);

	if (mkfifo(fifo_path, 0666) == -1) {
		free(fifo_path);
		return NULL;
	}

	return fifo_path;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x612(%rip), %rdi       # 0x2115
callq 0x1150
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1b1e
leaq 0x60b(%rip), %rax       # 0x2125
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x10d0
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10d0
movq -0x30(%rbp), %rdi
addq %rax, %rdi
addq $0x1, %rdi
callq 0x1080
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1b5d
movq $0x0, -0x8(%rbp)
jmp 0x1bda
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rcx
leaq 0x5ba(%rip), %rsi       # 0x212a
movb $0x0, %al
callq 0x1100
movq -0x28(%rbp), %rdi
callq 0x1160
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x1b9b
movq -0x28(%rbp), %rdi
callq 0x10c0
movq $0x0, -0x8(%rbp)
jmp 0x1bda
movl -0x14(%rbp), %edi
callq 0x1050
movq -0x28(%rbp), %rdi
callq 0x10a0
movq -0x28(%rbp), %rdi
movl $0x1b6, %esi            # imm = 0x1B6
callq 0x11c0
cmpl $-0x1, %eax
jne 0x1bd2
movq -0x28(%rbp), %rdi
callq 0x10c0
movq $0x0, -0x8(%rbp)
jmp 0x1bda
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/helpers.c
// Function: is_hex_color
bool is_hex_color(const char *color)
{
	if (color[0] != '#' || strlen(color) != 7) {
		return false;
	}
	for (int i = 1; i < 7; i++) {
		if (!isxdigit(color[i])) {
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x1d67
movq -0x10(%rbp), %rdi
callq 0x10d0
cmpq $0x7, %rax
je 0x1d6d
movb $0x0, -0x1(%rbp)
jmp 0x1db6
movl $0x1, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jge 0x1db2
callq 0x10f0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
jne 0x1da5
movb $0x0, -0x1(%rbp)
jmp 0x1db6
jmp 0x1da7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1d74
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/baskerville[P]bspwm/src/helpers.c
// Function: tokenize_with_escape
char *tokenize_with_escape(struct tokenize_state *state, const char *s, char sep)
{
	if (s != NULL) {
		// first call
		state->in_escape = false;
		state->pos = s;
		state->len = strlen(s) + 1;
	}

	char *outp = calloc(state->len, 1);
	char *ret = outp;
	if (!outp) return NULL;

	char cur;
	while (*state->pos) {
		--state->len;
		cur = *state->pos++;

		if (state->in_escape) {
			*outp++ = cur;
			state->in_escape = false;
			continue;
		}

		if (cur == '\\') {
			state->in_escape = !state->in_escape;
		} else if (cur == sep) {
			return ret;
		} else {
			*outp++ = cur;
		}
	}

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1e17
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x10d0
movq %rax, %rcx
addq $0x1, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
callq 0x1190
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1e49
movq $0x0, -0x8(%rbp)
jmp 0x1f00
jmp 0x1e4b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpb $0x0, (%rax)
je 0x1ef8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movb (%rax), %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x1eaa
movb -0x31(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x1e4b
movsbl -0x31(%rbp), %eax
cmpl $0x5c, %eax
jne 0x1ec7
movq -0x10(%rbp), %rax
movb (%rax), %cl
xorb $-0x1, %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
jmp 0x1ef3
movsbl -0x31(%rbp), %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x1edd
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f00
movb -0x31(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
jmp 0x1ef3
jmp 0x1e4b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/sound_device/UARTRecord.c
// Function: int_handler
void int_handler(){

	fprintf(stderr, "Interrupt received\n");

	if(UART_is_open(&uart))
		UART_close(&uart);

	exit(0);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x2dad(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdaf(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x10a0
leaq 0x2f59(%rip), %rdi      # 0x41bc
callq 0x1900
testb $0x1, %al
jne 0x126e
jmp 0x127a
leaq 0x2f47(%rip), %rdi      # 0x41bc
callq 0x1930
xorl %edi, %edi
callq 0x1120
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/sound_device/UARTRecord.c
// Function: main
int main(int argc, char **argv){

	signal(SIGINT, int_handler);

	struct arguments arguments;

	arguments.device_name = NULL;
	arguments.baud_rate = 230400;

	argp_parse(&argp, argc, argv, 0, 0, &arguments);

	if(arguments.device_name == NULL){
		fprintf(stderr, "Please specify a serial port to read from\n");
		return -1;
	}

	int status = UART_open(&uart, arguments.device_name, arguments.baud_rate);

	if(status != 0){
		fprintf(stderr, "Could not open serial port, terminating\n");
		return -1;
	}

	char buffer[BUFFER_SIZE];

	while(true){

		int bytes_read = UART_read(&uart, buffer, BUFFER_SIZE);
		if(bytes_read <= 0){
			fprintf(stderr, "Error reading! %d\n", bytes_read);
			break;
		}

		int bytes_written = fwrite(buffer, sizeof(char), bytes_read, stdout);
		if(bytes_written != bytes_read){
			fprintf(stderr, "Error writing!\n");
			break;
		}

		fflush(stdout);

	}

	fprintf(stderr, "Loop broken, closing...\n");

	UART_close(&uart);

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x2, %edi
leaq -0x72(%rip), %rsi       # 0x1240
callq 0x1090
movq $0x0, -0x20(%rbp)
movl $0x38400, -0x18(%rbp)   # imm = 0x38400
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
leaq 0x2ddc(%rip), %rdi      # 0x40b0
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r8d
leaq -0x20(%rbp), %r9
callq 0x1080
cmpq $0x0, -0x20(%rbp)
jne 0x130f
movq 0x2d06(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd1c(%rip), %rsi       # 0x2018
movb $0x0, %al
callq 0x10a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x140c
movq -0x20(%rbp), %rsi
movl -0x18(%rbp), %edx
leaq 0x2e9f(%rip), %rdi      # 0x41bc
callq 0x1490
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x134f
movq 0x2cc6(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd07(%rip), %rsi       # 0x2043
movb $0x0, %al
callq 0x10a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x140c
jmp 0x1351
leaq -0x40(%rbp), %rsi
leaq 0x2e60(%rip), %rdi      # 0x41bc
movl $0x19, %edx
callq 0x19c0
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jg 0x138c
movq 0x2c82(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0x44(%rbp), %edx
leaq 0xce9(%rip), %rsi       # 0x206c
movb $0x0, %al
callq 0x10a0
jmp 0x13e1
leaq -0x40(%rbp), %rdi
movslq -0x44(%rbp), %rdx
movq 0x2c3d(%rip), %rax      # 0x3fd8
movq (%rax), %rcx
movl $0x1, %esi
callq 0x1130
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
je 0x13cd
movq 0x2c3e(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xcbb(%rip), %rsi       # 0x207f
movb $0x0, %al
callq 0x10a0
jmp 0x13e1
movq 0x2c04(%rip), %rax      # 0x3fd8
movq (%rax), %rdi
callq 0x10b0
jmp 0x1351
movq 0x2c10(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xc9d(%rip), %rsi       # 0x208f
movb $0x0, %al
callq 0x10a0
leaq 0x2dbc(%rip), %rdi      # 0x41bc
callq 0x1930
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/sound_device/UARTRecord.c
// Function: parse_opt
static error_t parse_opt(int key, char *arg, struct argp_state *state){

	// remove cast in full C
	struct arguments *arguments = ((struct arguments*)(state->input));

	switch(key){
		case 's':
			arguments->device_name = arg;
			break;
		case 'b':
			arguments->baud_rate = atoi(arg);
			break;
		default:
			return ARGP_ERR_UNKNOWN;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0x62, %eax
je 0x1463
jmp 0x144c
movl -0x24(%rbp), %eax
subl $0x73, %eax
jne 0x1477
jmp 0x1456
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1480
movq -0x10(%rbp), %rdi
callq 0x1110
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x1480
movl $0x7, -0x4(%rbp)
jmp 0x1487
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/io/uart/UART.c
// Function: UART_close
int UART_close(UART *self){

	// Ensure any custom baud rate is reset to the normal speed
	struct serial_struct ss;
	ioctl(self->fd, TIOCGSERIAL, &ss);
	ss.flags &= ~ASYNC_SPD_MASK;
	ioctl(self->fd, TIOCSSERIAL, &ss);

	int status = close(self->fd);
	if(status == -1){
		perror("Unable to close socket");
		return -1;
	}

	self->fd = -1;

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl $0x541e, %esi           # imm = 0x541E
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x1050
movl -0x48(%rbp), %eax
andl $0xffffefcf, %eax       # imm = 0xFFFFEFCF
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl $0x541f, %esi           # imm = 0x541F
leaq -0x58(%rbp), %rdx
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x1060
movl %eax, -0x5c(%rbp)
cmpl $-0x1, -0x5c(%rbp)
jne 0x199c
leaq 0x7d5(%rip), %rdi       # 0x2163
callq 0x1100
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x19ad
movq -0x10(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DrYerzinia[P]C_DigiMode/src/io/uart/UART.c
// Function: UART_write
int UART_write(UART *self, char *buffer, int length){

	int bytes_written = write(self->fd, buffer, length);
	if(bytes_written != length){
		perror("Did not write length bytes");
		return -1;
	}

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x1030
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
je 0x1a46
leaq 0x742(%rip), %rdi       # 0x217a
callq 0x1100
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a4d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/singpolyma[P]mnemonicode/mndecode.c
// Function: main
int main(int argc, char **argv) {
	char buf[0x90000];
	mn_byte outbuf[0x10000];
	int buflen;
	int n, i;
	int hex_encoded_output = 0;

	if(argc > 1 && strcmp(argv[1],"-x") == 0) {
		hex_encoded_output = 1;
	}

	buflen = fread(buf, 1, sizeof buf - 1, stdin);
	buf[buflen] = 0;

	n = mn_decode(buf, outbuf, sizeof outbuf);
	if(n < 0) {
		fprintf(stderr, "mn_decode result %d\n", n);
		return EXIT_FAILURE;
	}

	if(hex_encoded_output) {
		for(i = 0; i < n; i++) {
			printf("%02X", outbuf[i]);
		}
	} else {
		fwrite(outbuf, 1, n, stdout);
	}

	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0020, %rsp          # imm = 0xA0020
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0xa0020(%rbp)
cmpl $0x1, -0x8(%rbp)
jle 0xb1dc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xe3c(%rip), %rsi       # 0xc004
callq 0xb050
cmpl $0x0, %eax
jne 0xb1dc
movl $0x1, -0xa0020(%rbp)
leaq -0x90010(%rbp), %rdi
movq 0x4dee(%rip), %rax      # 0xffd8
movq (%rax), %rcx
movl $0x1, %esi
movl $0x8ffff, %edx          # imm = 0x8FFFF
callq 0xb030
movl %eax, -0xa0014(%rbp)
movslq -0xa0014(%rbp), %rax
movb $0x0, -0x90010(%rbp,%rax)
leaq -0x90010(%rbp), %rdi
leaq -0xa0010(%rbp), %rsi
movl $0x10000, %edx          # imm = 0x10000
callq 0xbd40
movl %eax, -0xa0018(%rbp)
cmpl $0x0, -0xa0018(%rbp)
jge 0xb25f
movq 0x4db9(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movl -0xa0018(%rbp), %edx
leaq 0xdb8(%rip), %rsi       # 0xc007
movb $0x0, %al
callq 0xb060
movl $0x1, -0x4(%rbp)
jmp 0xb2d9
cmpl $0x0, -0xa0020(%rbp)
je 0xb2b0
movl $0x0, -0xa001c(%rbp)
movl -0xa001c(%rbp), %eax
cmpl -0xa0018(%rbp), %eax
jge 0xb2ae
movslq -0xa001c(%rbp), %rax
movzbl -0xa0010(%rbp,%rax), %esi
leaq 0xd86(%rip), %rdi       # 0xc01c
movb $0x0, %al
callq 0xb040
movl -0xa001c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa001c(%rbp)
jmp 0xb272
jmp 0xb2d2
leaq -0xa0010(%rbp), %rdi
movslq -0xa0018(%rbp), %rdx
movq 0x4d0b(%rip), %rax      # 0xffd0
movq (%rax), %rcx
movl $0x1, %esi
callq 0xb070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xa0020, %rsp          # imm = 0xA0020
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/singpolyma[P]mnemonicode/mnemonic.c
// Function: mn_encode_word_index
mn_index mn_encode_word_index (void *vsrc, int srcsize, int n)
{
  mn_word32 x = 0;		/* Temporary for MN_BASE arithmetic */
  int offset;			/* Offset into src */
  int remaining;		/* Octets remaining to end of src */
  int extra = 0;		/* Index 7 extra words for 24 bit data */
  int i;
  mn_byte *src = vsrc;

  if (n < 0 || n >= mn_words_required (srcsize))
    return 0;			/* word out of range */
  offset = (n / 3) * 4;		/* byte offset into src */
  remaining = srcsize - offset;
  if (remaining <= 0)
    return 0;
  if (remaining >= 4)
    remaining = 4;
  for (i = 0; i < remaining; i++)
    x |= (unsigned long)src[offset + i] << (i * 8);	/* endianness-agnostic */

  switch (n % 3)
    {
    case 2:			/* Third word of group */
      if (remaining == 3)	/*  special case for 24 bits */
	extra = MN_BASE;	/*  use one of the 7 3-letter words */
      x /= (MN_BASE * MN_BASE);
      break;
    case 1:			/* Second word of group */
      x /= MN_BASE;
    }
  return x % MN_BASE + extra + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x0, -0x18(%rbp)
jl 0xb356
movl -0x18(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x14(%rbp), %edi
callq 0xb2f0
movl %eax, %ecx
movl -0x3c(%rbp), %eax
cmpl %ecx, %eax
jl 0xb362
movl $0x0, -0x4(%rbp)
jmp 0xb460
movl -0x18(%rbp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
shll $0x2, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jg 0xb38e
movl $0x0, -0x4(%rbp)
jmp 0xb460
cmpl $0x4, -0x28(%rbp)
jl 0xb39b
movl $0x4, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0xb3d9
movq -0x38(%rbp), %rax
movl -0x24(%rbp), %ecx
addl -0x30(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
movl -0x30(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shlq %cl, %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0xb3a2
movslq -0x18(%rbp), %rcx
movl %ecx, %eax
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
movl %eax, -0x40(%rbp)
subl $0x1, %eax
je 0xb42f
jmp 0xb404
movl -0x40(%rbp), %eax
subl $0x2, %eax
jne 0xb441
jmp 0xb40e
cmpl $0x3, -0x28(%rbp)
jne 0xb41b
movl $0x65a, -0x2c(%rbp)     # imm = 0x65A
movq -0x20(%rbp), %rax
movl $0x2857a4, %ecx         # imm = 0x2857A4
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
jmp 0xb441
movq -0x20(%rbp), %rax
movl $0x65a, %ecx            # imm = 0x65A
xorl %edx, %edx
divq %rcx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl $0x65a, %ecx            # imm = 0x65A
xorl %edx, %edx
divq %rcx
movq %rdx, %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)