LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: tokenize
static char **
tokenize(char *tokenstring, char separator)
{
	static char *tokenvec[NTOKENS+1];
	char *tsp, *sepp;
	int tokencount;

	tsp = tokenstring;
	tokencount = 0;
	do {
		tokenvec[tokencount++] = tsp;
		if ((sepp = strchr(tsp, separator)) != 0) {
			*sepp++ = 0;
			tsp = sepp;
		}
	} while (sepp && tokencount < NTOKENS);
	if (sepp)
		fprintf(stderr, "too many words, \"%s\" ignored\n", sepp);
	tokenvec[tokencount] = 0;
	return tokenvec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdx
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
movslq %eax, %rcx
leaq 0x8096(%rip), %rax      # 0xed60
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
movsbl -0x9(%rbp), %esi
callq 0x2090
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x6cff
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6d01
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x25(%rbp)
je 0x6d17
cmpl $0xa, -0x24(%rbp)
setl %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x6cb1
cmpq $0x0, -0x20(%rbp)
je 0x6d41
movq 0x52cc(%rip), %rax      # 0xbff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x2b66(%rip), %rsi      # 0x98a0
movb $0x0, %al
callq 0x2150
movslq -0x24(%rbp), %rcx
leaq 0x8014(%rip), %rax      # 0xed60
movq $0x0, (%rax,%rcx,8)
leaq 0x8005(%rip), %rax      # 0xed60
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: suf_in_use
static int
suf_in_use(char *name, char *suffix)
{
	of_p ofp;

	/*
	 * Check for potential duplicate suffix use
	 */
	for (ofp=output_formats; ofp->of_name; ofp++) {
		if (!(ofp->of_flags&OFF_USEIT)) {
			/*
			 * Format not in use, no problem
			 */
			continue;
		}
		if (ofp->of_suffix != 0) {
			if (suffix == 0 || strcmp(ofp->of_suffix, suffix) != 0) {
				/*
				 * Not same suffix, no problem
				 */
				 continue;
			}
		} else {
			/*
			 * To check suffix is 0 (stdout)
			 */
			if (suffix != 0) {
				/*
				 * One 0, other not, no problem
				 */
				continue;
			}
		}
		/*
		 * Ok, we have a problem
		 */
		fprintf(stderr, "Cannot use %s, because %s shares suffix %s\n",
			name, ofp->of_name, suffix ? suffix : "NONE");
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x5519(%rip), %rax      # 0xc2a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x6e5b
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x6dad
jmp 0x6e4a
movq -0x20(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x6dd9
cmpq $0x0, -0x18(%rbp)
je 0x6dd5
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2120
cmpl $0x0, %eax
je 0x6dd7
jmp 0x6e4a
jmp 0x6de4
cmpq $0x0, -0x18(%rbp)
je 0x6de2
jmp 0x6e4a
jmp 0x6de4
movq 0x520d(%rip), %rax      # 0xbff8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x6e16
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x6e23
leaq 0x2acd(%rip), %rax      # 0x98ea
movq %rax, -0x40(%rbp)
jmp 0x6e23
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %r8
leaq 0x2a84(%rip), %rsi      # 0x98be
movb $0x0, %al
callq 0x2150
movl $0x1, -0x4(%rbp)
jmp 0x6e62
movq -0x20(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x20(%rbp)
jmp 0x6d8b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: output_closefiles
void
output_closefiles(void)
/*
 * Close all output files
 */
{
	of_p ofp;

	/* For all formats: */
	for (ofp=output_formats; ofp->of_name; ofp++) {
		/* If not in use forget it */
		if (ofp->of_file != NULL) {
			/*
			 * If there is a finish routine call it first
			 */
			if (ofp->of_finish)
				(*ofp->of_finish)(ofp->of_file);
			if (ofp->of_suffix)	/* So not STDOUT */
				fclose(ofp->of_file);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x51e1(%rip), %rax      # 0xc2a0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x711f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x710f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x70f5
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x710d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
jmp 0x710f
jmp 0x7111
movq -0x8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x8(%rbp)
jmp 0x70c3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: output_hand
void
output_hand(int boardno, dl_num *dnp)
/*
 * Convert goedel number to various internal forms as necessary
 * Output all desired formats
 */
{
	dl_int	dinternal;
	dl_byh	dbyhand;
	dl_byc	dbycard;
	of_p	ofp;
	hr_t	handrep;

	/*
	 * First create all necessary internal forms
	 * Bits in formatset have been inited in output_createfiles
	 */
	if (formatset&bit(BF_INTERNAL))
		code_to_hand(dnp, &dinternal);
	if (formatset&bit(BF_BYHAND))
		cnv_int_byh(&dinternal, &dbyhand);
	if (formatset&bit(BF_BYCARD))
		cnv_byh_byc(&dbyhand, &dbycard);

	/*
	 * Now call output routines
	 */
	for(ofp = output_formats; ofp->of_name; ofp++) {
		if (ofp->of_file == NULL)
			continue;
		handrep.hr_baseform = ofp->of_baseform;
		switch (ofp->of_baseform) {
		case BF_GOEDEL:
			handrep.hr_value.hv_dnp = dnp;
			break;
		case BF_INTERNAL:
			handrep.hr_value.hv_dip = &dinternal;
			break;
		case BF_BYHAND:
			handrep.hr_value.hv_dbhp = &dbyhand;
			break;
		case BF_BYCARD:
			handrep.hr_value.hv_dbcp = &dbycard;
			break;
		}
		(*ofp->of_printit)(ofp->of_file, boardno, &handrep);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x7c10(%rip), %eax      # 0xed58
andl $0x2, %eax
cmpl $0x0, %eax
je 0x715d
movq -0x10(%rbp), %rdi
leaq -0x44(%rbp), %rsi
callq 0x5990
movl 0x7bf5(%rip), %eax      # 0xed58
andl $0x4, %eax
cmpl $0x0, %eax
je 0x7178
leaq -0x44(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x7280
movl 0x7bda(%rip), %eax      # 0xed58
andl $0x8, %eax
cmpl $0x0, %eax
je 0x7196
leaq -0x78(%rbp), %rdi
leaq -0xac(%rbp), %rsi
callq 0x7460
leaq 0x5103(%rip), %rax      # 0xc2a0
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x7274
movq -0xb8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x71c8
jmp 0x725d
movq -0xb8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0xc8(%rbp)
movq -0xb8(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0xd0(%rbp)
subq $0x3, %rax
ja 0x723b
movq -0xd0(%rbp), %rax
leaq 0x2297(%rip), %rcx      # 0x9494
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x723b
leaq -0x44(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x723b
leaq -0x78(%rbp), %rax
movq %rax, -0xc0(%rbp)
jmp 0x723b
leaq -0xac(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0xb8(%rbp), %rcx
movq 0x10(%rcx), %rdi
movl -0x4(%rbp), %esi
leaq -0xc8(%rbp), %rdx
callq *%rax
movq -0xb8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0xb8(%rbp)
jmp 0x71a4
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: cnv_byh_byc
static void
cnv_byh_byc(dl_byh *dbhp, dl_byc *dbcp)
/*
 * Convert from a "bri" like coding to a cardposition type coding.
 * Representation is an array of 52 cards, from AS to 2C,
 * with as a value the compass position, 0 for N, 3 for W
 *
 * Note the -1 to convert from 1..52 cardnotation to 0..51 array index
 */
{
	int compass, card;

	for (compass = COMPASS_NORTH; compass <= COMPASS_WEST; compass++)
		for (card = 0; card < NCARDSPERHAND; card++)
			dbcp->dc_card[dbhp->dh_hand[compass][card] - 1] =
				compass;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jg 0x74c7
movl $0x0, -0x18(%rbp)
cmpl $0xd, -0x18(%rbp)
jge 0x74ba
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rsi
imulq $0xd, %rsi, %rsi
addq %rsi, %rcx
movslq -0x18(%rbp), %rsi
movzbl (%rcx,%rsi), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7480
jmp 0x74bc
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7473
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_dlm
static void
print_dlm(FILE *out, int boardno, hr_p hrp)
/*
 * Writes out one DLM record, including "checksum"
 * Record is mainly one lower case character per two cards
 */
{
	dl_byc *dbcp = hrp->hr_value.hv_dbcp;
	int i;
	int c;
	int checksum;

	if (boardno>99)	/* Format cannot do more than 99 */
		return;
	fprintf(out, "Duplicates %02d=0\n", boardno);
	fprintf(out, "Board %02d=", boardno);
	checksum = boardno;
	for(i=0; i<NCARDSPERDECK/2; i++) {
		c = 'a';
		c += dbcp->dc_card[2*i+0]<<2;
		c += dbcp->dc_card[2*i+1]<<0;
		putc(c, out);
		checksum ^= c;
	}
	fprintf(out, "%03d\n", checksum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x63, -0xc(%rbp)
jle 0x75aa
jmp 0x765b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x218d(%rip), %rsi      # 0x9745
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x21b6(%rip), %rsi      # 0x9783
movb $0x0, %al
callq 0x2150
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x1a, -0x24(%rbp)
jge 0x7646
movl $0x61, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
shll %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
shll $0x0, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movl -0x28(%rbp), %eax
xorl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x75e1
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0x2129(%rip), %rsi      # 0x977d
movb $0x0, %al
callq 0x2150
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_bri
static void
print_bri(FILE *out, int boardno, hr_p hrp)
/*
 * Writes out "bri" format, including filler
 *
 * It is unknown whether the strange half space, half zero fill
 * is actually necessary. This is just the way I saw my first BRI file
 */
{
	dl_byh *dbhp = hrp->hr_value.hv_dbhp;

	out_bri(out, dbhp);
	out_fill(out, ' ', 32);
	out_fill(out, 0, 18);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7e30
movq -0x8(%rbp), %rdi
movl $0x20, %edx
movl %edx, %esi
callq 0x6a50
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x12, %edx
callq 0x6a50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_pbn
static void
print_pbn(FILE *out, int boardno, hr_p hrp) {
	dl_byh *dbhp = hrp->hr_value.hv_dbhp;

	out_pbn_rec(out,"Event", 0);
	out_pbn_rec(out,"Site", 0);
	out_pbn_rec(out,"Date", 0);
	fprintf(out, "[Board \"%d\"]\n", boardno);
	out_pbn_rec(out,"West", 0);
	out_pbn_rec(out,"North", 0);
	out_pbn_rec(out,"East", 0);
	out_pbn_rec(out,"South", 0);
	out_pbn_rec(out,"Dealer", dealerstr[boardno%4]);
	out_pbn_rec(out,"Vulnerable", pbn_vulnrep[vuln_index[boardno%16]]);
	fprintf(out, "[Deal \"N");
	out_pbn(out, dbhp);
	fprintf(out, "\"]\n");
	out_pbn_rec(out,"Scoring", 0);
	out_pbn_rec(out,"Declarer", 0);
	out_pbn_rec(out,"Contract", 0);
	out_pbn_rec(out,"Result", 0);
	fprintf(out, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1fe6(%rip), %rsi      # 0x97d0
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1fd8(%rip), %rsi      # 0x97d6
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1fc9(%rip), %rsi      # 0x97db
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0x1fb7(%rip), %rsi      # 0x97e0
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rdi
leaq 0x1fb3(%rip), %rsi      # 0x97ee
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1fa4(%rip), %rsi      # 0x97f3
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1f96(%rip), %rsi      # 0x97f9
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1f87(%rip), %rsi      # 0x97fe
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x4ea7(%rip), %rax      # 0xc740
movq (%rax,%rcx,8), %rdx
leaq 0x1f60(%rip), %rsi      # 0x9804
callq 0x8220
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x4ebe(%rip), %rax      # 0xc780
movslq (%rax,%rcx,4), %rcx
leaq 0x4e93(%rip), %rax      # 0xc760
movq (%rax,%rcx,8), %rdx
leaq 0x1f33(%rip), %rsi      # 0x980b
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1f2e(%rip), %rsi      # 0x9816
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x8290
movq -0x8(%rbp), %rdi
leaq 0x1ee3(%rip), %rsi      # 0x97ea
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rdi
leaq 0x1f06(%rip), %rsi      # 0x981f
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1efa(%rip), %rsi      # 0x9827
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1eef(%rip), %rsi      # 0x9830
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1ee4(%rip), %rsi      # 0x9839
xorl %eax, %eax
movl %eax, %edx
callq 0x8220
movq -0x8(%rbp), %rdi
leaq 0x1b26(%rip), %rsi      # 0x948f
movb $0x0, %al
callq 0x2150
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_lin
static void
print_lin(FILE *out, int boardno, hr_p hrp)
/*
 * Write out the "pbn" record, with furnishings
 */
{
	dl_byh *dbhp = hrp->hr_value.hv_dbhp;

	fprintf(out, "qx|o%d|md|%d", boardno, (boardno+1)%4+1);
	out_handrep(out, dbhp, lin_suitstr, cardrep_int, COMPASS_SOUTH);
	putc(',', out);
	out_handrep(out, dbhp, lin_suitstr, cardrep_int, COMPASS_WEST);
	putc(',', out);
	out_handrep(out, dbhp, lin_suitstr, cardrep_int, COMPASS_NORTH);
	fprintf(out, "|rh||ah|Board %d|sv|%s|pg||\n", boardno, lin_vulnrep[vuln_index[boardno%16]]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, %ecx
movl -0x28(%rbp), %edx
addl $0x1, %ecx
leaq 0x1e96(%rip), %rsi      # 0x985c
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4e74(%rip), %rdx      # 0xc850
leaq 0x4d3d(%rip), %rcx      # 0xc720
movl $0x2, %r8d
callq 0x7f40
movq -0x8(%rbp), %rsi
movl $0x2c, %edi
callq 0x2130
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4e45(%rip), %rdx      # 0xc850
leaq 0x4d0e(%rip), %rcx      # 0xc720
movl $0x3, %r8d
callq 0x7f40
movq -0x8(%rbp), %rsi
movl $0x2c, %edi
callq 0x2130
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4e16(%rip), %rdx      # 0xc850
leaq 0x4cdf(%rip), %rcx      # 0xc720
xorl %r8d, %r8d
callq 0x7f40
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl -0x24(%rbp), %edx
movslq %eax, %rcx
leaq 0x4d13(%rip), %rax      # 0xc780
movslq (%rax,%rcx,4), %rcx
leaq 0x4e58(%rip), %rax      # 0xc8d0
movq (%rax,%rcx,8), %rcx
leaq 0x1de6(%rip), %rsi      # 0x9869
movb $0x0, %al
callq 0x2150
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_csv
static void
print_csv(FILE *out, int boardno, hr_p hrp)
/*
 * Write out a CSV record
 */
{
	dl_byh *dbhp = hrp->hr_value.hv_dbhp;

	out_cardrep(out, dbhp, csv_suitstr, cardrep_int);
	fprintf(out, "\",\"%d\",\"%s/%s\"\n",
		boardno,
		dealerstr[boardno%4],
		csv_vulnrep[vuln_index[boardno%16]]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq 0x4e32(%rip), %rdx      # 0xc8f0
leaq 0x4c5b(%rip), %rcx      # 0xc720
callq 0x7ef0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x4c57(%rip), %rax      # 0xc740
movq (%rax,%rcx,8), %rcx
movl -0xc(%rbp), %eax
movl $0x10, %esi
cltd
idivl %esi
movl %edx, %eax
movl -0x24(%rbp), %edx
movslq %eax, %rsi
leaq 0x4c79(%rip), %rax      # 0xc780
movslq (%rax,%rsi,4), %rsi
leaq 0x4e5e(%rip), %rax      # 0xc970
movq (%rax,%rsi,8), %r8
leaq 0x1d71(%rip), %rsi      # 0x988e
movb $0x0, %al
callq 0x2150
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_ber
static void
print_ber(FILE *out, int boardno, hr_p hrp)
/*
 * Writes out "ber" format, no filler or separators
 */
{
	dl_byc *dbcp = hrp->hr_value.hv_dbcp;
	int i;

	for(i=0; i<NCARDSPERDECK; i++)
		putc('1' + dbcp->dc_card[i], out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x34, -0x24(%rbp)
jge 0x7b7f
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %edi
addl $0x31, %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7b56
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_borel
static void
print_borel(FILE *out, int boardno, hr_p hrp)
/*
 * Write out a "bhg" record
 */
{
	dl_byh *dbhp = hrp->hr_value.hv_dbhp;
	int i, j, compass, card;

	for (i=0; i<NCOMPASS; i++) {
		/*
		 * Start at dealer of this hand
		 */
		compass = (boardno - 1 + i) % NCOMPASS;
		for (j=0; j<NCARDSPERHAND; j++) {
			card = dbhp->dh_hand[compass][j];
			putc(card <= 2*NCARDSPERHAND ?
				'A'+card-1 : 'a'+card-2*NCARDSPERHAND-1,
				out);
		}
	}
	fprintf(out, "\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x4, -0x24(%rbp)
jge 0x7c75
movl -0xc(%rbp), %eax
subl $0x1, %eax
addl -0x24(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x2c(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0xd, -0x28(%rbp)
jge 0x7c65
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xd, %rcx, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x30(%rbp)
cmpl $0x1a, -0x30(%rbp)
jg 0x7c3f
movl -0x30(%rbp), %eax
addl $0x41, %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7c4e
movl -0x30(%rbp), %eax
addl $0x61, %eax
subl $0x1a, %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7c0b
jmp 0x7c67
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7be6
movq -0x8(%rbp), %rdi
leaq 0x180f(%rip), %rsi      # 0x948f
movb $0x0, %al
callq 0x2150
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_dup_common
static void
print_dup_common(FILE *out, int boardno, dl_byh *dbhp, int not_on_screen)
/*
 * Write out a "dup" record
 * This is actually a BRI, followed by a DGE, and some padding
 */
{

	/*
	 * Horribly convoluted hack upon hack format
	 *
	 * Duplimate, generation X
	 */
	out_bri(out, dbhp);
	if (boardno == 1 && not_on_screen) {
		out_fill(out, ' ', 68);
	} else {
		out_dge(out, dbhp);
	}
	putc('Y', out);		/* Y to Random Hands */
	putc('N', out);		/* N to reverse order */
	putc('1', out);		/* Start at board 1 */
	putc(' ', out);
	putc(' ', out);
	putc('0', out);		/* No copies immediate */
	putc(' ', out);
	putc('0' + (prparp->pp_nboards/10)%10, out);/* tens of number */
	putc('0' + prparp->pp_nboards%10, out);	/* units of number */
	putc(' ', out);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7e30
cmpl $0x1, -0xc(%rbp)
jne 0x7d64
cmpl $0x0, -0x1c(%rbp)
je 0x7d64
movq -0x8(%rbp), %rdi
movl $0x20, %esi
movl $0x44, %edx
callq 0x6a50
jmp 0x7d71
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x7eb0
movq -0x8(%rbp), %rsi
movl $0x59, %edi
callq 0x2130
movq -0x8(%rbp), %rsi
movl $0x4e, %edi
callq 0x2130
movq -0x8(%rbp), %rsi
movl $0x31, %edi
callq 0x2130
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x2130
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x2130
movq -0x8(%rbp), %rsi
movl $0x30, %edi
callq 0x2130
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x2130
movq 0x6f76(%rip), %rax      # 0xed50
movl 0x8(%rax), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %edi
addl $0x30, %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movq 0x6f4e(%rip), %rax      # 0xed50
movl 0x8(%rax), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %edx, %edi
addl $0x30, %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movq -0x8(%rbp), %rsi
movl $0x20, %edi
callq 0x2130
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: out_bri
static void
out_bri(FILE *out, dl_byh *dbhp)
/*
 * Write out the "bri" record, no filler
 */
{
	int compass, i;

	/*
	 * Note the <COMPASS_WEST
	 * In this format only the hands of North, East and South are given
	 * West is left as an exercise for the Duplimate
	 * (West just gets what is left over)
	 */
	for (compass=COMPASS_NORTH; compass<COMPASS_WEST; compass++)
		for (i=0; i<NCARDSPERHAND; i++)
			fprintf(out,"%02d",dbhp->dh_hand[compass][i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x7e9b
movl $0x0, -0x18(%rbp)
cmpl $0xd, -0x18(%rbp)
jge 0x7e8e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
imulq $0xd, %rcx, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x1803(%rip), %rsi      # 0x967f
movb $0x0, %al
callq 0x2150
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x7e54
jmp 0x7e90
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7e47
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: out_handrep
static void
out_handrep(FILE *out, dl_byh *dbhp, char *suitstr[NCOMPASS][NSUIT], char *cardrep, int compass)
/*
 * Write out a "dge", "lin" or "pbn" single hand
 */
{
	int suit;
	int i;
	int card, card_in_suit;

	for (suit=SUIT_SPADES; suit<=SUIT_CLUBS; suit++) {
		fputs(suitstr[compass][suit], out);
		for (i=0; i<NCARDSPERHAND; i++) {
			/*
			 * Get card in this position for player
			 * If it is part of the suit we are working on
			 * (1..13 for spades, upto 40..52 for clubs)
			 * print it.
			 */
			card = dbhp->dh_hand[compass][i];
			card_in_suit = card - 13*suit;
			if (card_in_suit > 0 && card_in_suit <= 13)
				putc(cardrep[card_in_suit-1], out);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jg 0x8003
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rsi
callq 0x20c0
movl $0x0, -0x2c(%rbp)
cmpl $0xd, -0x2c(%rbp)
jge 0x7ff3
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0xd, %rcx, %rcx
addq %rcx, %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
imull $0xd, -0x28(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x7fe6
cmpl $0xd, -0x34(%rbp)
jg 0x7fe6
movq -0x20(%rbp), %rax
movl -0x34(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rsi
callq 0x2130
jmp 0x7fe8
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7f94
jmp 0x7ff5
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7f63
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: fill_dlm
static void
fill_dlm(FILE *out, int lowbrd, int highbrd)
{
	int i;
	int checksum;

	for (i=lowbrd+1; i<highbrd; i++) {
		checksum = i^14;	/* KGB calculated */
		fprintf(out, "Duplicates %02d=0\n", i);
		fprintf(out, "Board %02d=aaaaaabffffffkkkkkklpppppp%03d\n",
			i, checksum);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x8214
movl -0x14(%rbp), %eax
xorl $0xe, %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x155b(%rip), %rsi      # 0x9745
movb $0x0, %al
callq 0x2150
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %ecx
leaq 0x1556(%rip), %rsi      # 0x9758
movb $0x0, %al
callq 0x2150
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x81cb
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/output.c
// Function: print_kops_cds
static void
print_kops_cds(FILE *out, dl_byc *dbcp, int rotoffset) {
    int card, byte, suit, cardno, cardpos;

    for (card=0; card<NCARDSPERHAND; card++) {
	byte = 0;
	for (suit=0; suit<NSUIT; suit++) {
	    cardno = NCARDSPERHAND*suit+card;
	    cardpos = dbcp->dc_card[cardno];
	    cardpos = (cardpos+rotoffset)%NSUIT;
	    byte |= cardpos << 2*(NSUIT-1-suit);
	}
	putc(byte, out);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0xd, -0x18(%rbp)
jge 0x8365
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x834e
imull $0xd, -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl $0x3, %ecx
subl -0x20(%rbp), %ecx
shll %ecx
shll %cl, %eax
orl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x82fe
movl -0x1c(%rbp), %edi
movq -0x8(%rbp), %rsi
callq 0x2130
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x82ea
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/unix.c
// Function: gettod
void
gettod(struct timeval *tp)
/*
 * Fill in *tp with gettimeofday values
 * Side effect: calculate approx precision
 */
{
	int b;

	gettimeofday(tp, (struct timezone *) 0);
	/* Find how many bits are set in usec field */
	for(b = 0; b < 20; b++) {
		if (tp->tv_usec&(1<<b))
			break;
	}
	if (20-b > subsecbits) {
		subsecbits = 20-b;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x20b0
movl $0x0, -0xc(%rbp)
cmpl $0x14, -0xc(%rbp)
jge 0x83c5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
je 0x83b8
jmp 0x83c5
jmp 0x83ba
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8390
movl $0x14, %eax
subl -0xc(%rbp), %eax
cmpl 0x45c5(%rip), %eax      # 0xc998
jle 0x83e3
movl $0x14, %eax
subl -0xc(%rbp), %eax
movl %eax, 0x45b5(%rip)      # 0xc998
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/unix.c
// Function: getchtm
int
getchtm(int *nbits)
/*
 * Read one character from standard input
 * Time the wait, and use bits for random
 * MUST be in cbreak mode for this to work
 */
{
	struct timeval t1, t2;
	long sdiff, mdiff;
	int c;
	long shift;
	int b;

	gettod(&t1);
	c = getchar();
	gettod(&t2);
	mdiff = t2.tv_usec - t1.tv_usec;
	sdiff = t2.tv_sec - t1.tv_sec;
	if (sdiff > 1000)
		sdiff = 1000;
	mdiff += sdiff * 1000000;
	/*
	 * Everything slower than 1/8 second can be faked
	 * Trust at most half of the rest
	 */
	for (shift = mdiff, b= 0; shift>3 ; shift >>= 2, b++)
		;
	if (b <= MAX_INTERVAL_ENTROPY)
		*nbits = b;
	else
		*nbits = MAX_INTERVAL_ENTROPY;
	collect_more((byte *) &t1, sizeof(t1), 0);
	collect_more((byte *) &t2, sizeof(t2), 0);
	if (flog)
		fprintf(flog, "Collected character %d, timediff %ld, timebits %d\n",
			c, mdiff, *nbits);
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8370
callq 0x2140
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8370
movq -0x20(%rbp), %rax
subq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
subq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x3e8, -0x30(%rbp)     # imm = 0x3E8
jle 0x8440
movq $0x3e8, -0x30(%rbp)     # imm = 0x3E8
imulq $0xf4240, -0x30(%rbp), %rax # imm = 0xF4240
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
cmpq $0x3, -0x48(%rbp)
jle 0x847f
jmp 0x8468
movq -0x48(%rbp), %rax
sarq $0x2, %rax
movq %rax, -0x48(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x845f
cmpl $0x6, -0x4c(%rbp)
jg 0x8490
movl -0x4c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x849a
movq -0x8(%rbp), %rax
movl $0x6, (%rax)
leaq -0x18(%rbp), %rdi
movl $0x10, %esi
xorl %edx, %edx
callq 0x67e0
leaq -0x28(%rbp), %rdi
movl $0x10, %esi
xorl %edx, %edx
callq 0x67e0
leaq 0x6807(%rip), %rax      # 0xecc8
cmpq $0x0, (%rax)
je 0x84ed
leaq 0x67fa(%rip), %rax      # 0xecc8
movq (%rax), %rdi
movl -0x3c(%rbp), %edx
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movl (%rax), %r8d
leaq 0x1409(%rip), %rsi      # 0x98ef
movb $0x0, %al
callq 0x2150
movl -0x3c(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/unix.c
// Function: os_collect
void
os_collect(void) {
	int pid;
	struct timeval t;

	if (os_dev_random()) {
		return;
	}
	pid = getpid();
	/* Trust about 8 bits of randomness in pid */
	collect_more((byte *) &pid, sizeof(pid), 8);
	gettod(&t);
	/* Trust 6 bits of seconds, and half the subsecond bits */
	collect_more((byte *) &t, sizeof(t), 6+subsecbits/2);
	if (flog)
		fprintf(flog, "First TOD=(%ld, %ld), subsecbits = %d\n",
			t.tv_sec, t.tv_usec, subsecbits);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x85a0
cmpl $0x0, %eax
je 0x8514
jmp 0x858d
callq 0x2050
movl %eax, -0x4(%rbp)
leaq -0x4(%rbp), %rdi
movl $0x4, %esi
movl $0x8, %edx
callq 0x67e0
leaq -0x18(%rbp), %rdi
callq 0x8370
movl 0x445a(%rip), %eax      # 0xc998
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
addl $0x6, %edx
leaq -0x18(%rbp), %rdi
movl $0x10, %esi
callq 0x67e0
leaq 0x6768(%rip), %rax      # 0xecc8
cmpq $0x0, (%rax)
je 0x858d
leaq 0x675b(%rip), %rax      # 0xecc8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl 0x4419(%rip), %r8d      # 0xc998
leaq 0x139c(%rip), %rsi      # 0x9922
movb $0x0, %al
callq 0x2150
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/unix.c
// Function: os_dev_random
static int
os_dev_random(void) {
	int fd;
	byte buf[DEVRANDSIZE];
	int bytesread;

	fd = open(DEVRANDOM, 0);
	if (fd<0) {
		return 0;
	}
	bytesread = read(fd, buf, DEVRANDSIZE);
	if (bytesread != DEVRANDSIZE) {
		return 0;
	}
	close(fd);
	    
	collect_more(buf, bytesread, 8*bytesread);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x13a5(%rip), %rdi      # 0x9954
xorl %esi, %esi
movb $0x0, %al
callq 0x2170
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x85ca
movl $0x0, -0x4(%rbp)
jmp 0x860e
movl -0x8(%rbp), %edi
leaq -0x30(%rbp), %rsi
movl $0x28, %edx
callq 0x2100
movl %eax, -0x34(%rbp)
cmpl $0x28, -0x34(%rbp)
je 0x85ed
movl $0x0, -0x4(%rbp)
jmp 0x860e
movl -0x8(%rbp), %edi
callq 0x20f0
leaq -0x30(%rbp), %rdi
movl -0x34(%rbp), %esi
movl -0x34(%rbp), %edx
shll $0x3, %edx
callq 0x67e0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/unix.c
// Function: cbreak
void
cbreak(void)
/*
 * Set terminal to state where characters can be read one at a time
 * Also disable echo
 */
{
	struct termios newtios;

	newtios = tios;

	/* fiddle newtios */
	newtios.c_lflag &= ~(ICANON|ECHO);
	newtios.c_cc[VMIN] = 1;
	newtios.c_cc[VTIME] = 0;
	ioctl(0, STTY, &newtios);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq -0x3c(%rbp), %rdi
leaq 0x6785(%rip), %rsi      # 0xedb8
movl $0x3c, %edx
callq 0x2160
movl -0x30(%rbp), %eax
andl $-0xb, %eax
movl %eax, -0x30(%rbp)
movb $0x1, -0x25(%rbp)
movb $0x0, -0x26(%rbp)
xorl %edi, %edi
movl $0x5404, %esi           # imm = 0x5404
leaq -0x3c(%rbp), %rdx
movb $0x0, %al
callq 0x20e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hansvanstaveren[P]BigDeal/unix.c
// Function: legal_filename_prefix
int
legal_filename_prefix(char *s)
/*
 * Legal prefix to make legal name when three letter suffix added
 */
{

	if (*s == 0)	/* Too short */
		return 0;
	if (strlen(s) > 100)	/* Worst case would be System V with 10, but should be dead by now */
		return 0;
	while (*s) {
		if (*s == '/' || *s == ' ')	/* disallow space */
			return 0;
		s++;
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x86e1
movl $0x0, -0x4(%rbp)
jmp 0x873a
movq -0x10(%rbp), %rdi
callq 0x2070
cmpq $0x64, %rax
jbe 0x86f9
movl $0x0, -0x4(%rbp)
jmp 0x873a
jmp 0x86fb
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8733
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x871c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
jne 0x8725
movl $0x0, -0x4(%rbp)
jmp 0x873a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x86fb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128n8t8clocv2/ref/cloc.c
// Function: ae_init
int ae_init(ae_cxt* cxt, const byte* userkey, int keylen)
{
	if(keylen != STATE_LEN){
		return KEY_ERROR;
	}
	cxt->userkey = (byte*)userkey;
	cxt->pt_ekey = &(cxt->ekey);
	AES_set_encrypt_key(userkey, keylen*8, cxt->pt_ekey); /* set the encryption key */
	cxt->klen = keylen;
    
	return SUCCESS;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpl $0x10, 0xc(%rsp)
je 0x5563
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x55bd
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x120(%rax)
movq 0x18(%rsp), %rcx
addq $0x20, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x118(%rax)
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
shll $0x3, %esi
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rdx
callq 0x10a0
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x128(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128n8t8clocv2/ref/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
		unsigned char *c, unsigned long long *clen,
		const unsigned char *m, unsigned long long mlen,
		const unsigned char *ad, unsigned long long adlen,
		const unsigned char *nsec,                          //not relavent to CLOC
		const unsigned char *npub,
		const unsigned char *k
		)
{
    /* set ciphertext length */
    *clen = mlen + CRYPTO_ABYTES;
    
    unsigned char tag[CRYPTO_ABYTES];
    ae_cxt cxt;
    
    /* set key and compute round keys */
    if(ae_init(&cxt, k, CRYPTO_KEYBYTES))
        return RETURN_KEYSIZE_ERR;
    
    /* process the associated data */
    process_ad(&cxt, ad, adlen, npub, CRYPTO_NPUBBYTES);
    
    /* encrypt message */
    ae_encrypt(&cxt, (unsigned char*)m, mlen, c, tag, CRYPTO_ABYTES, ENC);
    
    /* copy the tag to the end of ciphertext */
    memcpy(c+mlen, tag, CRYPTO_ABYTES);
	return RETURN_SUCCESS;
}

// Assembly:
subq $0x1c8, %rsp            # imm = 0x1C8
movq 0x1e0(%rsp), %rax
movq 0x1d8(%rsp), %rax
movq 0x1d0(%rsp), %rax
movq %rdi, 0x1b8(%rsp)
movq %rsi, 0x1b0(%rsp)
movq %rdx, 0x1a8(%rsp)
movq %rcx, 0x1a0(%rsp)
movq %r8, 0x198(%rsp)
movq %r9, 0x190(%rsp)
movq 0x1a0(%rsp), %rcx
addq $0x8, %rcx
movq 0x1b0(%rsp), %rax
movq %rcx, (%rax)
movq 0x1e0(%rsp), %rsi
leaq 0x8(%rsp), %rdi
movl $0x10, %edx
callq 0x1090
cmpl $0x0, %eax
je 0x6022
movl $0xfffffffd, 0x1c4(%rsp) # imm = 0xFFFFFFFD
jmp 0x60a8
movq 0x198(%rsp), %rsi
movq 0x190(%rsp), %rdx
movq 0x1d8(%rsp), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %r8d
callq 0x1050
movq 0x1a8(%rsp), %rsi
movq 0x1a0(%rsp), %rdx
movq 0x1b8(%rsp), %rcx
leaq 0x188(%rsp), %r8
leaq 0x8(%rsp), %rdi
movl $0x8, %r9d
movl $0x1, (%rsp)
callq 0x10c0
movq 0x1b8(%rsp), %rax
movq 0x1a0(%rsp), %rcx
movq 0x188(%rsp), %rdx
movq %rdx, (%rax,%rcx)
movl $0x0, 0x1c4(%rsp)
movl 0x1c4(%rsp), %eax
addq $0x1c8, %rsp            # imm = 0x1C8
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128n8t8clocv2/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
		unsigned char *m,unsigned long long *mlen,
		unsigned char *nsec,                                //not relavent to CLOC
		const unsigned char *c,unsigned long long clen,
		const unsigned char *ad,unsigned long long adlen,
		const unsigned char *npub,
		const unsigned char *k
		)
{
    /* set plaintext length */
    *mlen = clen - CRYPTO_ABYTES;
    
    unsigned char tag[CRYPTO_ABYTES];
    ae_cxt cxt;
    
    /* set key and compute round keys */
    if(ae_init(&cxt, k, CRYPTO_KEYBYTES))
        return RETURN_KEYSIZE_ERR;
    
    /* process the associated data */
    process_ad(&cxt, ad, adlen, npub, CRYPTO_NPUBBYTES);
    
    /* decrypt ciphertext */
    ae_encrypt(&cxt, m, *mlen, (unsigned char*)c, tag, CRYPTO_ABYTES, DEC);
    
    /* compare the tag */
    int i;
    for(i = 0; i < CRYPTO_ABYTES; i++)
        if(tag[i] != c[(*mlen) + i]){
            return RETURN_TAG_NO_MATCH;
        }
    
	return RETURN_SUCCESS;
}

// Assembly:
subq $0x1d8, %rsp            # imm = 0x1D8
movq 0x1f0(%rsp), %rax
movq 0x1e8(%rsp), %rax
movq 0x1e0(%rsp), %rax
movq %rdi, 0x1c8(%rsp)
movq %rsi, 0x1c0(%rsp)
movq %rdx, 0x1b8(%rsp)
movq %rcx, 0x1b0(%rsp)
movq %r8, 0x1a8(%rsp)
movq %r9, 0x1a0(%rsp)
movq 0x1a8(%rsp), %rcx
subq $0x8, %rcx
movq 0x1c0(%rsp), %rax
movq %rcx, (%rax)
movq 0x1f0(%rsp), %rsi
leaq 0x18(%rsp), %rdi
movl $0x10, %edx
callq 0x1090
cmpl $0x0, %eax
je 0x6152
movl $0xfffffffd, 0x1d4(%rsp) # imm = 0xFFFFFFFD
jmp 0x621a
movq 0x1a0(%rsp), %rsi
movq 0x1e0(%rsp), %rdx
movq 0x1e8(%rsp), %rcx
leaq 0x18(%rsp), %rdi
movl $0x8, %r8d
callq 0x1050
movq 0x1c8(%rsp), %rsi
movq 0x1c0(%rsp), %rax
movq (%rax), %rdx
movq 0x1b0(%rsp), %rcx
leaq 0x198(%rsp), %r8
leaq 0x18(%rsp), %rdi
movl $0x8, %r9d
movl $0x2, (%rsp)
callq 0x10c0
movl $0x0, 0x14(%rsp)
cmpl $0x8, 0x14(%rsp)
jge 0x620f
movslq 0x14(%rsp), %rax
movzbl 0x198(%rsp,%rax), %eax
movq 0x1b0(%rsp), %rcx
movq 0x1c0(%rsp), %rdx
movq (%rdx), %rdx
movslq 0x14(%rsp), %rsi
addq %rsi, %rdx
movzbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x6200
movl $0xffffffff, 0x1d4(%rsp) # imm = 0xFFFFFFFF
jmp 0x621a
jmp 0x6202
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x61bc
movl $0x0, 0x1d4(%rsp)
movl 0x1d4(%rsp), %eax
addq $0x1d8, %rsp            # imm = 0x1D8
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128n8t8clocv2/ref/utils.c
// Function: print_cxt
void print_cxt(const ae_cxt* cxt)
{
	printf("user key of %d bytes:\n", cxt->klen);
	pstate(cxt->userkey, cxt->klen);
	printf("associated data of %llu bytes:\n", cxt->adlen);
	pstate(cxt->ad, cxt->adlen);
	printf("nonce of %llu bytes:\n", cxt->nlen);
	pstate(cxt->nonce, cxt->nlen);
	printf("plaintext of %llu bytes:\n", cxt->ptlen);
	pstate(cxt->pt, cxt->ptlen);
	printf("ciphertext of %llu bytes:\n", cxt->ctlen);
	pstate(cxt->ct, cxt->ctlen);
	printf("MAC of %d bytes:\n", cxt->tlen);
	pstate(cxt->tag, cxt->tlen);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x128(%rax), %esi
leaq 0x3502(%rip), %rdi      # 0x9848
movb $0x0, %al
callq 0x1030
movq (%rsp), %rax
movq 0x120(%rax), %rdi
movq (%rsp), %rax
movl 0x128(%rax), %esi
callq 0x10b0
movq (%rsp), %rax
movq 0x138(%rax), %rsi
leaq 0x34e6(%rip), %rdi      # 0x985f
movb $0x0, %al
callq 0x1030
movq (%rsp), %rax
movq 0x130(%rax), %rdi
movq (%rsp), %rax
movq 0x138(%rax), %rax
movl %eax, %esi
callq 0x10b0
movq (%rsp), %rax
movq 0x148(%rax), %rsi
leaq 0x34d0(%rip), %rdi      # 0x987f
movb $0x0, %al
callq 0x1030
movq (%rsp), %rax
movq 0x140(%rax), %rdi
movq (%rsp), %rax
movq 0x148(%rax), %rax
movl %eax, %esi
callq 0x10b0
movq (%rsp), %rax
movq 0x158(%rax), %rsi
leaq 0x34b0(%rip), %rdi      # 0x9895
movb $0x0, %al
callq 0x1030
movq (%rsp), %rax
movq 0x150(%rax), %rdi
movq (%rsp), %rax
movq 0x158(%rax), %rax
movl %eax, %esi
callq 0x10b0
movq (%rsp), %rax
movq 0x168(%rax), %rsi
leaq 0x3494(%rip), %rdi      # 0x98af
movb $0x0, %al
callq 0x1030
movq (%rsp), %rax
movq 0x160(%rax), %rdi
movq (%rsp), %rax
movq 0x168(%rax), %rax
movl %eax, %esi
callq 0x10b0
movq (%rsp), %rax
movl 0x178(%rax), %esi
leaq 0x347a(%rip), %rdi      # 0x98ca
movb $0x0, %al
callq 0x1030
movq (%rsp), %rax
movq 0x170(%rax), %rdi
movq (%rsp), %rax
movl 0x178(%rax), %esi
callq 0x10b0
popq %rax
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/crypto_aesctr/main.c
// Function: perftest
static int
perftest(void)
{
	struct crypto_aesctr * aesctr;
	struct crypto_aes_key * key_exp;
	uint8_t key_unexpanded[32];
	size_t i;

	/* Inform user about the hardware optimization status. */
	print_hardware("Performance test of AES-CTR");
	fflush(stdout);

	/* Prepare the key.  We're only performance-testing 256-bit keys. */
	for (i = 0; i < 32; i++)
		key_unexpanded[i] = (uint8_t)i;
	if ((key_exp = crypto_aes_key_expand(key_unexpanded, 32)) == NULL)
		goto err0;

	/* Prepare the aesctr object. */
	if ((aesctr = crypto_aesctr_alloc()) == NULL)
		goto err1;
	crypto_aesctr_init2(aesctr, key_exp, 0);

	/* Time the function. */
	if (perftest_buffers(nbytes_perftest, perfsizes, num_perf,
	    nbytes_warmup, 1, perftest_init, perftest_func, NULL, aesctr)) {
		warn0("perftest_buffers");
		goto err2;
	}

	/* Clean up. */
	crypto_aesctr_free(aesctr);
	crypto_aes_key_free(key_exp);

	/* Success! */
	return (0);

err2:
	crypto_aesctr_free(aesctr);
err1:
	crypto_aes_key_free(key_exp);
err0:
	/* Failure! */
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq 0x6aeb(%rip), %rdi      # 0x900a
callq 0x2870
movq 0xaacd(%rip), %rax      # 0xcff8
movq (%rax), %rdi
callq 0x2200
movq $0x0, -0x48(%rbp)
cmpq $0x20, -0x48(%rbp)
jae 0x255e
movq -0x48(%rbp), %rax
movb %al, %cl
movq -0x48(%rbp), %rax
movb %cl, -0x40(%rbp,%rax)
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
jmp 0x253b
leaq -0x40(%rbp), %rdi
movl $0x20, %esi
callq 0x35c0
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x257b
jmp 0x2637
callq 0x5720
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x258f
jmp 0x262e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x5760
movq -0x10(%rbp), %rax
movl $0x2000000, %edi        # imm = 0x2000000
leaq 0x7100(%rip), %rsi      # 0x96b0
movl $0xb, %edx
movl $0x9c4000, %ecx         # imm = 0x9C4000
movl $0x1, %r8d
leaq 0x2f9(%rip), %r9        # 0x28c0
leaq 0x342(%rip), %r10       # 0x2910
xorl %r11d, %r11d
movq %r10, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rax, 0x10(%rsp)
callq 0x72d0
cmpl $0x0, %eax
je 0x260a
jmp 0x25ef
leaq 0x6a30(%rip), %rdi      # 0x9026
movb $0x0, %al
callq 0x7b30
callq 0x2170
movl $0x0, (%rax)
jmp 0x2625
movq -0x10(%rbp), %rdi
callq 0x5cb0
movq -0x18(%rbp), %rdi
callq 0x36d0
movl $0x0, -0x4(%rbp)
jmp 0x263e
movq -0x10(%rbp), %rdi
callq 0x5cb0
movq -0x18(%rbp), %rdi
callq 0x36d0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/crypto_aesctr/main.c
// Function: perftest_init
static int
perftest_init(void * cookie, uint8_t * buf, size_t buflen)
{
	struct crypto_aesctr * aesctr = cookie;

	/* Clear buffer. */
	memset(buf, 0, buflen);

	/* Reset object. */
	crypto_aesctr_init2(aesctr, NULL, 0);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
xorl %esi, %esi
callq 0x2040
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x5760
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/crypto_aesctr/main.c
// Function: perftest_func
static int
perftest_func(void * cookie, uint8_t * buf, size_t buflen, size_t nreps)
{
	struct crypto_aesctr * aesctr = cookie;
	size_t i;

	/* Do the encryption. */
	for (i = 0; i < nreps; i++)
		crypto_aesctr_stream(aesctr, buf, buf, buflen);

	/* Success! */
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x2965
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x59b0
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x2938
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)