LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movw %si, %ax
movq %rdi, 0x80(%rsp)
movw %ax, 0x7e(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movl %r8d, 0x64(%rsp)
movl $0xffffffff, 0x60(%rsp) # imm = 0xFFFFFFFF
leaq 0x18(%rsp), %rdi
movl $0x10, %esi
movl $0x5, %edx
xorl %ecx, %ecx
callq 0x16b50
movq 0x80(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0x18(%rsp), %rcx
movswl 0x7e(%rsp), %edx
callq 0xd460
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x17d8d
leaq 0x657a(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
movl $0x3, %eax
cmpl %ecx, %eax
jg 0x17d8b
leaq 0x6570(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movq 0x80(%rsp), %rdx
movl $0x3, %edi
leaq 0x1f43(%rip), %rsi      # 0x19cca
movb $0x0, %al
callq *%rcx
jmp 0x17e00
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x17e20
movl %eax, %ecx
movl (%rsp), %eax
cmpl %ecx, %eax
jae 0x17dfe
movl 0x14(%rsp), %esi
leaq 0x18(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x17290
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movl 0x64(%rsp), %ecx
leaq 0x4(%rsp), %rdi
xorl %r8d, %r8d
callq 0x17830
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x17def
movl $0x0, 0x60(%rsp)
jmp 0x17e00
jmp 0x17df1
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x17d95
jmp 0x17e00
leaq 0x18(%rsp), %rdi
callq 0x16e10
movl 0x60(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2030
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x24c0
movl $0x0, -0x4(%rbp)
jmp 0x250e
jmp 0x24c2
movq -0x20(%rbp), %rdi
callq 0x21c0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x24fe
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2280
cmpl $0x0, %eax
jne 0x24fc
movq -0x20(%rbp), %rdi
callq 0x21b0
movl $0x1, -0x4(%rbp)
jmp 0x250e
jmp 0x24c2
movq -0x20(%rbp), %rdi
callq 0x21b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x5c3d(%rip), %rdi      # 0x8168
leaq 0x5c44(%rip), %rsi      # 0x8176
movb $0x0, %al
callq 0x2050
leaq 0x5c3b(%rip), %rdi      # 0x817b
movb $0x0, %al
callq 0x2050
leaq 0x5c74(%rip), %rdi      # 0x81c2
movb $0x0, %al
callq 0x2050
leaq 0x5cb2(%rip), %rdi      # 0x820e
movb $0x0, %al
callq 0x2050
leaq 0x5ceb(%rip), %rdi      # 0x8255
movb $0x0, %al
callq 0x2050
leaq 0x5d27(%rip), %rdi      # 0x829f
movb $0x0, %al
callq 0x2050
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x25ac
jmp 0x271a
cmpl $0x2, 0x8cf5(%rip)      # 0xb2a8
jle 0x25c3
leaq 0x5cfe(%rip), %rdi      # 0x82ba
movb $0x0, %al
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, %rdi
shlq $0x0, %rdi
addq $0x1, %rdi
callq 0x2260
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x2611
movq 0x89eb(%rip), %rax      # 0xafd8
movq (%rax), %rdi
leaq 0x5ce2(%rip), %rsi      # 0x82d9
movb $0x0, %al
callq 0x2290
leaq -0x10(%rbp), %rdi
callq 0x5030
movl $0x1, %edi
callq 0x2230
cmpl $0x2, 0x8c90(%rip)      # 0xb2a8
jle 0x2628
leaq 0x5ceb(%rip), %rdi      # 0x830c
movb $0x0, %al
callq 0x2050
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movzbl 0x32(%rcx), %ecx
cmpl %ecx, %eax
jge 0x26fa
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2190
movl $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x601c(%rip), %rsi      # 0x867d
callq 0x22e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x26ce
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
movslq -0x24(%rbp), %rax
imulq $0xf, %rax, %rax
addq %rax, %rsi
callq 0x21f0
cmpl $0x0, %eax
jne 0x26b6
movl $0x1, -0x28(%rbp)
cmpl $0x1, 0x8c08(%rip)      # 0xb2a8
jle 0x26b4
movq -0x18(%rbp), %rsi
leaq 0x5c6d(%rip), %rdi      # 0x831a
movb $0x0, %al
callq 0x2050
jmp 0x26b6
jmp 0x26b8
xorl %eax, %eax
movl %eax, %edi
leaq 0x5fba(%rip), %rsi      # 0x867d
callq 0x22e0
movq %rax, -0x18(%rbp)
jmp 0x266a
cmpl $0x0, -0x28(%rbp)
jne 0x26ea
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x24(%rbp), %rcx
imulq $0xf, %rcx, %rcx
addq %rcx, %rax
movb $0x0, (%rax)
jmp 0x26ec
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x262f
cmpl $0x2, 0x8ba7(%rip)      # 0xb2a8
jle 0x2711
leaq 0x5b49(%rip), %rdi      # 0x8253
movb $0x0, %al
callq 0x2050
movq -0x20(%rbp), %rdi
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x43ba
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
jle 0x4384
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x50, %eax
jge 0x4384
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
addl $0x40, %ecx
movb %cl, (%rax)
jmp 0x43aa
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x21, %eax
jle 0x43a8
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x10, %eax
jge 0x43a8
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
addl $0x10, %ecx
movb %cl, (%rax)
jmp 0x43aa
jmp 0x43ac
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x4350
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0x2380
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x40(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x38(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movzbl 0x10(%rax), %eax
cmpl $0x0, %eax
je 0x50f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x50(%rax)
jle 0x50b4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x50(%rax), %edi
callq 0x2380
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2210
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2370
cmpq $-0x1, %rax
jne 0x513f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5208
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2110
movb $0x3, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, 0x10(%rax)
je 0x5161
movb $-0x7d, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2180
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2150
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl 0x14(%rax), %eax
movb %al, -0x2f(%rbp)
movq -0x40(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movb %al, -0x2e(%rbp)
movq -0x40(%rbp), %rax
movl 0xc(%rax), %eax
movb %al, -0x2d(%rbp)
leaq -0x30(%rbp), %rdi
addq $0x4, %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x7000
leaq -0x30(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movswl %ax, %esi
callq 0x70c0
leaq -0x30(%rbp), %rdi
addq $0xa, %rdi
movq -0x10(%rbp), %rax
movswl 0x30(%rax), %esi
callq 0x70c0
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
callq 0x2090
cmpq $-0x1, %rax
jne 0x5201
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5208
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movb $0xd, -0x39(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
movl $0x20, %esi
xorl %edx, %edx
callq 0x2370
cmpq $-0x1, %rax
jne 0x5254
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5341
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x2110
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x32(%rcx), %ecx
cmpq %rcx, %rax
jae 0x5317
leaq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rsi
imulq $0xf, -0x38(%rbp), %rax
addq %rax, %rsi
movl $0xa, %edx
callq 0x2100
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
imulq $0xf, -0x38(%rbp), %rcx
addq %rcx, %rax
movb 0xb(%rax), %al
movb %al, -0x25(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
imulq $0xf, -0x38(%rbp), %rcx
addq %rcx, %rax
movb 0xc(%rax), %al
movb %al, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
imulq $0xf, -0x38(%rbp), %rcx
addq %rcx, %rax
movb 0xd(%rax), %al
movb %al, -0x1f(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
callq 0x2090
cmpq $-0x1, %rax
jne 0x5304
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5341
jmp 0x5306
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x526c
movq -0x10(%rbp), %rax
movl (%rax), %edi
leaq -0x39(%rbp), %rsi
movl $0x1, %edx
callq 0x2090
cmpq $-0x1, %rax
jne 0x533a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5341
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %dl, -0x19(%rbp)
movb %cl, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x32(%rax), %eax
addl $0x1, %eax
cltq
imulq $0xf, %rax, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x38(%rbp), %rsi
callq 0x2320
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x53a8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x548c
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
movzbl 0x32(%rax), %eax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
imulq $0xf, -0x40(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl $0xb, %edx
callq 0x2100
movb -0x19(%rbp), %cl
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
imulq $0xf, -0x40(%rbp), %rdx
addq %rdx, %rax
movb %cl, 0xb(%rax)
movb -0x1a(%rbp), %cl
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
imulq $0xf, -0x40(%rbp), %rdx
addq %rdx, %rax
movb %cl, 0xc(%rax)
movb -0x1b(%rbp), %cl
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
imulq $0xf, -0x40(%rbp), %rdx
addq %rdx, %rax
movb %cl, 0xd(%rax)
movq -0x10(%rbp), %rax
movb 0x32(%rax), %cl
addb $0x1, %cl
movb %cl, 0x32(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x18(%rax)
movzbl -0x1a(%rbp), %edx
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rax
movzwl 0x30(%rax), %eax
movl %eax, %esi
callq 0x2320
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x5479
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x548c
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x88, %edi
callq 0x2260
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x54d3
movq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x55cd
movl -0x14(%rbp), %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x5517
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl $0x1a4, %edx            # imm = 0x1A4
movb $0x0, %al
callq 0x2140
movq -0x20(%rbp), %rcx
movl %eax, (%rcx)
cmpl $-0x1, %eax
jne 0x5515
movq -0x20(%rbp), %rdi
callq 0x2210
movq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x55cd
jmp 0x554b
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movb $0x0, %al
callq 0x2140
movq -0x20(%rbp), %rcx
movl %eax, (%rcx)
cmpl $-0x1, %eax
jne 0x5549
movq -0x20(%rbp), %rdi
callq 0x2210
movq $-0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x55cd
jmp 0x554b
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x11(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x12(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x13(%rax)
movq -0x20(%rbp), %rax
movq $0x21, 0x18(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movw $0x1, 0x30(%rax)
movq -0x20(%rbp), %rax
movb $0x0, 0x32(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movzbl 0x32(%rcx), %ecx
cmpl %ecx, %eax
jge 0x6ae9
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x2210
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6ab7
movq -0x10(%rbp), %rdi
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sonicse[P]dbf2mysql/endian.c
// Function: get_long
long get_long(u_char *cp)
{
        long ret;

        ret = *cp++;
        ret += ((*cp++)<<8);
        ret += ((*cp++)<<16);
        ret += ((*cp++)<<24);

        return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shll $0x8, %eax
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shll $0x10, %eax
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
shll $0x18, %eax
cltq
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sonicse[P]dbf2mysql/endian.c
// Function: put_long
void put_long(u_char *cp, long lval)
{
        cp[0] = lval & 0xff;
        cp[1] = (lval >> 8) & 0xff;
        cp[2] = (lval >> 16) & 0xff;
        cp[3] = (lval >> 24) & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rax
sarq $0x8, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x10(%rbp), %rax
sarq $0x10, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x10(%rbp), %rax
sarq $0x18, %rax
andq $0xff, %rax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x28cdd(%rip), %rdi     # 0x2b004
movb $0x0, %al
callq 0x2040
leaq 0x28cf3(%rip), %rdi     # 0x2b028
movb $0x0, %al
callq 0x2040
leaq 0x28ced(%rip), %rdi     # 0x2b030
movb $0x0, %al
callq 0x2040
leaq 0x28d0c(%rip), %rdi     # 0x2b05d
movb $0x0, %al
callq 0x2040
leaq 0x28d29(%rip), %rdi     # 0x2b088
movb $0x0, %al
callq 0x2040
leaq 0x28d3b(%rip), %rdi     # 0x2b0a8
movb $0x0, %al
callq 0x2040
leaq 0x28d50(%rip), %rdi     # 0x2b0cb
movb $0x0, %al
callq 0x2040
leaq 0x28d70(%rip), %rdi     # 0x2b0f9
movb $0x0, %al
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
leaq -0x30(%rbp), %r9
leaq -0x38(%rbp), %r10
leaq -0x3c(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x23a0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x40(%rbp)
je 0x32c3
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x32fe
cmpl $0x0, -0x3c(%rbp)
je 0x32de
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2310
movl $0x0, -0x4(%rbp)
jmp 0x32fe
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x25d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2011c
jmp 0x2017e
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2017e
movl -0x24(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x20155
movq -0x8(%rbp), %rdi
leaq 0xe13a(%rip), %rsi      # 0x2e288
movb $0x0, %al
callq 0x21d0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0xe120(%rip), %rsi      # 0x2e28c
movb $0x0, %al
callq 0x21d0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2012b
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x201a9
jmp 0x201f1
movq -0x10(%rbp), %rax
movq 0x860(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x64(%rax), %ecx
leaq 0xe0c3(%rip), %rsi      # 0x2e291
movb $0x0, %al
callq 0x21d0
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $-0x68, %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
addq $0x38, %rcx
cmpq %rcx, %rax
jne 0x201b8
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_attestation_type_enum
void
kmip_print_attestation_type_enum(FILE *f, enum attestation_type value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_ATTEST_TPM_QUOTE:
        fprintf(f, "TPM Quote");
        break;
        
        case KMIP_ATTEST_TCG_INTEGRITY_REPORT:
        fprintf(f, "TCG Integrity Report");
        break;
        
        case KMIP_ATTEST_SAML_ASSERTION:
        fprintf(f, "SAML Assertion");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x20429
movq -0x8(%rbp), %rdi
leaq 0xfe36(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x20498
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x2044a
jmp 0x20436
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x2045e
jmp 0x20440
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x20472
jmp 0x20486
movq -0x8(%rbp), %rdi
leaq 0xdffd(%rip), %rsi      # 0x2e452
movb $0x0, %al
callq 0x21d0
jmp 0x20498
movq -0x8(%rbp), %rdi
leaq 0xdff3(%rip), %rsi      # 0x2e45c
movb $0x0, %al
callq 0x21d0
jmp 0x20498
movq -0x8(%rbp), %rdi
leaq 0xdff4(%rip), %rsi      # 0x2e471
movb $0x0, %al
callq 0x21d0
jmp 0x20498
movq -0x8(%rbp), %rdi
leaq 0xfeca(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_batch_error_continuation_option
void
kmip_print_batch_error_continuation_option(FILE *f, enum batch_error_continuation_option value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_BATCH_CONTINUE:
        fprintf(f, "Continue");
        break;
        
        case KMIP_BATCH_STOP:
        fprintf(f, "Stop");
        break;
        
        case KMIP_BATCH_UNDO:
        fprintf(f, "Undo");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x204c9
movq -0x8(%rbp), %rdi
leaq 0xfd96(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x20538
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x204ea
jmp 0x204d6
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x204fe
jmp 0x204e0
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x20512
jmp 0x20526
movq -0x8(%rbp), %rdi
leaq 0xdf8b(%rip), %rsi      # 0x2e480
movb $0x0, %al
callq 0x21d0
jmp 0x20538
movq -0x8(%rbp), %rdi
leaq 0xdf80(%rip), %rsi      # 0x2e489
movb $0x0, %al
callq 0x21d0
jmp 0x20538
movq -0x8(%rbp), %rdi
leaq 0xdf71(%rip), %rsi      # 0x2e48e
movb $0x0, %al
callq 0x21d0
jmp 0x20538
movq -0x8(%rbp), %rdi
leaq 0xfe2a(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_result_status_enum
void
kmip_print_result_status_enum(FILE *f, enum result_status value)
{
    switch(value)
    {
        case KMIP_STATUS_SUCCESS:
        fprintf(f, "Success");
        break;
        
        case KMIP_STATUS_OPERATION_FAILED:
        fprintf(f, "Operation Failed");
        break;
        
        case KMIP_STATUS_OPERATION_PENDING:
        fprintf(f, "Operation Pending");
        break;
        
        case KMIP_STATUS_OPERATION_UNDONE:
        fprintf(f, "Operation Undone");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x3, %rax
ja 0x20ae0
movq -0x18(%rbp), %rax
leaq 0xcf69(%rip), %rcx      # 0x2d9f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0xdc01(%rip), %rsi      # 0x2e69c
movb $0x0, %al
callq 0x21d0
jmp 0x20af2
movq -0x8(%rbp), %rdi
leaq 0xdbf5(%rip), %rsi      # 0x2e6a4
movb $0x0, %al
callq 0x21d0
jmp 0x20af2
movq -0x8(%rbp), %rdi
leaq 0xdbf2(%rip), %rsi      # 0x2e6b5
movb $0x0, %al
callq 0x21d0
jmp 0x20af2
movq -0x8(%rbp), %rdi
leaq 0xdbf0(%rip), %rsi      # 0x2e6c7
movb $0x0, %al
callq 0x21d0
jmp 0x20af2
movq -0x8(%rbp), %rdi
leaq 0xf870(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_object_type_enum
void
kmip_print_object_type_enum(FILE *f, enum object_type value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_OBJTYPE_CERTIFICATE:
        fprintf(f, "Certificate");
        break;
        
        case KMIP_OBJTYPE_SYMMETRIC_KEY:
        fprintf(f, "Symmetric Key");
        break;
        
        case KMIP_OBJTYPE_PUBLIC_KEY:
        fprintf(f, "Public Key");
        break;
        
        case KMIP_OBJTYPE_PRIVATE_KEY:
        fprintf(f, "Private Key");
        break;
        
        case KMIP_OBJTYPE_SPLIT_KEY:
        fprintf(f, "Split Key");
        break;
        
        case KMIP_OBJTYPE_TEMPLATE:
        fprintf(f, "Template");
        break;
        
        case KMIP_OBJTYPE_SECRET_DATA:
        fprintf(f, "Secret Data");
        break;
        
        case KMIP_OBJTYPE_OPAQUE_OBJECT:
        fprintf(f, "Opaque Object");
        break;
        
        case KMIP_OBJTYPE_PGP_KEY:
        fprintf(f, "PGP Key");
        break;

        case KMIP_OBJTYPE_CERTIFICATE_REQUEST:
        fprintf(f, "Certificate Request");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x211dc
movq -0x8(%rbp), %rdi
leaq 0xf086(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x9, %eax
ja 0x212d8
movq -0x18(%rbp), %rax
leaq 0xcc05(%rip), %rcx      # 0x2de00
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0xdaa2(%rip), %rsi      # 0x2ecb1
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xdafe(%rip), %rsi      # 0x2ed24
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xdb21(%rip), %rsi      # 0x2ed5e
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xdaee(%rip), %rsi      # 0x2ed42
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xd3b2(%rip), %rsi      # 0x2e61d
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xda3e(%rip), %rsi      # 0x2ecbd
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xda33(%rip), %rsi      # 0x2ecc6
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xda2b(%rip), %rsi      # 0x2ecd2
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xda25(%rip), %rsi      # 0x2ece0
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xda19(%rip), %rsi      # 0x2ece8
movb $0x0, %al
callq 0x21d0
jmp 0x212ea
movq -0x8(%rbp), %rdi
leaq 0xf078(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_key_compression_type_enum
void
kmip_print_key_compression_type_enum(FILE *f, enum key_compression_type value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_KEYCOMP_EC_PUB_UNCOMPRESSED:
        fprintf(f, "EC Public Key Type Uncompressed");
        break;
        
        case KMIP_KEYCOMP_EC_PUB_X962_COMPRESSED_PRIME:
        fprintf(f, "EC Public Key Type X9.62 Compressed Prime");
        break;
        
        case KMIP_KEYCOMP_EC_PUB_X962_COMPRESSED_CHAR2:
        fprintf(f, "EC Public Key Type X9.62 Compressed Char2");
        break;
        
        case KMIP_KEYCOMP_EC_PUB_X962_HYBRID:
        fprintf(f, "EC Public Key Type X9.62 Hybrid");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2158c
movq -0x8(%rbp), %rdi
leaq 0xecd6(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x21612
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x21600
movq -0x18(%rbp), %rax
leaq 0xc8dd(%rip), %rcx      # 0x2de84
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0xd90e(%rip), %rsi      # 0x2eec9
movb $0x0, %al
callq 0x21d0
jmp 0x21612
movq -0x8(%rbp), %rdi
leaq 0xd91a(%rip), %rsi      # 0x2eee9
movb $0x0, %al
callq 0x21d0
jmp 0x21612
movq -0x8(%rbp), %rdi
leaq 0xd930(%rip), %rsi      # 0x2ef13
movb $0x0, %al
callq 0x21d0
jmp 0x21612
movq -0x8(%rbp), %rdi
leaq 0xd946(%rip), %rsi      # 0x2ef3d
movb $0x0, %al
callq 0x21d0
jmp 0x21612
movq -0x8(%rbp), %rdi
leaq 0xed50(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_name_type_enum
void
kmip_print_name_type_enum(FILE *f, enum name_type value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_NAME_UNINTERPRETED_TEXT_STRING:
        fprintf(f, "Uninterpreted Text String");
        break;
        
        case KMIP_NAME_URI:
        fprintf(f, "URI");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x21bb9
movq -0x8(%rbp), %rdi
leaq 0xe6a6(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x21c0a
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x21bd0
jmp 0x21bc6
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x21be4
jmp 0x21bf8
movq -0x8(%rbp), %rdi
leaq 0xd503(%rip), %rsi      # 0x2f0de
movb $0x0, %al
callq 0x21d0
jmp 0x21c0a
movq -0x8(%rbp), %rdi
leaq 0xd509(%rip), %rsi      # 0x2f0f8
movb $0x0, %al
callq 0x21d0
jmp 0x21c0a
movq -0x8(%rbp), %rdi
leaq 0xe758(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_state_enum
void
kmip_print_state_enum(FILE *f, enum state value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_STATE_PRE_ACTIVE:
        fprintf(f, "Pre-Active");
        break;
        
        case KMIP_STATE_ACTIVE:
        fprintf(f, "Active");
        break;
        
        case KMIP_STATE_DEACTIVATED:
        fprintf(f, "Deactivated");
        break;
        
        case KMIP_STATE_COMPROMISED:
        fprintf(f, "Compromised");
        break;
        
        case KMIP_STATE_DESTROYED:
        fprintf(f, "Destroyed");
        break;
        
        case KMIP_STATE_DESTROYED_COMPROMISED:
        fprintf(f, "Destroyed Compromised");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x21dec
movq -0x8(%rbp), %rdi
leaq 0xe476(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x21e9e
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x5, %eax
ja 0x21e8c
movq -0x18(%rbp), %rax
leaq 0xc1a5(%rip), %rcx      # 0x2dfb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0xd2dd(%rip), %rsi      # 0x2f0fc
movb $0x0, %al
callq 0x21d0
jmp 0x21e9e
movq -0x8(%rbp), %rdi
leaq 0xd2cd(%rip), %rsi      # 0x2f100
movb $0x0, %al
callq 0x21d0
jmp 0x21e9e
movq -0x8(%rbp), %rdi
leaq 0xd2c0(%rip), %rsi      # 0x2f107
movb $0x0, %al
callq 0x21d0
jmp 0x21e9e
movq -0x8(%rbp), %rdi
leaq 0xd2c2(%rip), %rsi      # 0x2f11d
movb $0x0, %al
callq 0x21d0
jmp 0x21e9e
movq -0x8(%rbp), %rdi
leaq 0xcd70(%rip), %rsi      # 0x2ebdf
movb $0x0, %al
callq 0x21d0
jmp 0x21e9e
movq -0x8(%rbp), %rdi
leaq 0xd290(%rip), %rsi      # 0x2f113
movb $0x0, %al
callq 0x21d0
jmp 0x21e9e
movq -0x8(%rbp), %rdi
leaq 0xe4c4(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_padding_method_enum
void
kmip_print_padding_method_enum(FILE *f, enum padding_method value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_PAD_NONE:
        fprintf(f, "None");
        break;
        
        case KMIP_PAD_OAEP:
        fprintf(f, "OAEP");
        break;
        
        case KMIP_PAD_PKCS5:
        fprintf(f, "PKCS5");
        break;
        
        case KMIP_PAD_SSL3:
        fprintf(f, "SSL3");
        break;
        
        case KMIP_PAD_ZEROS:
        fprintf(f, "Zeros");
        break;
        
        case KMIP_PAD_ANSI_X923:
        fprintf(f, "ANSI X9.23");
        break;
        
        case KMIP_PAD_ISO_10126:
        fprintf(f, "ISO 10126");
        break;
        
        case KMIP_PAD_PKCS1v15:
        fprintf(f, "PKCS1 v1.5");
        break;
        
        case KMIP_PAD_X931:
        fprintf(f, "X9.31");
        break;
        
        case KMIP_PAD_PSS:
        fprintf(f, "PSS");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x220dc
movq -0x8(%rbp), %rdi
leaq 0xe186(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x9, %eax
ja 0x221d8
movq -0x18(%rbp), %rax
leaq 0xbf15(%rip), %rcx      # 0x2e010
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0xd09c(%rip), %rsi      # 0x2f1ab
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xd08a(%rip), %rsi      # 0x2f1b0
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xd078(%rip), %rsi      # 0x2f1b5
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xd067(%rip), %rsi      # 0x2f1bb
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xd055(%rip), %rsi      # 0x2f1c0
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xd047(%rip), %rsi      # 0x2f1c6
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xd03e(%rip), %rsi      # 0x2f1d1
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xd034(%rip), %rsi      # 0x2f1db
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xd02b(%rip), %rsi      # 0x2f1e6
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xd01d(%rip), %rsi      # 0x2f1ec
movb $0x0, %al
callq 0x21d0
jmp 0x221ea
movq -0x8(%rbp), %rdi
leaq 0xe178(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_mask_generator_enum
void
kmip_print_mask_generator_enum(FILE *f, enum mask_generator value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_MASKGEN_MGF1:
        fprintf(f, "MGF1");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x228a9
movq -0x8(%rbp), %rdi
leaq 0xd9b6(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x228d9
movl -0xc(%rbp), %eax
subl $0x1, %eax
jne 0x228c7
jmp 0x228b3
movq -0x8(%rbp), %rdi
leaq 0xcc2f(%rip), %rsi      # 0x2f4ed
movb $0x0, %al
callq 0x21d0
jmp 0x228d9
movq -0x8(%rbp), %rdi
leaq 0xda89(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_wrapping_method_enum
void
kmip_print_wrapping_method_enum(FILE *f, enum wrapping_method value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_WRAP_ENCRYPT:
        fprintf(f, "Encrypt");
        break;
        
        case KMIP_WRAP_MAC_SIGN:
        fprintf(f, "MAC/sign");
        break;
        
        case KMIP_WRAP_ENCRYPT_MAC_SIGN:
        fprintf(f, "Encrypt then MAC/sign");
        break;
        
        case KMIP_WRAP_MAC_SIGN_ENCRYPT:
        fprintf(f, "MAC/sign then encrypt");
        break;
        
        case KMIP_WRAP_TR31:
        fprintf(f, "TR-31");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x2290c
movq -0x8(%rbp), %rdi
leaq 0xd956(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x229a6
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x22994
movq -0x18(%rbp), %rax
leaq 0xb801(%rip), %rcx      # 0x2e128
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0xbc8f(%rip), %rsi      # 0x2e5ca
movb $0x0, %al
callq 0x21d0
jmp 0x229a6
movq -0x8(%rbp), %rdi
leaq 0xcbb0(%rip), %rsi      # 0x2f4ff
movb $0x0, %al
callq 0x21d0
jmp 0x229a6
movq -0x8(%rbp), %rdi
leaq 0xcb8f(%rip), %rsi      # 0x2f4f2
movb $0x0, %al
callq 0x21d0
jmp 0x229a6
movq -0x8(%rbp), %rdi
leaq 0xcb91(%rip), %rsi      # 0x2f508
movb $0x0, %al
callq 0x21d0
jmp 0x229a6
movq -0x8(%rbp), %rdi
leaq 0xcb93(%rip), %rsi      # 0x2f51e
movb $0x0, %al
callq 0x21d0
jmp 0x229a6
movq -0x8(%rbp), %rdi
leaq 0xd9bc(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_encoding_option_enum
void
kmip_print_encoding_option_enum(FILE *f, enum encoding_option value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_ENCODE_NO_ENCODING:
        fprintf(f, "No Encoding");
        break;
        
        case KMIP_ENCODE_TTLV_ENCODING:
        fprintf(f, "TTLV Encoding");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x229d9
movq -0x8(%rbp), %rdi
leaq 0xd886(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x22a2a
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x229f0
jmp 0x229e6
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x22a04
jmp 0x22a18
movq -0x8(%rbp), %rdi
leaq 0xcb29(%rip), %rsi      # 0x2f524
movb $0x0, %al
callq 0x21d0
jmp 0x22a2a
movq -0x8(%rbp), %rdi
leaq 0xcb21(%rip), %rsi      # 0x2f530
movb $0x0, %al
callq 0x21d0
jmp 0x22a2a
movq -0x8(%rbp), %rdi
leaq 0xd938(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/OpenKMIP[P]libkmip/src/kmip_io.c
// Function: kmip_print_key_wrap_type_enum
void
kmip_print_key_wrap_type_enum(FILE *f, enum key_wrap_type value)
{
    if(value == 0)
    {
        fprintf(f, "-");
        return;
    }
    
    switch(value)
    {
        case KMIP_WRAPTYPE_NOT_WRAPPED:
        fprintf(f, "Not Wrapped");
        break;
        
        case KMIP_WRAPTYPE_AS_REGISTERED:
        fprintf(f, "As Registered");
        break;
        
        default:
        fprintf(f, "Unknown");
        break;
    };
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x22a59
movq -0x8(%rbp), %rdi
leaq 0xd806(%rip), %rsi      # 0x30256
movb $0x0, %al
callq 0x21d0
jmp 0x22aaa
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x22a70
jmp 0x22a66
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x22a84
jmp 0x22a98
movq -0x8(%rbp), %rdi
leaq 0xcac3(%rip), %rsi      # 0x2f53e
movb $0x0, %al
callq 0x21d0
jmp 0x22aaa
movq -0x8(%rbp), %rdi
leaq 0xcabb(%rip), %rsi      # 0x2f54a
movb $0x0, %al
callq 0x21d0
jmp 0x22aaa
movq -0x8(%rbp), %rdi
leaq 0xd8b8(%rip), %rsi      # 0x3035b
movb $0x0, %al
callq 0x21d0
addq $0x10, %rsp
popq %rbp
retq