LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/macrodef.c
// Function: macro_tab
void macro_tab() {
	long s = 0;
	int i = 0;
	char *p;
	if ((tmpmac = macro_head))
		fprintf(file_lst,
		        "\n\n size  name                            "
		        "parameters\n");
	while (tmpmac) {
		i++;
		s += tmpmac->size;
		fprintf(file_lst, "%5u. %-31s", tmpmac->size, tmpmac->name);
		p = tmpmac->name;
		while (*p++)
			;
		while (*p) {
			fprintf(file_lst, " %s", p);
			while (*p++)
				;
		}
		fprintf(file_lst, "\n");
		tmpmac = tmpmac->nextmac;
	}
	if (macro_head)
		fprintf(file_lst,
		        "\nMemory used to store %d macro definitions: %ld. "
		        "bytes.\n",
		        i, s);
	else
		fprintf(file_lst, "\n\nNo macros defined.\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x835f(%rip), %rax      # 0xdab8
movq (%rax), %rax
leaq 0x8525(%rip), %r14      # 0xdc88
movq %rax, (%r14)
testq %rax, %rax
je 0x578c
leaq 0x832e(%rip), %rax      # 0xdaa0
movq (%rax), %rcx
leaq 0x4290(%rip), %rdi      # 0x9a0c
pushq $0x34
popq %rsi
pushq $0x1
popq %rdx
callq 0x1220
movq (%r14), %rcx
jmp 0x578e
xorl %ecx, %ecx
leaq 0x830b(%rip), %r15      # 0xdaa0
leaq 0x42b0(%rip), %r12      # 0x9a4c
xorl %ebp, %ebp
movl $0x0, 0x4(%rsp)
testq %rcx, %rcx
je 0x5822
movl 0x8(%rcx), %r13d
movq (%r15), %rdi
addq $0xc, %rcx
leaq 0x4284(%rip), %rsi      # 0x9a41
movl %r13d, %edx
xorl %eax, %eax
callq 0x1140
movq %r14, %rbx
movq (%r14), %r14
addq $0xc, %r14
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x57d1
incl 0x4(%rsp)
cmpb $0x0, (%r14)
je 0x5806
movq (%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x1140
movq %r14, %rax
leaq 0x1(%rax), %r14
cmpb $0x0, (%rax)
movq %r14, %rax
jne 0x57f8
jmp 0x57df
addq %r13, %rbp
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x1110
movq %rbx, %r14
movq (%rbx), %rax
movq (%rax), %rcx
movq %rcx, (%rbx)
jmp 0x57a6
leaq 0x828f(%rip), %rax      # 0xdab8
cmpq $0x0, (%rax)
movq (%r15), %rcx
je 0x5858
leaq 0x4217(%rip), %rsi      # 0x9a50
movq %rcx, %rdi
movl 0x4(%rsp), %edx
movq %rbp, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1140
leaq 0x422a(%rip), %rdi      # 0x9a89
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1220
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/opcode.c
// Function: opcode
void opcode() {
	int i;
	for (wrt = i = 0; nmi[i]; i += 2)
		wrt |= s2[0] == nmi[i] &&
		       s2[1] == nmi[i + 1] && /* is a write and */
		       ((s3[0] != 'a' && s3[0] != 'A') ||
		        s3[1]); /* not accumulator */
	addr = print = data = known = 1;
	i = d[0] = parseopr();
	if (data) {
		loc_cntr += data; /* increment the current location counter */
		if (mpulevel[i & 255] > cputype) display_error(error = 'I');
	}
}

// Assembly:
pushq %rbx
leaq 0x856c(%rip), %rax      # 0xddec
andl $0x0, (%rax)
leaq 0x881e(%rip), %rcx      # 0xe0a8
movq (%rcx), %rcx
leaq 0x881c(%rip), %rdx      # 0xe0b0
movq (%rdx), %rdx
xorl %esi, %esi
leaq 0x7df1(%rip), %rdi      # 0xd691
pushq $0x1
popq %r8
movb -0x1(%rdi), %r10b
testb %r10b, %r10b
je 0x58e5
xorl %r9d, %r9d
cmpb %r10b, (%rcx)
jne 0x58da
movb 0x1(%rcx), %r10b
cmpb (%rdi), %r10b
jne 0x58da
movzbl (%rdx), %r10d
orl $0x20, %r10d
movl %r8d, %r9d
cmpl $0x61, %r10d
jne 0x58da
xorl %r9d, %r9d
cmpb $0x0, 0x1(%rdx)
setne %r9b
orl %r9d, %esi
movl %esi, (%rax)
addq $0x2, %rdi
jmp 0x58a4
leaq 0x89e7(%rip), %rax      # 0xe2d3
movb $0x1, %cl
movb %cl, (%rax)
leaq 0x89da(%rip), %rbx      # 0xe2d1
movb %cl, (%rbx)
leaq 0x84fc(%rip), %rax      # 0xddfc
movl $0x1, (%rax)
leaq 0x89c3(%rip), %rax      # 0xe2d0
movb %cl, (%rax)
callq 0x59b0
leaq 0x88b5(%rip), %rcx      # 0xe1d0
movb %al, (%rcx)
movsbq (%rbx), %rcx
testq %rcx, %rcx
je 0x595c
leaq 0x7ef3(%rip), %rdx      # 0xd820
addq %rcx, (%rdx)
movzbl %al, %eax
leaq 0x7816(%rip), %rcx      # 0xd150
movsbl (%rax,%rcx), %eax
leaq 0x7f83(%rip), %rcx      # 0xd8c8
cmpl %eax, (%rcx)
jge 0x595c
leaq 0x84b0(%rip), %rax      # 0xde00
movb $0x49, (%rax)
pushq $0x49
popq %rdi
popq %rbx
jmp 0x1e1c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/opcode.c
// Function: searchstr
int searchstr(char *str, char *key, int size) {
	int i, j, k;
	for (i = j = 0; str[i]; i += size, j++) {
		for (k = 0; k < size && str[i + k] == key[k]; k++)
			;
		if (k == size) return (j);
	}
	return (-1);
}

// Assembly:
pushq %rbp
pushq %rbx
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %r8d
cmovgl %edx, %r8d
movslq %edx, %r9
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rdi, %r10
xorl %r11d, %r11d
cmpb $0x0, (%rdi,%rcx)
je 0x59ad
xorl %ebx, %ebx
cmpq %rbx, %r8
je 0x5998
movb (%r10,%rbx), %bpl
cmpb (%rsi,%rbx), %bpl
jne 0x599b
incq %rbx
jmp 0x5984
movl %r8d, %ebx
cmpl %edx, %ebx
je 0x59aa
addq %r9, %rcx
incl %r11d
addq %r9, %r10
jmp 0x597c
movl %r11d, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/outline.c
// Function: outhex
void outhex(unsigned int addr, char data) {
	if (!binptr) {
		sprintf(binbuf, ";00%04X", binadr = addr);
		chksum = addr >> 8 & 255;
		chksum += addr & 255;
		binptr = 5;
	}
	if (addr == binadr && binptr < 37) {
		sprintf(&binbuf[binptr += 2], "%02X", data & 255);
		chksum += data & 255;
		binadr++;
	} else {
		int i = (binptr - 5) / 2;
		chksum += i;
		if (i > 15) {
			binbuf[1] = '1';
			i &= 15;
		}
		binbuf[2] = i + (i > 9 ? '7' : '0');
		sprintf(&binbuf[binptr += 2], "%04X\0", chksum);
		fprintf(file_obj, "%s\n", binbuf);
		binlin++;
		binptr = 0;
		outhex(addr, data);
	}
	binadr = addr + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movl %edi, %ebx
leaq 0x6653(%rip), %r15      # 0xd810
movl (%r15), %ecx
testl %ecx, %ecx
jne 0x7200
leaq 0x6649(%rip), %rax      # 0xd814
movl %ebx, (%rax)
leaq 0x6acc(%rip), %rdi      # 0xdca0
leaq 0x29fd(%rip), %rsi      # 0x9bd8
movl %ebx, %edx
xorl %eax, %eax
callq 0x1200
movl %ebx, %eax
shrl $0x8, %eax
movl $0xff, %ecx
andl %ecx, %eax
andl %ebx, %ecx
addl %eax, %ecx
leaq 0x6611(%rip), %rax      # 0xd80c
movl %ecx, (%rax)
pushq $0x5
popq %rcx
leaq 0x660d(%rip), %r12      # 0xd814
cmpl $0x24, %ecx
jg 0x724c
cmpl %ebx, (%r12)
jne 0x724c
leal 0x2(%rcx), %eax
movl %eax, (%r15)
movslq %ecx, %rax
leaq 0x6a7e(%rip), %rcx      # 0xdca0
leaq (%rax,%rcx), %rdi
addq $0x2, %rdi
movzbl %bpl, %ebp
leaq 0x2945(%rip), %rsi      # 0x9b7a
movl %ebp, %edx
xorl %eax, %eax
callq 0x1200
leaq 0x65c7(%rip), %rax      # 0xd80c
addl %ebp, (%rax)
jmp 0x72de
leal -0x5(%rcx), %eax
pushq $0x2
popq %rsi
cltd
idivl %esi
leaq 0x65b0(%rip), %rsi      # 0xd80c
movl (%rsi), %edx
addl %eax, %edx
movl %edx, (%rsi)
cmpl $0x25, %ecx
jl 0x7275
leaq 0x6a32(%rip), %rsi      # 0xdca0
movb $0x31, 0x1(%rsi)
andl $0xf, %eax
leal 0x30(%rax), %esi
leal 0x37(%rax), %edi
cmpl $0xa, %eax
cmovll %esi, %edi
leaq 0x6a18(%rip), %r14      # 0xdca0
movb %dil, 0x2(%r14)
leal 0x2(%rcx), %eax
movl %eax, (%r15)
movslq %ecx, %rax
leaq (%r14,%rax), %rdi
addq $0x2, %rdi
leaq 0x293c(%rip), %rsi      # 0x9be0
xorl %eax, %eax
callq 0x1200
leaq 0x6586(%rip), %rax      # 0xd838
movq (%rax), %rdi
leaq 0x21f5(%rip), %rsi      # 0x94b1
movq %r14, %rdx
xorl %eax, %eax
callq 0x1140
leaq 0x654b(%rip), %rax      # 0xd818
incl (%rax)
andl $0x0, (%r15)
movsbl %bpl, %esi
movl %ebx, %edi
callq 0x71aa
incl %ebx
movl %ebx, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/outline.c
// Function: outline
void outline(char addr, char data, char *d, char equ, char known) {
	int i;
	linenum++;
	outline1(file_tmp, addr, data, d, equ, known);
	if (prnerrcon && *error_field != ' ' && pass == 2) {
		outline1(stdout, addr, data, d, equ, known);
		errcount--;
	}
	print = error = 0;
	dbyt = byte = word = FALSE;
	spechar = ' ';
	if (!equ) codebytes += data;
	if (emitobj && pass == 2 && !equ)
		for (i = 0; i < data; i++)
			outhex((unsigned int)(old_loc + i), d[i]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r15d
movl %ecx, %r14d
movq %rdx, %rbx
leaq 0x6880(%rip), %rax      # 0xdb88
incl (%rax)
movl %esi, %ebp
movl %edi, %r12d
leaq 0x6442(%rip), %rax      # 0xd758
movq (%rax), %rdi
movl %r12d, %esi
movl %ebp, %edx
movq %rbx, %rcx
movl %r14d, %r8d
movl %r15d, %r9d
callq 0x6d7e
leaq 0x64d5(%rip), %rax      # 0xd808
cmpl $0x0, (%rax)
leaq 0x64c7(%rip), %r13      # 0xd804
je 0x737d
leaq 0x693a(%rip), %rax      # 0xdc80
cmpb $0x20, (%rax)
je 0x737d
cmpl $0x2, (%r13)
jne 0x737d
movq 0x5c77(%rip), %rax      # 0xcfd0
movq (%rax), %rdi
movsbl %r12b, %esi
movsbl %bpl, %edx
movsbl %r14b, %r8d
movsbl %r15b, %r9d
movq %rbx, %rcx
callq 0x6d7e
leaq 0x64ad(%rip), %rax      # 0xd828
decl (%rax)
leaq 0x6a78(%rip), %rax      # 0xddfc
andl $0x0, (%rax)
leaq 0x671e(%rip), %rax      # 0xdaac
andl $0x0, (%rax)
leaq 0x6710(%rip), %rax      # 0xdaa8
andl $0x0, (%rax)
leaq 0x670e(%rip), %rax      # 0xdab0
andl $0x0, (%rax)
leaq 0x6a54(%rip), %rax      # 0xde00
movb $0x0, (%rax)
leaq 0x6870(%rip), %rax      # 0xdc26
movb $0x20, (%rax)
testb %r14b, %r14b
jne 0x73cc
movsbq %bpl, %rax
leaq 0x642f(%rip), %rcx      # 0xd7f8
addq %rax, (%rcx)
testb %r14b, %r14b
jne 0x7418
leaq 0x6458(%rip), %rax      # 0xd830
cmpl $0x0, (%rax)
je 0x7418
cmpl $0x2, (%r13)
jne 0x7418
movzbl %bpl, %eax
xorl %r14d, %r14d
testb %bpl, %bpl
cmovlel %r14d, %eax
movzbl %al, %r15d
leaq 0x69e3(%rip), %r12      # 0xdde0
cmpq %r14, %r15
je 0x7418
movl (%r12), %edi
addl %r14d, %edi
movsbl (%rbx,%r14), %esi
callq 0x71aa
incq %r14
jmp 0x73fd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/pass1.c
// Function: good_symbol
int good_symbol(char *p) {
	int i = 1;
	if (isalpha(*p) || *p == '.' || *p == '_') /* global symbol */
		for (; i < 32 && p[i]; i++)
			if (!isalpha(p[i]) && !isdigit(p[i]) && p[i] != '.' &&
			    p[i] != '_' & p[i] != '$') {
				display_error(error = 'C');
				return (0);
			}
	return (1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1240
movq (%rax), %rcx
movsbq (%rbx), %rdx
movzwl (%rcx,%rdx,2), %eax
btl $0xa, %eax
pushq $0x1
popq %rax
jb 0x7452
movzbl %dl, %edx
cmpl $0x5f, %edx
je 0x7452
cmpl $0x2e, %edx
jne 0x749f
pushq $0x1
popq %rdx
cmpq $0x20, %rdx
je 0x749f
movsbq (%rbx,%rdx), %rsi
testq %rsi, %rsi
je 0x749f
cmpb $0x2e, %sil
je 0x7486
movzwl (%rcx,%rsi,2), %edi
andl $0xc00, %edi            # imm = 0xC00
jne 0x7486
cmpb $0x24, %sil
je 0x7486
movzbl %sil, %esi
cmpl $0x5f, %esi
jne 0x748b
incq %rdx
jmp 0x7455
leaq 0x696e(%rip), %rax      # 0xde00
movb $0x43, (%rax)
pushq $0x43
popq %rdi
callq 0x1e1c
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/pass1.c
// Function: good_label
int good_label(char *p) {
	int i;

	if (!*p) return (1); /* empty labels are okay */
	if (isdigit(*p)) {   /* must be a local symbol */
		for (i = error = 0; isdigit(*p) && *p; p++)
			i = i * 10 + *p - '0';
		if (*p++ != '$') display_error(error = 'F');
		if (*p) display_error(error = 'F');
		if (i > 255 || i < 1) display_error(error = 'F');
		return (!error);
	}
	return (good_symbol(p));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movsbq (%rdi), %r14
testq %r14, %r14
je 0x74cd
movq %rdi, %rbx
callq 0x1240
movq (%rax), %rcx
testb $0x8, 0x1(%rcx,%r14,2)
jne 0x74d2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7428
pushq $0x1
popq %rax
jmp 0x754b
leaq 0x6927(%rip), %r14      # 0xde00
movb $0x0, (%r14)
movq (%rax), %rax
incq %rbx
xorl %ebp, %ebp
movsbq -0x1(%rbx), %rcx
testq %rcx, %rcx
je 0x7509
movzwl (%rax,%rcx,2), %edx
andl $0x800, %edx            # imm = 0x800
je 0x7509
imull $0xa, %ebp, %edx
leal (%rdx,%rcx), %ebp
addl $-0x30, %ebp
incq %rbx
jmp 0x74e5
cmpb $0x24, %cl
je 0x751a
movb $0x46, (%r14)
pushq $0x46
popq %rdi
callq 0x1e1c
cmpb $0x0, (%rbx)
je 0x752b
movb $0x46, (%r14)
pushq $0x46
popq %rdi
callq 0x1e1c
movl $0xffffff00, %eax       # imm = 0xFFFFFF00
addl %eax, %ebp
cmpl %eax, %ebp
ja 0x7542
movb $0x46, (%r14)
pushq $0x46
popq %rdi
callq 0x1e1c
xorl %eax, %eax
cmpb $0x0, (%r14)
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/pass1.c
// Function: get_label
void get_label(char *p, int endlocal) {
	if (!*p || isspace(*p)) return; /* no label */
	addr = TRUE;
	if (isdigit(*p)) { /* must be a local symbol */
		int i;
		char s[32];
		for (i = 0; isdigit(*p) && *p; p++) i = i * 10 + *p - '0';
		makelocal(i, s);
		insert_symbol(s, loc_cntr, 1, 1, 1);
	} else {
		insert_symbol(p, loc_cntr, 1, 1, 0);
		if (endlocal) clear_local();
	}
	ptr->label = TRUE;
	if (ptr->multiple) display_error(error = 'M');
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsbq (%rdi), %r14
testq %r14, %r14
je 0x7640
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1240
movq (%rax), %rcx
testb $0x20, 0x1(%rcx,%r14,2)
jne 0x7640
leaq 0x6d4b(%rip), %rcx      # 0xe2d0
movb $0x1, (%rcx)
movq (%rax), %rax
movsbq (%rbx), %rcx
movzwl (%rax,%rcx,2), %edx
btl $0xb, %edx
jb 0x75c0
leaq 0x6280(%rip), %rax      # 0xd820
movq (%rax), %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %ecx, %edx
xorl %r8d, %r8d
callq 0x812d
testl %ebp, %ebp
je 0x760f
xorl %eax, %eax
callq 0x86cd
jmp 0x760f
incq %rbx
xorl %edi, %edi
testb %cl, %cl
je 0x75ea
andl $0x800, %edx            # imm = 0x800
je 0x75ea
movsbl %cl, %ecx
imull $0xa, %edi, %edx
leal (%rdx,%rcx), %edi
addl $-0x30, %edi
movsbq (%rbx), %rcx
movzwl (%rax,%rcx,2), %edx
incq %rbx
jmp 0x75c5
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x80de
leaq 0x6224(%rip), %rax      # 0xd820
movq (%rax), %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdi
movl %ecx, %edx
movl %ecx, %r8d
callq 0x812d
leaq 0x663a(%rip), %rax      # 0xdc50
movq (%rax), %rax
movzwl 0x20(%rax), %ecx
movl %ecx, %edx
orl $0x200, %edx            # imm = 0x200
movw %dx, 0x20(%rax)
testb $0x8, %cl
je 0x7640
leaq 0x67cb(%rip), %rax      # 0xde00
movb $0x4d, (%rax)
pushq $0x4d
popq %rdi
callq 0x1e1c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/symbol.c
// Function: allocsym
char *allocsym(int symlen) {
	/* returns a pointer for use as a symbol table entry */

	int symptr = symbol_ptr;
	symbol_ptr += sizeof(struct smbl) - 31 + symlen;
	if (symbol_ptr >= SYMBLKSZ) {
		symbol_buf = (char *)calloc(SYMBLKSZ, 1);
		if (!symbol_buf)
			error_msg("Available memory exceeded storing symbol",
			          "", 4);
		symptr = 0;
		symbol_ptr = sizeof(struct smbl) - 31 + symlen;
		symblk++;
	}
	return (symbol_buf + symptr);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x58b7(%rip), %eax      # 0xd6ac
leal (%rax,%rbx), %ecx
addl $0x29, %ecx
movl %ecx, 0x58ab(%rip)      # 0xd6ac
cmpl $0x1000, %ecx           # imm = 0x1000
jl 0x7e49
addl $0x29, %ebx
pushq $0x1
popq %rsi
movl $0x1000, %edi           # imm = 0x1000
callq 0x1120
movq %rax, 0x66b8(%rip)      # 0xe4d8
testq %rax, %rax
jne 0x7e3b
leaq 0x1e24(%rip), %rdi      # 0x9c50
leaq 0x1ce6(%rip), %rsi      # 0x9b19
pushq $0x4
popq %rdx
callq 0x1ddf
movl %ebx, 0x586b(%rip)      # 0xd6ac
incl 0x5861(%rip)            # 0xd6a8
xorl %eax, %eax
cltq
addq 0x6686(%rip), %rax      # 0xe4d8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/symbol.c
// Function: move
void move() {
	if (direction[level] == direction[level + 1]) {
		head(level + 1);
		xchg(level, level + 1);
		path[level]->weight = path[level + 1]->weight = BALANCED;
	} else {
		head(level + 2);
		xchg(level, level + 2);
		xchg(level + 1, level + 2);
		path[level + 2]->weight = BALANCED;
		if (direction[level + 1] == direction[level + 2]) {
			path[level]->weight = BALANCED;
			path[level + 1]->weight = !direction[level + 1];
		} else if (direction[level + 2] != BALANCED) {
			path[level]->weight = !direction[level];
			path[level + 1]->weight = BALANCED;
		} else
			path[level]->weight = path[level + 1]->weight =
			        BALANCED;
	}
}

// Assembly:
pushq %rbx
movslq 0x65d5(%rip), %rdi      # 0xe4e0
leaq 0x66ce(%rip), %rbx      # 0xe5e0
movl (%rbx,%rdi,4), %eax
cmpl 0x4(%rbx,%rdi,4), %eax
jne 0x7f5f
incq %rdi
callq 0x7e54
movl 0x65b7(%rip), %edi      # 0xe4e0
leal 0x1(%rdi), %esi
callq 0x7e90
movslq 0x65a8(%rip), %rax      # 0xe4e0
leaq 0x65b1(%rip), %rcx      # 0xe4f0
movq 0x8(%rcx,%rax,8), %rdx
movl 0x20(%rdx), %esi
andl $-0x4, %esi
orl $0x2, %esi
movw %si, 0x20(%rdx)
movq (%rcx,%rax,8), %rax
addq $0x20, %rax
movw $0x2, %dx
jmp 0x7fd4
addl $0x2, %edi
callq 0x7e54
movl 0x6573(%rip), %edi      # 0xe4e0
leal 0x2(%rdi), %esi
callq 0x7e90
movl 0x6565(%rip), %esi      # 0xe4e0
leal 0x1(%rsi), %edi
addl $0x2, %esi
callq 0x7e90
movslq 0x6553(%rip), %rax      # 0xe4e0
leaq 0x655c(%rip), %rcx      # 0xe4f0
movq 0x10(%rcx,%rax,8), %rdx
movl 0x20(%rdx), %esi
andl $-0x4, %esi
orl $0x2, %esi
movw %si, 0x20(%rdx)
movl 0x8(%rbx,%rax,4), %edx
cmpl %edx, 0x4(%rbx,%rax,4)
jne 0x7fe3
movq (%rcx,%rax,8), %rdx
movl 0x20(%rdx), %esi
andl $-0x4, %esi
orl $0x2, %esi
movw %si, 0x20(%rdx)
xorl %edx, %edx
cmpl $0x0, 0x4(%rbx,%rax,4)
sete %dl
movq 0x8(%rcx,%rax,8), %rax
addq $0x20, %rax
movl (%rax), %ecx
andl $-0x4, %ecx
movzwl %dx, %edx
orl %ecx, %edx
movw %dx, (%rax)
popq %rbx
retq
cmpl $0x2, %edx
je 0x7f3f
xorl %edx, %edx
cmpl $0x0, (%rbx,%rax,4)
sete %dl
movq (%rcx,%rax,8), %rsi
movl 0x20(%rsi), %edi
andl $-0x4, %edi
orl %edx, %edi
movw %di, 0x20(%rsi)
movq 0x8(%rcx,%rax,8), %rax
jmp 0x7f55
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/symbol.c
// Function: addref
void addref(struct xrfr **xref, int def) {
	struct xrfr *new;
	if (pass > 1) return;
	if (--xrefcnt <= 0) {
		xrefcnt = XREFALLOC;
		if (!(xrefheap = (struct xrfr *)calloc(XREFALLOC,
		                                       sizeof(struct xrfr))))
			error_msg("Available memory exceeded adding reference",
			          "", 4);
	}
	new = xrefheap++;        /* pointer to memory to be used for xref */
	new->linenumb = linenum; /* line number of reference */
	new->def = def;          /* is symbol defined on this line? */
	new->wrt = wrt;          /* is it a write operation to this symbol? */
	new->known = ptr->known; /* is symbol defined at this point? */
	new->next = *xref;       /* pointer to next reference */
	*xref = new;             /* add the reference to the list */
}

// Assembly:
leaq 0x57ee(%rip), %rax      # 0xd804
cmpl $0x1, (%rax)
jg 0x80dd
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x64a3(%rip), %eax      # 0xe4d0
leal -0x1(%rax), %ecx
movl %ecx, 0x649a(%rip)      # 0xe4d0
cmpl $0x1, %eax
jg 0x8074
movl $0x200, 0x648b(%rip)    # imm = 0x200
pushq $0x10
popq %rsi
movl $0x200, %edi            # imm = 0x200
callq 0x1120
movq %rax, 0x65ff(%rip)      # 0xe658
testq %rax, %rax
jne 0x8074
leaq 0x1c14(%rip), %rdi      # 0x9c79
leaq 0x1aad(%rip), %rsi      # 0x9b19
pushq $0x4
popq %rdx
callq 0x1ddf
movq 0x65dd(%rip), %rax      # 0xe658
leaq 0x10(%rax), %rcx
movq %rcx, 0x65d2(%rip)      # 0xe658
leaq 0x5afb(%rip), %rcx      # 0xdb88
movl (%rcx), %ecx
movl %ecx, 0xc(%rax)
movb 0x8(%rax), %cl
andb $0x1, %bpl
andb $-0x4, %cl
orb %bpl, %cl
leaq 0x5d46(%rip), %rdx      # 0xddec
movb (%rdx), %dl
addb %dl, %dl
andb $0x2, %dl
orb %cl, %dl
movb %dl, 0x8(%rax)
leaq 0x5b97(%rip), %rcx      # 0xdc50
movq (%rcx), %rcx
movzwl 0x20(%rcx), %ecx
shrl $0x6, %ecx
andb $0x4, %cl
andb $-0x5, %dl
orb %cl, %dl
movb %dl, 0x8(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/symbol.c
// Function: makelocal
void makelocal(int i, char *s) {
	/*
	        local symbols are stored in the permanent symbol table. The only
	        difference between permanent and local symbols is that cross
	        references to local symbols are not kept and that local symbols
	        are not printed in the symbol table listing.

	        local symbol names consist of a - follow by a 4 character
	        base 26 local symbol block number AAAA BAAA CAAA ... YZZZ ZZZZ,
	        followed by the 2 hex digit local symbol number. this function
	        creates the local symbol name.
	*/
	int j = i >> 4 & 15;
	i &= 15;
	s[0] = '-';    /* the first character indicating a local symbol */
	s[1] = lbn[0]; /* the local symbol block number */
	s[2] = lbn[1];
	s[3] = lbn[2];
	s[4] = lbn[3];
	s[5] = j + (j > 9 ? '7' : '0'); /* the local symbol number in hex */
	s[6] = i + (i > 9 ? '7' : '0');
	s[7] = 0; /* null to terminate string */
}

// Assembly:
movl %edi, %eax
shrl $0x4, %eax
andl $0xf, %eax
andl $0xf, %edi
movb $0x2d, (%rsi)
leaq 0x5739(%rip), %rcx      # 0xd82c
movb (%rcx), %dl
movb %dl, 0x1(%rsi)
movb 0x1(%rcx), %dl
movb %dl, 0x2(%rsi)
movb 0x2(%rcx), %dl
movb %dl, 0x3(%rsi)
movb 0x3(%rcx), %cl
movb %cl, 0x4(%rsi)
leal 0x30(%rax), %ecx
leal 0x37(%rax), %edx
cmpl $0xa, %eax
cmovbl %ecx, %edx
movb %dl, 0x5(%rsi)
leal 0x30(%rdi), %eax
leal 0x37(%rdi), %ecx
cmpl $0xa, %edi
cmovbl %eax, %ecx
movb %cl, 0x6(%rsi)
movb $0x0, 0x7(%rsi)
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/symbol.c
// Function: find_symbol
struct smbl *find_symbol(char *sym) { /* find the address of a symbol's entry */
	struct smbl *pntr;
	int i;
	pntr = root_symtab;
	while (pntr)                             /* while not a terminal node */
		if ((i = strcmp(pntr->name, sym))) /* if symbol name not equal */
			pntr = pntr->link[i <
			                  0]; /* try the appropriate sub-node */
		else
			return (pntr); /* found the symbol in table */
	return (NULL);                 /* symbol not found */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x56db(%rip), %rax      # 0xdac0
movq (%rax), %r14
testq %r14, %r14
je 0x8406
leaq 0x22(%r14), %rdi
movq %rbx, %rsi
callq 0x1130
testl %eax, %eax
je 0x8406
shrl $0x1f, %eax
leaq (%r14,%rax,8), %rax
jmp 0x83e5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/symbol.c
// Function: output_symbol
void output_symbol(struct smbl *pntr) {
	char c;
	symknt++;
	if (pntr->link[0]) output_symbol(pntr->link[0]);
	if (pntr->name[0] == '-')
		locknt++;
	else {
		c = ' ';
		if (pntr->equate) c = '=';   /* equated symbol */
		if (pntr->multiple) c = 'M'; /* multiply defined symbol */
		if (!pntr->defined) c = '?'; /* undefined symbol */
		if (pntr->section) c = 'S';  /* program section name */
		fprintf(file_lst, "\n%c %04lX %-31s ", c, pntr->value & 0xffffL,
		        pntr->name);
		if (prnxref) prnref(pntr->xref);
	}
	if (pntr->link[1]) output_symbol(pntr->link[1]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x1806(%rip), %xmm0     # 0x9c30
punpcklwd %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3]
movdqa %xmm0, (%rsp)
pushq $0x3f
popq %r13
leaq 0x5662(%rip), %r15      # 0xdaa0
pushq $0x53
popq %rbp
leaq 0x185c(%rip), %r14      # 0x9ca4
leaq 0x551d(%rip), %r12      # 0xd96c
incl 0x620b(%rip)            # 0xe660
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8462
callq 0x8411
cmpb $0x2d, 0x22(%rbx)
jne 0x8470
incl 0x61f6(%rip)            # 0xe664
jmp 0x84d0
movd 0x20(%rbx), %xmm0
pshuflw $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0,4,5,6,7]
punpcklwd %xmm0, %xmm0    # xmm0 = xmm0[0,0,1,1,2,2,3,3]
pand (%rsp), %xmm0
pcmpeqw 0x17b5(%rip), %xmm0     # 0x9c40
movmskps %xmm0, %eax
pushq $0x20
popq %rdx
testb $0x8, %al
jne 0x8498
pushq $0x3d
popq %rdx
leaq 0x22(%rbx), %r8
testb $0x4, %al
pushq $0x4d
popq %rcx
cmovel %ecx, %edx
testb $0x2, %al
cmovnel %r13d, %edx
movq (%r15), %rdi
testb $0x1, %al
cmovel %ebp, %edx
movzwl 0x18(%rbx), %ecx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
cmpl $0x0, (%r12)
je 0x84d0
movq 0x10(%rbx), %rdi
callq 0x84ec
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x844f
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/symbol.c
// Function: prnref
void prnref(struct xrfr *tmp) {
	int i = 0;
	char c;
	while (tmp) {
		c = ' '; /* nothing interesting about this reference */
		if (tmp->def)
			c = '#'; /* symbol defined on this line */
		else if (tmp->wrt)
			c = '$'; /* symbol is operand of write instruction */
		else if (!tmp->known)
			c = '?'; /* symbol is undefined here */
		fprintf(file_lst, "%6d%c", tmp->linenumb, c);
		tmp = tmp->next;
		refknt++;
		i++;
		if (i > (wide ? 12 : 4)) {
			i = 0;
			fprintf(file_lst, "\n       %31s ", " ");
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x23
popq %rbp
leaq 0x559c(%rip), %r13      # 0xdaa0
leaq 0x1894(%rip), %r14      # 0x9d9f
leaq 0x5462(%rip), %r15      # 0xd974
xorl %r12d, %r12d
testq %rbx, %rbx
je 0x858a
movb 0x8(%rbx), %al
movl %ebp, %ecx
testb $0x1, %al
jne 0x8535
pushq $0x24
popq %rcx
testb $0x2, %al
jne 0x8535
testb $0x4, %al
pushq $0x20
popq %rcx
pushq $0x3f
popq %rax
cmovel %eax, %ecx
movq (%r13), %rdi
movl 0xc(%rbx), %edx
movq %r14, %rsi
xorl %eax, %eax
callq 0x1140
movq (%rbx), %rbx
incl 0x6119(%rip)            # 0xe668
leal 0x1(%r12), %eax
xorl %ecx, %ecx
cmpl $0x0, (%r15)
setne %cl
leal 0x4(,%rcx,8), %ecx
cmpl %ecx, %r12d
movl %eax, %r12d
jl 0x8515
movq (%r13), %rdi
xorl %r12d, %r12d
leaq 0x182b(%rip), %rsi      # 0x9da5
leaq 0xb09(%rip), %rdx       # 0x908a
xorl %eax, %eax
callq 0x1140
jmp 0x8515
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/symbol.c
// Function: list_sym
void list_sym() {
	refknt = locknt = symknt = 0;
	fprintf(file_lst, "\nErrors detected in %d line", errcount);
	if (errcount != 1) fprintf(file_lst, "s");
	fprintf(file_lst, ".\n\f\n");
	fprintf(file_lst, " value name                            ");
	if (prnxref) fprintf(file_lst, "cross reference");
	fprintf(file_lst, "\n");
	if (root_symtab) output_symbol(root_symtab);
	fprintf(file_lst,
	        "\n\nMemory used to store %d local symbols: %d. bytes.", locknt,
	        26 * locknt);
	fprintf(file_lst,
	        "\n\nMemory used to store %d permanent symbols: %d. bytes.",
	        symknt - locknt, SYMBLKSZ * symblk + symbol_ptr - locknt * 26);
	if (!prnxref) return;
	fprintf(file_lst,
	        "\n\nMemory used for cross reference table: %ld. bytes.",
	        (long)refknt * (long)sizeof(struct xrfr));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
andl $0x0, 0x60bc(%rip)      # 0xe660
andl $0x0, 0x60b9(%rip)      # 0xe664
andl $0x0, 0x60b6(%rip)      # 0xe668
leaq 0x54e7(%rip), %r14      # 0xdaa0
movq (%r14), %rdi
leaq 0x5265(%rip), %rbx      # 0xd828
movl (%rbx), %edx
leaq 0x16e9(%rip), %rsi      # 0x9cb5
xorl %eax, %eax
callq 0x1140
cmpl $0x1, (%rbx)
je 0x85e3
movq (%r14), %rsi
pushq $0x73
popq %rdi
callq 0x1110
movq (%r14), %rcx
leaq 0x16e4(%rip), %rdi      # 0x9cd1
pushq $0x4
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1220
movq (%r14), %rcx
leaq 0x16d1(%rip), %rdi      # 0x9cd6
pushq $0x27
popq %rsi
movq %rbx, %rdx
callq 0x1220
leaq 0x5355(%rip), %rbx      # 0xd96c
cmpl $0x0, (%rbx)
je 0x8631
movq (%r14), %rcx
leaq 0x1309(%rip), %rdi      # 0x992f
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x1220
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x1110
leaq 0x547d(%rip), %rax      # 0xdac0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x8650
callq 0x8411
movq (%r14), %rdi
movl 0x600b(%rip), %edx      # 0xe664
imull $0x1a, %edx, %ecx
leaq 0x169b(%rip), %rsi      # 0x9cfe
xorl %eax, %eax
callq 0x1140
movq (%r14), %rdi
movl 0x5fed(%rip), %edx      # 0xe660
movl 0x5feb(%rip), %eax      # 0xe664
subl %eax, %edx
movl 0x5027(%rip), %esi      # 0xd6a8
shll $0xc, %esi
imull $-0x1a, %eax, %ecx
addl 0x501f(%rip), %ecx      # 0xd6ac
addl %esi, %ecx
leaq 0x169c(%rip), %rsi      # 0x9d32
xorl %eax, %eax
callq 0x1140
cmpl $0x0, (%rbx)
je 0x86c5
movq (%r14), %rdi
movslq 0x5fbc(%rip), %rdx      # 0xe668
shlq $0x4, %rdx
leaq 0x16b3(%rip), %rsi      # 0x9d6a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1140
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mist64[P]cbm6502asm/src/symbol.c
// Function: clear_local
void clear_local() { /* increment the local symbol block number */
	int i;
	for (i = 0; i < 4; i++) {
		if (++lbn[i] <= 'Z') return;
		lbn[i] = 'A';
	}
}

// Assembly:
xorl %eax, %eax
leaq 0x5156(%rip), %rcx      # 0xd82c
cmpq $0x4, %rax
je 0x86f2
movb (%rcx,%rax), %dl
incb %dl
movb %dl, (%rcx,%rax)
cmpb $0x5b, %dl
jl 0x86f2
movb $0x41, (%rcx,%rax)
incq %rax
jmp 0x86d6
retq
// File: /workspace/github_c_makefile_star2_O2/TomCrypto[P]avxfish/src/bench.c
// Function: scribble_memory
static void scribble_memory(void *ptr, size_t length) {
  uint32_t value = 1;

  for (size_t i = 0; i < length / 4; ++i) {
    value = (value * 8198291 + 3921);
    ((uint32_t *)ptr)[i] = value;
  }
}

// Assembly:
shrq $0x2, %rsi
pushq $0x1
popq %rax
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x403599
imull $0x7d1893, %eax, %eax   # imm = 0x7D1893
addl $0xf51, %eax            # imm = 0xF51
movl %eax, (%rdi,%rcx,4)
incq %rcx
jmp 0x403581
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_05/any.c
// Function: any
int any(char str1[], char str2[])
{
  int i, j;
  for (i = 0; str1[i] != '\0'; ++i)
  {
    for (j = 0; str2[j] != '\0'; ++j)
    {
      if (str1[i] == str2[j])
      {
        return i;
      }
    }
  }

  return -1;
}

// Assembly:
xorl %ecx, %ecx
pushq $-0x1
popq %rax
movb (%rdi,%rcx), %dl
testb %dl, %dl
je 0x11be
movq %rsi, %r8
movb (%r8), %r9b
testb %r9b, %r9b
je 0x11b7
incq %r8
cmpb %r9b, %dl
jne 0x11a5
jmp 0x11bc
incq %rcx
jmp 0x119b
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/log.c
// Function: LOG_writeBlobToBinFile
int LOG_writeBlobToBinFile(char *binFile,BLOB_s *pBlob)
{
	int fd = open(binFile,O_RDWR | O_CREAT,0666);
	CHECK_EXPR_RET(fd < 0,-1);

	BLOB_DATA_TYPE *pData = BLOB_data(pBlob);

	int writeSize = sizeof(BLOB_DATA_TYPE)*pBlob->count;
	int nwrite = write(fd,&pData[0],writeSize);
	CHECK_EXPR_RET(nwrite != writeSize,-1);

	close(fd);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
pushq $0x42
popq %rsi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x1080
testl %eax, %eax
js 0x1647
movl %eax, %ebx
movq %r14, %rdi
callq 0x1e16
movl 0x30(%r14), %ecx
shll $0x3, %ecx
movslq %ecx, %r14
movl %ebx, %edi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1050
cmpl %eax, %r14d
jne 0x1660
movl %ebx, %edi
callq 0x10e0
xorl %eax, %eax
jmp 0x1682
leaq 0x9f2(%rip), %rdi       # 0x2040
leaq 0xa01(%rip), %rsi       # 0x2056
leaq 0xa30(%rip), %rdx       # 0x208c
pushq $0x57
jmp 0x1677
leaq 0x9d9(%rip), %rdi       # 0x2040
leaq 0x9e8(%rip), %rsi       # 0x2056
leaq 0xa17(%rip), %rdx       # 0x208c
pushq $0x5d
popq %rcx
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_create
int BLOB_create(BLOB_s **pBlob,
						unsigned long numSize,
						unsigned long channelSize, 
						unsigned long heightSize,
						unsigned long widthSize,
						BOOL bShape)
{
	unsigned long counts = 0;
	CHECK_EXPR_RET(numSize <= 0,-1);
	CHECK_EXPR_RET(channelSize <= 0,-1);
	CHECK_EXPR_RET(heightSize <= 0,-1);
	CHECK_EXPR_RET(widthSize <= 0,-1);

	CHECK_EXPR_RET(pBlob == NULL,-1);

	*pBlob = (BLOB_s *)malloc(sizeof(BLOB_s));
	CHECK_EXPR_RET(*pBlob == NULL,-1);

	(*pBlob)->numSize = numSize;
	(*pBlob)->widthSize = widthSize;
	(*pBlob)->heightSize = heightSize;
	(*pBlob)->channelSize = channelSize;
	
	counts = (*pBlob)->numSize * (*pBlob)->channelSize *\
				(*pBlob)->heightSize * (*pBlob)->widthSize;
	
	(*pBlob)->pady = 0;
	(*pBlob)->padx = 0;
	(*pBlob)->count = counts;
	if (bShape == TRUE) {
		BLOB_shape(*pBlob);
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1908
movq %rdx, %r15
testq %rdx, %rdx
je 0x1921
movq %rcx, %r14
testq %rcx, %rcx
je 0x193a
movq %r8, %r12
testq %r8, %r8
je 0x1953
movq %rdi, %rbp
testq %rdi, %rdi
je 0x196c
movl %r9d, %ebx
movq %rsi, %r13
pushq $0x40
popq %rdi
callq 0x10a0
movq %rax, (%rbp)
testq %rax, %rax
je 0x1985
movq %r13, 0x10(%rax)
movq %r12, 0x28(%rax)
movq %r14, 0x20(%rax)
movq %r15, 0x18(%rax)
imulq %r13, %r15
imulq %r12, %r14
andq $0x0, 0x38(%rax)
imulq %r15, %r14
movq %r14, 0x30(%rax)
xorl %ebp, %ebp
cmpb $0x1, %bl
jne 0x19a7
movq %rax, %rdi
callq 0x19b8
jmp 0x19a7
leaq 0x731(%rip), %rdi       # 0x2040
leaq 0x7e7(%rip), %rsi       # 0x20fd
leaq 0x7e7(%rip), %rdx       # 0x2104
pushq $0xc
jmp 0x199c
leaq 0x718(%rip), %rdi       # 0x2040
leaq 0x7ce(%rip), %rsi       # 0x20fd
leaq 0x7ce(%rip), %rdx       # 0x2104
pushq $0xd
jmp 0x199c
leaq 0x6ff(%rip), %rdi       # 0x2040
leaq 0x7b5(%rip), %rsi       # 0x20fd
leaq 0x7b5(%rip), %rdx       # 0x2104
pushq $0xe
jmp 0x199c
leaq 0x6e6(%rip), %rdi       # 0x2040
leaq 0x79c(%rip), %rsi       # 0x20fd
leaq 0x79c(%rip), %rdx       # 0x2104
pushq $0xf
jmp 0x199c
leaq 0x6cd(%rip), %rdi       # 0x2040
leaq 0x783(%rip), %rsi       # 0x20fd
leaq 0x783(%rip), %rdx       # 0x2104
pushq $0x11
jmp 0x199c
leaq 0x6b4(%rip), %rdi       # 0x2040
leaq 0x76a(%rip), %rsi       # 0x20fd
leaq 0x76a(%rip), %rdx       # 0x2104
pushq $0x14
popq %rcx
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_createAddPad
int BLOB_createAddPad(BLOB_s **pBlob,
						unsigned long numSize,
						unsigned long channelSize, 
						unsigned long heightSize,
						unsigned long widthSize,
						BOOL bShape,int pady,int padx)
{
	int ret = BLOB_create(pBlob,numSize,channelSize,heightSize+pady*2,widthSize+padx*2,bShape);
	CHECK_EXPR_RET(ret != 0,-1);

	BLOB_s *blob = *pBlob;
	blob->pady = pady;
	blob->padx = padx;

	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x28(%rsp), %r14d
movl 0x20(%rsp), %r15d
leal (%r15,%r15), %eax
cltq
addq %rax, %rcx
leal (%r14,%r14), %eax
cltq
addq %rax, %r8
callq 0x186c
testl %eax, %eax
je 0x1a4e
leaq 0x60f(%rip), %rdi       # 0x2040
leaq 0x6c5(%rip), %rsi       # 0x20fd
leaq 0x6d1(%rip), %rdx       # 0x2110
pushq $0x30
popq %rcx
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
jmp 0x1a5b
movq (%rbx), %rax
movl %r15d, 0x38(%rax)
movl %r14d, 0x3c(%rax)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_shapeAddPad
int BLOB_shapeAddPad(BLOB_s *pDataSrc,BLOB_s *pData,int pady,int padx)
{
	CHECK_EXPR_RET(pDataSrc == NULL,-1);
	CHECK_EXPR_RET(pData == NULL,-1);
	CHECK_EXPR_RET(pady > pDataSrc->heightSize,-1);
	CHECK_EXPR_RET(padx > pDataSrc->widthSize,-1);
	
	BLOB_DATA_PTR(pDataSrc,ptrDataSrc);
	BLOB_DATA_PTR(pData,ptrData);
	for (int i_num = 0;i_num < pData->numSize;i_num++) {	
		for (int i_channel = 0;i_channel  < pData->channelSize;i_channel++) {
			for (int i_height = 0;i_height < pData->heightSize - pady;i_height++) {	
				for (int i_width = 0;i_width < pData->widthSize - padx;i_width++) {	
					ptrData[i_num][i_channel][i_height + pady][i_width + padx] = 
						ptrDataSrc[i_num][i_channel][i_height][i_width];	
				
				}
			}
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x1a8f
movq %rsi, %rax
testq %rsi, %rsi
je 0x1a93
movq %rdi, %r8
movslq %edx, %rsi
movq 0x20(%rdi), %rdx
cmpq %rsi, %rdx
jae 0x1a97
pushq $0x3d
jmp 0x1aa5
pushq $0x3b
jmp 0x1aa5
pushq $0x3c
jmp 0x1aa5
movslq %ecx, %rdi
movq 0x28(%r8), %rcx
cmpq %rdi, %rcx
jae 0x1ad4
pushq $0x3e
popq %rcx
leaq 0x593(%rip), %rdi       # 0x2040
leaq 0x649(%rip), %rsi       # 0x20fd
leaq 0x667(%rip), %rdx       # 0x2122
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%r8), %r9
movq 0x10(%rax), %r10
movq %r10, 0x10(%rsp)
movq 0x18(%rax), %r10
movq 0x20(%rax), %r11
movq 0x28(%rax), %rbx
movq %r11, %r14
subq %rsi, %r14
movq %rbx, %r15
subq %rdi, %r15
imulq %rbx, %rsi
shlq $0x3, %rdi
leaq (%rdi,%rsi,8), %rsi
addq 0x8(%rax), %rsi
movq %rsi, %rax
imulq %rbx, %r11
movq %r11, %rsi
imulq %r10, %rsi
shlq $0x3, %rsi
movq %rsi, 0x8(%rsp)
shlq $0x3, %r11
shlq $0x3, %rbx
imulq %rcx, %rdx
movq 0x18(%r8), %rsi
imulq %rdx, %rsi
shlq $0x3, %rsi
movq %rsi, (%rsp)
shlq $0x3, %rdx
shlq $0x3, %rcx
xorl %r13d, %r13d
cmpq 0x10(%rsp), %r13
je 0x1bb8
movq %r9, 0x20(%rsp)
movq %r9, %r8
movq %rax, 0x18(%rsp)
movq %rax, %r9
xorl %eax, %eax
cmpq %r10, %rax
je 0x1ba0
movq %r8, %rbp
movq %r9, %r12
xorl %edi, %edi
cmpq %r14, %rdi
je 0x1b95
xorl %esi, %esi
cmpq %rsi, %r15
je 0x1b8a
movsd (%rbp,%rsi,8), %xmm0
movsd %xmm0, (%r12,%rsi,8)
incq %rsi
jmp 0x1b74
incq %rdi
addq %rbx, %r12
addq %rcx, %rbp
jmp 0x1b6d
incq %rax
addq %r11, %r9
addq %rdx, %r8
jmp 0x1b60
incq %r13
movq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
movq 0x20(%rsp), %r9
addq (%rsp), %r9
jmp 0x1b47
xorl %eax, %eax
jmp 0x1ac5
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_shapeLike
int BLOB_shapeLike(BLOB_s *pDataSrc,BLOB_s **pData)
{
	CHECK_EXPR_RET(pDataSrc == NULL,-1);
	CHECK_EXPR_RET(pData == NULL,-1);

	*pData = (BLOB_s *)malloc(sizeof(BLOB_s));
	CHECK_EXPR_RET(*pData == NULL,-1);

	memcpy(*pData,pDataSrc,sizeof(BLOB_s));
	
	BLOB_shape(*pData);
	
	return 0;	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1c0d
movq %rsi, %r14
testq %rsi, %rsi
je 0x1c26
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq 0x10a0
movq %rax, (%r14)
testq %rax, %rax
je 0x1c3f
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups 0x30(%rbx), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq %rax, %rdi
callq 0x19b8
xorl %eax, %eax
jmp 0x1c61
leaq 0x42c(%rip), %rdi       # 0x2040
leaq 0x4e2(%rip), %rsi       # 0x20fd
leaq 0x511(%rip), %rdx       # 0x2133
pushq $0x55
jmp 0x1c56
leaq 0x413(%rip), %rdi       # 0x2040
leaq 0x4c9(%rip), %rsi       # 0x20fd
leaq 0x4f8(%rip), %rdx       # 0x2133
pushq $0x56
jmp 0x1c56
leaq 0x3fa(%rip), %rdi       # 0x2040
leaq 0x4b0(%rip), %rsi       # 0x20fd
leaq 0x4df(%rip), %rdx       # 0x2133
pushq $0x59
popq %rcx
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_shapeByPtr
int BLOB_shapeByPtr(BLOB_s *pBlob,BLOB_DATA_TYPE *pData,int len)
{
	CHECK_EXPR_RET(pData == NULL,-1);
	CHECK_EXPR_RET(pBlob == NULL,-1);
	CHECK_EXPR_RET(len != pBlob->count,-1);
	
	BLOB_shape(pBlob);
	BLOB_DATA_PTR(pBlob,ptr);
	int k = 0;
	for (int i_num = 0;i_num < pBlob->numSize;i_num++) {	
		for (int i_channel = 0;i_channel  < pBlob->channelSize;i_channel++) {
			for (int i_height = 0;i_height < pBlob->heightSize;i_height++) {	
				for (int i_width = 0;i_width < pBlob->widthSize;i_width++) {	
					ptr[i_num][i_channel][i_height][i_width] = pData[k++];	
				}
			}
		}
	}
	
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x1d42
movq %rdi, %r14
testq %rdi, %rdi
je 0x1d46
movslq %edx, %rax
cmpq %rax, 0x30(%r14)
jne 0x1d4a
movq %rsi, %rbx
movq %r14, %rdi
callq 0x19b8
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rsi
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movq %rsi, %r9
imulq %rdx, %r9
movq %r9, %rax
imulq %rcx, %rax
shlq $0x3, %rax
movq %rax, 0x8(%rsp)
shlq $0x3, %r9
leaq (,%rsi,8), %r11
xorl %r14d, %r14d
xorl %ebp, %ebp
cmpq 0x10(%rsp), %r14
je 0x1d7b
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %rcx, %r12
je 0x1d38
movq %r15, %r13
xorl %r8d, %r8d
cmpq %rdx, %r8
je 0x1d30
movslq %ebp, %rax
leaq (%rbx,%rax,8), %r10
xorl %eax, %eax
cmpq %rax, %rsi
je 0x1d26
movsd (%r10,%rax,8), %xmm0
movsd %xmm0, (%r13,%rax,8)
incq %rax
jmp 0x1d0f
addl %eax, %ebp
incq %r8
addq %r11, %r13
jmp 0x1d01
incq %r12
addq %r9, %r15
jmp 0x1cf6
incq %r14
addq 0x8(%rsp), %rdi
jmp 0x1ce5
pushq $0x6d
jmp 0x1d4c
pushq $0x6e
jmp 0x1d4c
pushq $0x6f
popq %rcx
leaq 0x2ec(%rip), %rdi       # 0x2040
leaq 0x3a2(%rip), %rsi       # 0x20fd
leaq 0x3eb(%rip), %rdx       # 0x214d
xorl %eax, %eax
callq 0x1030
pushq $-0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x1d6c
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_printPara
void BLOB_printPara(BLOB_s *pBolb)
{	
	printf("num:     %ld\n",pBolb->numSize);
	printf("channel: %ld\n",pBolb->channelSize);
	printf("height:  %ld\n",pBolb->heightSize);
	printf("width:   %ld\n",pBolb->widthSize);
	printf("size:    %ld\n",pBolb->count);
	printf("bytes:   %ld\n",pBolb->count*sizeof(BLOB_DATA_TYPE));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
leaq 0x3ad(%rip), %rdi       # 0x215d
xorl %eax, %eax
callq 0x1030
movq 0x18(%rbx), %rsi
leaq 0x3a9(%rip), %rdi       # 0x216b
xorl %eax, %eax
callq 0x1030
movq 0x20(%rbx), %rsi
leaq 0x3a5(%rip), %rdi       # 0x2179
xorl %eax, %eax
callq 0x1030
movq 0x28(%rbx), %rsi
leaq 0x3a1(%rip), %rdi       # 0x2187
xorl %eax, %eax
callq 0x1030
movq 0x30(%rbx), %rsi
leaq 0x39d(%rip), %rdi       # 0x2195
xorl %eax, %eax
callq 0x1030
movq 0x30(%rbx), %rsi
shlq $0x3, %rsi
leaq 0x395(%rip), %rdi       # 0x21a3
xorl %eax, %eax
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_print
void BLOB_print(BLOB_s *pBlob)
{
	CHECK_EXPR_RET_VOID(pBlob==NULL);
	
	unsigned long batches = 1/*pBlob->batches*/;
	unsigned long width = pBlob->widthSize;
	unsigned long height = pBlob->heightSize;
	unsigned long num = pBlob->numSize;
	unsigned long channels = pBlob->channelSize;
	
	BLOB_DATA_PTR(pBlob,ptr);
	for (int i_channel = 0;i_channel  < channels;i_channel++) {
		for (int i_batch = 0;i_batch < batches;i_batch++) {
			for (int i_num = 0;i_num < num;i_num++) {	
				for (int i_height = 0;i_height < height;i_height++) {	
					for (int i_width = 0;i_width < width;i_width++) {	
						printf("%lf ",ptr[i_num][i_channel][i_height+pBlob->pady][i_width+pBlob->padx]);	
					}
					printf(" ");
				}
				printf("  ");
			}
			printf("\n");
		}
		printf(" ");
	}
}

// Assembly:
testq %rdi, %rdi
je 0x1f95
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r13
movq 0x20(%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rdi), %rcx
movq %rcx, 0x38(%rsp)
movq 0x18(%rdi), %rcx
movq %rax, 0x48(%rsp)
imulq %r13, %rax
movq %rax, 0x8(%rsp)
movq %rcx, 0x18(%rsp)
imulq %rcx, %rax
movq %rax, 0x28(%rsp)
leaq 0x312(%rip), %r12       # 0x21bc
xorl %ecx, %ecx
cmpq 0x18(%rsp), %rcx
je 0x1f86
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
imulq %rcx, %rax
movq 0x10(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, 0x30(%rsp)
xorl %ecx, %ecx
cmpq 0x38(%rsp), %rcx
je 0x1f69
movq 0x28(%rsp), %rax
movq %rcx, 0x40(%rsp)
imulq %rcx, %rax
movq 0x30(%rsp), %rcx
leaq (%rcx,%rax,8), %r15
xorl %eax, %eax
cmpq 0x48(%rsp), %rax
je 0x1f4e
movq %rax, 0x50(%rsp)
movslq %eax, %rbp
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x1f3c
movslq 0x38(%rbx), %rax
addq %rbp, %rax
imulq %r13, %rax
leaq (%r15,%rax,8), %rax
movl 0x3c(%rbx), %ecx
addl %r14d, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x1030
incq %r14
jmp 0x1f0b
pushq $0x20
popq %rdi
callq 0x10b0
movq 0x50(%rsp), %rax
incq %rax
jmp 0x1ef9
leaq 0x26c(%rip), %rdi       # 0x21c1
xorl %eax, %eax
callq 0x1030
movq 0x40(%rsp), %rcx
incq %rcx
jmp 0x1ed5
pushq $0xa
popq %rdi
callq 0x10b0
pushq $0x20
popq %rdi
callq 0x10b0
movq 0x20(%rsp), %rcx
incq %rcx
jmp 0x1eac
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa4(%rip), %rdi        # 0x2040
leaq 0x15a(%rip), %rsi       # 0x20fd
leaq 0x207(%rip), %rdx       # 0x21b1
movl $0xae, %ecx
xorl %eax, %eax
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/aparrish[P]rwet-examples-c/markov.c
// Function: main
int main(int argc, char** argv) {

	int len, n, i, line_count;
	char* line;
	markov_gen_t* gen;

	if (argc != 3) {
		fprintf(stderr, "usage: markov n line_count\n");
		exit(-1);
	}

	n = atoi(argv[1]);
	line_count = atoi(argv[2]);

	gen = markov_gen_new(n, 100);
	while (!feof(stdin)) {
		len = ap_getline(&line, stdin);
		markov_gen_feed(gen, line);
		free(line);
	}

	/* uncomment to dump markov chain data */
	/*markov_gen_dump(gen);*/

	for (i = 0; i < line_count; i++) {
		markov_gen_generate_new(gen, &line);
		printf("%s\n", line);
		free(line);
	}

	markov_gen_free(gen);

	return 0;
	
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3, %edi
jne 0x1322
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x1100
movl %eax, %r14d
movq 0x10(%rbx), %rdi
callq 0x1100
movl %eax, %ebp
pushq $0x64
popq %rsi
movl %r14d, %edi
callq 0x172c
movq %rax, %rbx
movq 0x3d2d(%rip), %r15      # 0x4fd8
movq %rsp, %r14
movq (%r15), %rdi
callq 0x10a0
testl %eax, %eax
jne 0x12dc
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2b9c
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x1776
movq (%rsp), %rdi
callq 0x1030
jmp 0x12ae
xorl %r15d, %r15d
testl %ebp, %ebp
cmovgl %ebp, %r15d
movq %rsp, %r14
subl $0x1, %r15d
jb 0x130d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x22c8
movq (%rsp), %rdi
callq 0x1050
movq (%rsp), %rdi
callq 0x1030
jmp 0x12e8
movq %rbx, %rdi
callq 0x2972
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x3ccf(%rip), %rax      # 0x4ff8
movq (%rax), %rcx
leaq 0x1cd1(%rip), %rdi      # 0x3004
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x1130
pushq $-0x1
popq %rdi
callq 0x1120
nop
// File: /workspace/github_c_makefile_star2_O2/aparrish[P]rwet-examples-c/markov_gen.c
// Function: markov_gen_new
markov_gen_t* markov_gen_new(int n, int max) {
	markov_gen_t* mg;
	mg = (markov_gen_t*)malloc(sizeof(markov_gen_t));
	mg->n = n;
	mg->max = max;
	mg->ngrams = NULL;
	utarray_new(mg->beginnings, &ptr_icd);
	return mg;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %ebp
pushq $0x18
popq %rdi
callq 0x10c0
movq %rax, %r14
movl %ebp, (%rax)
movl %ebx, 0x4(%rax)
andq $0x0, 0x8(%rax)
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x1090
movq %rax, 0x10(%r14)
movups 0x3969(%rip), %xmm0     # 0x50c8
movups %xmm0, 0x8(%rax)
movups 0x396e(%rip), %xmm0     # 0x50d8
movups %xmm0, 0x18(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq