LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf.c
// Function: dbf_put_fields
int dbf_put_fields(dbhead *dbh) {
	dbf_field	field;
	u_long		t;
	u_char		end = 0x0D;

	if (lseek(dbh->db_fd, sizeof(dbf_header), SEEK_SET) == -1) {
		return DBF_ERROR;
	}

/* Set dataarea of field to '\0' */
	memset(&field,'\0',sizeof(dbf_field));

	for (t = 0; t < dbh->db_nfields; t++) {
		strncpy(field.dbf_name, dbh->db_fields[t].db_name, DBF_NAMELEN - 1);
		field.dbf_type = dbh->db_fields[t].db_type;
		field.dbf_flen = dbh->db_fields[t].db_flen;
		field.dbf_dec = dbh->db_fields[t].db_dec;

		if (write(dbh->db_fd, &field, sizeof(dbf_field)) == -1) {
			return DBF_ERROR;
		}
	}

	if (write(dbh->db_fd, &end, 1) == -1) {
		return DBF_ERROR;
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movb $0xd, 0xf(%rsp)
movl (%rdi), %edi
pushq $0x20
popq %rsi
xorl %edx, %edx
callq 0x2390
pushq $-0x1
popq %rcx
cmpq $-0x1, %rax
je 0x4501
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
pushq $-0x1
popq %rbp
xorl %ebx, %ebx
movzbl 0x32(%r14), %eax
incq %rbp
cmpq %rax, %rbp
jae 0x44e6
leaq 0xf(%rbx), %r12
movq 0x40(%r14), %r13
leaq (%rbx,%r13), %rsi
movq %r15, %rdi
pushq $0xa
popq %rdx
callq 0x2110
movb 0xb(%r13,%rbx), %al
movb %al, 0x1b(%rsp)
movb 0xc(%r13,%rbx), %al
movb %al, 0x20(%rsp)
movb 0xd(%r13,%rbx), %al
movb %al, 0x21(%rsp)
movl (%r14), %edi
movq %r15, %rsi
pushq $0x20
popq %rdx
callq 0x20a0
movq %r12, %rbx
cmpq $-0x1, %rax
jne 0x448b
pushq $-0x1
popq %rcx
jmp 0x4501
movl (%r14), %edi
leaq 0xf(%rsp), %rsi
pushq $0x1
popq %rdx
callq 0x20a0
xorl %ecx, %ecx
cmpq $-0x1, %rax
sete %cl
negl %ecx
movl %ecx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf.c
// Function: dbf_add_field
int dbf_add_field(dbhead *dbh, char *name, u_char type,
		  u_char length, u_char dec) {
f_descr	*ptr;
u_char	*foo;
u_long	size, field_no;

	size = (dbh->db_nfields + 1) * sizeof(f_descr);
	if (!(ptr = (f_descr *) realloc(dbh->db_fields, size))) {
		return DBF_ERROR;
	}
	dbh->db_fields = ptr;

	field_no = dbh->db_nfields;
	strncpy(dbh->db_fields[field_no].db_name, name, DBF_NAMELEN);
	dbh->db_fields[field_no].db_type = type;
	dbh->db_fields[field_no].db_flen = length;
	dbh->db_fields[field_no].db_dec = dec;

	dbh->db_nfields++;
	dbh->db_hlen += sizeof(dbf_field);
	dbh->db_rlen += length;

	if (!(foo = (u_char *) realloc(dbh->db_buff, dbh->db_rlen))) {
		return DBF_ERROR;
	}

	dbh->db_buff = foo;

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movl %ecx, %r14d
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %rbx
movzbl 0x32(%rdi), %eax
imulq $0xf, %rax, %rsi
addq $0xf, %rsi
movq 0x40(%rdi), %rdi
callq 0x2350
pushq $-0x1
popq %rcx
testq %rax, %rax
je 0x45b4
movq %rax, %r15
movq %rax, 0x40(%rbx)
movl %r12d, 0x4(%rsp)
movzbl 0x32(%rbx), %r12d
movq %r13, %rsi
imulq $0xf, %r12, %r13
movq %rax, %rdi
addq %r13, %rdi
pushq $0xb
popq %rdx
callq 0x2110
movb %bpl, 0xb(%r15,%r13)
movb %r14b, 0xc(%r15,%r13)
movl 0x4(%rsp), %eax
movb %al, 0xd(%r15,%r13)
leal 0x1(%r12), %eax
movb %al, 0x32(%rbx)
addq $0x20, 0x18(%rbx)
movzbl %r14b, %eax
addw 0x30(%rbx), %ax
movw %ax, 0x30(%rbx)
movq 0x38(%rbx), %rdi
movzwl %ax, %esi
callq 0x2350
pushq $-0x1
popq %rcx
testq %rax, %rax
je 0x45b4
movq %rax, 0x38(%rbx)
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf.c
// Function: dbf_open_new
dbhead *dbf_open_new(char *name, int flags) {
dbhead	*dbh;

	if (!(dbh = (dbhead *)malloc(sizeof(dbhead)))) {
		return (dbhead *)DBF_ERROR;
	}

	if (flags & O_CREAT) {
		if ((dbh->db_fd = open(name, flags, DBF_FILE_MODE)) == -1) {
			free(dbh);
			return (dbhead *)DBF_ERROR;
		}
	} else {
		if ((dbh->db_fd = open(name, flags)) == -1) {
			free(dbh);
			return (dbhead *)DBF_ERROR;
		}
	}
		

	dbh->db_offset = 0;
	dbh->db_memo = 0;
	dbh->db_year = 0;
	dbh->db_month = 0;
	dbh->db_day	= 0;
	dbh->db_hlen = sizeof(dbf_header) + 1;
	dbh->db_records = 0;
	dbh->db_currec = 0;
	dbh->db_rlen = 1;
	dbh->db_nfields = 0;
	dbh->db_buff = NULL;
	dbh->db_fields = (f_descr *)NULL;

	return dbh;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl $0x88, %edi
callq 0x2280
pushq $-0x1
popq %r15
testq %rax, %rax
je 0x463e
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
testb $0x40, %bpl
jne 0x45fb
xorl %eax, %eax
callq 0x2150
jmp 0x4607
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2150
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x4636
andl $0x0, 0x10(%rbx)
andq $0x0, 0x8(%rbx)
movq $0x21, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movw $0x1, 0x30(%rbx)
movb $0x0, 0x32(%rbx)
movups %xmm0, 0x38(%rbx)
jmp 0x4641
movq %rbx, %rdi
callq 0x2230
movq %r15, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf.c
// Function: dbf_build_record
field *dbf_build_record(dbhead *dbh)
{
    int 	t;
    field	*fields;
  
    if (!(fields = (field *)calloc(dbh->db_nfields, sizeof(field)))) {
	return (field *)DBF_ERROR;
    }
  
    for ( t = 0; t < dbh->db_nfields; t++)
    {
	switch(dbh->db_fields[t].db_type)
	{
	  case 'M':
	    fields[t].db_blen = dbh->mb_blksiz + 1;
	    break;

	  case 'B':
	  case 'Y':
	    fields[t].db_blen = 26;
	    break;

	  case 'T':
	    fields[t].db_blen = 24;
	    break;

	  case 'I':
	    fields[t].db_blen = 16;
	    break;

	  case 'G':
	  case 'P':
	    fields[t].db_blen = dbh->mb_blksiz * 2 + 2; /* Binary to hex representation */
	    break;

	  default:
	    fields[t].db_blen = dbh->db_fields[t].db_flen + 1;
	}

	if (!(fields[t].db_contents = (char *)malloc(fields[t].db_blen)))
	{
	    int		i;
	    for (i = 0; i < t; i++)
		if (fields[i].db_contents != 0)
		    free(fields[i].db_contents);
	    free(fields);
	    return (field *)DBF_ERROR;
	}
	strncpy(fields[t].db_name, dbh->db_fields[t].db_name, DBF_NAMELEN);
	fields[t].db_type = dbh->db_fields[t].db_type;
	//printf("TYPE: %d NAME: %s LEN: %d\n",dbh->db_fields[t].db_type, dbh->db_fields[t].db_name,dbh->db_fields[t].db_flen); 
	fields[t].db_flen = dbh->db_fields[t].db_flen;
	fields[t].db_dec  = dbh->db_fields[t].db_dec;
    } 
    return fields;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movzbl 0x32(%rdi), %r12d
pushq $0x20
popq %rsi
movq %r12, %rdi
callq 0x2140
movq %rax, %rbp
pushq $-0x1
popq %rax
testq %rbp, %rbp
je 0x4f5d
xorl %r14d, %r14d
movq %rbp, (%rsp)
xorl %ebx, %ebx
cmpq %rbx, %r12
je 0x4f2d
movq 0x40(%r15), %r13
movzbl 0xb(%r13,%r14), %eax
leal -0x47(%rax), %ecx
cmpl $0x9, %ecx
ja 0x4eba
leaq 0x1bd1(%rip), %rdx      # 0x6a74
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x68(%r15), %rax
leaq 0x2(,%rax,2), %rdi
jmp 0x4ee4
pushq $0x1a
popq %rdi
cmpl $0x42, %eax
je 0x4ee4
cmpl $0x54, %eax
je 0x4ee1
cmpl $0x59, %eax
je 0x4ee4
movzbl 0xc(%r13,%r14), %edi
jmp 0x4edc
pushq $0x10
jmp 0x4ee3
movq 0x68(%r15), %rdi
incq %rdi
jmp 0x4ee4
pushq $0x18
popq %rdi
movq %rdi, 0x10(%rbp)
callq 0x2280
movq %rax, 0x18(%rbp)
testq %rax, %rax
je 0x4f33
leaq (%r14,%r13), %rsi
movq %rbp, %rdi
pushq $0xb
popq %rdx
callq 0x2110
movb 0xb(%r13,%r14), %al
movb %al, 0xb(%rbp)
movb 0xc(%r13,%r14), %al
movb %al, 0xc(%rbp)
movb 0xd(%r13,%r14), %al
movb %al, 0xd(%rbp)
incq %rbx
addq $0x20, %rbp
addq $0xf, %r14
jmp 0x4e81
movq (%rsp), %rax
jmp 0x4f5d
movq (%rsp), %r15
movq %r15, %r14
addq $0x18, %r14
subq $0x1, %rbx
jb 0x4f52
movq (%r14), %rdi
callq 0x2230
addq $0x20, %r14
jmp 0x4f3e
movq %r15, %rdi
callq 0x2230
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf.c
// Function: dbf_free_record
void dbf_free_record(dbhead *dbh, field *rec) {
	int t;

	for ( t = 0; t < dbh->db_nfields; t++) {

	  free(rec[t].db_contents);

	}

	free(rec);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsi), %r15
xorl %r12d, %r12d
movzbl 0x32(%r14), %eax
cmpq %rax, %r12
jae 0x4f9c
movq (%r15), %rdi
callq 0x2230
incq %r12
addq $0x20, %r15
jmp 0x4f81
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2230
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/demos/demo_create.c
// Function: print_help
void
print_help(const char *app)
{
    printf("Usage: %s [flag value | flag] ...\n\n", app);
    printf("Flags:\n");
    printf("-a addr : the IP address of the KMIP server\n");
    printf("-c path : path to client certificate file\n");
    printf("-h      : print this help info\n");
    printf("-k path : path to client key file\n");
    printf("-p port : the port number of the KMIP server\n");
    printf("-r path : path to CA certificate file\n");
}

// Assembly:
pushq %rax
movq %rdi, %rsi
leaq 0x16cad(%rip), %rdi     # 0x19004
xorl %eax, %eax
callq 0x2040
leaq 0x16e65(%rip), %rdi     # 0x191ca
callq 0x2210
leaq 0x16e60(%rip), %rdi     # 0x191d1
callq 0x2210
leaq 0x16e80(%rip), %rdi     # 0x191fd
callq 0x2210
leaq 0x16e9e(%rip), %rdi     # 0x19227
callq 0x2210
leaq 0x16eb1(%rip), %rdi     # 0x19246
callq 0x2210
leaq 0x16ec7(%rip), %rdi     # 0x19268
callq 0x2210
leaq 0x16ee8(%rip), %rdi     # 0x19295
popq %rax
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/demos/demo_create.c
// Function: parse_arguments
int
parse_arguments(int argc, char **argv,
                char **server_address, char **server_port,
                char **client_certificate, char **client_key, char **ca_certificate,
                int *print_usage)
{
    if(argc <= 1)
    {
        print_help(argv[0]);
        return(-1);
    }
    
    for(int i = 1; i < argc; i++)
    {
        if(strncmp(argv[i], "-a", 2) == 0)
            *server_address = argv[++i];
        else if(strncmp(argv[i], "-c", 2) == 0)
            *client_certificate = argv[++i];
        else if(strncmp(argv[i], "-h", 2) == 0)
            *print_usage = 1;
        else if(strncmp(argv[i], "-k", 2) == 0)
            *client_key = argv[++i];
        else if(strncmp(argv[i], "-p", 2) == 0)
            *server_port = argv[++i];
        else if(strncmp(argv[i], "-r", 2) == 0)
            *ca_certificate = argv[++i];
        else
        {
            printf("Invalid option: '%s'\n", argv[i]);
            print_help(argv[0]);
            return(-1);
        }
    }
    
    return(0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
cmpl $0x2, %edi
jge 0x23cf
movq (%r14), %rdi
callq 0x234c
pushq $-0x1
popq %rax
jmp 0x247b
movl %edi, %ebx
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rdi
pushq $0x1
popq %rbp
cmpl %ebx, %ebp
jge 0x2472
movslq %ebp, %r10
movq (%r14,%r10,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x245c
cmpb $0x61, 0x1(%rsi)
jne 0x2404
incl %ebp
movq 0x8(%r14,%r10,8), %rsi
movq %rsi, (%rdx)
jmp 0x2458
cmpb $0x63, 0x1(%rsi)
jne 0x2416
incl %ebp
movq 0x8(%r14,%r10,8), %rsi
movq %rsi, (%r8)
jmp 0x2458
cmpb $0x68, 0x1(%rsi)
jne 0x2424
movl $0x1, (%rax)
jmp 0x2458
cmpb $0x6b, 0x1(%rsi)
jne 0x2436
incl %ebp
movq 0x8(%r14,%r10,8), %rsi
movq %rsi, (%r9)
jmp 0x2458
cmpb $0x70, 0x1(%rsi)
jne 0x2448
incl %ebp
movq 0x8(%r14,%r10,8), %rsi
movq %rsi, (%rcx)
jmp 0x2458
cmpb $0x72, 0x1(%rsi)
jne 0x245c
incl %ebp
movq 0x8(%r14,%r10,8), %rsi
movq %rsi, (%rdi)
incl %ebp
jmp 0x23de
leaq 0x16bc5(%rip), %rdi     # 0x19028
xorl %eax, %eax
callq 0x2040
movq (%r14), %rdi
callq 0x234c
xorl %eax, %eax
cmpl %ebx, %ebp
setl %al
negl %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/demos/demo_create.c
// Function: main
int
main(int argc, char **argv)
{
    char *server_address = NULL;
    char *server_port = NULL;
    char *client_certificate = NULL;
    char *client_key = NULL;
    char *ca_certificate = NULL;
    int help = 0;
    
    int error = parse_arguments(argc, argv, &server_address, &server_port, &client_certificate, &client_key, &ca_certificate, &help);
    if(error)
        return(error);
    if(help)
    {
        print_help(argv[0]);
        return(0);
    }
    
    use_low_level_api(server_address, server_port, client_certificate, client_key, ca_certificate);
    return(0);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
leaq 0x28(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x20(%rsp), %rcx
andq $0x0, (%rcx)
leaq 0x18(%rsp), %r8
andq $0x0, (%r8)
leaq 0x10(%rsp), %r9
andq $0x0, (%r9)
leaq 0x8(%rsp), %rax
andq $0x0, (%rax)
leaq 0x4(%rsp), %r10
andl $0x0, (%r10)
pushq %r10
pushq %rax
callq 0x23b3
addq $0x10, %rsp
testl %eax, %eax
je 0x2d0f
pushq $-0x1
popq %rax
jmp 0x2d40
cmpl $0x0, 0x4(%rsp)
je 0x2d20
movq (%rbx), %rdi
callq 0x234c
jmp 0x2d3e
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x2480
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_buffer
void
kmip_print_buffer(FILE *f, void *buffer, int size)
{
    if(buffer == NULL)
    {
        return;
    }
    
    uint8 *index = (uint8 *)buffer;
    for(int i = 0; i < size; i++)
    {
        if(i % 16 == 0)
        {
            fprintf(f, "\n0x");
        }
        fprintf(f, "%02X", index[i]);
    }
}

// Assembly:
testq %rsi, %rsi
je 0x12585
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %ebx
pushq $0x1
popq %rbp
leaq 0x94a3(%rip), %r12      # 0x1b9e0
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x12577
testb $0xf, %r13b
jne 0x12560
leaq 0x948a(%rip), %rdi      # 0x1b9dc
pushq $0x3
popq %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x2240
movzbl (%r14,%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2200
incq %r13
jmp 0x12540
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_stack_trace
void
kmip_print_stack_trace(FILE *f, KMIP *ctx)
{
    if(ctx == NULL)
    {
        return;
    }
    
    ErrorFrame *index = ctx->frame_index;
    do
    {
        fprintf(f, "- %s @ line: %d\n", index->function, index->line);
    } while(index-- != ctx->errors);
}

// Assembly:
testq %rsi, %rsi
je 0x125d7
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x860(%rsi), %r15
addq $0x38, %rbx
addq $0x68, %r15
leaq 0x9436(%rip), %r12      # 0x1b9e5
movl -0x4(%r15), %ecx
addq $-0x68, %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2200
cmpq %rbx, %r15
jne 0x125af
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_attestation_type_enum
void
kmip_print_attestation_type_enum(FILE *f, enum attestation_type value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_ATTEST_TPM_QUOTE:
        fprintf(f, "TPM Quote");
        break;
        
        case KMIP_ATTEST_TCG_INTEGRITY_REPORT:
        fprintf(f, "TCG Integrity Report");
        break;
        
        case KMIP_ATTEST_SAML_ASSERTION:
        fprintf(f, "SAML Assertion");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
movq %rdi, %rcx
cmpl $0x3, %esi
ja 0x1271c
movl %esi, %eax
leaq 0x8cc9(%rip), %rdx      # 0x1b3b0
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
pushq $0x2d
popq %rdi
movq %rcx, %rsi
jmp 0x21b0
leaq 0x94ae(%rip), %rdi      # 0x1bbb0
pushq $0x14
jmp 0x12725
leaq 0x94b8(%rip), %rdi      # 0x1bbc5
pushq $0xe
jmp 0x12725
leaq 0x948e(%rip), %rdi      # 0x1bba6
pushq $0x9
jmp 0x12725
leaq 0xb38c(%rip), %rdi      # 0x1daaf
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
jmp 0x2240
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_name_type_enum
void
kmip_print_name_type_enum(FILE *f, enum name_type value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_NAME_UNINTERPRETED_TEXT_STRING:
        fprintf(f, "Uninterpreted Text String");
        break;
        
        case KMIP_NAME_URI:
        fprintf(f, "URI");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
movq %rdi, %rcx
cmpl $0x2, %esi
je 0x1331f
cmpl $0x1, %esi
je 0x13314
testl %esi, %esi
jne 0x1332a
pushq $0x2d
popq %rdi
movq %rcx, %rsi
jmp 0x21b0
leaq 0x9517(%rip), %rdi      # 0x1c832
pushq $0x19
jmp 0x13333
leaq 0x9526(%rip), %rdi      # 0x1c84c
pushq $0x3
jmp 0x13333
leaq 0xa77e(%rip), %rdi      # 0x1daaf
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
jmp 0x2240
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_encoding_option_enum
void
kmip_print_encoding_option_enum(FILE *f, enum encoding_option value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_ENCODE_NO_ENCODING:
        fprintf(f, "No Encoding");
        break;
        
        case KMIP_ENCODE_TTLV_ENCODING:
        fprintf(f, "TTLV Encoding");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
movq %rdi, %rcx
cmpl $0x2, %esi
je 0x13a00
cmpl $0x1, %esi
je 0x139f5
testl %esi, %esi
jne 0x13a0b
pushq $0x2d
popq %rdi
movq %rcx, %rsi
jmp 0x21b0
leaq 0x927c(%rip), %rdi      # 0x1cc78
pushq $0xb
jmp 0x13a14
leaq 0x927d(%rip), %rdi      # 0x1cc84
pushq $0xd
jmp 0x13a14
leaq 0xa09d(%rip), %rdi      # 0x1daaf
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
jmp 0x2240
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_key_wrap_type_enum
void
kmip_print_key_wrap_type_enum(FILE *f, enum key_wrap_type value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_WRAPTYPE_NOT_WRAPPED:
        fprintf(f, "Not Wrapped");
        break;
        
        case KMIP_WRAPTYPE_AS_REGISTERED:
        fprintf(f, "As Registered");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
movq %rdi, %rcx
cmpl $0x2, %esi
je 0x13a44
cmpl $0x1, %esi
je 0x13a39
testl %esi, %esi
jne 0x13a4f
pushq $0x2d
popq %rdi
movq %rcx, %rsi
jmp 0x21b0
leaq 0x9252(%rip), %rdi      # 0x1cc92
pushq $0xb
jmp 0x13a58
leaq 0x9253(%rip), %rdi      # 0x1cc9e
pushq $0xd
jmp 0x13a58
leaq 0xa059(%rip), %rdi      # 0x1daaf
pushq $0x7
popq %rsi
pushq $0x1
popq %rdx
jmp 0x2240
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8f6c(%rip), %rsi      # 0x1cf59
leaq 0x51bd(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r12, %r8
xorl %eax, %eax
callq 0x2200
testq %r12, %r12
je 0x14078
movq (%r12), %rax
testq %rax, %rax
je 0x14078
leal 0x2(%rbx), %edx
movq 0x10(%rax), %r8
leaq 0x8f5f(%rip), %rsi      # 0x1cf7b
leaq 0x518e(%rip), %rcx      # 0x191b1
movq %r14, %rdi
xorl %eax, %eax
callq 0x2200
movq (%r12), %r15
leal 0x4(%rbx), %ebp
addl $0x6, %ebx
pushq $0x1
popq %r12
leaq 0x8f48(%rip), %r13      # 0x1cf8a
movq (%r15), %r15
testq %r15, %r15
je 0x14078
movq %r14, %rdi
movq %r13, %rsi
movl %ebp, %edx
leaq 0x5158(%rip), %rcx      # 0x191b1
movq %r12, %r8
xorl %eax, %eax
callq 0x2200
movq 0x10(%r15), %rax
movl (%rax), %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x13df5
incq %r12
jmp 0x14042
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip_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:
movq %rdi, %rcx
testl %esi, %esi
je 0x140c4
cmpl $0x1, %esi
jne 0x140d6
leaq 0x8eda(%rip), %rdi      # 0x1cf9a
pushq $0x4
jmp 0x140cd
leaq 0x8ed4(%rip), %rdi      # 0x1cf9f
pushq $0x5
popq %rsi
pushq $0x1
popq %rdx
jmp 0x2240
pushq $0x2d
popq %rdi
movq %rcx, %rsi
jmp 0x21b0
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %r8
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8ead(%rip), %rsi      # 0x1cfa5
leaq 0x50b2(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r15, %r9
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x14139
addl $0x2, %ebx
movl 0x8(%r15), %r8d
movq (%r15), %r9
leaq 0x8e90(%rip), %rsi      # 0x1cfb1
leaq 0x5089(%rip), %rcx      # 0x191b1
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x2200
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r8
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x8e48(%rip), %rsi      # 0x1cfa5
leaq 0x504d(%rip), %rcx      # 0x191b1
movl %r15d, %edx
movq %r14, %r9
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x14201
leal 0x2(%r15), %edx
leaq 0x8e3c(%rip), %rsi      # 0x1cfc1
leaq 0x5025(%rip), %rcx      # 0x191b1
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2200
addl $0x4, %r15d
leaq 0x8e2a(%rip), %r13      # 0x1cfcb
leaq 0x7838(%rip), %rbp      # 0x1b9e0
xorl %r12d, %r12d
cmpq 0x8(%r14), %r12
jae 0x141e8
testb $0xf, %r12b
jne 0x141ce
movq %rbx, %rdi
movq %r13, %rsi
movl %r15d, %edx
leaq 0x4fea(%rip), %rcx      # 0x191b1
xorl %eax, %eax
callq 0x2200
movq (%r14), %rax
movzbl (%rax,%r12), %edx
movq %rbx, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2200
incq %r12
jmp 0x141ab
pushq $0xa
popq %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip_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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8d68(%rip), %rsi      # 0x1cfd2
leaq 0x4f40(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x142ca
addl $0x2, %ebx
movl (%r15), %r8d
leaq 0x8d5d(%rip), %rsi      # 0x1cfec
leaq 0x4f1b(%rip), %r12      # 0x191b1
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x4(%r15), %r8d
leaq 0x8d4a(%rip), %rsi      # 0x1cffa
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2200
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8d1f(%rip), %rsi      # 0x1d008
leaq 0x4ec1(%rip), %rcx      # 0x191b1
movl %ebp, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1434d
addl $0x2, %ebp
movq (%r14), %rcx
leaq 0x8d08(%rip), %rdx      # 0x1d016
movq %rbx, %rdi
movl %ebp, %esi
callq 0x140e1
leaq 0x8d02(%rip), %rsi      # 0x1d021
leaq 0x4e8b(%rip), %rcx      # 0x191b1
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2200
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x132f8
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8cca(%rip), %rsi      # 0x1d030
leaq 0x4e44(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x143af
addl $0x2, %ebx
movq (%r15), %rcx
leaq 0x8cb4(%rip), %rdx      # 0x1d03f
movq %r14, %rdi
movl %ebx, %esi
callq 0x1413f
movq 0x8(%r15), %rcx
leaq 0x8ca8(%rip), %rdx      # 0x1d048
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1413f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8c8b(%rip), %rsi      # 0x1d054
leaq 0x4de1(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x14412
addl $0x2, %ebx
movq (%r15), %rcx
leaq 0x8c90(%rip), %rdx      # 0x1d07e
movq %r14, %rdi
movl %ebx, %esi
callq 0x140e1
movq 0x8(%r15), %rcx
leaq 0x8c91(%rip), %rdx      # 0x1d094
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x140e1
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0x8ac4(%rip), %rsi      # 0x1d253
leaq 0x4a1b(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x147d1
addl $0x2, %ebx
movq (%r14), %rcx
leaq 0x5322(%rip), %rdx      # 0x19ad6
movq %r15, %rdi
movl %ebx, %esi
callq 0x140e1
movq 0x8(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x14418
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0x8a8c(%rip), %rsi      # 0x1d277
leaq 0x49bf(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1482d
addl $0x2, %ebx
movq (%r14), %rcx
leaq 0x52c6(%rip), %rdx      # 0x19ad6
movq %r15, %rdi
movl %ebx, %esi
callq 0x140e1
movq 0x8(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x14418
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8a54(%rip), %rsi      # 0x1d29e
leaq 0x4960(%rip), %rcx      # 0x191b1
movl %ebp, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1491b
addl $0x2, %ebp
leaq 0x8a49(%rip), %rsi      # 0x1d2b9
leaq 0x493a(%rip), %r15      # 0x191b1
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2200
movl (%r14), %esi
movq %rbx, %rdi
callq 0x1396f
pushq $0xa
popq %r12
movl %r12d, %edi
movq %rbx, %rsi
callq 0x21b0
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1477b
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x147d7
movq 0x18(%r14), %rcx
leaq 0x8a07(%rip), %rdx      # 0x1d2ce
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1413f
movq 0x20(%r14), %rcx
leaq 0x8a00(%rip), %rdx      # 0x1d2dc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1413f
leaq 0x8a00(%rip), %rsi      # 0x1d2ed
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x139d9
movl %r12d, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0x8822(%rip), %rsi      # 0x1d320
leaq 0x46ac(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x14b93
addl $0x2, %ebx
leaq 0x8813(%rip), %rsi      # 0x1d333
leaq 0x468a(%rip), %r12      # 0x191b1
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl (%r14), %esi
movq %r15, %rdi
callq 0x1333c
pushq $0xa
popq %rbp
movl %ebp, %edi
movq %r15, %rsi
callq 0x21b0
leaq 0x87f2(%rip), %rsi      # 0x1d347
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x14087
movl %ebp, %edi
movq %r15, %rsi
callq 0x21b0
movl (%r14), %edx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14924
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r15
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x1, %edx
je 0x14c0a
cmpl $0x8, %edx
jne 0x14c87
leaq 0x8792(%rip), %rdx      # 0x1d387
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1413f
movl %ecx, %ebp
leaq 0x877e(%rip), %rsi      # 0x1d391
leaq 0x4597(%rip), %rcx      # 0x191b1
movq %r14, %rdi
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x14c7e
movq (%r15), %rcx
movq 0x8(%r15), %r12
movq 0x10(%r15), %r15
addl $0x2, %ebx
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x14b9c
leaq 0x8755(%rip), %rsi      # 0x1d3a4
leaq 0x455b(%rip), %rcx      # 0x191b1
movq %r14, %rdi
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
subq $0x1, %r15
jb 0x14c7e
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x14ae7
addq $0x10, %r12
jmp 0x14c65
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x872a(%rip), %rsi      # 0x1d3b8
leaq 0x451c(%rip), %rcx      # 0x191b1
movq %r14, %rdi
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2200
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0x8710(%rip), %rsi      # 0x1d3d3
leaq 0x44e7(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x14db4
addl $0x2, %ebx
leaq 0x86fd(%rip), %rsi      # 0x1d3e6
leaq 0x44c1(%rip), %r12      # 0x191b1
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl (%r14), %esi
movq %r15, %rdi
callq 0x12ea9
pushq $0xa
popq %rbp
movl %ebp, %edi
movq %r15, %rsi
callq 0x21b0
leaq 0x86dd(%rip), %rsi      # 0x1d3fb
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x12fd9
movl %ebp, %edi
movq %r15, %rsi
callq 0x21b0
movl 0x10(%r14), %edx
movl (%r14), %ecx
movq 0x8(%r14), %r8
movq %r15, %rdi
movl %ebx, %esi
callq 0x14bd0
leaq 0x83de(%rip), %rsi      # 0x1d13d
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x14(%r14), %esi
movq %r15, %rdi
callq 0x13038
movl %ebp, %edi
movq %r15, %rsi
callq 0x21b0
movl 0x18(%r14), %r8d
leaq 0x8686(%rip), %rsi      # 0x1d415
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movq 0x20(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14833
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0x8661(%rip), %rsi      # 0x1d432
leaq 0x43d9(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x14dfe
addl $0x2, %ebx
movq (%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x14cac
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8628(%rip), %rsi      # 0x1d485
leaq 0x434d(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x14eba
movq (%r15), %rax
testq %rax, %rax
je 0x14eba
leal 0x2(%rbx), %edx
movq 0x10(%rax), %r8
leaq 0x8519(%rip), %rsi      # 0x1d3a4
leaq 0x431f(%rip), %rcx      # 0x191b1
movq %r14, %rdi
xorl %eax, %eax
callq 0x2200
movq (%r15), %r15
addl $0x4, %ebx
movq (%r15), %r15
testq %r15, %r15
je 0x14eba
movq 0x10(%r15), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x14ae7
jmp 0x14ea2
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
leaq 0x85be(%rip), %rsi      # 0x1d499
leaq 0x42cf(%rip), %rcx      # 0x191b1
movl %r14d, %edx
movq %rbx, %r8
xorl %eax, %eax
callq 0x2200
testq %rbx, %rbx
je 0x14f89
leal 0x2(%r14), %ebp
movq 0x8(%rbx), %r8
leaq 0x85ae(%rip), %rsi      # 0x1d4b5
leaq 0x42a3(%rip), %rcx      # 0x191b1
xorl %r12d, %r12d
movq %r15, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2200
addl $0x4, %r14d
xorl %r13d, %r13d
cmpq 0x8(%rbx), %r13
jae 0x14f44
movq (%rbx), %rdx
addq %r12, %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x142d6
incq %r13
addq $0x10, %r12
jmp 0x14f24
movq 0x18(%rbx), %r8
leaq 0x8455(%rip), %rsi      # 0x1d3a4
leaq 0x425b(%rip), %rcx      # 0x191b1
xorl %r12d, %r12d
movq %r15, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2200
xorl %r13d, %r13d
cmpq 0x18(%rbx), %r13
jae 0x14f89
movq 0x10(%rbx), %rdx
addq %r12, %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x14ae7
incq %r13
addq $0x10, %r12
jmp 0x14f68
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/OpenKMIP[P]libkmip/src/kmip_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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0x8518(%rip), %rsi      # 0x1d4c4
leaq 0x41fe(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x15026
addl $0x2, %ebx
leaq 0x8516(%rip), %rsi      # 0x1d4e4
leaq 0x41dc(%rip), %rcx      # 0x191b1
movq %r15, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x2200
movl (%r14), %esi
movq %r15, %rdi
callq 0x12e08
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x21b0
movq 0x8(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
callq 0x14ec0
movq 0x10(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
callq 0x14e49
movq 0x18(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x13fd3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0x84b5(%rip), %rsi      # 0x1d4f5
leaq 0x416a(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x150b3
addl $0x2, %ebx
leaq 0x8482(%rip), %rsi      # 0x1d4e4
leaq 0x4148(%rip), %rcx      # 0x191b1
movq %r15, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x2200
movl (%r14), %esi
movq %r15, %rdi
callq 0x12e08
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0x21b0
movq 0x8(%r14), %rcx
leaq 0x4a40(%rip), %rdx      # 0x19ad6
movq %r15, %rdi
movl %ebx, %esi
callq 0x140e1
movq 0x10(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x14ec0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0x8446(%rip), %rsi      # 0x1d516
leaq 0x40da(%rip), %rcx      # 0x191b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x151a7
addl $0x2, %ebx
movq (%r14), %rcx
leaq 0x49dd(%rip), %rdx      # 0x19ad6
movq %r15, %rdi
movl %ebx, %esi
callq 0x140e1
leaq 0x82dc(%rip), %rsi      # 0x1d3e6
leaq 0x40a0(%rip), %r12      # 0x191b1
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x8(%r14), %esi
movq %r15, %rdi
callq 0x12ea9
pushq $0xa
popq %rbp
movl %ebp, %edi
movq %r15, %rsi
callq 0x21b0
leaq 0x83f3(%rip), %rsi      # 0x1d533
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x18(%r14), %esi
movq %r15, %rdi
callq 0x13a1d
movl %ebp, %edi
movq %r15, %rsi
callq 0x21b0
leaq 0x828f(%rip), %rsi      # 0x1d3fb
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0xc(%r14), %esi
movq %r15, %rdi
callq 0x12fd9
movl %ebp, %edi
movq %r15, %rsi
callq 0x21b0
movq 0x10(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x14e2f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq