LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: print_type
void print_type(type *t){
	uint64_t d0;
	uint64_t d1;
	uint64_t d2;
	unsigned int index;
	unsigned int type_entry_int;

	d0 = t->d0;
	d1 = t->d1;
	d2 = t->d2;
	index = t->current_index;

	while(d0 | d1 | d2){
		type_entry_int = 0;
		if(d0&1){
			type_entry_int |= 1;
		}
		if(d1&1){
			type_entry_int |= 2;
		}
		if(d2&1){
			type_entry_int |= 4;
		}
		switch(type_entry_int){
			case type_void:
				printf("void, ");
				break;
			case type_int:
				printf("int, ");
				break;
			case type_char:
				printf("char, ");
				break;
			case type_pointer:
				printf("pointer to ");
				break;
			case type_function:
				printf("function ( ");
				break;
			case type_returns:
				printf(") returning ");
				break;
			case type_list:
				index--;
				printf("list of length %d of ", t->list_indicies[index]);
				break;
			default:
				printf("unknown ");
		}
		d0 >>= 1;
		d1 >>= 1;
		d2 >>= 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r13
movq 0x8(%rdi), %rbp
movq 0x10(%rdi), %r14
movl 0x38(%rdi), %r15d
leaq 0x17da(%rip), %r12      # 0x9010
movq %rbp, %rax
orq %r13, %rax
orq %r14, %rax
je 0x78cf
movl %r13d, %eax
andl $0x1, %eax
movl %ebp, %ecx
andl $0x1, %ecx
leal (%rax,%rcx,2), %eax
movl %r14d, %ecx
andl $0x1, %ecx
leal (%rax,%rcx,4), %eax
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
leaq 0x181d(%rip), %rdi      # 0x9089
jmp 0x78ba
leaq 0x17d9(%rip), %rdi      # 0x904e
jmp 0x78ba
leaq 0x17c3(%rip), %rdi      # 0x9041
jmp 0x78ba
leaq 0x17c0(%rip), %rdi      # 0x9047
jmp 0x78ba
decl %r15d
movl 0x18(%rbx,%r15,4), %esi
leaq 0x17db(%rip), %rdi      # 0x9073
xorl %eax, %eax
callq 0x10a0
jmp 0x78c1
leaq 0x1792(%rip), %rdi      # 0x903a
jmp 0x78ba
leaq 0x17a9(%rip), %rdi      # 0x905a
jmp 0x78ba
leaq 0x17ac(%rip), %rdi      # 0x9066
xorl %eax, %eax
callq 0x10a0
shrq %r13
shrq %rbp
shrq %r14
jmp 0x7836
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: parse_type
void parse_type(type *t, char **c, char *identifier_name, char *argument_names, unsigned int identifier_length, unsigned int num_arguments){
	skip_whitespace(c);
	if(!parse_datatype(t, c)){
		snprintf(error_message, sizeof(error_message), "Expected 'void', 'int', or 'char'");
		do_error(1);
	}

	skip_whitespace(c);

	parse_type_recursive(t, c, identifier_name, argument_names, identifier_length, num_arguments);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x7549
movq %r13, %rdi
movq %r12, %rsi
callq 0x7455
testb %al, %al
jne 0x793c
movups 0x1789(%rip), %xmm0     # 0x90a2
leaq 0x4bc0(%rip), %rax      # 0xc4e0
movaps %xmm0, 0x10(%rax)
movups 0x1767(%rip), %xmm0     # 0x9092
movaps %xmm0, (%rax)
movw $0x27, 0x20(%rax)
pushq $0x1
popq %rdi
callq 0x56c5
movq %r12, %rdi
callq 0x7549
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebp, %r8d
movl %ebx, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7966
// File: /workspace/github_c_makefile_star2_O2/been-jamming[P]MinimalCC/types.c
// Function: parse_type_arguments
void parse_type_arguments(type *t, char **c, char *argument_names, unsigned int identifier_length, unsigned int num_arguments){
	type temp_type = (type) {.d0 = 0, .d1 = 0, .d2 = 0};

	if(**c == ')'){
		return;
	}
	if(argument_names && !num_arguments){
		snprintf(error_message, sizeof(error_message), "Too many arguments!");
		do_error(1);;
	}
	parse_type(&temp_type, c, argument_names, NULL, identifier_length, 0);
	if(peek_type(&temp_type) == type_list){
		pop_type(&temp_type);
		temp_type.current_index--;
		add_type_entry(&temp_type, type_pointer);
	}
	skip_whitespace(c);
	if(**c == ','){
		++*c;
		skip_whitespace(c);
		if(argument_names && num_arguments){
			num_arguments--;
			argument_names += identifier_length;
		}
		parse_type_arguments(t, c, argument_names, identifier_length, num_arguments);
	} else if(**c != ')'){
		snprintf(error_message, sizeof(error_message), "Expected ',' or ')'\n");
		do_error(1);
	}

	append_type(t, temp_type);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
pxor %xmm0, %xmm0
movdqa %xmm0, 0x70(%rsp)
movdqa %xmm0, 0x60(%rsp)
movdqa %xmm0, 0x50(%rsp)
movdqa %xmm0, 0x40(%rsp)
movq (%rsi), %rax
cmpb $0x29, (%rax)
je 0x7df1
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
sete %al
testl %r8d, %r8d
setne %cl
orb %al, %cl
jne 0x7cd2
movdqu 0x1019(%rip), %xmm0     # 0x8cd1
leaq 0x4821(%rip), %rax      # 0xc4e0
movdqa %xmm0, (%rax)
movl $0x217374, 0x10(%rax)   # imm = 0x217374
pushq $0x1
popq %rdi
callq 0x56c5
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
movl %r14d, %r8d
xorl %r9d, %r9d
callq 0x78de
movl (%r13), %eax
movl 0x8(%r13), %ecx
andl $0x1, %eax
andl $0x1, %ecx
leal (%rax,%rcx,2), %eax
movl 0x10(%r13), %ecx
andl $0x1, %ecx
leal (%rax,%rcx,4), %eax
cmpl $0x7, %eax
jne 0x7d3e
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x761b
decl 0x38(%r13)
movdqa (%r13), %xmm0
paddq %xmm0, %xmm0
movdqa %xmm0, (%r13)
movq 0x10(%r13), %rax
leaq 0x1(,%rax,2), %rax
movq %rax, 0x10(%r13)
movq %r15, %rdi
callq 0x7549
movq (%r15), %rax
movzbl (%rax), %ecx
cmpl $0x29, %ecx
je 0x7dc0
cmpl $0x2c, %ecx
jne 0x7d97
testl %ebp, %ebp
setne %r13b
incq %rax
movq %rax, (%r15)
movq %r15, %rdi
callq 0x7549
testq %r12, %r12
setne %al
xorl %edx, %edx
andb %r13b, %al
movl %r14d, %ecx
cmovneq %rcx, %rdx
addq %r12, %rdx
movzbl %al, %eax
subl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %ecx
movl %ebp, %r8d
callq 0x7c58
jmp 0x7dc0
movdqu 0x1315(%rip), %xmm0     # 0x90b4
leaq 0x473a(%rip), %rax      # 0xc4e0
movdqa %xmm0, (%rax)
movabsq $0xa27292720726f, %rcx  # imm = 0xA27292720726F
movq %rcx, 0xd(%rax)
pushq $0x1
popq %rdi
callq 0x56c5
movdqa 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movaps 0x70(%rsp), %xmm3
movups %xmm3, 0x30(%rsp)
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movdqu %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x7279
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp-unpriv.c
// Function: probe_setup
void
probe_setup(struct event_base *parent_event_base)
{
	signal(SIGCHLD, SIG_IGN);
	if (regcomp(&re_reply,
	    "[0-9]+ bytes.*icmp_.eq=([0-9][0-9]*) .*time=([0-9].[0-9]*)",
	    REG_EXTENDED | REG_NEWLINE) != 0) {
		fprintf(stderr,
		    "regcomp: error compiling regular expression\n");
		exit(1);
	}
	if (regcomp(&re_other, "From .*icmp_.eq=([0-9][0-9]*)"
	    "( Destination Host Unreachable| Destination unreachable| )",
	    REG_EXTENDED | REG_NEWLINE) != 0) {
		fprintf(stderr,
		    "regcomp: error compiling regular expression\n");
		exit(1);
	}
	if (regcomp(&re_xmiterr, "(ping|ping6|connect): "
	    "(sentto|UDP connect|sendmsg|Network is unreachable)",
	    REG_EXTENDED | REG_NEWLINE) != 0) {
		fprintf(stderr,
		    "regcomp: error compiling regular expression\n");
		exit(1);
	}
}

// Assembly:
pushq %rax
pushq $0x11
popq %rdi
pushq $0x1
popq %rsi
callq 0x2210
leaq 0x44f1(%rip), %rdi      # 0x72a0
leaq 0x1347(%rip), %rsi      # 0x40fd
pushq $0x5
popq %rdx
callq 0x21f0
testl %eax, %eax
jne 0x2df8
leaq 0x4517(%rip), %rdi      # 0x72e0
leaq 0x1395(%rip), %rsi      # 0x4165
pushq $0x5
popq %rdx
callq 0x21f0
testl %eax, %eax
jne 0x2df8
leaq 0x453d(%rip), %rdi      # 0x7320
leaq 0x13d3(%rip), %rsi      # 0x41bd
pushq $0x5
popq %rdx
callq 0x21f0
testl %eax, %eax
jne 0x2df8
popq %rax
retq
movq 0x41d9(%rip), %rax      # 0x6fd8
movq (%rax), %rcx
leaq 0x132f(%rip), %rdi      # 0x4138
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x23d0
pushq $0x1
popq %rdi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp-unpriv.c
// Function: probe_new
struct probe *
probe_new(const char *line, void *owner)
{
	struct probe *prb;
	union addr sa;
	int salen;

	prb = calloc(1, sizeof(*prb));
	if (prb == NULL) {
		perror("malloc");
		return (NULL);
	}
	prb->fd = -1;
	prb->owner = owner;
	strncat(prb->host, line, sizeof(prb->host) - 1);
	prb->evbuf = evbuffer_new();
	if (prb->evbuf == NULL) {
		probe_free(prb);
		return NULL;
	}

	salen = sizeof(sa);
	if (evutil_parse_sockaddr_port(prb->host, &sa.sa, &salen) == 0) {
		sa(prb)->sa_family = sa.sa.sa_family;
		if (sa.sa.sa_family == AF_INET6) {
			memcpy(&sin6(prb)->sin6_addr, &sa.sin6.sin6_addr,
			    sizeof(sin6(prb)->sin6_addr));
		} else {
			memcpy(&sin(prb)->sin_addr, &sa.sin.sin_addr,
			    sizeof(sin(prb)->sin_addr));
		}
		prb->resolved = 1;
	} else {
		prb->dnstask = dnstask_new(prb->host, resolved, prb);
		if (prb->dnstask == NULL) {
			probe_free(prb);
			return NULL;
		}
	}
	return (prb);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
pushq $0x1
popq %rdi
movl $0x98, %esi
callq 0x2140
testq %rax, %rax
je 0x2f0d
movq %rax, %rbx
orl $-0x1, 0x64(%rax)
movq %r15, 0x90(%rax)
pushq $0x3f
popq %rdx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2150
callq 0x2040
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x2ecc
movq %rsp, %rdx
movl $0x1c, (%rdx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x2ed8
leaq 0xaf(%rip), %rsi        # 0x2f64
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x3d0c
movq %rax, 0x88(%rbx)
testq %rax, %rax
jne 0x2f00
movq %rbx, %rdi
callq 0x2f1b
xorl %ebx, %ebx
jmp 0x2f00
movzwl 0x4(%rsp), %eax
movw %ax, 0x44(%rbx)
cmpw $0xa, %ax
jne 0x2ef2
movups 0xc(%rsp), %xmm0
movups %xmm0, 0x4c(%rbx)
jmp 0x2ef9
movl 0x8(%rsp), %eax
movl %eax, 0x48(%rbx)
movl $0x1, 0x40(%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11d3(%rip), %rdi      # 0x40e7
callq 0x2180
jmp 0x2ed4
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp-unpriv.c
// Function: probe_free
void probe_free(struct probe *prb)
{

	if (prb->fd >= 0)
		close(prb->fd);
	if (prb->ev_read)
		event_free(prb->ev_read);
	if (prb->dnstask)
		dnstask_free(prb->dnstask);
	if (prb->evbuf)
		evbuffer_free(prb->evbuf);
	free(prb);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x64(%rdi), %edi
testl %edi, %edi
js 0x2f2b
callq 0x23e0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2f39
callq 0x2390
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x2f4a
callq 0x3e08
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x2f5b
callq 0x2090
movq %rbx, %rdi
popq %rbx
jmp 0x2220
// File: /workspace/github_c_makefile_star2_O2/martintopholm[P]xping/icmp-unpriv.c
// Function: resolved
static void
resolved(int af, void *address, void *thunk)
{
	struct probe *prb = thunk;
	if (af == AF_INET6) {
		if (sin6(prb)->sin6_family == AF_INET6 &&
		    memcmp(&sin6(prb)->sin6_addr, (struct in6_addr *)address,
		    sizeof(sin6(prb)->sin6_addr)) == 0)
			return;
		sin6(prb)->sin6_family = AF_INET6;
		memmove(&sin6(prb)->sin6_addr, (struct in6_addr *)address,
		    sizeof(sin6(prb)->sin6_addr));
		killping(prb);
		prb->resolved = 1;
	} else if (af == AF_INET) {
		if (sin(prb)->sin_family == AF_INET &&
		    memcmp(&sin(prb)->sin_addr, (struct in_addr *)address,
		    sizeof(sin(prb)->sin_addr)) == 0)
			return;
		sin(prb)->sin_family = AF_INET;
		memmove(&sin(prb)->sin_addr, (struct in_addr *)address,
		    sizeof(sin(prb)->sin_addr));
		killping(prb);
		prb->resolved = 1;
	} else if (af == 0) {
		prb->resolved = 0;
		killping(prb);
	}
	target_resolved(prb->owner, af, address);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %ebp
testl %edi, %edi
je 0x2fdf
cmpl $0x2, %ebp
je 0x2fb0
cmpl $0xa, %ebp
jne 0x2fec
cmpw $0xa, 0x44(%r14)
jne 0x2f9f
movdqu (%rbx), %xmm0
movdqu 0x4c(%r14), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x3001
movw $0xa, 0x44(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x4c(%r14)
jmp 0x2fcd
cmpw $0x2, 0x44(%r14)
jne 0x2fc0
movl 0x48(%r14), %eax
cmpl (%rbx), %eax
je 0x3001
movw $0x2, 0x44(%r14)
movl (%rbx), %eax
movl %eax, 0x48(%r14)
movq %r14, %rdi
callq 0x3426
movl $0x1, 0x40(%r14)
jmp 0x2fec
andl $0x0, 0x40(%r14)
movq %r14, %rdi
callq 0x3426
movq 0x90(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x25fb
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/marcespie[P]unix-samples/lab/pollsig2.c
// Function: main
int
main()
{
	struct pollfd pfd[1];

	int pip[2];
	errwrap(pipe(pip));

	int pid;

	errwrap(pid = fork());
	if (pid == 0) {
		sleep(5);
		fprintf(stderr, "Okay thxbye\n");
		exit(0);
	}
	signal(SIGCHLD, reaper);

	// now we "wait"

	pfd[0].fd = pip[0];
	pfd[0].events = POLLIN;
	int n = poll(pfd, 1, INFTIM);
	if (n == -1 && errno == EINTR) {
		fprintf(stderr, "Everything is okay\n");
	}
}

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rdi
callq 0x1040
cmpl $-0x1, %eax
je 0x1241
callq 0x10b0
testl %eax, %eax
je 0x124a
cmpl $-0x1, %eax
je 0x1275
leaq -0x2d(%rip), %rsi       # 0x11bc
pushq $0x11
popq %rdi
callq 0x1050
movl 0x8(%rsp), %eax
leaq 0x10(%rsp), %rdi
movl %eax, (%rdi)
movw $0x1, 0x4(%rdi)
pushq $0x1
popq %rsi
pushq $-0x1
popq %rdx
callq 0x1070
cmpl $-0x1, %eax
jne 0x121c
callq 0x1030
cmpl $0x4, (%rax)
je 0x1223
xorl %eax, %eax
addq $0x18, %rsp
retq
movq 0x2dce(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdf4(%rip), %rdi       # 0x2028
pushq $0x13
popq %rsi
pushq $0x1
popq %rdx
callq 0x1090
jmp 0x121c
leaq 0xdbc(%rip), %rsi       # 0x2004
jmp 0x127c
pushq $0x5
popq %rdi
callq 0x10a0
movq 0x2d9f(%rip), %rax      # 0x3ff8
movq (%rax), %rcx
leaq 0xdb8(%rip), %rdi       # 0x201b
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x1090
xorl %edi, %edi
callq 0x1080
leaq 0xd92(%rip), %rsi       # 0x200e
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.3/print-env.c
// Function: main
int main ()
{
  char** var;
  for (var = environ; *var != NULL; ++var)
    printf ("%s\n", *var);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x2e97(%rip), %rax      # 0x3fe0
movq (%rax), %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x115f
callq 0x1030
addq $0x8, %rbx
jmp 0x114c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/eridanhq[P]miraclelib/setfreq.c
// Function: main
int main(int argc, char *argv[])
{
	int memfd;
	void *mapped_base;

	double fLO_in;

	fLO_in = atof(argv[1]);

	memfd = open("/dev/mem", O_RDWR | O_SYNC);
	if (memfd == -1) {
		printf("Can't open /dev/mem.\n");
		exit(0);
	}

	// Map one page of memory into user space such that the device is in that page, but it may not
	// be at the start of the page
	mapped_base = mmap( (void *) MEM0_BASE_ADDRESS, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, memfd, SPI_BASE_ADDRESS);
	if (mapped_base == (void *) -1) {
		printf("Can't map the memory to user space.\n");
		exit(0);
	}

	/* ----------- INSERT CODE BELOW THIS LINE ------------ */

	set_freq_tx(fLO_in, mapped_base);

	/* ----------- INSERT CODE ABOVE THIS LINE ------------ */

	// Close memory
	if (munmap(mapped_base, MAP_SIZE) == -1) {
		printf("Can't unmap memory from user space.\n");
		exit(0);
	}
	close(memfd);

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rdi
callq 0x1070
movsd %xmm0, (%rsp)
leaq 0xd9f(%rip), %rdi       # 0x2004
movl $0x101002, %esi         # imm = 0x101002
xorl %eax, %eax
callq 0x1100
cmpl $-0x1, %eax
je 0x12cf
movl %eax, %ebx
pushq $0x3
popq %rdx
pushq $0x11
popq %rcx
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x400000, %esi         # imm = 0x400000
movl $0x64000000, %r9d       # imm = 0x64000000
movl %eax, %r8d
callq 0x1090
cmpq $-0x1, %rax
je 0x12d8
movq %rax, %r14
movsd (%rsp), %xmm0
movq %rax, %rdi
callq 0x1bb5
movl $0x400000, %esi         # imm = 0x400000
movq %r14, %rdi
callq 0x10f0
cmpl $-0x1, %eax
je 0x12e1
movl %ebx, %edi
callq 0x10d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xd7f(%rip), %rdi       # 0x2055
jmp 0x12e8
leaq 0xd52(%rip), %rdi       # 0x2031
jmp 0x12e8
leaq 0xd25(%rip), %rdi       # 0x200d
callq 0x1060
xorl %edi, %edi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]hash-prospector/hillclimb.c
// Function: usage
static void
usage(FILE *f)
{
    fprintf(f, "usage: hillclimb [-EhIqs] [-p INIT] [-x SEED]\n");
    fprintf(f, "  -E       Evaluate given pattern (-p)\n");
    fprintf(f, "  -h       Print this message and exit\n");
    fprintf(f, "  -I       Invert given pattern (-p) an quit\n");
    fprintf(f, "  -p INIT  Provide an initial hash function\n");
    fprintf(f, "  -q       Print less information (quiet)\n");
    fprintf(f, "  -s       Quit after finding a local minima\n");
    fprintf(f, "  -x SEED  Seed PRNG from a string (up to 32 bytes)\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x167b(%rip), %rdi      # 0x3170
pushq $0x2e
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1130
leaq 0x1691(%rip), %rdi      # 0x319f
pushq $0x27
popq %r15
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1130
leaq 0x16a0(%rip), %rdi      # 0x31c7
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1130
leaq 0x16b3(%rip), %rdi      # 0x31ef
pushq $0x2d
popq %r15
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1130
leaq 0x16c8(%rip), %rdi      # 0x321d
pushq $0x2c
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1130
leaq 0x16e0(%rip), %rdi      # 0x324a
pushq $0x2a
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1130
leaq 0x16f6(%rip), %rdi      # 0x3275
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1130
leaq 0x170f(%rip), %rdi      # 0x32a3
pushq $0x34
popq %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1130
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]hash-prospector/hillclimb.c
// Function: hash_print
static void
hash_print(const struct hash *h)
{
    putchar('[');
    for (int i = 0; i < HASHN; i++)
        printf("%2d %08lx ", h->s[i], (unsigned long)h->c[i]);
    printf("%2d]", h->s[HASHN]);
    fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x5b
popq %rdi
callq 0x1040
pushq $-0x3
popq %r15
leaq 0x143f(%rip), %r14      # 0x32d8
testq %r15, %r15
je 0x1eb8
movsbl 0xf(%rbx,%r15), %esi
movl 0xc(%rbx,%r15,4), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1070
incq %r15
jmp 0x1e99
movsbl 0xf(%rbx), %esi
leaq 0x1420(%rip), %rdi      # 0x32e3
xorl %eax, %eax
callq 0x1070
movq 0x3107(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]hash-prospector/hillclimb.c
// Function: exact_bias32
static double
exact_bias32(const struct hash *f)
{
    int i; // declare here to work around Visual Studio issue
    long long bins[32][32] = {{0}};
    static const uint64_t range = (UINT64_C(1) << 32) / EXACT_SPLIT;
    #pragma omp parallel for
    for (i = 0; i < EXACT_SPLIT; i++) {
        long long b[32][32] = {{0}};
        for (uint64_t x = i * range; x < (i + 1) * range; x++) {
            uint32_t h0 = hash(f, x);
            for (int j = 0; j < 32; j++) {
                uint32_t bit = UINT32_C(1) << j;
                uint32_t h1 = hash(f, x ^ bit);
                uint32_t set = h0 ^ h1;
                for (int k = 0; k < 32; k++)
                    b[j][k] += (set >> k) & 1;
            }
        }
        #pragma omp critical
        for (int j = 0; j < 32; j++)
            for (int k = 0; k < 32; k++)
                bins[j][k] += b[j][k];
    }
    double mean = 0.0;
    for (int j = 0; j < 32; j++) {
        for (int k = 0; k < 32; k++) {
            double diff = (bins[j][k] - 2147483648L) / 2147483648.0;
            mean += (diff * diff) / (32 * 32);
        }
    }
    return sqrt(mean) * 1000.0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4018, %rsp           # imm = 0x4018
movq %rdi, %rbx
leaq 0x2010(%rsp), %rdi
xorl %r13d, %r13d
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x1090
cmpq $0x20, %r13
je 0x1fd2
movl $0x2000, %edx           # imm = 0x2000
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x1090
movq %r13, %r12
shlq $0x1b, %r12
incq %r13
movq %r13, 0x8(%rsp)
shlq $0x1b, %r13
cmpq %r13, %r12
jae 0x1f8e
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2243
movl %eax, %ebp
leaq 0x10(%rsp), %r15
xorl %r14d, %r14d
cmpq $0x20, %r14
je 0x1f89
movl %r12d, %esi
btcl %r14d, %esi
movq %rbx, %rdi
callq 0x2243
xorl %ebp, %eax
xorl %ecx, %ecx
cmpq $0x20, %rcx
je 0x1f7d
btl %ecx, %eax
adcq $0x0, (%r15,%rcx,8)
incq %rcx
jmp 0x1f6a
incq %r14
addq $0x100, %r15            # imm = 0x100
jmp 0x1f51
incq %r12
jmp 0x1f37
leaq 0x2010(%rsp), %rax
leaq 0x10(%rsp), %rcx
xorl %edx, %edx
movq 0x8(%rsp), %r13
movl $0x100, %r8d            # imm = 0x100
cmpq $0x20, %rdx
je 0x1f09
xorl %esi, %esi
cmpq $0x20, %rsi
je 0x1fc7
movq (%rcx,%rsi,8), %rdi
addq %rdi, (%rax,%rsi,8)
incq %rsi
jmp 0x1fb4
incq %rdx
addq %r8, %rcx
addq %r8, %rax
jmp 0x1fa8
xorpd %xmm0, %xmm0
leaq 0x2010(%rsp), %rax
xorl %ecx, %ecx
movq $-0x80000000, %rdx      # imm = 0x80000000
movsd 0x1029(%rip), %xmm1     # 0x3018
movsd 0x1029(%rip), %xmm2     # 0x3020
cmpq $0x20, %rcx
je 0x2031
xorl %esi, %esi
cmpq $0x20, %rsi
je 0x2026
movq (%rax,%rsi,8), %rdi
addq %rdx, %rdi
cvtsi2sd %rdi, %xmm3
mulsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
mulsd %xmm2, %xmm3
addsd %xmm3, %xmm0
incq %rsi
jmp 0x1fff
incq %rcx
addq $0x100, %rax            # imm = 0x100
jmp 0x1ff7
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2041
sqrtsd %xmm0, %xmm0
jmp 0x2046
callq 0x1140
mulsd 0xfda(%rip), %xmm0      # 0x3028
addq $0x4018, %rsp           # imm = 0x4018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]hash-prospector/hillclimb.c
// Function: rng_init
static void
rng_init(uint64_t rng[4])
{
    void *p = malloc(1024L * 1024);
    rng[0] = uepoch();
    rng[1] = (uint64_t)rng_init;
    rng[2] = (uint64_t)rng;
    rng[3] = (uint64_t)p;
    free(p);
    mix64x4(rng);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x100000, %edi         # imm = 0x100000
callq 0x10e0
movq %rax, %r14
callq 0x125c
movq %rax, (%rbx)
leaq -0x23(%rip), %rax       # 0x2060
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ba7
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]hash-prospector/hillclimb.c
// Function: hash_equal
static int
hash_equal(const struct hash *a, const struct hash *b)
{
    for (int i = 0; i < HASHN; i++) {
        if (a->c[i] != b->c[i])
            return 0;
        if (a->s[i] != b->s[i])
            return 0;
    }
    return a->s[HASHN] == b->s[HASHN];
}

// Assembly:
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x3, %rcx
je 0x2237
movl (%rdi,%rcx,4), %edx
cmpl (%rsi,%rcx,4), %edx
jne 0x2236
movb 0xc(%rdi,%rcx), %dl
leaq 0x1(%rcx), %r8
cmpb 0xc(%rsi,%rcx), %dl
movq %r8, %rcx
je 0x2217
retq
movb 0xf(%rdi), %cl
xorl %eax, %eax
cmpb 0xf(%rsi), %cl
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]hash-prospector/hillclimb.c
// Function: hash
static uint32_t
hash(const struct hash *h, uint32_t x)
{
    for (int i = 0; i < HASHN; i++) {
        x ^= x >> h->s[i];
        x *= h->c[i];
    }
    x ^= x >> h->s[HASHN];
    return x;
}

// Assembly:
pushq $-0x3
popq %rax
testq %rax, %rax
je 0x2261
movb 0xf(%rdi,%rax), %cl
movl %esi, %edx
shrl %cl, %edx
xorl %esi, %edx
imull 0xc(%rdi,%rax,4), %edx
incq %rax
movl %edx, %esi
jmp 0x2246
movb 0xf(%rdi), %cl
movl %esi, %eax
shrl %cl, %eax
xorl %esi, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/test/fin.c
// Function: main
int main(int argc, const char* argv[]) {
    fin_ctx_t* ctx = fin_ctx_create_default();
    if (argc == 1)
        fin_ctx_eval_str(ctx, "void Main() { io.WriteLine(\"Hello, world!\"); }");
    else
        fin_ctx_eval_file(ctx, argv[1]);
    fin_ctx_destroy(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r15d
xorl %eax, %eax
callq 0x4d94
movq %rax, %rbx
cmpl $0x1, %r15d
jne 0x342d
leaq 0x5be1(%rip), %rsi      # 0x9004
movq %rbx, %rdi
callq 0x4e08
jmp 0x3439
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x4e4e
movq %rbx, %rdi
callq 0x4dcd
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_destroy
void fin_ast_destroy(fin_ast_module_t* mod) {
    fin_ast_func_destroy(mod, mod->funcs);
    fin_ast_enum_destroy(mod, mod->enums);
    fin_ast_type_destroy(mod, mod->types);
    fin_str_destroy(mod->ctx, mod->name);
    mod->ctx->alloc(mod, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
callq 0x37f6
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x3852
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x3896
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x79ab
movq (%rbx), %rax
movq (%rax), %rax
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_func_destroy
static void fin_ast_func_destroy(fin_ast_module_t* mod, fin_ast_func_t* func) {
    if (!func)
        return;
    fin_ast_func_destroy(mod, func->next);
    fin_str_destroy(mod->ctx, func->name);
    fin_ast_param_destroy(mod, func->params);
    fin_ast_stmt_destroy(mod, &func->block->base);
    fin_ast_type_ref_destroy(mod, func->ret);
    mod->ctx->alloc(func, 0);
}

// Assembly:
testq %rsi, %rsi
je 0x3851
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rsi
callq 0x37f6
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x79ab
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x4aa5
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x4ae9
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4bd0
movq (%r14), %rax
movq (%rax), %rax
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_enum_destroy
static void fin_ast_enum_destroy(fin_ast_module_t* mod, fin_ast_enum_t* en) {
    if (!en)
        return;
    fin_ast_enum_destroy(mod, en->next);
    fin_str_destroy(mod->ctx, en->name);
    fin_ast_enum_val_destroy(mod, en->values);
    mod->ctx->alloc(en, 0);
}

// Assembly:
testq %rsi, %rsi
je 0x3895
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0x3852
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x79ab
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4cbb
movq (%r14), %rax
movq (%rax), %rax
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_type_destroy
static void fin_ast_type_destroy(fin_ast_module_t* mod, fin_ast_type_t* type) {
    if (!type)
        return;
    fin_ast_type_destroy(mod, type->next);
    fin_str_destroy(mod->ctx, type->name);
    fin_ast_field_destroy(mod, type->fields);
    mod->ctx->alloc(type, 0);
}

// Assembly:
testq %rsi, %rsi
je 0x38d9
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0x3896
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x79ab
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4cff
movq (%r14), %rax
movq (%rax), %rax
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_expect
static void fin_ast_expect(fin_lex_t* lex, fin_lex_type_t type) {
    if (fin_lex_get_type(lex) == type) {
        fin_lex_next(lex);
        return;
    }
    assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
callq 0x5559
cmpl %r14d, %eax
jne 0x38fd
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4f82
leaq 0x57bd(%rip), %rdi      # 0x90c1
leaq 0x57b8(%rip), %rsi      # 0x90c3
leaq 0x57bf(%rip), %rcx      # 0x90d1
pushq $0x18
popq %rdx
callq 0x3120
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_generics
static fin_ast_generic_t* fin_ast_parse_generics(fin_ctx_t* ctx, fin_lex_t* lex) {
    if (!fin_lex_match(lex, fin_lex_type_lt))
        return NULL;
    fin_ast_generic_t*  gen  = NULL;
    fin_ast_generic_t** tail = &gen;
    while (true) {
        *tail = (fin_ast_generic_t*)ctx->alloc(NULL, sizeof(fin_ast_generic_t));
        (*tail)->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
        tail = &(*tail)->next;
        if (!fin_lex_match(lex, fin_lex_type_comma))
            break;
    }
    fin_ast_expect(lex, fin_lex_type_gt);
    return gen;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x26
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x399c
leaq -0x30(%rbp), %r13
andq $0x0, (%r13)
pushq $0x10
popq %r15
pushq $0x9
popq %r12
xorl %edi, %edi
movl %r15d, %esi
callq *(%r14)
movq %rax, (%r13)
movq %rbx, %rdi
callq 0x55f7
movq %r14, %rdi
movq %rax, %rsi
callq 0x781e
movq (%r13), %rcx
movq %rax, (%rcx)
movq (%r13), %r13
addq $0x8, %r13
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5537
testb %al, %al
jne 0x394e
pushq $0x2a
popq %rsi
movq %rbx, %rdi
callq 0x38da
movq -0x30(%rbp), %rax
jmp 0x399e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_type_ref
static fin_ast_type_ref_t* fin_ast_parse_type_ref(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_type_ref_t* type = (fin_ast_type_ref_t*)ctx->alloc(NULL, sizeof(fin_ast_type_ref_t));
    type->module = NULL;
    type->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    if (fin_lex_match(lex, fin_lex_type_dot)) {
        type->module = type->name;
        type->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    }
    return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x10
popq %rsi
xorl %edi, %edi
callq *(%rbx)
movq %rax, %r14
andq $0x0, (%rax)
movq %r15, %rdi
callq 0x55f7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x781e
movq %rax, 0x8(%r14)
pushq $0x8
popq %rsi
movq %r15, %rdi
callq 0x5537
testb %al, %al
je 0x3a0f
movq 0x8(%r14), %rax
movq %rax, (%r14)
movq %r15, %rdi
callq 0x55f7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x781e
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_expr
static fin_ast_expr_t* fin_ast_parse_expr(fin_ctx_t* ctx, fin_lex_t* lex, fin_ast_expr_t* expr) {
    if (!expr)
        expr = fin_ast_parse_cond_or_expr(ctx, lex);
    switch (fin_lex_get_type(lex)) {
        case fin_lex_type_question:
            return fin_ast_parse_cond_expr(ctx, lex, expr);
        case fin_lex_type_dot:
            return fin_ast_parse_id_expr(ctx, lex, expr);
        case fin_lex_type_l_paren:
            return fin_ast_parse_invoke_expr(ctx, lex, expr);
        case fin_lex_type_eq:
        case fin_lex_type_plus_eq:
        case fin_lex_type_minus_eq:
        case fin_lex_type_star_eq:
        case fin_lex_type_slash_eq:
        case fin_lex_type_percent_eq:
        case fin_lex_type_amp_eq:
        case fin_lex_type_pipe_eq:
        case fin_lex_type_caret_eq:
        case fin_lex_type_lt_lt_eq:
        case fin_lex_type_gt_gt_eq:
            return fin_ast_parse_assign_expr(ctx, lex, expr);
        default:
            return expr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
jne 0x3a44
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b10
movq %rax, %r15
movq %rbx, %rdi
callq 0x5559
cmpl $0x2e, %eax
ja 0x3a9b
movl %eax, %ecx
movabsq $0x223fc0010000, %rdx   # imm = 0x223FC0010000
btq %rcx, %rdx
jae 0x3a79
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3c73
cmpq $0xa, %rcx
je 0x3ab6
cmpq $0x2e, %rcx
jne 0x3a9b
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3bdd
cmpl $0x8, %eax
jne 0x3b04
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3b75
pushq $0x20
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movl $0x8, (%rax)
movq %r15, 0x8(%rax)
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x38da
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b10
movq %rax, 0x10(%r12)
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x38da
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b10
movq %rax, 0x18(%r12)
movq %r12, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_cond_or_expr
static fin_ast_expr_t* fin_ast_parse_cond_or_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_cond_and_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_pipe_pipe))
        op = fin_ast_binary_type_or;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_cond_or_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3dbd
movq %rax, %r15
pushq $0x1a
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3b69
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movabsq $0x1100000007, %rax     # imm = 0x1100000007
movq %rax, (%r12)
movq %r15, 0x8(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3b10
movq %rax, 0x10(%r12)
movq %r12, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_id_expr
static fin_ast_expr_t* fin_ast_parse_id_expr(fin_ctx_t* ctx, fin_lex_t* lex, fin_ast_expr_t* primary) {
    fin_ast_id_expr_t* id_expr = (fin_ast_id_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_id_expr_t));
    id_expr->base.type = fin_ast_expr_type_id;
    id_expr->primary = primary;
    id_expr->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    if (fin_lex_match(lex, fin_lex_type_dot))
        return fin_ast_parse_id_expr(ctx, lex, &id_expr->base);
    return &id_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %r13
movq %r15, %r12
xorl %edi, %edi
pushq $0x18
popq %rsi
callq *(%r14)
movq %rax, %r15
andl $0x0, (%rax)
movq %r12, 0x8(%rax)
movq %rbx, %rdi
callq 0x55f7
movq %r14, %rdi
movq %rax, %rsi
callq 0x781e
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5537
testb %al, %al
jne 0x3b90
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_invoke_expr
static fin_ast_expr_t* fin_ast_parse_invoke_expr(fin_ctx_t* ctx, fin_lex_t* lex, fin_ast_expr_t* id) {
    fin_ast_invoke_expr_t* invoke_expr = (fin_ast_invoke_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_invoke_expr_t));
    invoke_expr->base.type = fin_ast_expr_type_invoke;
    invoke_expr->id = id;
    fin_ast_expect(lex, fin_lex_type_l_paren);
    fin_ast_arg_expr_t** tail = &invoke_expr->args;
    *tail = NULL;
    while (!fin_lex_match(lex, fin_lex_type_r_paren)) {
        if (invoke_expr->args)
            fin_ast_expect(lex, fin_lex_type_comma);
        *tail = fin_ast_parse_arg_expr(ctx, lex);
        tail = &(*tail)->next;
    }
    return &invoke_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r13
movl $0xa, (%rax)
movq %r12, 0x8(%rax)
pushq $0x2e
popq %rsi
movq %rbx, %rdi
callq 0x38da
andq $0x0, 0x10(%r13)
movq %r13, -0x30(%rbp)
addq $0x10, %r13
pushq $0x2f
popq %r12
movq %r13, %r15
movq %rbx, %rdi
movl %r12d, %esi
callq 0x5537
testb %al, %al
jne 0x3c60
cmpq $0x0, (%r13)
je 0x3c49
movq %rbx, %rdi
pushq $0x9
popq %rsi
callq 0x38da
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44e2
movq %rax, (%r15)
addq $0x10, %rax
movq %rax, %r15
jmp 0x3c28
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_cond_and_expr
static fin_ast_expr_t* fin_ast_parse_cond_and_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_or_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_amp_amp))
        op = fin_ast_binary_type_and;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_cond_and_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3e22
movq %rax, %r15
pushq $0x1b
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3e16
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movabsq $0x1000000007, %rax     # imm = 0x1000000007
movq %rax, (%r12)
movq %r15, 0x8(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3dbd
movq %rax, 0x10(%r12)
movq %r12, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_or_expr
static fin_ast_expr_t* fin_ast_parse_or_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_xor_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_pipe))
        op = fin_ast_binary_type_bor;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_or_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3e87
movq %rax, %r15
pushq $0x16
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3e7b
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movabsq $0xe00000007, %rax      # imm = 0xE00000007
movq %rax, (%r12)
movq %r15, 0x8(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e22
movq %rax, 0x10(%r12)
movq %r12, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_xor_expr
static fin_ast_expr_t* fin_ast_parse_xor_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_and_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_caret))
        op = fin_ast_binary_type_bxor;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_xor_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3eec
movq %rax, %r15
pushq $0xd
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3ee0
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movabsq $0xf00000007, %rax      # imm = 0xF00000007
movq %rax, (%r12)
movq %r15, 0x8(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e87
movq %rax, 0x10(%r12)
movq %r12, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_and_expr
static fin_ast_expr_t* fin_ast_parse_and_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_equality_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_amp))
        op = fin_ast_binary_type_eq;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_and_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3f51
movq %rax, %r15
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3f45
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movabsq $0xb00000007, %rax      # imm = 0xB00000007
movq %rax, (%r12)
movq %r15, 0x8(%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3eec
movq %rax, 0x10(%r12)
movq %r12, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_equality_expr
static fin_ast_expr_t* fin_ast_parse_equality_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_relational_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_eq_eq))
        op = fin_ast_binary_type_eq;
    else if (fin_lex_match(lex, fin_lex_type_bang_eq))
        op = fin_ast_binary_type_neq;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_equality_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4049
movq %rax, %r15
pushq $0x26
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3f80
pushq $0x7
jmp 0x3fb7
pushq $0x2a
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3f93
pushq $0x9
jmp 0x3fb7
pushq $0x28
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3fa6
pushq $0x8
jmp 0x3fb7
pushq $0x2c
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3fe5
pushq $0xa
popq %r13
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movl $0x7, (%rax)
movl %r13d, 0x4(%rax)
movq %r15, 0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4049
movq %rax, 0x10(%r12)
movq %r12, %r15
pushq $0x1c
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x3ff8
pushq $0xb
jmp 0x4009
pushq $0x1d
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x4037
pushq $0xc
popq %r13
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movl $0x7, (%rax)
movl %r13d, 0x4(%rax)
movq %r15, 0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f51
movq %rax, 0x10(%r12)
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_shift_expr
static fin_ast_expr_t* fin_ast_parse_shift_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_additive_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_lt_lt))
        op = fin_ast_binary_type_shl;
    else if (fin_lex_match(lex, fin_lex_type_gt_gt))
        op = fin_ast_binary_type_shr;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_shift_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x40c9
movq %rax, %r15
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x4078
pushq $0x5
jmp 0x4089
pushq $0x2b
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x40b7
pushq $0x6
popq %r13
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movl $0x7, (%rax)
movl %r13d, 0x4(%rax)
movq %r15, 0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4049
movq %rax, 0x10(%r12)
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_additive_expr
static fin_ast_expr_t* fin_ast_parse_additive_expr(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_expr_t* lhs = fin_ast_parse_multiplicative_expr(ctx, lex);
    fin_ast_binary_type_t op;
    if (fin_lex_match(lex, fin_lex_type_plus))
        op = fin_ast_binary_type_add;
    else if (fin_lex_match(lex, fin_lex_type_minus))
        op = fin_ast_binary_type_sub;
    else
        return lhs;
    fin_ast_binary_expr_t* bin_expr = (fin_ast_binary_expr_t*)ctx->alloc(NULL, sizeof(fin_ast_binary_expr_t));
    bin_expr->base.type = fin_ast_expr_type_binary;
    bin_expr->op = op;
    bin_expr->lhs = lhs;
    bin_expr->rhs = fin_ast_parse_additive_expr(ctx, lex);
    return &bin_expr->base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4148
movq %rax, %r15
pushq $0x12
popq %rsi
movq %rbx, %rdi
callq 0x5537
xorl %r13d, %r13d
testb %al, %al
jne 0x410a
pushq $0x13
popq %rsi
movq %rbx, %rdi
callq 0x5537
testb %al, %al
je 0x4136
pushq $0x1
popq %r13
pushq $0x18
popq %rsi
xorl %edi, %edi
callq *(%r14)
movq %rax, %r12
movl $0x7, (%rax)
movl %r13d, 0x4(%rax)
movq %r15, 0x8(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40c9
movq %rax, 0x10(%r12)
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq