LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0xeed0
cmpl $0x9, %eax
jne 0xeeac
movq %rdi, (%rsi)
movzbl (%rdi), %eax
testl %eax, %eax
je 0xeed0
cmpl $0xa, %eax
je 0xeed6
incq %rdi
jmp 0xeebf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movb $0x0, (%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
movq %rsp, %r13
movq %r13, %rdi
movl $0x10, %esi
movl $0x5, %edx
xorl %ecx, %ecx
callq 0xe894
xorl %edi, %edi
movq %r12, %rsi
movl %ebx, %edx
movq %r13, %rcx
callq 0x8e68
testl %eax, %eax
je 0xf21d
leaq 0x80d6(%rip), %rax      # 0x172c8
movl (%rax), %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x3, %eax
jl 0xf26a
leaq 0x80cb(%rip), %rax      # 0x172d0
movq (%rax), %rcx
leaq 0x2a34(%rip), %rsi      # 0x11c43
movl $0x3, %edi
movq %r12, %rdx
xorl %eax, %eax
callq *%rcx
jmp 0xf26a
cmpl $0x0, 0xc(%rsp)
je 0xf265
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
xorl %r12d, %r12d
leaq 0x48(%rsp), %r13
movq %rsp, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0xec6f
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebp, %ecx
xorl %r8d, %r8d
callq 0xeee1
testl %eax, %eax
cmovel %eax, %ebx
je 0xf26a
incl %r12d
cmpl 0xc(%rsp), %r12d
jb 0xf231
jmp 0xf26a
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq %rsp, %rdi
callq 0xea0d
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_O1/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 0x2825
movq %rax, %rbx
movq %rbx, %rdi
callq 0x21e0
testq %rax, %rax
je 0x281a
movq (%rax), %rdi
movq %r14, %rsi
callq 0x22b0
testl %eax, %eax
jne 0x27f6
movl $0x1, %r15d
jmp 0x281d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x21d0
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x38d7(%rip), %rdi      # 0x610d
leaq 0x38de(%rip), %rsi      # 0x611b
xorl %eax, %eax
callq 0x2050
leaq 0x3f1e(%rip), %rdi      # 0x6769
callq 0x22f0
leaq 0x3f58(%rip), %rdi      # 0x67af
callq 0x22f0
leaq 0x3f97(%rip), %rdi      # 0x67fa
callq 0x22f0
leaq 0x3fd1(%rip), %rdi      # 0x6840
callq 0x22f0
leaq 0x400e(%rip), %rdi      # 0x6889
popq %rax
jmp 0x22f0
// File: /workspace/github_c_makefile_star2_O1/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, (%rsp)
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x29e4
cmpl $0x3, 0x6968(%rip)      # 0x9210
jl 0x28b6
leaq 0x3ff2(%rip), %rdi      # 0x68a3
callq 0x22f0
movq 0x10(%rsp), %rdi
callq 0x20d0
leaq 0x1(%rax), %rdi
callq 0x2280
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x29f3
cmpl $0x3, 0x6932(%rip)      # 0x9210
jl 0x28ee
leaq 0x386c(%rip), %rdi      # 0x6153
xorl %eax, %eax
callq 0x2050
movq (%rsp), %rax
cmpb $0x0, 0x32(%rax)
je 0x29b9
leaq 0x3b4d(%rip), %r15      # 0x6450
leaq 0x3857(%rip), %r12      # 0x6161
xorl %ebp, %ebp
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x21b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2310
testq %rax, %rax
je 0x298a
movq %rax, %r13
xorl %ebx, %ebx
leaq (,%rbp,4), %rax
addq %rbp, %rax
leaq (%rax,%rax,2), %r14
movq (%rsp), %rax
movq 0x40(%rax), %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x2210
testl %eax, %eax
jne 0x2974
movl $0x1, %ebx
cmpl $0x2, 0x68ab(%rip)      # 0x9210
jl 0x2974
movq %r12, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
movq %r15, %rsi
callq 0x2310
movq %rax, %r13
testq %rax, %rax
jne 0x2942
testl %ebx, %ebx
jne 0x29a5
movq (%rsp), %rax
movq 0x40(%rax), %rax
leaq (,%rbp,4), %rcx
addq %rbp, %rcx
leaq (%rcx,%rcx,2), %rcx
movb $0x0, (%rax,%rcx)
incq %rbp
movq (%rsp), %rax
movzbl 0x32(%rax), %eax
cmpq %rax, %rbp
jb 0x290c
cmpl $0x3, 0x6850(%rip)      # 0x9210
jl 0x29cc
movl $0xa, %edi
callq 0x22a0
movq 0x8(%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
movq %rsp, %rdi
callq 0x23d0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b25
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x2, 0x67f4(%rip)      # 0x9210
jl 0x2a2a
leaq 0x3e9c(%rip), %rdi      # 0x68c1
callq 0x22f0
cmpb $0x0, (%r14)
je 0x2b17
movq %r14, %rbp
movq %r14, %rdi
movl $0x3d, %esi
callq 0x20b0
testq %rax, %rax
je 0x2b17
movq %rax, %r13
movb $0x0, (%rax)
movq %rax, %r12
incq %r12
cmpb $0x0, 0x1(%rax)
movq %r12, %r14
je 0x2a82
movq %r12, %rdi
movl $0x2c, %esi
callq 0x20b0
testq %rax, %rax
je 0x2a7f
movq %rax, %r14
movb $0x0, (%rax)
incq %r14
jmp 0x2a82
xorl %r14d, %r14d
movq %r12, %rdi
callq 0x20d0
cmpq $0xb, %rax
jb 0x2aab
leaq 0x36cd(%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 0x2ad1
movq 0x40(%rbx), %r13
movq %r13, %rdi
movq %rbp, %rsi
callq 0x22b0
testl %eax, %eax
je 0x2aed
addq $0xf, %r13
decq %r15
jne 0x2ab9
leaq 0x36d0(%rip), %rdi      # 0x61a8
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2050
testq %r14, %r14
jne 0x2a2a
jmp 0x2b17
movq %r13, %rdi
movq %r12, %rsi
callq 0x21b0
cmpl $0x2, 0x6711(%rip)      # 0x9210
jl 0x2ae2
leaq 0x3686(%rip), %rdi      # 0x618e
movq %rbp, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2050
jmp 0x2ae2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3e81
incq %rdi
movb $0x40, %cl
cmpb $-0x50, %al
jl 0x3e73
movl %eax, %edx
andb $-0x10, %dl
movb $0x10, %cl
cmpb $-0x20, %dl
jne 0x3e78
orb %cl, %al
movb %al, -0x1(%rdi)
movb (%rdi), %al
incq %rdi
testb %al, %al
jne 0x3e61
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
cmpb $0x0, 0x10(%rax)
je 0x45ea
movl 0x50(%rax), %edi
testl %edi, %edi
jle 0x45c7
callq 0x23b0
movq (%rbx), %rax
movl $0x0, 0x50(%rax)
movq 0x58(%rax), %rdi
callq 0x2230
movq (%rbx), %rax
xorl %ecx, %ecx
movq %rcx, 0x58(%rax)
movq (%rbx), %rax
movq %rcx, 0x60(%rax)
movq (%rbx), %rdi
callq 0x2230
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x46be
xorps %xmm0, %xmm0
leaq 0x4(%rsp), %r14
movaps %xmm0, -0x4(%r14)
movaps %xmm0, 0xc(%r14)
movb $0x3, -0x4(%r14)
cmpb $0x0, 0x10(%rbx)
movl $0x3, %eax
movl $0x83, %ecx
cmovel %eax, %ecx
movb %cl, -0x4(%r14)
xorl %edi, %edi
callq 0x21a0
leaq 0x20(%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 0x5596
leaq 0x8(%rsp), %rdi
movswl 0x18(%rbx), %esi
callq 0x559d
leaq 0xa(%rsp), %rdi
movswl 0x30(%rbx), %esi
callq 0x559d
movl (%rbx), %edi
movq %rsp, %rsi
movl $0x20, %edx
callq 0x20a0
movq %rax, %rcx
xorl %eax, %eax
cmpq $-0x1, %rcx
sete %al
negl %eax
jmp 0x46c3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4791
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
cmpb $0x0, 0x32(%r14)
je 0x4774
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 0x4791
incq %r13
movzbl 0x32(%r14), %eax
addq $0xf, %r12
cmpq %rax, %r13
jb 0x471d
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_O1/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
leaq (%rax,%rax,4), %rax
leaq (%rax,%rax,2), %rsi
addq $0xf, %rsi
movq 0x40(%rdi), %rdi
callq 0x2350
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x4852
movq %rax, %r15
movq %rax, 0x40(%rbx)
movl %r12d, 0x4(%rsp)
movzbl 0x32(%rbx), %r12d
leaq (%r12,%r12,4), %rax
movq %r13, %rsi
leaq (%rax,%rax,2), %r13
movq %r15, %rdi
addq %r13, %rdi
movl $0xb, %edx
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
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x4852
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_O1/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 0x48db
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
testb $0x40, %bpl
jne 0x4892
xorl %eax, %eax
callq 0x2150
jmp 0x489e
movl $0x1a4, %edx            # imm = 0x1A4
xorl %eax, %eax
callq 0x2150
movl %eax, (%rbx)
cmpl $-0x1, %eax
je 0x48d3
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 0x48e2
movq %rbx, %rdi
callq 0x2230
movq $-0x1, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x20, %esi
movq %r12, %rdi
callq 0x2140
movq %rax, %r14
movq $-0x1, %rax
testq %r14, %r14
je 0x52d9
testq %r12, %r12
je 0x52a3
movq 0x40(%r15), %r13
shll $0x5, %r12d
xorl %ebx, %ebx
xorl %ebp, %ebp
movzbl 0xb(%r13), %eax
movl $0x1a, %edi
cmpl $0x53, %eax
jg 0x5222
leal -0x47(%rax), %ecx
cmpl $0x9, %ecx
ja 0x522e
leaq 0x1869(%rip), %rdx      # 0x6a74
movslq (%rdx,%rcx,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x68(%r15), %rax
leaq 0x2(,%rax,2), %rdi
jmp 0x524f
cmpl $0x54, %eax
je 0x524a
cmpl $0x59, %eax
je 0x524f
jmp 0x5233
cmpl $0x42, %eax
je 0x524f
movzbl 0xc(%r13), %edi
jmp 0x5245
movl $0x10, %edi
jmp 0x524f
movq 0x68(%r15), %rdi
incq %rdi
jmp 0x524f
movl $0x18, %edi
movq %rdi, 0x10(%r14,%rbx)
callq 0x2280
movq %rax, 0x18(%r14,%rbx)
testq %rax, %rax
je 0x52a8
leaq (%r14,%rbx), %rdi
movl $0xb, %edx
movq %r13, %rsi
callq 0x2110
movb 0xb(%r13), %al
movb %al, 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 0x51ed
movq %r14, %rax
jmp 0x52d9
testq %rbx, %rbx
je 0x52ca
movq %r14, %rbx
addq $0x18, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x52c1
callq 0x2230
addq $0x20, %rbx
decq %rbp
jne 0x52b4
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_O1/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 0x531c
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 0x5303
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2230
// File: /workspace/github_c_makefile_star2_O1/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 0x1eb99(%rip), %rdi     # 0x21020
xorl %eax, %eax
callq 0x2040
leaq 0x1ed63(%rip), %rdi     # 0x211f8
callq 0x2210
leaq 0x1ed5e(%rip), %rdi     # 0x211ff
callq 0x2210
leaq 0x1ed7e(%rip), %rdi     # 0x2122b
callq 0x2210
leaq 0x1ed9c(%rip), %rdi     # 0x21255
callq 0x2210
leaq 0x1edaf(%rip), %rdi     # 0x21274
callq 0x2210
leaq 0x1edc5(%rip), %rdi     # 0x21296
callq 0x2210
leaq 0x1ede6(%rip), %rdi     # 0x212c3
popq %rax
jmp 0x2210
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x18(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %rbx
cmpl $0x2, %edi
jge 0x251f
movq (%rbx), %rdi
callq 0x247c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x2644
movl %edi, %ebp
movl $0x1, %r12d
movb $0x1, %r14b
movslq %r12d, %r13
movq (%rbx,%r13,8), %r15
movl $0x2, %edx
movq %r15, %rdi
leaq 0x1eb04(%rip), %rsi     # 0x21044
callq 0x20a0
testl %eax, %eax
je 0x25dd
movl $0x2, %edx
movq %r15, %rdi
leaq 0x1eaeb(%rip), %rsi     # 0x21047
callq 0x20a0
testl %eax, %eax
je 0x25ed
movl $0x2, %edx
movq %r15, %rdi
leaq 0x1ead2(%rip), %rsi     # 0x2104a
callq 0x20a0
testl %eax, %eax
je 0x25fd
movl $0x2, %edx
movq %r15, %rdi
leaq 0x1eabd(%rip), %rsi     # 0x2104d
callq 0x20a0
testl %eax, %eax
je 0x260a
movl $0x2, %edx
movq %r15, %rdi
leaq 0x1eaa8(%rip), %rsi     # 0x21050
callq 0x20a0
testl %eax, %eax
je 0x261a
movl $0x2, %edx
movq %r15, %rdi
leaq 0x1ea93(%rip), %rsi     # 0x21053
callq 0x20a0
testl %eax, %eax
jne 0x2653
leal 0x1(%r13), %r12d
movq 0x8(%rbx,%r13,8), %rax
movq 0x60(%rsp), %rcx
jmp 0x2628
leal 0x1(%r13), %r12d
movq 0x8(%rbx,%r13,8), %rax
movq 0x20(%rsp), %rcx
jmp 0x2628
leal 0x1(%r13), %r12d
movq 0x8(%rbx,%r13,8), %rax
movq 0x18(%rsp), %rcx
jmp 0x2628
movq 0x68(%rsp), %rax
movl $0x1, (%rax)
jmp 0x262b
leal 0x1(%r13), %r12d
movq 0x8(%rbx,%r13,8), %rax
movq 0x10(%rsp), %rcx
jmp 0x2628
leal 0x1(%r13), %r12d
movq 0x8(%rbx,%r13,8), %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
incl %r12d
cmpl %ebp, %r12d
setl %r14b
jl 0x252a
movzbl %r14b, %eax
andl $0x1, %eax
negl %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e9fc(%rip), %rdi     # 0x21056
movq %r15, %rsi
xorl %eax, %eax
callq 0x2040
movq (%rbx), %rdi
callq 0x247c
jmp 0x263b
// File: /workspace/github_c_makefile_star2_O1/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 0x2f1f
cmpl $0x0, 0x4(%rsp)
je 0x2eff
movq (%rbx), %rdi
callq 0x247c
jmp 0x2f1d
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq 0x266e
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x1a251
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r13d
leaq 0xae66(%rip), %r15      # 0x2506c
leaq 0xae63(%rip), %r12      # 0x25070
xorl %ebp, %ebp
testb $0xf, %bpl
jne 0x1a22a
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 0x1a20f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1a2a3
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 0xadfa(%rip), %r12      # 0x25075
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 0x1a27b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa6b7(%rip), %rsi      # 0x265e9
leaq 0x52a6(%rip), %rcx      # 0x211df
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1bfc5
movq (%r15), %rax
testq %rax, %rax
je 0x1bfc5
leal 0x2(%rbx), %edx
movq 0x10(%rax), %r8
leaq 0xa6ab(%rip), %rsi      # 0x2660b
leaq 0x5278(%rip), %rcx      # 0x211df
movq %r14, %rdi
xorl %eax, %eax
callq 0x2200
movq (%r15), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x1bfc5
leal 0x4(%rbx), %ebp
addl $0x6, %ebx
movl $0x1, %r15d
leaq 0x5250(%rip), %r13      # 0x211df
movq %r14, %rdi
leaq 0xa681(%rip), %rsi      # 0x2661a
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 0x1bd38
incq %r15
movq (%r12), %r12
testq %r12, %r12
jne 0x1bf8f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa5e5(%rip), %rsi      # 0x26635
leaq 0x5188(%rip), %rcx      # 0x211df
movl %ebx, %edx
movq %r15, %r9
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1c091
addl $0x2, %ebx
movl 0x8(%r15), %r8d
movq (%r15), %r9
leaq 0xa5c8(%rip), %rsi      # 0x26641
leaq 0x515f(%rip), %rcx      # 0x211df
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_O1/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 0xa580(%rip), %rsi      # 0x26635
leaq 0x5123(%rip), %rcx      # 0x211df
movl %r15d, %edx
movq %rbx, %r9
xorl %eax, %eax
callq 0x2200
testq %rbx, %rbx
je 0x1c160
leal 0x2(%r15), %edx
leaq 0xa574(%rip), %rsi      # 0x26651
leaq 0x50fb(%rip), %rcx      # 0x211df
movq %r14, %rdi
xorl %eax, %eax
callq 0x2200
cmpq $0x0, 0x8(%rbx)
je 0x1c145
addl $0x4, %r15d
leaq 0x50df(%rip), %r13      # 0x211df
leaq 0x8f69(%rip), %rbp      # 0x25070
xorl %r12d, %r12d
testb $0xf, %r12b
jne 0x1c127
movq %r14, %rdi
leaq 0xa541(%rip), %rsi      # 0x2665b
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 0x1c10a
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_O1/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 0xa497(%rip), %rsi      # 0x26662
leaq 0x500d(%rip), %rcx      # 0x211df
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1c22b
addl $0x2, %ebx
movl (%r15), %r8d
leaq 0xa48c(%rip), %rsi      # 0x2667c
leaq 0x4fe8(%rip), %r12      # 0x211df
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x4(%r15), %r8d
leaq 0xa479(%rip), %rsi      # 0x2668a
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_O1/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 0xa44e(%rip), %rsi      # 0x26698
leaq 0x4f8e(%rip), %rcx      # 0x211df
movl %ebp, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1c2b0
addl $0x2, %ebp
movq (%r14), %rcx
leaq 0xa437(%rip), %rdx      # 0x266a6
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c039
leaq 0xa431(%rip), %rsi      # 0x266b1
leaq 0x4f58(%rip), %rcx      # 0x211df
movq %rbx, %rdi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2200
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x1b11c
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_O1/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 0xa3f7(%rip), %rsi      # 0x266c0
leaq 0x4f0f(%rip), %rcx      # 0x211df
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1c312
addl $0x2, %ebx
movq (%r15), %rcx
leaq 0xa3e1(%rip), %rdx      # 0x266cf
movq %r14, %rdi
movl %ebx, %esi
callq 0x1c097
movq 0x8(%r15), %rcx
leaq 0xa3d5(%rip), %rdx      # 0x266d8
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1c097
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa3b8(%rip), %rsi      # 0x266e4
leaq 0x4eac(%rip), %rcx      # 0x211df
movl %ebx, %edx
movq %r15, %r8
xorl %eax, %eax
callq 0x2200
testq %r15, %r15
je 0x1c375
addl $0x2, %ebx
movq (%r15), %rcx
leaq 0xa3bd(%rip), %rdx      # 0x2670e
movq %r14, %rdi
movl %ebx, %esi
callq 0x1c039
movq 0x8(%r15), %rcx
leaq 0xa3be(%rip), %rdx      # 0x26724
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1c039
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa1d0(%rip), %rsi      # 0x268e3
leaq 0x4ac5(%rip), %rcx      # 0x211df
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1c755
addl $0x2, %ebx
movq (%r14), %rcx
leaq 0x6c29(%rip), %rdx      # 0x23361
movq %r15, %rdi
movl %ebx, %esi
callq 0x1c039
movq 0x8(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1c37b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa198(%rip), %rsi      # 0x26907
leaq 0x4a69(%rip), %rcx      # 0x211df
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1c7b1
addl $0x2, %ebx
movq (%r14), %rcx
leaq 0x6bcd(%rip), %rdx      # 0x23361
movq %r15, %rdi
movl %ebx, %esi
callq 0x1c039
movq 0x8(%r14), %rdx
movq %r15, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1c37b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa161(%rip), %rsi      # 0x2692e
leaq 0x4a0b(%rip), %rcx      # 0x211df
movl %ebp, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1c8a0
addl $0x2, %ebp
leaq 0xa156(%rip), %rsi      # 0x26949
leaq 0x49e5(%rip), %r15      # 0x211df
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2200
movl (%r14), %esi
movq %rbx, %rdi
callq 0x1b874
movl $0xa, %edi
movq %rbx, %rsi
callq 0x21b0
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c6ff
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c75b
movq 0x18(%r14), %rcx
leaq 0xa116(%rip), %rdx      # 0x2695e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c097
movq 0x20(%r14), %rcx
leaq 0xa10f(%rip), %rdx      # 0x2696c
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1c097
leaq 0xa10f(%rip), %rsi      # 0x2697d
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x28(%r14), %esi
movq %rbx, %rdi
callq 0x1b8ed
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_O1/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 0x9f17(%rip), %rsi      # 0x269b0
leaq 0x473f(%rip), %rcx      # 0x211df
movl %ebx, %edx
movq %r14, %r8
xorl %eax, %eax
callq 0x2200
testq %r14, %r14
je 0x1cb38
addl $0x2, %ebx
leaq 0x9f04(%rip), %rsi      # 0x269c3
leaq 0x4719(%rip), %r12      # 0x211df
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl (%r14), %esi
movq %r15, %rdi
callq 0x1b16c
movl $0xa, %edi
movq %r15, %rsi
callq 0x21b0
leaq 0x9ee3(%rip), %rsi      # 0x269d7
movq %r15, %rdi
movl %ebx, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x2200
movl 0x4(%r14), %esi
movq %r15, %rdi
callq 0x1bfd4
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 0x1c8ab
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1cbb2
cmpl $0x8, %edx
jne 0x1cc34
leaq 0x9e7a(%rip), %rdx      # 0x26a17
movq %r14, %rdi
movl %ebx, %esi
movq %r12, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1c097
movl %ecx, %ebp
leaq 0x9e66(%rip), %rsi      # 0x26a21
leaq 0x461d(%rip), %rcx      # 0x211df
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %r8
xorl %eax, %eax
callq 0x2200
testq %r12, %r12
je 0x1cc2b
movq (%r12), %rcx
movq 0x8(%r12), %r15
movq 0x10(%r12), %r12
addl $0x2, %ebx
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x1cb44
leaq 0x9e3a(%rip), %rsi      # 0x26a34
leaq 0x45de(%rip), %rcx      # 0x211df
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %r8
xorl %eax, %eax
callq 0x2200
testq %r12, %r12
je 0x1cc2b
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x1ca82
addq $0x10, %r15
decq %r12
jne 0x1cc15
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9e0d(%rip), %rsi      # 0x26a48
leaq 0x459d(%rip), %rcx      # 0x211df
movq %r14, %rdi
movl %ebx, %edx
movq %r12, %r8
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2200