LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_delete
int
cf_vector_delete(cf_vector *v, uint32_t index)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	// check bounds
	if (index >= v->len)
		return (-1);
	// check for last - no copy
	if (index != v->len - 1) {
		memmove(v->vector + (index * v->value_len), 
				v->vector + ((index+1) * v->value_len),
				(v->len - (index+1)) * v->value_len );
	}
	v->len --;
	
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return(0);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testb $0x1, 0x4(%rdi)
movl %esi, %ebp
movq %rdi, %rbx
je 0xe8d9
leaq 0x20(%rbx), %rdi
callq 0x23b0
movl 0xc(%rbx), %edx
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpl %ebp, %edx
jbe 0xe92c
leal -0x1(%rdx), %eax
cmpl %ebp, %eax
je 0xe914
movl (%rbx), %ecx
movq 0x10(%rbx), %rax
movl %ecx, %edi
movl %ecx, %esi
imull %ebp, %edi
incl %ebp
subl %ebp, %edx
imull %ebp, %esi
addq %rax, %rdi
imull %ecx, %edx
addq %rax, %rsi
callq 0x2460
movl 0xc(%rbx), %eax
decl %eax
movl %eax, 0xc(%rbx)
xorl %r14d, %r14d
testb $0x1, 0x4(%rbx)
je 0xe92c
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_delete_range
int
cf_vector_delete_range(cf_vector *v, uint32_t idx_start, uint32_t idx_end)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	// check bounds
	if (idx_start >= idx_end)
		return (-1);
	if (idx_start >= v->len)
		return(-1);
	if (idx_end >= v->len)
		return(-1);
	
	// Copy down if not at end
	if (idx_end != v->len - 1) {
		memmove( v->vector + (idx_start * v->value_len),
				v->vector + ((idx_end+1) * v->value_len),
			    (v->len - (idx_end+1)) * v->value_len );
	
	}
	v->len -= (idx_end - idx_start) + 1;
	
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testb $0x1, 0x4(%rdi)
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
je 0xe952
leaq 0x20(%rbx), %rdi
callq 0x23b0
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
cmpl %r14d, %ebp
jae 0xe9b8
movl 0xc(%rbx), %edx
cmpl %r14d, %edx
jbe 0xe9b8
leal -0x1(%rdx), %eax
cmpl %r14d, %eax
je 0xe996
movl (%rbx), %ecx
movq 0x10(%rbx), %rax
leal 0x1(%r14), %r8d
subl %r8d, %edx
movl %ecx, %esi
movl %ecx, %edi
imull %ecx, %edx
imull %ebp, %edi
imull %r8d, %esi
addq %rax, %rdi
addq %rax, %rsi
callq 0x2460
movl 0xc(%rbx), %edx
notl %r14d
xorl %r15d, %r15d
addl %ebp, %r14d
addl %edx, %r14d
movl %r14d, 0xc(%rbx)
testb $0x1, 0x4(%rbx)
je 0xe9b8
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_compact
void
cf_vector_compact(cf_vector *v)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	if (v->alloc_len && (v->len != v->alloc_len)) {
		v->vector = (uint8_t*)realloc(v->vector, v->len * v->alloc_len);
		v->alloc_len = v->len;
	}
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return;
}

// Assembly:
pushq %rbx
testb $0x1, 0x4(%rdi)
movq %rdi, %rbx
je 0xe9d9
leaq 0x20(%rbx), %rdi
callq 0x23b0
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xe9fd
movl 0xc(%rbx), %esi
cmpl %eax, %esi
je 0xe9fd
movq 0x10(%rbx), %rdi
imull %eax, %esi
callq 0x2470
movq %rax, 0x10(%rbx)
movl 0xc(%rbx), %eax
movl %eax, 0x8(%rbx)
testb $0x1, 0x4(%rbx)
jne 0xea05
popq %rbx
retq
addq $0x20, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x2190
nop
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/cl_info.c
// Function: citrusleaf_info_parse_single
int
citrusleaf_info_parse_single(char *values, char **value)
{
	while (*values && (*values != '\t'))
		values++;
	if (*values == 0)	return(-1);
	values++;
	*value = values;
	while (*values && (*values != '\n'))
		values++;
	if (*values == 0)	return(-1);
	*values = 0;
	return(0);
	
}

// Assembly:
incq %rdi
movzbl -0x1(%rdi), %eax
testl %eax, %eax
je 0xea38
cmpl $0x9, %eax
jne 0xea14
movq %rdi, (%rsi)
movzbl (%rdi), %eax
testl %eax, %eax
je 0xea38
cmpl $0xa, %eax
je 0xea3e
incq %rdi
jmp 0xea27
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
xorl %eax, %eax
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/cl_info.c
// Function: citrusleaf_info
int
citrusleaf_info(char *hostname, short port, char *names, char **values, int timeout_ms)
{
	int rv = -1;
	cf_vector sockaddr_in_v;
	cf_vector_init(&sockaddr_in_v, sizeof( struct sockaddr_in ), 5, 0);
	if (0 != cl_lookup(NULL, hostname, port, &sockaddr_in_v)) {
		cf_debug("Could not find host %s", hostname);
		goto Done;
	}
	
	for (uint i=0; i < cf_vector_size(&sockaddr_in_v) ; i++) 
	{
		struct sockaddr_in  sa_in;
		cf_vector_get(&sockaddr_in_v, i, &sa_in);

		if (0 == citrusleaf_info_host(&sa_in, names, values, timeout_ms, false)) {
			rv = 0;
			goto Done;
		}
	}
	
Done:
	cf_vector_destroy( &sockaddr_in_v );	
	return(rv);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsp, %r13
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
movl $0x10, %esi
movl $0x5, %edx
xorl %ecx, %ecx
movl %r8d, %ebp
movq %r13, %rdi
callq 0xe409
xorl %edi, %edi
movq %r12, %rsi
movl %ebx, %edx
movq %r13, %rcx
callq 0x8bfc
testl %eax, %eax
je 0xed7a
leaq 0x7579(%rip), %rax      # 0x162c8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl (%rax), %eax
cmpl $0x3, %eax
jl 0xedc5
leaq 0x756e(%rip), %rax      # 0x162d0
leaq 0x1efa(%rip), %rsi      # 0x10c63
movl $0x3, %edi
movq %r12, %rdx
movq (%rax), %rcx
xorl %eax, %eax
callq *%rcx
jmp 0xedc5
cmpl $0x0, 0xc(%rsp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0xedc5
movq %rsp, %r12
leaq 0x48(%rsp), %r13
xorl %ebx, %ebx
movq %r12, %rdi
movl %ebx, %esi
movq %r13, %rdx
callq 0xe7d4
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xea49
testl %eax, %eax
je 0xedc3
incl %ebx
cmpl 0xc(%rsp), %ebx
jb 0xed90
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xedc5
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0xe580
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sonicse[P]dbf2mysql/dbf2mysql.c
// Function: check_table
int check_table(MYSQL *sock, char *table) {
    MYSQL_RES *result;
    MYSQL_ROW row;

    if ((result = mysql_list_tables(sock, NULL)) == NULL)
        return 0;
    while ((row = mysql_fetch_row(result)) != NULL) {
        if (strcmp((char *) row[0], table) == 0) {
            mysql_free_result(result);
            return 1;
        }
    }
    mysql_free_result(result);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
xorl %r15d, %r15d
xorl %esi, %esi
callq 0x2030
testq %rax, %rax
je 0x2865
movq %rax, %rbx
movq %rbx, %rdi
callq 0x21e0
testq %rax, %rax
je 0x285a
movq (%rax), %rdi
movq %r14, %rsi
callq 0x22b0
testl %eax, %eax
jne 0x2836
movl $0x1, %r15d
jmp 0x285d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x21d0
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sonicse[P]dbf2mysql/dbf2mysql.c
// Function: usage
void usage(void) {
    printf("dbf2mysql %s\n", VERSION);
    printf("usage: dbf2mysql [-h hostname] [-d dbase] [-t table] [-p primary key]\n");
    printf("                 [-o field[,field]] [-s oldname=newname[,oldname=newname]]\n");
    printf("                 [-i field[,field]] [-c] [-f] [-F] [-n] [-r] [-u|-l] \n");
    printf("                 [-v[v]] [-x] [-q]  [-P password] [-U user] [-C charset]\n");
    printf("                 dbf-file\n");
}

// Assembly:
pushq %rax
leaq 0x3897(%rip), %rdi      # 0x610d
leaq 0x389e(%rip), %rsi      # 0x611b
xorl %eax, %eax
callq 0x2050
leaq 0x3ede(%rip), %rdi      # 0x6769
callq 0x22f0
leaq 0x3f18(%rip), %rdi      # 0x67af
callq 0x22f0
leaq 0x3f57(%rip), %rdi      # 0x67fa
callq 0x22f0
leaq 0x3f91(%rip), %rdi      # 0x6840
callq 0x22f0
leaq 0x3fce(%rip), %rdi      # 0x6889
popq %rax
jmp 0x22f0
// File: /workspace/github_c_makefile_star2_O3/sonicse[P]dbf2mysql/dbf2mysql.c
// Function: do_onlyfields
void do_onlyfields(char *flist, dbhead *dbh) {
    char *s, *flist2;
    int i, match;

    if (flist == NULL) return;

    if (verbose > 2)
        printf("Removing not specified fields\n");

    if ((flist2 = malloc(strlen(flist) * sizeof (char) + 1)) == NULL) {
        fprintf(stderr, "Memory allocation error in function do_onlyfields\n");
        dbf_close(&dbh);
        exit(1);
    }

    if (verbose > 2)
        printf("Used fields: ");
    for (i = 0; i < dbh -> db_nfields; i++) {
        strcpy(flist2, flist);
        match = 0;
        for (s = strtok(flist2, ","); s != NULL; s = strtok(NULL, ",")) {
            if (strcasecmp(s, dbh -> db_fields[i].db_name) == 0) {
                match = 1;
                if (verbose > 1)
                    printf("%s", s);
            }
        }
        if (match == 0) dbh -> db_fields[i].db_name[0] = '\0';
    }
    if (verbose > 2)
        printf("\n");
    free(flist2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x2a08
movq %rsi, %rbx
cmpl $0x3, 0x6924(%rip)      # 0x9210
jl 0x28fa
leaq 0x3fae(%rip), %rdi      # 0x68a3
callq 0x22f0
movq 0x8(%rsp), %rdi
callq 0x20d0
leaq 0x1(%rax), %rdi
callq 0x2280
movq %rax, (%rsp)
testq %rax, %rax
je 0x2a17
cmpl $0x3, 0x68ef(%rip)      # 0x9210
jl 0x2931
leaq 0x3829(%rip), %rdi      # 0x6153
xorl %eax, %eax
callq 0x2050
cmpb $0x0, 0x32(%rbx)
je 0x29de
leaq 0x3b0e(%rip), %r12      # 0x6450
xorl %r14d, %r14d
movq (%rsp), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x21b0
movq %r15, %rdi
movq %r12, %rsi
callq 0x2310
testq %rax, %rax
je 0x29be
movq %rax, %rbp
xorl %r15d, %r15d
leaq (%r14,%r14,4), %rax
leaq (%rax,%rax,2), %r13
movq 0x40(%rbx), %rsi
addq %r13, %rsi
movq %rbp, %rdi
callq 0x2210
testl %eax, %eax
jne 0x29a7
movl $0x1, %r15d
cmpl $0x2, 0x687c(%rip)      # 0x9210
jl 0x29a7
leaq 0x37c4(%rip), %rdi      # 0x6161
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
movq %r12, %rsi
callq 0x2310
movq %rax, %rbp
testq %rax, %rax
jne 0x2974
testl %r15d, %r15d
jne 0x29ce
movq 0x40(%rbx), %rax
leaq (%r14,%r14,4), %rcx
leaq (%rcx,%rcx,2), %rcx
movb $0x0, (%rax,%rcx)
incq %r14
movzbl 0x32(%rbx), %eax
cmpq %rax, %r14
jb 0x2945
cmpl $0x3, 0x682b(%rip)      # 0x9210
jl 0x29f1
movl $0xa, %edi
callq 0x22a0
movq (%rsp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2230
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %rdi
callq 0x23d0
// File: /workspace/github_c_makefile_star2_O3/sonicse[P]dbf2mysql/dbf2mysql.c
// Function: do_substitute
void do_substitute(char *subarg, dbhead *dbh) {
    /* NOTE: subarg is modified in this function */
    int i, bad;
    char *p, *oldname, *newname;
    if (subarg == NULL) return;

    if (verbose > 1) {
        printf("Substituting new field names\n");
    }
    /* use strstr instead of strtok because of possible empty tokens */
    oldname = subarg;
    while (oldname && strlen(oldname) && (p = strstr(oldname, "="))) {
        *p = '\0'; /* mark end of oldname */
        newname = ++p; /* point past \0 of oldname */
        if (strlen(newname)) { /* if not an empty string */
            p = strstr(newname, ",");
            if (p) {
                *p = '\0'; /* mark end of newname */
                p++; /* point past where the comma was */
            }
        }
        if (strlen(newname) >= DBF_NAMELEN) {
            printf("Truncating new field name %s to %d chars\n",
                    newname, DBF_NAMELEN - 1);
            newname[DBF_NAMELEN - 1] = '\0';
        }
        bad = 1;
        for (i = 0; i < dbh->db_nfields; i++) {
            if (strcmp(dbh->db_fields[i].db_name, oldname) == 0) {
                bad = 0;
                strcpy(dbh->db_fields[i].db_name, newname);
                if (verbose > 1) {
                    printf("Substitute old:%s new:%s\n",
                            oldname, newname);
                }
                break;
            }
        }
        if (bad) {
            printf("Warning: old field name %s not found\n",
                    oldname);
        }
        oldname = p;
    }
}

// Assembly:
testq %rdi, %rdi
je 0x2b4b
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, 0x67ce(%rip)      # 0x9210
jl 0x2a50
leaq 0x3e76(%rip), %rdi      # 0x68c1
callq 0x22f0
cmpb $0x0, (%r14)
je 0x2b3d
movq %r14, %rbp
movq %r14, %rdi
movl $0x3d, %esi
callq 0x20b0
testq %rax, %rax
je 0x2b3d
movq %rax, %r13
movb $0x0, (%rax)
movq %rax, %r12
incq %r12
cmpb $0x0, 0x1(%rax)
movq %r12, %r14
je 0x2aa8
movq %r12, %rdi
movl $0x2c, %esi
callq 0x20b0
testq %rax, %rax
je 0x2aa5
movq %rax, %r14
movb $0x0, (%rax)
incq %r14
jmp 0x2aa8
xorl %r14d, %r14d
movq %r12, %rdi
callq 0x20d0
cmpq $0xb, %rax
jb 0x2ad1
leaq 0x36a7(%rip), %rdi      # 0x6164
movq %r12, %rsi
movl $0xa, %edx
xorl %eax, %eax
callq 0x2050
movb $0x0, 0xb(%r13)
movzbl 0x32(%rbx), %r15d
testq %r15, %r15
je 0x2af7
movq 0x40(%rbx), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x22b0
testl %eax, %eax
je 0x2b13
addq $0xf, %r13
decq %r15
jne 0x2adf
leaq 0x36aa(%rip), %rdi      # 0x61a8
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2050
testq %r14, %r14
jne 0x2a50
jmp 0x2b3d
movq %r13, %rdi
movq %r12, %rsi
callq 0x21b0
cmpl $0x2, 0x66eb(%rip)      # 0x9210
jl 0x2b08
leaq 0x3660(%rip), %rdi      # 0x618e
movq %rbp, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
jmp 0x2b08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sonicse[P]dbf2mysql/dbf.c
// Function: cp866_cp1251
void cp866_cp1251( char* s ) {
    char *c;
    for( c=s; *c!=0; ++c ) {
        if( *c>-129 && *c<-80 )
            *c += 64;
        else if( *c>-33 && *c<-16 )
            *c += 16;
    }
}

// Assembly:
movb (%rdi), %al
testb %al, %al
je 0x3eb9
incq %rdi
movb $0x40, %cl
cmpb $-0x50, %al
jl 0x3eab
movl %eax, %edx
andb $-0x10, %dl
movb $0x10, %cl
cmpb $-0x20, %dl
jne 0x3eb0
orb %cl, %al
movb %al, -0x1(%rdi)
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x3e99
retq
// File: /workspace/github_c_makefile_star2_O3/sonicse[P]dbf2mysql/dbf.c
// Function: dbf_close
void dbf_close(dbhead **dbhp)
{
    close((*dbhp)->db_fd);

    free((*dbhp)->db_fields);
    (*dbhp)->db_fields = NULL;	/* Defend against getting called twice */

    free((*dbhp)->db_buff);
    (*dbhp)->db_buff = NULL;

    if ((*dbhp)->db_memo != DBF_MTYPE_NONE)
    {
	/* since memo files aren't on stdin this works */
	if ((*dbhp)->db_memofd > 0)
	    close((*dbhp)->db_memofd);
	(*dbhp)->db_memofd = 0;
	free((*dbhp)->mb_buffer);
	(*dbhp)->mb_buffer = NULL;
	(*dbhp)->mb_bufsiz = 0;
    }

    free(*dbhp);
    *dbhp = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl (%rax), %edi
callq 0x23b0
movq (%rbx), %rax
movq 0x40(%rax), %rdi
callq 0x2230
movq (%rbx), %rax
xorl %r14d, %r14d
movq %r14, 0x40(%rax)
movq (%rbx), %rax
movq 0x38(%rax), %rdi
callq 0x2230
movq (%rbx), %rax
movq %r14, 0x38(%rax)
movq (%rbx), %rdi
cmpb $0x0, 0x10(%rdi)
je 0x4598
movl 0x50(%rdi), %eax
testl %eax, %eax
jle 0x4578
movl %eax, %edi
callq 0x23b0
movq (%rbx), %rdi
movl $0x0, 0x50(%rdi)
movq 0x58(%rdi), %rdi
callq 0x2230
movq (%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x58(%rax)
movq (%rbx), %rdi
movq %rcx, 0x60(%rdi)
callq 0x2230
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/sonicse[P]dbf2mysql/dbf.c
// Function: dbf_write_head
int	dbf_write_head(dbhead *dbh) {
	dbf_header	head;
	time_t now;
	struct tm *dbf_time;

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

/* fill up the diskheader */

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

	head.dbh_dbt = DBH_NORMAL;
	if (dbh->db_memo) head.dbh_dbt = DBH_MEMO;

	now = time((time_t *)NULL); 
	dbf_time = localtime(&now);
	head.dbh_year = dbf_time->tm_year;
	head.dbh_month = dbf_time->tm_mon + 1; /* Months since January + 1 */
	head.dbh_day = dbf_time->tm_mday;

	put_long(head.dbh_records, dbh->db_records);
	put_short(head.dbh_hlen, dbh->db_hlen);
	put_short(head.dbh_rlen, dbh->db_rlen);
	
	if (write(dbh->db_fd, &head, sizeof(dbf_header)) == -1 ) {
		return DBF_ERROR;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl (%rdi), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2390
cmpq $-0x1, %rax
je 0x4663
leaq 0xc(%rsp), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r14)
movups %xmm0, (%r14)
cmpb $0x0, 0x10(%rbx)
movl $0x3, %eax
movl $0x83, %ecx
cmovel %eax, %ecx
movb %cl, -0x4(%r14)
xorl %edi, %edi
callq 0x21a0
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x2160
movb 0x14(%rax), %cl
movb %cl, -0x3(%r14)
movb 0x10(%rax), %cl
incb %cl
movb %cl, -0x2(%r14)
movb 0xc(%rax), %al
movb %al, -0x1(%r14)
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x5526
leaq 0x10(%rsp), %rdi
movswl 0x18(%rbx), %esi
callq 0x552d
leaq 0x12(%rsp), %rdi
movswl 0x30(%rbx), %esi
callq 0x552d
movl (%rbx), %edi
leaq 0x8(%rsp), %rsi
movl $0x20, %edx
callq 0x20a0
movq %rax, %rcx
xorl %eax, %eax
cmpq $-0x1, %rcx
sete %al
negl %eax
jmp 0x4668
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x20, %esi
xorl %edx, %edx
callq 0x2390
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpq $-0x1, %rax
je 0x4736
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
cmpb $0x0, 0x32(%r14)
je 0x4719
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
xorl %r13d, %r13d
movq 0x40(%r14), %rbp
leaq (%r12,%rbp), %rsi
movl $0xa, %edx
movq %r15, %rdi
callq 0x2110
movb 0xb(%rbp,%r12), %al
movb %al, 0x1b(%rsp)
movb 0xc(%rbp,%r12), %al
movb %al, 0x20(%rsp)
movb 0xd(%rbp,%r12), %al
movb %al, 0x21(%rsp)
movl (%r14), %edi
movl $0x20, %edx
movq %r15, %rsi
callq 0x20a0
cmpq $-0x1, %rax
je 0x4736
incq %r13
movzbl 0x32(%r14), %eax
addq $0xf, %r12
cmpq %rax, %r13
jb 0x46c2
movl (%r14), %edi
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq 0x20a0
xorl %ebx, %ebx
cmpq $-0x1, %rax
sete %bl
negl %ebx
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x88, %edi
callq 0x2280
testq %rax, %rax
je 0x4880
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
testb $0x40, %bpl
jne 0x4837
xorl %eax, %eax
callq 0x2150
jmp 0x4843
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2150
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x4878
movl $0x0, 0x10(%rbx)
movq $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 0x4887
movq %rbx, %rdi
callq 0x2230
movq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, (%rsp)
movzbl 0x32(%rdi), %r12d
movl $0x20, %esi
movq %r12, %rdi
callq 0x2140
movq %rax, %r14
movq $-0x1, %rax
testq %r14, %r14
je 0x526c
testq %r12, %r12
je 0x5236
movq (%rsp), %rax
movq 0x40(%rax), %r13
shll $0x5, %r12d
xorl %ebx, %ebx
xorl %ebp, %ebp
movb 0xb(%r13), %r15b
movzbl %r15b, %eax
movl $0x1a, %edi
cmpl $0x53, %eax
jg 0x51b5
leal -0x47(%rax), %ecx
cmpl $0x9, %ecx
ja 0x51c1
leaq 0x18da(%rip), %rdx      # 0x6a74
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq (%rsp), %rax
movq 0x68(%rax), %rax
leaq 0x2(,%rax,2), %rdi
jmp 0x51e6
cmpl $0x54, %eax
je 0x51e1
cmpl $0x59, %eax
je 0x51e6
jmp 0x51c6
cmpl $0x42, %eax
je 0x51e6
movzbl 0xc(%r13), %edi
jmp 0x51dc
movl $0x10, %edi
jmp 0x51e6
movq (%rsp), %rax
movq 0x68(%rax), %rdi
incq %rdi
jmp 0x51e6
movl $0x18, %edi
movq %rdi, 0x10(%r14,%rbx)
callq 0x2280
movq %rax, 0x18(%r14,%rbx)
testq %rax, %rax
je 0x523b
leaq (%r14,%rbx), %rdi
movl $0xb, %edx
movq %r13, %rsi
callq 0x2110
movb %r15b, 0xb(%r14,%rbx)
movb 0xc(%r13), %al
movb %al, 0xc(%r14,%rbx)
movb 0xd(%r13), %al
movb %al, 0xd(%r14,%rbx)
incq %rbp
addq $0x20, %rbx
addq $0xf, %r13
cmpq %rbx, %r12
jne 0x5179
movq %r14, %rax
jmp 0x526c
testq %rbx, %rbx
je 0x525d
movq %r14, %rbx
addq $0x18, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5254
callq 0x2230
addq $0x20, %rbx
decq %rbp
jne 0x5247
movq %r14, %rdi
callq 0x2230
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpb $0x0, 0x32(%rdi)
je 0x52af
movq %rdi, %r14
leaq 0x18(%rbx), %r15
xorl %r12d, %r12d
movq (%r15), %rdi
callq 0x2230
incq %r12
movzbl 0x32(%r14), %eax
addq $0x20, %r15
cmpq %rax, %r12
jb 0x5296
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2230
// File: /workspace/github_c_makefile_star2_O3/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 0x1db7d(%rip), %rdi     # 0x20004
xorl %eax, %eax
callq 0x2040
leaq 0x1dd35(%rip), %rdi     # 0x201ca
callq 0x2210
leaq 0x1dd30(%rip), %rdi     # 0x201d1
callq 0x2210
leaq 0x1dd50(%rip), %rdi     # 0x201fd
callq 0x2210
leaq 0x1dd6e(%rip), %rdi     # 0x20227
callq 0x2210
leaq 0x1dd81(%rip), %rdi     # 0x20246
callq 0x2210
leaq 0x1dd97(%rip), %rdi     # 0x20268
callq 0x2210
leaq 0x1ddb8(%rip), %rdi     # 0x20295
popq %rax
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpl $0x2, %edi
jl 0x25a1
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %r10
movl $0x1, %r11d
movslq %r11d, %r14
movq (%rbx,%r14,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x2593
cmpb $0x61, 0x1(%rsi)
jne 0x2527
leal 0x1(%r14), %r11d
movq 0x8(%rbx,%r14,8), %rsi
movq %rsi, (%rdx)
jmp 0x2583
cmpb $0x63, 0x1(%rsi)
jne 0x253b
leal 0x1(%r14), %r11d
movq 0x8(%rbx,%r14,8), %rsi
movq %rsi, (%r8)
jmp 0x2583
cmpb $0x68, 0x1(%rsi)
jne 0x2549
movl $0x1, (%rax)
jmp 0x2583
cmpb $0x6b, 0x1(%rsi)
jne 0x255d
leal 0x1(%r14), %r11d
movq 0x8(%rbx,%r14,8), %rsi
movq %rsi, (%r9)
jmp 0x2583
cmpb $0x70, 0x1(%rsi)
jne 0x2571
leal 0x1(%r14), %r11d
movq 0x8(%rbx,%r14,8), %rsi
movq %rsi, (%rcx)
jmp 0x2583
cmpb $0x72, 0x1(%rsi)
jne 0x2593
leal 0x1(%r14), %r11d
movq 0x8(%rbx,%r14,8), %rsi
movq %rsi, (%r10)
incl %r11d
cmpl %edi, %r11d
jl 0x2503
xorl %eax, %eax
jmp 0x25ae
leaq 0x1da8e(%rip), %rdi     # 0x20028
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rdi
callq 0x247c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %eax, %eax
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
leaq 0x10(%rsp), %r9
movq %rax, (%r9)
leaq 0x8(%rsp), %r10
movq %rax, (%r10)
leaq 0x4(%rsp), %rax
movl $0x0, (%rax)
pushq %rax
pushq %r10
callq 0x24e3
addq $0x10, %rsp
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x2e5b
cmpl $0x0, 0x4(%rsp)
je 0x2e3b
movq (%rbx), %rdi
callq 0x247c
jmp 0x2e59
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x25b6
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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
sete %al
testl %edx, %edx
setle %cl
orb %al, %cl
jne 0x19379
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r13d
leaq 0xad9e(%rip), %r15      # 0x240cc
leaq 0xad9b(%rip), %r12      # 0x240d0
xorl %ebp, %ebp
testb $0xf, %bpl
jne 0x19352
movl $0x3, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %r14, %rcx
callq 0x2240
movzbl (%rbx,%rbp), %edx
movq %r14, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x2200
incq %rbp
cmpq %rbp, %r13
jne 0x19337
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x193cb
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 0xad32(%rip), %r12      # 0x240d5
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 0x193a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0xa5ef(%rip), %rsi      # 0x25649
leaq 0x5150(%rip), %rcx      # 0x201b1
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1b0ed
movq (%r15), %rax
testq %rax, %rax
je 0x1b0ed
leal 0x2(%rbx), %edx
movq 0x10(%rax), %r8
leaq 0xa5e3(%rip), %rsi      # 0x2566b
leaq 0x5122(%rip), %rcx      # 0x201b1
movq %r14, %rdi
xorl %eax, %eax
callq 0x2200
movq (%r15), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x1b0ed
leal 0x4(%rbx), %ebp
addl $0x6, %ebx
movl $0x1, %r15d
leaq 0x50fa(%rip), %r13      # 0x201b1
movq %r14, %rdi
leaq 0xa5b9(%rip), %rsi      # 0x2567a
movl %ebp, %edx
movq %r13, %rcx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
movq 0x10(%r12), %rax
movl (%rax), %edx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1ae60
incq %r15
movq (%r12), %r12
testq %r12, %r12
jne 0x1b0b7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa51d(%rip), %rsi      # 0x25695
leaq 0x5032(%rip), %rcx      # 0x201b1
movl %ebx, %edx
movq %r15, %r9
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1b1b9
addl $0x2, %ebx
movl 0x8(%r15), %r8d
movq (%r15), %r9
leaq 0xa500(%rip), %rsi      # 0x256a1
leaq 0x5009(%rip), %rcx      # 0x201b1
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_O3/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, %rbx
movq %rdx, %r8
movl %esi, %r15d
movq %rdi, %r14
leaq 0xa4b8(%rip), %rsi      # 0x25695
leaq 0x4fcd(%rip), %rcx      # 0x201b1
movl %r15d, %edx
movq %rbx, %r9
xorl %eax, %eax
callq 0x2200
testq %rbx, %rbx
je 0x1b288
leal 0x2(%r15), %edx
leaq 0xa4ac(%rip), %rsi      # 0x256b1
leaq 0x4fa5(%rip), %rcx      # 0x201b1
movq %r14, %rdi
xorl %eax, %eax
callq 0x2200
cmpq $0x0, 0x8(%rbx)
je 0x1b26d
addl $0x4, %r15d
leaq 0x4f89(%rip), %r13      # 0x201b1
leaq 0x8ea1(%rip), %rbp      # 0x240d0
xorl %r12d, %r12d
testb $0xf, %r12b
jne 0x1b24f
movq %r14, %rdi
leaq 0xa479(%rip), %rsi      # 0x256bb
movl %r15d, %edx
movq %r13, %rcx
xorl %eax, %eax
callq 0x2200
movq (%rbx), %rax
movzbl (%rax,%r12), %edx
movq %r14, %rdi
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2200
incq %r12
cmpq 0x8(%rbx), %r12
jb 0x1b232
movl $0xa, %edi
movq %r14, %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_O3/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 0xa3cf(%rip), %rsi      # 0x256c2
leaq 0x4eb7(%rip), %rcx      # 0x201b1
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1b353
addl $0x2, %ebx
movl (%r15), %r8d
leaq 0xa3c4(%rip), %rsi      # 0x256dc
leaq 0x4e92(%rip), %r12      # 0x201b1
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x4(%r15), %r8d
leaq 0xa3b1(%rip), %rsi      # 0x256ea
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_O3/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 0xa386(%rip), %rsi      # 0x256f8
leaq 0x4e38(%rip), %rcx      # 0x201b1
movl %ebp, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1b3d8
addl $0x2, %ebp
movq (%r14), %rcx
leaq 0xa36f(%rip), %rdx      # 0x25706
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b161
leaq 0xa369(%rip), %rsi      # 0x25711
leaq 0x4e02(%rip), %rcx      # 0x201b1
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2200
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x1a244
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x21b0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa32f(%rip), %rsi      # 0x25720
leaq 0x4db9(%rip), %rcx      # 0x201b1
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1b43a
addl $0x2, %ebx
movq (%r15), %rcx
leaq 0xa319(%rip), %rdx      # 0x2572f
movq %r14, %rdi
movl %ebx, %esi
callq 0x1b1bf
movq 0x8(%r15), %rcx
leaq 0xa30d(%rip), %rdx      # 0x25738
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1b1bf
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa2f0(%rip), %rsi      # 0x25744
leaq 0x4d56(%rip), %rcx      # 0x201b1
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1b49d
addl $0x2, %ebx
movq (%r15), %rcx
leaq 0xa2f5(%rip), %rdx      # 0x2576e
movq %r14, %rdi
movl %ebx, %esi
callq 0x1b161
movq 0x8(%r15), %rcx
leaq 0xa2f6(%rip), %rdx      # 0x25784
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1b161
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa108(%rip), %rsi      # 0x25943
leaq 0x496f(%rip), %rcx      # 0x201b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1b87d
addl $0x2, %ebx
movq (%r14), %rcx
leaq 0x6b61(%rip), %rdx      # 0x223c1
movq %r15, %rdi
movl %ebx, %esi
callq 0x1b161
movq 0x8(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1b4a3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa0d0(%rip), %rsi      # 0x25967
leaq 0x4913(%rip), %rcx      # 0x201b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1b8d9
addl $0x2, %ebx
movq (%r14), %rcx
leaq 0x6b05(%rip), %rdx      # 0x223c1
movq %r15, %rdi
movl %ebx, %esi
callq 0x1b161
movq 0x8(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1b4a3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xa099(%rip), %rsi      # 0x2598e
leaq 0x48b5(%rip), %rcx      # 0x201b1
movl %ebp, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1b9c8
addl $0x2, %ebp
leaq 0xa08e(%rip), %rsi      # 0x259a9
leaq 0x488f(%rip), %r15      # 0x201b1
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2200
movl (%r14), %esi
movq %rbx, %rdi
callq 0x1a99c
movl $0xa, %edi
movq %rbx, %rsi
callq 0x21b0
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b827
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b883
movq 0x18(%r14), %rcx
leaq 0xa04e(%rip), %rdx      # 0x259be
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b1bf
movq 0x20(%r14), %rcx
leaq 0xa047(%rip), %rdx      # 0x259cc
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1b1bf
leaq 0xa047(%rip), %rsi      # 0x259dd
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x1aa15
movl $0xa, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
leaq 0x9e4f(%rip), %rsi      # 0x25a10
leaq 0x45e9(%rip), %rcx      # 0x201b1
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1bc60
addl $0x2, %ebx
leaq 0x9e3c(%rip), %rsi      # 0x25a23
leaq 0x45c3(%rip), %r12      # 0x201b1
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl (%r14), %esi
movq %r15, %rdi
callq 0x1a294
movl $0xa, %edi
movq %r15, %rsi
callq 0x21b0
leaq 0x9e1b(%rip), %rsi      # 0x25a37
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x1b0fc
movl $0xa, %edi
movq %r15, %rsi
callq 0x21b0
movl (%r14), %edx
movq 0x8(%r14), %rcx
movq %r15, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1b9d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x1, %edx
je 0x1bcda
cmpl $0x8, %edx
jne 0x1bd5c
leaq 0x9db2(%rip), %rdx      # 0x25a77
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1b1bf
movl %ecx, %ebp
leaq 0x9d9e(%rip), %rsi      # 0x25a81
leaq 0x44c7(%rip), %rcx      # 0x201b1
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %r8
xorl %eax, %eax
callq 0x2200
testq %r12, %r12
je 0x1bd53
movq (%r12), %rcx
movq 0x8(%r12), %r15
movq 0x10(%r12), %r12
addl $0x2, %ebx
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x1bc6c
leaq 0x9d72(%rip), %rsi      # 0x25a94
leaq 0x4488(%rip), %rcx      # 0x201b1
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %r8
xorl %eax, %eax
callq 0x2200
testq %r12, %r12
je 0x1bd53
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x1bbaa
addq $0x10, %r15
decq %r12
jne 0x1bd3d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9d45(%rip), %rsi      # 0x25aa8
leaq 0x4447(%rip), %rcx      # 0x201b1
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %r8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2200