LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x8b1a(%rip), %rax      # 0x10a98
movq (%rax), %rax
leaq 0x8ce0(%rip), %rcx      # 0x10c68
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x7fa9
leaq 0x8ae8(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0x59f1(%rip), %rsi      # 0xd993
movb $0x0, %al
callq 0x1120
jmp 0x7fab
leaq 0x8cb6(%rip), %rax      # 0x10c68
cmpq $0x0, (%rax)
je 0x80a8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq 0x8c9c(%rip), %rax      # 0x10c68
movq (%rax), %rax
movl 0x8(%rax), %eax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x8a9f(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0x8c7d(%rip), %rax      # 0x10c68
movq (%rax), %rax
movl 0x8(%rax), %edx
leaq 0x8c70(%rip), %rax      # 0x10c68
movq (%rax), %rcx
addq $0xc, %rcx
leaq 0x59c2(%rip), %rsi      # 0xd9c8
movb $0x0, %al
callq 0x1120
leaq 0x8c54(%rip), %rax      # 0x10c68
movq (%rax), %rax
addq $0xc, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpb $0x0, (%rax)
je 0x8035
jmp 0x801f
jmp 0x8037
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x8074
leaq 0x8a39(%rip), %rax      # 0x10a80
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x597e(%rip), %rsi      # 0xd9d3
movb $0x0, %al
callq 0x1120
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
cmpb $0x0, (%rax)
je 0x8072
jmp 0x805c
jmp 0x8037
leaq 0x8a05(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0x5a1a(%rip), %rsi      # 0xda9f
movb $0x0, %al
callq 0x1120
leaq 0x8bd5(%rip), %rax      # 0x10c68
movq (%rax), %rax
movq (%rax), %rcx
leaq 0x8bc8(%rip), %rax      # 0x10c68
movq %rcx, (%rax)
jmp 0x7fab
leaq 0x89e9(%rip), %rax      # 0x10a98
cmpq $0x0, (%rax)
je 0x80d6
leaq 0x89c4(%rip), %rax      # 0x10a80
movq (%rax), %rdi
movl -0xc(%rbp), %edx
movq -0x8(%rbp), %rcx
leaq 0x590a(%rip), %rsi      # 0xd9d7
movb $0x0, %al
callq 0x1120
jmp 0x80ee
leaq 0x89a3(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0x5929(%rip), %rsi      # 0xda10
movb $0x0, %al
callq 0x1120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x8cb6(%rip), %rax      # 0x10dcc
movl $0x0, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x8549(%rip), %rax      # 0x10670
cmpb $0x0, (%rax,%rcx)
je 0x81ef
leaq 0x8f50(%rip), %rax      # 0x11088
movq (%rax), %rax
movsbl (%rax), %ecx
movslq -0x4(%rbp), %rdx
leaq 0x8527(%rip), %rax      # 0x10670
movsbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x5(%rbp)
jne 0x81c7
leaq 0x8f2b(%rip), %rax      # 0x11088
movq (%rax), %rax
movsbl 0x1(%rax), %ecx
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq 0x84fc(%rip), %rax      # 0x10670
movsbl (%rax,%rdx), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x5(%rbp)
jne 0x81c7
leaq 0x8f08(%rip), %rax      # 0x11090
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x61, %eax
je 0x81aa
leaq 0x8ef6(%rip), %rax      # 0x11090
movq (%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0x6(%rbp)
jne 0x81c1
leaq 0x8edf(%rip), %rax      # 0x11090
movq (%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x6(%rbp)
movb -0x6(%rbp), %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
leaq 0x8bf6(%rip), %rax      # 0x10dcc
orl (%rax), %ecx
leaq 0x8bed(%rip), %rax      # 0x10dcc
movl %ecx, (%rax)
movl -0x4(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0x811c
leaq 0x90bd(%rip), %rax      # 0x112b3
movb $0x1, (%rax)
leaq 0x90b1(%rip), %rax      # 0x112b1
movb $0x1, (%rax)
leaq 0x8bd2(%rip), %rax      # 0x10ddc
movl $0x1, (%rax)
leaq 0x9099(%rip), %rax      # 0x112b0
movb $0x1, (%rax)
callq 0x8350
leaq 0x8f8a(%rip), %rcx      # 0x111b0
movb %al, (%rcx)
movsbl %al, %eax
movl %eax, -0x4(%rbp)
leaq 0x907c(%rip), %rax      # 0x112b1
cmpb $0x0, (%rax)
je 0x8290
leaq 0x9070(%rip), %rax      # 0x112b1
movsbq (%rax), %rcx
leaq 0x85b4(%rip), %rax      # 0x10800
addq (%rax), %rcx
leaq 0x85aa(%rip), %rax      # 0x10800
movq %rcx, (%rax)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movslq %eax, %rcx
leaq 0x7ec5(%rip), %rax      # 0x10130
movsbl (%rax,%rcx), %eax
leaq 0x8632(%rip), %rcx      # 0x108a8
cmpl (%rcx), %eax
jle 0x828e
leaq 0x8b5f(%rip), %rax      # 0x10de0
movb $0x49, (%rax)
movl $0x49, %edi
callq 0x2350
jmp 0x8290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x8343
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x29(%rbp)
jge 0x8304
movq -0x10(%rbp), %rax
movl -0x20(%rbp), %ecx
addl -0x28(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x830d
jmp 0x831a
jmp 0x830f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x82d2
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x832a
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x834a
jmp 0x832c
movl -0x1c(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x82bd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movb %r8b, %al
movb %dil, -0x1(%rbp)
movb %sil, -0x2(%rbp)
movq %rdx, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movb %al, -0x12(%rbp)
leaq 0x5e94(%rip), %rax      # 0x10b68
movl (%rax), %ecx
addl $0x1, %ecx
leaq 0x5e88(%rip), %rax      # 0x10b68
movl %ecx, (%rax)
leaq 0x5a4f(%rip), %rax      # 0x10738
movq (%rax), %rdi
movb -0x1(%rbp), %sil
movb -0x2(%rbp), %dl
movq -0x10(%rbp), %rcx
movb -0x11(%rbp), %al
movsbl %sil, %esi
movsbl %dl, %edx
movsbl %al, %r8d
movsbl -0x12(%rbp), %r9d
callq 0xa530
leaq 0x5ad2(%rip), %rax      # 0x107e8
cmpl $0x0, (%rax)
je 0xad78
leaq 0x5f3e(%rip), %rax      # 0x10c60
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0xad78
leaq 0x5ab3(%rip), %rax      # 0x107e4
cmpl $0x2, (%rax)
jne 0xad78
movq 0x52a3(%rip), %rax      # 0xffe0
movq (%rax), %rdi
movb -0x1(%rbp), %sil
movb -0x2(%rbp), %dl
movq -0x10(%rbp), %rcx
movb -0x11(%rbp), %al
movsbl %sil, %esi
movsbl %dl, %edx
movsbl %al, %r8d
movsbl -0x12(%rbp), %r9d
callq 0xa530
leaq 0x5a9e(%rip), %rax      # 0x10808
movl (%rax), %ecx
addl $-0x1, %ecx
leaq 0x5a92(%rip), %rax      # 0x10808
movl %ecx, (%rax)
leaq 0x6061(%rip), %rax      # 0x10de0
movb $0x0, (%rax)
leaq 0x6053(%rip), %rax      # 0x10ddc
movl $0x0, (%rax)
leaq 0x5cf6(%rip), %rax      # 0x10a8c
movl $0x0, (%rax)
leaq 0x5ce5(%rip), %rax      # 0x10a88
movl $0x0, (%rax)
leaq 0x5ce0(%rip), %rax      # 0x10a90
movl $0x0, (%rax)
leaq 0x5e49(%rip), %rax      # 0x10c06
movb $0x20, (%rax)
cmpb $0x0, -0x11(%rbp)
jne 0xaddf
movsbq -0x2(%rbp), %rcx
leaq 0x5a06(%rip), %rax      # 0x107d8
addq (%rax), %rcx
leaq 0x59fc(%rip), %rax      # 0x107d8
movq %rcx, (%rax)
leaq 0x5a2a(%rip), %rax      # 0x10810
cmpl $0x0, (%rax)
je 0xae40
leaq 0x59f2(%rip), %rax      # 0x107e4
cmpl $0x2, (%rax)
jne 0xae40
cmpb $0x0, -0x11(%rbp)
jne 0xae40
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movsbl -0x2(%rbp), %ecx
cmpl %ecx, %eax
jge 0xae3e
leaq 0x5faa(%rip), %rax      # 0x10dc0
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
addq %rcx, %rax
movl %eax, %edi
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0xaaa0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xae04
jmp 0xae40
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
callq 0x1200
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0xae9f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
je 0xae9f
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
jne 0xaf91
jmp 0xaea1
xorl %eax, %eax
cmpl $0x20, -0x14(%rbp)
movb %al, -0x15(%rbp)
jge 0xaec1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xaecd
jmp 0xaf8f
callq 0x1200
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0xaf7f
callq 0x1200
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
jne 0xaf7f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2e, %eax
je 0xaf7f
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x5f, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
movq -0x10(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl $0x24, %ecx
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xaf7f
leaq 0x5e77(%rip), %rax      # 0x10de0
movb $0x43, (%rax)
movl $0x43, %edi
callq 0x2350
movl $0x0, -0x4(%rbp)
jmp 0xaf98
jmp 0xaf81
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xaea1
jmp 0xaf91
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0xafd1
movl $0x1, -0x4(%rbp)
jmp 0xb0f6
callq 0x1200
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xb0ea
leaq 0x5de4(%rip), %rax      # 0x10de0
movb $0x0, (%rax)
movl $0x0, -0x14(%rbp)
callq 0x1200
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xb03c
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xb045
jmp 0xb066
imull $0xa, -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb006
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %eax
cmpl $0x24, %eax
je 0xb091
leaq 0x5d5c(%rip), %rax      # 0x10de0
movb $0x46, (%rax)
movl $0x46, %edi
callq 0x2350
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb0ae
leaq 0x5d3f(%rip), %rax      # 0x10de0
movb $0x46, (%rax)
movl $0x46, %edi
callq 0x2350
cmpl $0xff, -0x14(%rbp)
jg 0xb0bd
cmpl $0x1, -0x14(%rbp)
jge 0xb0d1
leaq 0x5d1c(%rip), %rax      # 0x10de0
movb $0x46, (%rax)
movl $0x46, %edi
callq 0x2350
leaq 0x5d08(%rip), %rax      # 0x10de0
cmpb $0x0, (%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xb0f6
movq -0x10(%rbp), %rdi
callq 0xae50
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb138
callq 0x1200
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0xb13d
jmp 0xb279
leaq 0x616c(%rip), %rax      # 0x112b0
movb $0x1, (%rax)
callq 0x1200
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xb1ff
movl $0x0, -0x10(%rbp)
callq 0x1200
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xb1a8
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xb1b1
jmp 0xb1d2
imull $0xa, -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
movsbl (%rcx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xb172
movl -0x10(%rbp), %edi
leaq -0x30(%rbp), %rsi
callq 0xc280
leaq -0x30(%rbp), %rdi
leaq 0x5617(%rip), %rax      # 0x10800
movq (%rax), %rsi
movl $0x1, %r8d
movl %r8d, %edx
movl %r8d, %ecx
callq 0xc340
jmp 0xb22b
movq -0x8(%rbp), %rdi
leaq 0x55f6(%rip), %rax      # 0x10800
movq (%rax), %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
movl %ecx, %edx
callq 0xc340
cmpl $0x0, -0xc(%rbp)
je 0xb229
movb $0x0, %al
callq 0xcc70
jmp 0xb22b
leaq 0x59fe(%rip), %rax      # 0x10c30
movq (%rax), %rax
movw 0x20(%rax), %cx
andw $0xfdff, %cx            # imm = 0xFDFF
orw $0x200, %cx             # imm = 0x200
movw %cx, 0x20(%rax)
leaq 0x59e2(%rip), %rax      # 0x10c30
movq (%rax), %rax
movw 0x20(%rax), %ax
shrw $0x3, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xb279
leaq 0x5b74(%rip), %rax      # 0x10de0
movb $0x4d, (%rax)
movl $0x4d, %edi
callq 0x2350
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x49eb(%rip), %eax      # 0x1068c
movl %eax, -0x8(%rbp)
movslq -0x4(%rbp), %rcx
addq $0x29, %rcx
movslq 0x49d9(%rip), %rax      # 0x1068c
addq %rcx, %rax
movl %eax, 0x49d0(%rip)      # 0x1068c
cmpl $0x1000, 0x49c6(%rip)   # imm = 0x1000
jl 0xbd24
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x1100
movq %rax, 0x57da(%rip)      # 0x114b8
cmpq $0x0, 0x57d2(%rip)      # 0x114b8
jne 0xbd00
leaq 0x1ec2(%rip), %rdi      # 0xdbb1
leaq 0x1daa(%rip), %rsi      # 0xdaa0
movl $0x4, %edx
callq 0x22f0
movl $0x0, -0x8(%rbp)
movslq -0x4(%rbp), %rax
addq $0x29, %rax
movl %eax, 0x4977(%rip)      # 0x1068c
movl 0x496d(%rip), %eax      # 0x10688
addl $0x1, %eax
movl %eax, 0x4964(%rip)      # 0x10688
movq 0x578d(%rip), %rax      # 0x114b8
movslq -0x8(%rbp), %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mist64[P]cbm6502asm/src/symbol.c
// Function: head
void head(int i) {
	/* link sub-tree rooted at critical node  */

	if (level)
		path[level - 1]->link[direction[level - 1]] = path[i];
	else
		root_symtab = path[i]; /* first entry */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x0, 0x5772(%rip)      # 0x114c0
je 0xbd93
movslq -0x4(%rbp), %rcx
leaq 0x5775(%rip), %rax      # 0x114d0
movq (%rax,%rcx,8), %rdx
movl 0x575b(%rip), %eax      # 0x114c0
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x575e(%rip), %rax      # 0x114d0
movq (%rax,%rcx,8), %rax
movl 0x5744(%rip), %ecx      # 0x114c0
subl $0x1, %ecx
movslq %ecx, %rsi
leaq 0x5837(%rip), %rcx      # 0x115c0
movslq (%rcx,%rsi,4), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xbdac
movslq -0x4(%rbp), %rcx
leaq 0x5732(%rip), %rax      # 0x114d0
movq (%rax,%rcx,8), %rcx
leaq 0x4cf7(%rip), %rax      # 0x10aa0
movq %rcx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x467e(%rip), %rax      # 0x107e4
cmpl $0x1, (%rax)
jle 0xc170
jmp 0xc26c
movl 0x533a(%rip), %eax      # 0x114b0
addl $-0x1, %eax
movl %eax, 0x5331(%rip)      # 0x114b0
cmpl $0x0, %eax
jg 0xc1c4
movl $0x200, 0x5322(%rip)    # imm = 0x200
movl $0x200, %edi            # imm = 0x200
movl $0x10, %esi
callq 0x1100
movq %rax, 0x5494(%rip)      # 0x11638
cmpq $0x0, %rax
jne 0xc1c2
leaq 0x1a29(%rip), %rdi      # 0xdbda
leaq 0x18e8(%rip), %rsi      # 0xdaa0
movl $0x4, %edx
callq 0x22f0
jmp 0xc1c4
movq 0x546d(%rip), %rax      # 0x11638
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x545f(%rip)      # 0x11638
movq %rax, -0x18(%rbp)
leaq 0x4984(%rip), %rax      # 0x10b68
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movb %cl, %dl
movb 0x8(%rax), %cl
andb $0x1, %dl
andb $-0x2, %cl
orb %dl, %cl
movb %cl, 0x8(%rax)
leaq 0x4bc1(%rip), %rax      # 0x10dcc
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movb %cl, %dl
movb 0x8(%rax), %cl
andb $0x1, %dl
shlb %dl
andb $-0x3, %cl
orb %dl, %cl
movb %cl, 0x8(%rax)
leaq 0x4a06(%rip), %rax      # 0x10c30
movq (%rax), %rax
movw 0x20(%rax), %ax
shrw $0x8, %ax
andw $0x1, %ax
movzwl %ax, %ecx
movq -0x18(%rbp), %rax
movb %cl, %dl
movb 0x8(%rax), %cl
andb $0x1, %dl
shlb $0x2, %dl
andb $-0x5, %cl
orb %dl, %cl
movb %cl, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
sarl $0x4, %eax
andl $0xf, %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
movb $0x2d, (%rax)
leaq 0x455e(%rip), %rax      # 0x1080c
movb (%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
leaq 0x454e(%rip), %rax      # 0x1080c
movb 0x1(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
leaq 0x453d(%rip), %rax      # 0x1080c
movb 0x2(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
leaq 0x452c(%rip), %rax      # 0x1080c
movb 0x3(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movl -0x14(%rbp), %eax
movl -0x14(%rbp), %esi
movl $0x30, %ecx
movl $0x37, %edx
cmpl $0x9, %esi
cmovgl %edx, %ecx
addl %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movl -0x4(%rbp), %eax
movl -0x4(%rbp), %esi
movl $0x30, %ecx
movl $0x37, %edx
cmpl $0x9, %esi
cmovgl %edx, %ecx
addl %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x7(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x427d(%rip), %rax      # 0x10aa0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc874
movq -0x18(%rbp), %rdi
addq $0x22, %rdi
movq -0x10(%rbp), %rsi
callq 0x1110
movl %eax, -0x1c(%rbp)
cmpl $0x0, %eax
je 0xc868
movq -0x18(%rbp), %rax
cmpl $0x0, -0x1c(%rbp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xc872
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc87c
jmp 0xc82a
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x4d9e(%rip), %eax      # 0x11640
addl $0x1, %eax
movl %eax, 0x4d95(%rip)      # 0x11640
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0xc8c1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xc890
movq -0x8(%rbp), %rax
movsbl 0x22(%rax), %eax
cmpl $0x2d, %eax
jne 0xc8e2
movl 0x4d70(%rip), %eax      # 0x11644
addl $0x1, %eax
movl %eax, 0x4d67(%rip)      # 0x11644
jmp 0xc9a4
movb $0x20, -0x9(%rbp)
movq -0x8(%rbp), %rax
movw 0x20(%rax), %ax
shrw $0x5, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xc902
movb $0x3d, -0x9(%rbp)
movq -0x8(%rbp), %rax
movw 0x20(%rax), %ax
shrw $0x3, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xc91e
movb $0x4d, -0x9(%rbp)
movq -0x8(%rbp), %rax
movw 0x20(%rax), %ax
shrw $0x2, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
jne 0xc93a
movb $0x3f, -0x9(%rbp)
movq -0x8(%rbp), %rax
movw 0x20(%rax), %ax
shrw $0x4, %ax
andw $0x1, %ax
movzwl %ax, %eax
cmpl $0x0, %eax
je 0xc956
movb $0x53, -0x9(%rbp)
leaq 0x4123(%rip), %rax      # 0x10a80
movq (%rax), %rdi
movsbl -0x9(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
movq -0x8(%rbp), %r8
addq $0x22, %r8
leaq 0x1283(%rip), %rsi      # 0xdc05
movb $0x0, %al
callq 0x1120
leaq 0x3fbc(%rip), %rax      # 0x1094c
cmpl $0x0, (%rax)
je 0xc9a2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc9d0
jmp 0xc9a4
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc9bc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xc890
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcacf
movb $0x20, -0xd(%rbp)
movq -0x8(%rbp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xca09
movb $0x23, -0xd(%rbp)
jmp 0xca3e
movq -0x8(%rbp), %rax
movb 0x8(%rax), %al
shrb %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xca22
movb $0x24, -0xd(%rbp)
jmp 0xca3c
movq -0x8(%rbp), %rax
movb 0x8(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xca3a
movb $0x3f, -0xd(%rbp)
jmp 0xca3c
jmp 0xca3e
leaq 0x403b(%rip), %rax      # 0x10a80
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %edx
movsbl -0xd(%rbp), %ecx
leaq 0x12b6(%rip), %rsi      # 0xdd10
movb $0x0, %al
callq 0x1120
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movl 0x4bd6(%rip), %eax      # 0x11648
addl $0x1, %eax
movl %eax, 0x4bcd(%rip)      # 0x11648
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x3ec6(%rip), %rcx      # 0x10954
movl (%rcx), %esi
movl $0x4, %ecx
movl $0xc, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
cmpl %ecx, %eax
jle 0xcaca
movl $0x0, -0xc(%rbp)
leaq 0x3fce(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0x125a(%rip), %rsi      # 0xdd16
leaq 0x5cc(%rip), %rdx       # 0xd08f
movb $0x0, %al
callq 0x1120
jmp 0xc9e3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movl $0x0, 0x4b52(%rip)      # 0x11640
movl $0x0, 0x4b4c(%rip)      # 0x11644
movl $0x0, 0x4b46(%rip)      # 0x11648
leaq 0x3f77(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0x3cf5(%rip), %rax      # 0x10808
movl (%rax), %edx
leaq 0x10fa(%rip), %rsi      # 0xdc16
movb $0x0, %al
callq 0x1120
leaq 0x3cde(%rip), %rax      # 0x10808
cmpl $0x1, (%rax)
je 0xcb47
leaq 0x3f4a(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0xe95(%rip), %rsi       # 0xd9d5
movb $0x0, %al
callq 0x1120
leaq 0x3f32(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0x10da(%rip), %rsi      # 0xdc32
movb $0x0, %al
callq 0x1120
leaq 0x3f1a(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0x10c7(%rip), %rsi      # 0xdc37
movb $0x0, %al
callq 0x1120
leaq 0x3dce(%rip), %rax      # 0x1094c
cmpl $0x0, (%rax)
je 0xcb9b
leaq 0x3ef6(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0x10cb(%rip), %rsi      # 0xdc5f
movb $0x0, %al
callq 0x1120
leaq 0x3ede(%rip), %rax      # 0x10a80
movq (%rax), %rdi
leaq 0xef3(%rip), %rsi       # 0xda9f
movb $0x0, %al
callq 0x1120
leaq 0x3ee6(%rip), %rax      # 0x10aa0
cmpq $0x0, (%rax)
je 0xcbcf
leaq 0x3ed9(%rip), %rax      # 0x10aa0
movq (%rax), %rdi
callq 0xc890
leaq 0x3eaa(%rip), %rax      # 0x10a80
movq (%rax), %rdi
movl 0x4a65(%rip), %edx      # 0x11644
imull $0x1a, 0x4a5e(%rip), %ecx # 0x11644
leaq 0x1082(%rip), %rsi      # 0xdc6f
movb $0x0, %al
callq 0x1120
leaq 0x3e85(%rip), %rax      # 0x10a80
movq (%rax), %rdi
movl 0x4a3c(%rip), %edx      # 0x11640
subl 0x4a3a(%rip), %edx      # 0x11644
movl 0x3a78(%rip), %ecx      # 0x10688
shll $0xc, %ecx
addl 0x3a73(%rip), %ecx      # 0x1068c
imull $0x1a, 0x4a24(%rip), %eax # 0x11644
subl %eax, %ecx
leaq 0x107a(%rip), %rsi      # 0xdca3
movb $0x0, %al
callq 0x1120
leaq 0x3d15(%rip), %rax      # 0x1094c
cmpl $0x0, (%rax)
jne 0xcc3e
jmp 0xcc61
leaq 0x3e3b(%rip), %rax      # 0x10a80
movq (%rax), %rdi
movslq 0x49f9(%rip), %rdx      # 0x11648
shlq $0x4, %rdx
leaq 0x1081(%rip), %rsi      # 0xdcdb
movb $0x0, %al
callq 0x1120
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
cmpl $0x4, -0x4(%rbp)
jge 0xccbf
movslq -0x4(%rbp), %rdx
leaq 0x3b80(%rip), %rax      # 0x1080c
movb (%rax,%rdx), %al
addb $0x1, %al
leaq 0x3b74(%rip), %rcx      # 0x1080c
movb %al, (%rcx,%rdx)
movsbl %al, %eax
cmpl $0x5a, %eax
jg 0xcca5
jmp 0xccbf
movslq -0x4(%rbp), %rcx
leaq 0x3b5c(%rip), %rax      # 0x1080c
movb $0x41, (%rax,%rcx)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcc7b
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/TomCrypto[P]avxfish/src/bench.c
// Function: encryption_speed
static void encryption_speed(void) {
  const size_t bufsize = 1024 * 1024 * 1024;
  const size_t trials = 25;
  double times = 0.0;

  __attribute__((aligned(64))) uint64_t subkeys[336];
  void *memory = aligned_memory_alloc(bufsize, 64);

  for (size_t i = 0; i < trials; ++i) {
    scribble_memory(subkeys, sizeof(subkeys));
    scribble_memory(memory, bufsize);

    double t0 = timestamp();

    for (size_t j = 0; j < bufsize / 128; ++j) {
      // 1024 bits = 128 bytes processed by iteration
      avxfish(((uint8_t *)memory) + 128 * j, subkeys);
    }

    double t1 = timestamp();
    times += t1 - t0;
  }

  aligned_free(memory);

  printf(": %.3f MB/s\n", trials * (bufsize / 1024.0 / 1024.0) / times);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0xb00, %rsp            # imm = 0xB00
movq $0x40000000, 0xae8(%rsp) # imm = 0x40000000
movq $0x19, 0xae0(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0xad8(%rsp)
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x40, %esi
callq 0x404060
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
cmpq $0x19, 0x30(%rsp)
jae 0x404030
leaq 0x40(%rsp), %rdi
movl $0xa80, %esi            # imm = 0xA80
callq 0x4040b0
movq 0x38(%rsp), %rdi
movl $0x40000000, %esi       # imm = 0x40000000
callq 0x4040b0
callq 0x404110
movsd %xmm0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
cmpq $0x800000, 0x20(%rsp)   # imm = 0x800000
jae 0x403ff4
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rax
shlq $0x7, %rax
addq %rax, %rdi
leaq 0x40(%rsp), %rsi
callq 0x4016c0
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x403fbe
callq 0x404110
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
addsd 0xad8(%rsp), %xmm0
movsd %xmm0, 0xad8(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x403f80
movq 0x38(%rsp), %rdi
callq 0x404150
movsd 0x95fc6(%rip), %xmm0    # 0x49a008
divsd 0xad8(%rsp), %xmm0
leaq 0x95fc6(%rip), %rdi     # 0x49a018
movb $0x1, %al
callq 0x40dfd0
movq %rbp, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/TomCrypto[P]avxfish/src/bench.c
// Function: aligned_memory_alloc
static void *aligned_memory_alloc(size_t size, size_t alignment) {
  void *ptr;

  if (posix_memalign(&ptr, alignment, size)) {
    printf("error: failed to allocate memory");
    exit(EXIT_FAILURE);
  }

  return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq -0x18(%rbp), %rdi
callq 0x424050
cmpl $0x0, %eax
je 0x40409e
leaq 0x95f98(%rip), %rdi     # 0x49a025
movb $0x0, %al
callq 0x40dfd0
movl $0x1, %edi
callq 0x40d4a0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
shrq $0x2, %rcx
cmpq %rcx, %rax
jae 0x404107
imull $0x7d1893, -0x14(%rbp), %eax # imm = 0x7D1893
addl $0xf51, %eax            # imm = 0xF51
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edx
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x4040cb
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/trivia0v2/ref/encrypt.c
// Function: load64
u64 load64(const u8 *Bytes)
{int i; u64 temp, 
Block=0;
Block = Bytes[0];
for(i = 1; i <8; i++) {Block <<= 8; Block = (Block)^(u64)(Bytes[i]);} return Block;}

// Assembly:
movq %rdi, -0x8(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movq %rax, -0x20(%rsp)
movl $0x1, -0xc(%rsp)
cmpl $0x8, -0xc(%rsp)
jge 0x1290
movq -0x20(%rsp), %rax
shlq $0x8, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq -0x8(%rsp), %rcx
movslq -0xc(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorq %rcx, %rax
movq %rax, -0x20(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1253
movq -0x20(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/trivia0v2/ref/encrypt.c
// Function: load32
u32 load32(const u8 *Bytes)
{int i; u32 temp, 
Block=0;
Block = (u8)Bytes[0];
for(i = 1; i <4; i++) {Block <<= 8; Block = (Block)^(u32)(Bytes[i]);} return Block;}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x8(%rsp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rsp)
movl $0x1, -0xc(%rsp)
cmpl $0x4, -0xc(%rsp)
jge 0x12f8
movl -0x14(%rsp), %eax
shll $0x8, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
movslq -0xc(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movl %eax, -0x14(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x12c1
movl -0x14(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_2/exercise_2_05/any.c
// Function: main
int main(void)
{
  char str1[MAXSTR] = "xxxabcabc";
  char str2[MAXSTR] = "cbaa";

  printf("%d", any(str1, str2));

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x7e0, %rsp            # imm = 0x7E0
movl $0x0, -0x4(%rbp)
leaq -0x3f0(%rbp), %rdi
leaq 0xe90(%rip), %rsi       # 0x2010
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x1050
leaq -0x7e0(%rbp), %rdi
xorl %esi, %esi
movl $0x3e8, %edx            # imm = 0x3E8
callq 0x1040
movb $0x63, -0x7e0(%rbp)
movb $0x62, -0x7df(%rbp)
movb $0x61, -0x7de(%rbp)
movb $0x61, -0x7dd(%rbp)
leaq -0x3f0(%rbp), %rdi
leaq -0x7e0(%rbp), %rsi
callq 0x11f0
movl %eax, %esi
leaq 0x1223(%rip), %rdi      # 0x23f8
movb $0x0, %al
callq 0x1030
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x126a
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x125d
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x1250
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1271
jmp 0x1252
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x121b
jmp 0x125f
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1203
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/shaswata56[P]BenchUtil/BenchmarkFLOPS32.c
// Function: main
int main (int argc, char** argv) {
    int n;
    if (argc == 1) {
        printf("Number of CPU cores to run Benchmark: ");
        scanf("%d", &n);
    } else {
        n = atoi(argv[1]);
    }
    printf("Benchmarking for 32 Bit Floating point operations per second\n");
    initFLOPS32(n);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x121e
leaq 0xe69(%rip), %rdi       # 0x206c
movb $0x0, %al
callq 0x1050
leaq 0xe82(%rip), %rdi       # 0x2093
leaq -0x14(%rbp), %rsi
movb $0x0, %al
callq 0x10b0
jmp 0x122e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
movl %eax, -0x14(%rbp)
leaq 0xe61(%rip), %rdi       # 0x2096
movb $0x0, %al
callq 0x1050
movl -0x14(%rbp), %edi
callq 0x1250
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/test/test_log.c
// Function: main
int main(int argc,char **argv)
{
	if (argc != 3) {
		help();
		return -1;
	}
	LOG_compBinFile(argv[1],argv[2],28*28*500*sizeof(float));
	
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x123a
callq 0x11e0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x125b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl $0x17ed00, %edx         # imm = 0x17ED00
callq 0x19a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x42, %esi
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x1080
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x1918
leaq 0x1753(%rip), %rdi      # 0x3048
leaq 0x1762(%rip), %rsi      # 0x305e
leaq 0x1791(%rip), %rdx      # 0x3094
movl $0x57, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1988
movq -0x18(%rbp), %rdi
callq 0x26e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
shlq $0x3, %rax
movl %eax, -0x2c(%rbp)
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x1050
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x1979
leaq 0x16f2(%rip), %rdi      # 0x3048
leaq 0x1701(%rip), %rsi      # 0x305e
leaq 0x1730(%rip), %rdx      # 0x3094
movl $0x5d, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1988
movl -0x1c(%rbp), %edi
callq 0x10d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xtanitfy[P]Murphy/src/blob.c
// Function: BLOB_shape
int BLOB_shape(BLOB_s *pBlob)
{
	CHECK_EXPR_RET(pBlob == NULL,-1);
	pBlob->data = (BLOB_DATA_TYPE *)malloc(sizeof(BLOB_DATA_TYPE)*pBlob->count);
	memset(pBlob->data,0,pBlob->count * sizeof(BLOB_DATA_TYPE));
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1efd
leaq 0x116e(%rip), %rdi      # 0x3048
leaq 0x1224(%rip), %rsi      # 0x3105
leaq 0x1262(%rip), %rdx      # 0x314a
movl $0x65, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1f3b
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
shlq $0x3, %rdi
callq 0x10b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x1070
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r9b, %al
movl 0x18(%rbp), %r9d
movl 0x10(%rbp), %r9d
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl 0x10(%rbp), %eax
shll %eax
cltq
addq %rax, %rcx
movq -0x30(%rbp), %r8
movl 0x18(%rbp), %eax
shll %eax
cltq
addq %rax, %r8
movsbl -0x31(%rbp), %r9d
callq 0x1c80
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
je 0x1fdf
leaq 0x108c(%rip), %rdi      # 0x3048
leaq 0x1142(%rip), %rsi      # 0x3105
leaq 0x114e(%rip), %rdx      # 0x3118
movl $0x30, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2005
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movl 0x10(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x38(%rax)
movl 0x18(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x3c(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2324
leaq 0xd4a(%rip), %rdi       # 0x3048
leaq 0xe00(%rip), %rsi       # 0x3105
leaq 0xe2f(%rip), %rdx       # 0x313b
movl $0x55, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23c5
cmpq $0x0, -0x18(%rbp)
jne 0x2355
leaq 0xd16(%rip), %rdi       # 0x3048
leaq 0xdcc(%rip), %rsi       # 0x3105
leaq 0xdfb(%rip), %rdx       # 0x313b
movl $0x56, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23c5
movl $0x40, %edi
callq 0x10b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x239d
leaq 0xcce(%rip), %rdi       # 0x3048
leaq 0xd84(%rip), %rsi       # 0x3105
leaq 0xdb3(%rip), %rdx       # 0x313b
movl $0x59, %ecx
movb $0x0, %al
callq 0x1030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x23c5
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl $0x40, %edx
callq 0x1090
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x1ec0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop