LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movl %r9d, (%rsp)
movq 0x18(%rsp), %rdi
callq 0xbb70
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xb980
cmpb $0x0, %al
jne 0xc3d2
leaq 0x517b(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0x1ee1(%rip), %rdx      # 0xe2a2
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x18(%rsp), %rdi
callq 0xbb70
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movl 0x4(%rsp), %r8d
movl (%rsp), %r9d
callq 0xc410
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movl %ecx, 0x8c(%rsp)
movl %r8d, 0x88(%rsp)
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x10c0
movq 0x98(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
jne 0xc857
jmp 0xca11
cmpq $0x0, 0x90(%rsp)
je 0xc890
cmpl $0x0, 0x88(%rsp)
jne 0xc890
leaq 0x4cbd(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0x1676(%rip), %rdx      # 0xdef5
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
movl 0x8c(%rsp), %r8d
leaq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
xorl %r9d, %r9d
callq 0xc370
leaq 0x48(%rsp), %rdi
callq 0xbdb0
cmpl $0x7, %eax
jne 0xc8f2
leaq 0x48(%rsp), %rdi
callq 0xbe20
movl 0x80(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x80(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x4, %esi
callq 0xb510
movq 0x98(%rsp), %rdi
callq 0xbb70
movq 0x98(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2c, %eax
jne 0xc9a5
movq 0x98(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x98(%rsp), %rdi
callq 0xbb70
cmpq $0x0, 0x90(%rsp)
je 0xc977
cmpl $0x0, 0x88(%rsp)
je 0xc977
movl 0x88(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x88(%rsp)
movl 0x8c(%rsp), %ecx
movq 0x90(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x90(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %rsi
movq 0x90(%rsp), %rdx
movl 0x8c(%rsp), %ecx
movl 0x88(%rsp), %r8d
callq 0xc800
jmp 0xc9de
movq 0x98(%rsp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
je 0xc9dc
leaq 0x4b71(%rip), %rdi      # 0x11530
movl $0x100, %esi            # imm = 0x100
leaq 0x18f9(%rip), %rdx      # 0xe2c4
movb $0x0, %al
callq 0x10b0
movl $0x1, %edi
callq 0x87b0
jmp 0xc9de
movq 0xa0(%rsp), %rdi
movups 0x48(%rsp), %xmm0
movups 0x58(%rsp), %xmm1
movups 0x68(%rsp), %xmm2
movups 0x78(%rsp), %xmm3
movq %rsp, %rax
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xb630
addq $0xa8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x11, %edi
movl $0x1, %esi
callq 0x2210
leaq 0x3fe6(%rip), %rdi      # 0x7298
leaq 0x1f30(%rip), %rsi      # 0x51e9
movl $0x5, %edx
callq 0x21f0
cmpl $0x0, %eax
je 0x32ea
movq 0x3d09(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
leaq 0x1f4b(%rip), %rsi      # 0x5224
movb $0x0, %al
callq 0x2310
movl $0x1, %edi
callq 0x2230
leaq 0x3fe7(%rip), %rdi      # 0x72d8
leaq 0x1f59(%rip), %rsi      # 0x5251
movl $0x5, %edx
callq 0x21f0
cmpl $0x0, %eax
je 0x3329
movq 0x3cca(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
leaq 0x1f0c(%rip), %rsi      # 0x5224
movb $0x0, %al
callq 0x2310
movl $0x1, %edi
callq 0x2230
leaq 0x3fe8(%rip), %rdi      # 0x7318
leaq 0x1f72(%rip), %rsi      # 0x52a9
movl $0x5, %edx
callq 0x21f0
cmpl $0x0, %eax
je 0x3368
movq 0x3c8b(%rip), %rax      # 0x6fd8
movq (%rax), %rdi
leaq 0x1ecd(%rip), %rsi      # 0x5224
movb $0x0, %al
callq 0x2310
movl $0x1, %edi
callq 0x2230
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x98, %esi
callq 0x2140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x33e3
leaq 0x1e02(%rip), %rdi      # 0x51d3
callq 0x2190
movq $0x0, -0x8(%rbp)
jmp 0x34f2
movq -0x20(%rbp), %rax
movl $0xffffffff, 0x64(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x3f, %edx
callq 0x2150
callq 0x2040
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x80(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x80(%rax)
jne 0x3446
movq -0x20(%rbp), %rdi
callq 0x3500
movq $0x0, -0x8(%rbp)
jmp 0x34f2
movl $0x1c, -0x40(%rbp)
movq -0x20(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x20b0
cmpl $0x0, %eax
jne 0x34a5
movw -0x3c(%rbp), %cx
movq -0x20(%rbp), %rax
movw %cx, 0x44(%rax)
movzwl -0x3c(%rbp), %eax
cmpl $0xa, %eax
jne 0x348e
movq -0x20(%rbp), %rax
movq -0x34(%rbp), %rcx
movq %rcx, 0x4c(%rax)
movq -0x2c(%rbp), %rcx
movq %rcx, 0x54(%rax)
jmp 0x3498
movq -0x20(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, 0x48(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x40(%rax)
jmp 0x34ea
movq -0x20(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0xdc(%rip), %rsi        # 0x3590
callq 0x4b10
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x88(%rax)
jne 0x34e8
movq -0x20(%rbp), %rdi
callq 0x3500
movq $0x0, -0x8(%rbp)
jmp 0x34f2
jmp 0x34ea
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
jl 0x3522
movq -0x8(%rbp), %rax
movl 0x64(%rax), %edi
callq 0x23d0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x353a
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x2390
movq -0x8(%rbp), %rax
cmpq $0x0, 0x88(%rax)
je 0x3558
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x4cb0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x80(%rax)
je 0x3576
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rdi
callq 0x2090
movq -0x8(%rbp), %rdi
callq 0x2220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0xa, -0x4(%rbp)
jne 0x362a
movq -0x20(%rbp), %rax
movzwl 0x44(%rax), %eax
cmpl $0xa, %eax
jne 0x35f1
movq -0x20(%rbp), %rax
addq $0x44, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movups (%rcx), %xmm1
movups (%rax), %xmm0
pcmpeqb %xmm1, %xmm0
pmovmskb %xmm0, %eax
subl $0xffff, %eax           # imm = 0xFFFF
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x35f1
jmp 0x36c9
movq -0x20(%rbp), %rax
movw $0xa, 0x44(%rax)
movq -0x20(%rbp), %rax
addq $0x44, %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x20(%rbp), %rdi
callq 0x3d70
movq -0x20(%rbp), %rax
movl $0x1, 0x40(%rax)
jmp 0x36b2
cmpl $0x2, -0x4(%rbp)
jne 0x3694
movq -0x20(%rbp), %rax
movzwl 0x44(%rax), %eax
cmpl $0x2, %eax
jne 0x3660
movq -0x20(%rbp), %rax
addq $0x44, %rax
addq $0x4, %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl (%rax), %eax
subl %ecx, %eax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x3660
jmp 0x36c9
movq -0x20(%rbp), %rax
movw $0x2, 0x44(%rax)
movq -0x20(%rbp), %rax
addq $0x44, %rax
addq $0x4, %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rdi
callq 0x3d70
movq -0x20(%rbp), %rax
movl $0x1, 0x40(%rax)
jmp 0x36b0
cmpl $0x0, -0x4(%rbp)
jne 0x36ae
movq -0x20(%rbp), %rax
movl $0x0, 0x40(%rax)
movq -0x20(%rbp), %rdi
callq 0x3d70
jmp 0x36b0
jmp 0x36b2
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rdi
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x2700
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/martintopholm[P]xping/icmp-unpriv.c
// Function: execping
static void
execping(struct probe *prb)
{
	char address[64];
	char interval[24];

	evutil_snprintf(interval, sizeof(interval), "%f",
	    (double)i_interval/1000);

	if (sa(prb)->sa_family == AF_INET6) {
		evutil_inet_ntop(sa(prb)->sa_family, &sin6(prb)->sin6_addr,
		    address, sizeof(address));
		execlp("ping6", "ping6", "-ni", interval, address, NULL);
	} else {
		evutil_inet_ntop(sa(prb)->sa_family, &sin(prb)->sin_addr,
		    address, sizeof(address));
		execlp("ping", "ping", "-ni", interval, address, NULL);
	}
	exit(1); /* in case exec fails */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0x3571(%rip), %rax      # 0x7208
cvtsi2sdl (%rax), %xmm0
movsd 0x1365(%rip), %xmm1     # 0x5008
divsd %xmm1, %xmm0
movl $0x18, %esi
leaq 0x168f(%rip), %rdx      # 0x5342
movb $0x1, %al
callq 0x2110
movq -0x8(%rbp), %rax
movzwl 0x44(%rax), %eax
cmpl $0xa, %eax
jne 0x3d10
movq -0x8(%rbp), %rax
movzwl 0x44(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x44, %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %rdx
movl $0x40, %ecx
callq 0x23c0
leaq -0x70(%rbp), %rcx
leaq -0x50(%rbp), %r8
leaq 0x164d(%rip), %rsi      # 0x5345
leaq 0x164c(%rip), %rdx      # 0x534b
xorl %eax, %eax
movl %eax, %r9d
movq %rsi, %rdi
movb $0x0, %al
callq 0x2070
jmp 0x3d57
movq -0x8(%rbp), %rax
movzwl 0x44(%rax), %edi
movq -0x8(%rbp), %rsi
addq $0x44, %rsi
addq $0x4, %rsi
leaq -0x50(%rbp), %rdx
movl $0x40, %ecx
callq 0x23c0
leaq -0x70(%rbp), %rcx
leaq -0x50(%rbp), %r8
leaq 0x1489(%rip), %rsi      # 0x51ca
leaq 0x1603(%rip), %rdx      # 0x534b
xorl %eax, %eax
movl %eax, %r9d
movq %rsi, %rdi
movb $0x0, %al
callq 0x2070
movl $0x1, %edi
callq 0x2230
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x1040
cmpl $-0x1, %eax
jne 0x1200
movl $0x1, %edi
leaq 0xe0b(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1070
jmp 0x1202
jmp 0x1204
callq 0x10b0
movl %eax, -0x18(%rbp)
cmpl $-0x1, %eax
jne 0x1224
movl $0x1, %edi
leaq 0xdf1(%rip), %rsi       # 0x200e
movb $0x0, %al
callq 0x1070
jmp 0x1226
cmpl $0x0, -0x18(%rbp)
jne 0x1255
movl $0x5, %edi
callq 0x10a0
movq 0x2dbb(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xdd4(%rip), %rsi       # 0x201b
movb $0x0, %al
callq 0x1060
xorl %edi, %edi
callq 0x1090
movl $0x11, %edi
leaq -0xa1(%rip), %rsi       # 0x11c0
callq 0x1050
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movw $0x1, -0x8(%rbp)
leaq -0xc(%rbp), %rdi
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1080
movl %eax, -0x1c(%rbp)
cmpl $-0x1, -0x1c(%rbp)
jne 0x12b0
callq 0x1030
cmpl $0x4, (%rax)
jne 0x12b0
movq 0x2d59(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xd7f(%rip), %rsi       # 0x2028
movb $0x0, %al
callq 0x1060
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e8a(%rip), %rax      # 0x3fe0
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x118a
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xe8f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
jmp 0x115d
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x14c8(%rip), %rsi      # 0x324f
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x14e5(%rip), %rsi      # 0x327e
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x14fb(%rip), %rsi      # 0x32a6
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x1511(%rip), %rsi      # 0x32ce
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x152d(%rip), %rsi      # 0x32fc
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x1548(%rip), %rsi      # 0x3329
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x1561(%rip), %rsi      # 0x3354
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
leaq 0x157d(%rip), %rsi      # 0x3382
movb $0x0, %al
callq 0x10c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hillclimb.c
// Function: hash_parse
static int
hash_parse(struct hash *h, char *str)
{
    long s;
    unsigned long c;
    char *end, *tok;
    if (*str != '[')
        return 0;
    str++;
    for (int i = 0; i < HASHN; i++) {
        tok = strtok(i ? 0 : str, " ");
        s = strtol(tok, &end, 10);
        if (s < 1 || s > 31 || !(*end == 0 || *end == ' '))
            return 0;
        h->s[i] = s;
        tok = strtok(0, " ");
        c = strtoul(tok, &end, 16);
        if (c > 0xffffffffUL || !(*end == 0 || *end == ' '))
            return 0;
        h->c[i] = c;
    }
    tok = strtok(0, "]");
    s = strtol(tok, &end, 10);
    if (s < 1 || s > 31 || *end)
        return 0;
    h->s[HASHN] = s;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5b, %eax
je 0x1e48
movl $0x0, -0x4(%rbp)
jmp 0x1fc2
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x3c(%rbp)
cmpl $0x3, -0x3c(%rbp)
jge 0x1f61
cmpl $0x0, -0x3c(%rbp)
je 0x1e73
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x1e7b
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
leaq 0x1376(%rip), %rsi      # 0x31fc
callq 0x1110
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x10d0
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jl 0x1ecb
cmpq $0x1f, -0x20(%rbp)
jg 0x1ecb
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1ed7
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x1ed7
movl $0x0, -0x4(%rbp)
jmp 0x1fc2
movq -0x20(%rbp), %rax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb %dl, 0xc(%rax,%rcx)
xorl %eax, %eax
movl %eax, %edi
leaq 0x1308(%rip), %rsi      # 0x31fc
callq 0x1110
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0x10, %edx
callq 0x1120
movq %rax, -0x28(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x28(%rbp)
ja 0x1f36
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1f42
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x1f42
movl $0x0, -0x4(%rbp)
jmp 0x1fc2
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1e5b
xorl %eax, %eax
movl %eax, %edi
leaq 0x1459(%rip), %rsi      # 0x33c5
callq 0x1110
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movl $0xa, %edx
callq 0x10d0
movq %rax, -0x20(%rbp)
cmpq $0x1, -0x20(%rbp)
jl 0x1fa5
cmpq $0x1f, -0x20(%rbp)
jg 0x1fa5
movq -0x30(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x1fae
movl $0x0, -0x4(%rbp)
jmp 0x1fc2
movq -0x20(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0xf(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hillclimb.c
// Function: load64
static uint64_t
load64(const void *buf)
{
    const unsigned char *p = buf;
    return (uint64_t)p[0] <<  0 |
           (uint64_t)p[1] <<  8 |
           (uint64_t)p[2] << 16 |
           (uint64_t)p[3] << 24 |
           (uint64_t)p[4] << 32 |
           (uint64_t)p[5] << 40 |
           (uint64_t)p[6] << 48 |
           (uint64_t)p[7] << 56;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shlq $0x0, %rax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shlq $0x18, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x4(%rcx), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
shlq $0x28, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
shlq $0x30, %rcx
orq %rcx, %rax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
shlq $0x38, %rcx
orq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hillclimb.c
// Function: modinv32
static uint32_t
modinv32(uint32_t x)
{
    uint32_t a = x;
    x += x - a * x * x;
    x += x - a * x * x;
    x += x - a * x * x;
    x += x - a * x * x;
    x += x - a * x * x;
    return x;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
imull -0x4(%rbp), %ecx
imull -0x4(%rbp), %ecx
subl %ecx, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
imull -0x4(%rbp), %ecx
imull -0x4(%rbp), %ecx
subl %ecx, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
imull -0x4(%rbp), %ecx
imull -0x4(%rbp), %ecx
subl %ecx, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
imull -0x4(%rbp), %ecx
imull -0x4(%rbp), %ecx
subl %ecx, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl -0x8(%rbp), %ecx
imull -0x4(%rbp), %ecx
imull -0x4(%rbp), %ecx
subl %ecx, %eax
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x5b, %edi
callq 0x1040
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x2486
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %esi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, %edx
leaq 0xf43(%rip), %rdi       # 0x33b7
movb $0x0, %al
callq 0x1080
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x244d
movq -0x8(%rbp), %rax
movsbl 0xf(%rax), %esi
leaq 0xf2d(%rip), %rdi       # 0x33c2
movb $0x0, %al
callq 0x1080
movq 0x2b35(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
callq 0x1100
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x100000, %edi         # imm = 0x100000
callq 0x10f0
movq %rax, -0x10(%rbp)
callq 0x1260
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq -0x34(%rip), %rcx       # 0x27d0
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x28ee
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x28ba
movl $0x0, -0x4(%rbp)
jmp 0x290b
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl 0xc(%rax,%rcx), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsbl 0xc(%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x28e1
movl $0x0, -0x4(%rbp)
jmp 0x290b
jmp 0x28e3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2893
movq -0x10(%rbp), %rax
movsbl 0xf(%rax), %eax
movq -0x18(%rbp), %rcx
movsbl 0xf(%rcx), %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x29dd
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
movsbl 0xc(%rcx,%rdx), %ecx
shrl %cl, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
imull -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x29a2
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movsbl 0xf(%rcx), %ecx
shrl %cl, %eax
xorl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]hash-prospector/hillclimb.c
// Function: hash_gen
static void
hash_gen(struct hash *h, uint64_t rng[4])
{
    for (int i = 0; i < HASHN; i++)
        h->c[i] = (rand64(rng) >> 32) | 1u;
    for (int i = 0; i <= HASHN; i++)
        h->s[i] = 16;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0x2a46
movq -0x10(%rbp), %rdi
callq 0x2cf0
shrq $0x20, %rax
orq $0x1, %rax
movl %eax, %edx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2a17
movl $0x0, -0x18(%rbp)
cmpl $0x3, -0x18(%rbp)
jg 0x2a6b
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x10, 0xc(%rax,%rcx)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2a4d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, %al
callq 0x61a0
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x3429
movq -0x18(%rbp), %rdi
leaq 0x9be2(%rip), %rsi      # 0xd004
callq 0x62a0
jmp 0x343a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6300
movq -0x18(%rbp), %rdi
callq 0x6230
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_type
static fin_ast_type_t* fin_ast_parse_type(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_type_t* type = (fin_ast_type_t*)ctx->alloc(NULL, sizeof(fin_ast_type_t));
    fin_ast_expect(lex, fin_lex_type_struct);
    type->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    type->generics = fin_ast_parse_generics(ctx, lex);
    fin_ast_expect(lex, fin_lex_type_l_brace);
    fin_ast_field_t** field_tail = &type->fields;
    *field_tail = NULL;
    while (!fin_lex_match(lex, fin_lex_type_r_brace)) {
        *field_tail = fin_ast_parse_field(ctx, lex);
        field_tail = &(*field_tail)->next;
    }
    type->next = NULL;
    return type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x20, %esi
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3e, %esi
callq 0x3ae0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6e30
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rdi
movl $0x32, %esi
callq 0x3ae0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x33, %esi
callq 0x6cd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x3686
jmp 0x36ae
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3c40
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x3670
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_enum
static fin_ast_enum_t* fin_ast_parse_enum(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_enum_t* e = (fin_ast_enum_t*)ctx->alloc(NULL, sizeof(fin_ast_enum_t));
    fin_ast_expect(lex, fin_lex_type_enum);
    e->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    fin_ast_expect(lex, fin_lex_type_l_brace);
    fin_ast_enum_val_t** val_tail = &e->values;
    *val_tail = NULL;
    while (!fin_lex_match(lex, fin_lex_type_r_brace)) {
        if (e->values)
            fin_ast_expect(lex, fin_lex_type_comma);
        *val_tail = fin_ast_parse_enum_val(ctx, lex);
        val_tail = &(*val_tail)->next;
    }
    e->next = NULL;
    return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x3f, %esi
callq 0x3ae0
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6e30
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x32, %esi
callq 0x3ae0
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x33, %esi
callq 0x6cd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x376e
jmp 0x37af
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3787
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3db0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x3758
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_func
static fin_ast_func_t* fin_ast_parse_func(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_func_t* func = (fin_ast_func_t*)ctx->alloc(NULL, sizeof(fin_ast_func_t));
    func->ret = fin_ast_parse_type_ref(ctx, lex);
    func->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    func->generics = fin_ast_parse_generics(ctx, lex);
    fin_ast_expect(lex, fin_lex_type_l_paren);
    fin_ast_param_t** tail = &func->params;
    *tail = NULL;
    while (!fin_lex_match(lex, fin_lex_type_r_paren)) {
        if (func->params)
            fin_ast_expect(lex, fin_lex_type_comma);
        *tail = fin_ast_parse_param(ctx, lex);
        tail = &(*tail)->next;
    }
    func->block = fin_ast_parse_block_stmt(ctx, lex);
    func->next = NULL;
    return func;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x30, %esi
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ce0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6e30
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
movl $0x2e, %esi
callq 0x3ae0
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
movl $0x2f, %esi
callq 0x6cd0
xorb $-0x1, %al
testb $0x1, %al
jne 0x3890
jmp 0x38d1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x38a9
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x3ae0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
jmp 0x387a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5160
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x3970
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3a00
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3a70
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3989
jmp 0x39f2
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x3970
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x5b50
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x5bc0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x5db0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3a19
jmp 0x3a60
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3a00
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6040
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3a89
jmp 0x3ad0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x3a70
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0xb0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x60b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6d10
cmpl -0xc(%rbp), %eax
jne 0x3b0c
movq -0x8(%rbp), %rdi
callq 0x6490
addq $0x10, %rsp
popq %rbp
retq
leaq 0x9702(%rip), %rdi      # 0xd215
leaq 0x96fd(%rip), %rsi      # 0xd217
movl $0x18, %edx
leaq 0x96ff(%rip), %rcx      # 0xd225
callq 0x3110
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x26, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x3b8f
movq $0x0, -0x8(%rbp)
jmp 0x3c28
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x10, %esi
callq *(%rax)
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6e30
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl %edx, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movl -0x30(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movl $0x9, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x3c10
jmp 0x3c12
jmp 0x3b9f
movq -0x18(%rbp), %rdi
movl $0x2a, %esi
callq 0x3ae0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_field
static fin_ast_field_t* fin_ast_parse_field(fin_ctx_t* ctx, fin_lex_t* lex) {
    fin_ast_field_t* field = (fin_ast_field_t*)ctx->alloc(NULL, sizeof(fin_ast_field_t));
    field->type = fin_ast_parse_type_ref(ctx, lex);
    field->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    fin_ast_expect(lex, fin_lex_type_semicolon);
    field->next = NULL;
    return field;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ce0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6e30
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movl $0xc, %esi
callq 0x3ae0
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x10, %esi
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6e30
movq -0x40(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x3d55
jmp 0x3d97
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6e30
movq -0x48(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl %edx, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movl -0x30(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/naleksiev[P]fin/src/fin_ast.c
// Function: fin_ast_parse_enum_val
static struct fin_ast_enum_val_t* fin_ast_parse_enum_val(fin_ctx_t* ctx, fin_lex_t* lex) {
    struct fin_ast_enum_val_t* val = (fin_ast_enum_val_t*)ctx->alloc(NULL, sizeof(fin_ast_enum_val_t));
    val->name = fin_str_from_lex(ctx, fin_lex_consume_name(lex));
    val->expr = fin_lex_match(lex, fin_lex_type_eq) ? fin_ast_parse_expr(ctx, lex, NULL) : NULL;
    val->next = NULL;
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edi
movl $0x18, %esi
callq *(%rax)
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6e30
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movl %edx, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x3b30
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x6cd0
testb $0x1, %al
jne 0x3e19
jmp 0x3e30
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x3e60
movq %rax, -0x38(%rbp)
jmp 0x3e38
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x3e38
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3e8c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3f30
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6d10
addl $-0x8, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x26, %eax
ja 0x3f13
movq -0x28(%rbp), %rax
leaq 0x9186(%rip), %rcx      # 0xd034
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3fe0
movq %rax, -0x8(%rbp)
jmp 0x3f1b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4080
movq %rax, -0x8(%rbp)
jmp 0x3f1b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4130
movq %rax, -0x8(%rbp)
jmp 0x3f1b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4200
movq %rax, -0x8(%rbp)
jmp 0x3f1b
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)