LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/compile.c
// Function: compile_string_constants
void compile_string_constants(char *c, FILE *output_file){
	unsigned char ignore;

	ignore = 0;
	skip_whitespace(&c);
	while(*c){
		if(ignore || *c != '"'){
			ignore = 0;
			if(*c == '\\' || *c == '\''){
				ignore = 1;
			} else if(*c == '\n'){
				current_line++;
			}
			c++;
		} else {
			c++;
			fprintf(output_file, "__str%d:\n", num_strs);
			fprintf(output_file, ".asciiz \"");
			place_string_constant(&c, output_file);
			fprintf(output_file, "\n");
			num_strs++;
		}
		skip_whitespace(&c);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movq %r14, %rdi
callq 0x79e2
movq (%r14), %rax
movb (%rax), %cl
testb %cl, %cl
je 0x5d2e
xorl %ebp, %ebp
leaq 0x41c6(%rip), %r14      # 0x9e50
leaq 0x41c9(%rip), %r15      # 0x9e5a
leaq 0x8(%rsp), %r12
movl %ecx, %edx
xorb $0x22, %dl
orb %bpl, %dl
jne 0x5cf2
incq %rax
movq %rax, 0x8(%rsp)
movl 0x772a(%rip), %edx      # 0xd3d8
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1100
movl $0x9, %esi
movl $0x1, %edx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1190
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6fb5
movl $0xa, %edi
movq %rbx, %rsi
callq 0x10e0
incl 0x76e8(%rip)            # 0xd3d8
jmp 0x5d17
movb $0x1, %bpl
cmpb $0x5c, %cl
je 0x5d0f
movzbl %cl, %ecx
cmpl $0x27, %ecx
je 0x5d0f
cmpl $0xa, %ecx
jne 0x5d0d
incl 0x78f3(%rip)            # 0xd600
xorl %ebp, %ebp
incq %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
callq 0x79e2
movq 0x8(%rsp), %rax
movb (%rax), %cl
testb %cl, %cl
jne 0x5c96
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/compile.c
// Function: place_string_constant
void place_string_constant(char **c, FILE *output_file){
	unsigned char ignore_next = 0;
	char *beginning;

	beginning = *c;

	while(**c && (**c != '"' || ignore_next)){
		fprintf(output_file, "%c", **c);
		if(**c == '\\'){
			ignore_next = 1;
		} else {
			ignore_next = 0;
		}
		if(**c == '\n'){
			program_pointer = *c;
			snprintf(error_message, sizeof(error_message), "Expected closing '\"'");
			do_error(1);
		}
		++*c;
	}

	if(!**c){
		program_pointer = beginning;
		snprintf(error_message, sizeof(error_message), "Expected closing '\"'");
		do_error(1);
	}
	fprintf(output_file, "\"");
	++*c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
movb (%r15), %al
testb %al, %al
je 0x7000
movq %rsi, %r14
movq %rdi, %rbx
xorl %ecx, %ecx
cmpb $0x22, %al
sete %dl
notb %cl
testb %dl, %cl
jne 0x7009
movsbl %al, %edi
movq %r14, %rsi
callq 0x10e0
movq (%rbx), %rax
movb (%rax), %cl
cmpb $0xa, %cl
je 0x701f
cmpb $0x5c, %cl
sete %cl
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb 0x1(%rax), %al
testb %al, %al
jne 0x6fcc
movq %r15, 0x65e9(%rip)      # 0xd5f0
jmp 0x7026
movl $0x22, %edi
movq %r14, %rsi
callq 0x10e0
incq (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, 0x65ca(%rip)      # 0xd5f0
movups 0x2e0e(%rip), %xmm0     # 0x9e3b
movaps %xmm0, 0x64ac(%rip)     # 0xd4e0
movabsq $0x27222720676e69, %rax # imm = 0x27222720676E69
movq %rax, 0x64a8(%rip)      # 0xd4ed
movl $0x1, %edi
callq 0x5b10
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/compile.c
// Function: parse_arguments
void parse_arguments(int argc, char **argv, char *filenames[], unsigned int num_filenames, char **output_filename){
	unsigned int current_arg;
	unsigned int current_filename = 0;
	enum cmd_argtype argtype = cmd_source_file;

	for(current_arg = 1; current_arg < argc; current_arg++){
		switch(argtype){
			case cmd_source_file:
				if(argv[current_arg][0] == '-'){
					if(argv[current_arg][1] == 'h' || (argv[current_arg][1] == '-' && argv[current_arg][2] == 'h')){//Display help message
						printf("Arguments:\n-h --help     Displays this help message\n-o            Specify output file\n\nTo compile:\nmcc [SOURCE1] [SOURCE2] [SOURCE3] ... -o [OUTPUT_FILE]\n");
						exit(1);
					} else if(argv[current_arg][1] == 'o'){
						argtype = cmd_output_file;
					} else {
						fprintf(stderr, "Unrecognized option '%s'\n", argv[current_arg]);
						exit(1);
					}
				} else {
					if(current_filename < num_filenames){
						filenames[current_filename] = argv[current_arg];
						current_filename++;
					} else {
						fprintf(stderr, "Too many source files\n");
						exit(1);
					}
				}
				break;
			case cmd_output_file:
				if(argv[current_arg][0] == '-'){
					fprintf(stderr, "Expected output file name after '-o'\n");
					exit(1);
				}
				*output_filename = argv[current_arg];
				argtype = cmd_source_file;
				break;
		}
	}
}

// Assembly:
pushq %rbx
cmpl $0x2, %edi
jb 0x70a8
movl %edi, %eax
xorl %r11d, %r11d
movl $0x1, %r9d
xorl %r10d, %r10d
movq (%rsi,%r9,8), %rdi
movb (%rdi), %bl
testl %r11d, %r11d
je 0x7078
cmpb $0x2d, %bl
je 0x70aa
movq %rdi, (%r8)
jmp 0x709d
cmpb $0x2d, %bl
jne 0x708e
movzbl 0x1(%rdi), %ebx
movl $0x1, %r11d
cmpl $0x6f, %ebx
je 0x70a0
jmp 0x70af
cmpl %ecx, %r10d
jae 0x70da
movl %r10d, %r11d
movq %rdi, (%rdx,%r11,8)
incl %r10d
xorl %r11d, %r11d
incq %r9
cmpq %r9, %rax
jne 0x7063
popq %rbx
retq
callq 0x12e6
cmpl $0x68, %ebx
je 0x70bf
cmpl $0x2d, %ebx
jne 0x70d5
cmpb $0x68, 0x2(%rdi)
jne 0x70d5
leaq 0x2e77(%rip), %rdi      # 0x9f3d
callq 0x1060
movl $0x1, %edi
callq 0x1180
callq 0x1330
callq 0x130b
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/dictionary.c
// Function: free_dictionary
void free_dictionary(dictionary dict, void (*free_value)(void *)){
	unsigned char i;

	for(i = 0; i < 8; i++){
		if(dict.next_chars[i]){
			free_dictionary_recursive(dict.next_chars[i], free_value);
			free(dict.next_chars[i]);
		}
	}

	if(dict.value){
		free_value(dict.value);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x30(%rsp), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rbx
testq %rbx, %rbx
je 0x7311
movq %rbx, %rdi
movq %r12, %rsi
callq 0x733f
movq %rbx, %rdi
callq 0x1030
incq %r15
cmpq $0x8, %r15
jne 0x72f5
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x7333
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/dictionary.c
// Function: free_dictionary_recursive
static void free_dictionary_recursive(dictionary *dict, void (*free_value)(void *)){
	unsigned char i;

	for(i = 0; i < 8; i++){
		if(dict->next_chars[i]){
			free_dictionary_recursive(dict->next_chars[i], free_value);
			free(dict->next_chars[i]);
		}
	}

	if(dict->value){
		free_value(dict->value);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x7367
movq %r15, %rsi
callq 0x733f
movq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
cmpq $0x8, %r14
jne 0x734d
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x7383
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/dictionary.c
// Function: write_dictionary
void write_dictionary(dictionary *dict, char *string, void *value, unsigned char offset){
	unsigned char zeros = 0;
	unsigned char c;

	while(*string){
		c = (*string)>>offset | (*(string + 1))<<(8 - offset);
		zeros = 0;

		if(!(c&15)){
			zeros += 4;
			c>>=4;
		}
		if(!(c&3)){
			zeros += 2;
			c>>=2;
		}
		if(!(c&1)){
			zeros++;
		}

		offset += zeros + 1;
		string += (offset&0x08)>>3;
		offset = offset&0x07;
		if(!dict->next_chars[zeros]){
			dict->next_chars[zeros] = malloc(sizeof(dictionary));
			*(dict->next_chars[zeros]) = create_dictionary((void *) 0);
		}
		dict = dict->next_chars[zeros];
	}
	
	dict->value = value;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r15
movb (%rsi), %al
testb %al, %al
je 0x7509
movl %ecx, %ebp
movq %rsi, %r14
movsbl %al, %eax
movl %ebp, %ecx
sarl %cl, %eax
movzbl 0x1(%r14), %edx
movb $0x8, %cl
subb %bpl, %cl
shll %cl, %edx
orl %eax, %edx
movl %edx, %eax
shrb $0x4, %al
testb $0xf, %dl
sete %cl
movzbl %al, %eax
cmovnel %edx, %eax
shlb $0x2, %cl
leal 0x2(%rcx), %edx
movl %eax, %esi
shrb $0x2, %sil
testb $0x3, %al
movzbl %cl, %ecx
movzbl %dl, %edx
cmovnel %ecx, %edx
movzbl %sil, %ecx
cmovnel %eax, %ecx
andb $0x1, %cl
orb %dl, %cl
xorb $0x1, %cl
addb %cl, %bpl
incb %bpl
movzbl %bpl, %eax
btl $0x3, %eax
adcq $0x0, %r14
movzbl %cl, %r12d
movq (%r15,%r12,8), %rcx
testq %rcx, %rcx
jne 0x74f5
movl $0x48, %edi
callq 0x1140
movq %rax, (%r15,%r12,8)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq $0x0, 0x40(%rax)
movq (%r15,%r12,8), %rcx
andb $0x7, %bpl
movb (%r14), %al
movq %rcx, %r15
testb %al, %al
jne 0x745e
jmp 0x750c
movq %r15, %rcx
movq %rbx, 0x40(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/dictionary.c
// Function: iterate_dictionary
void iterate_dictionary(dictionary dict, void (*func)(void *)){
	unsigned char i;
	
	if(dict.value){
		func(dict.value);
	}

	for(i = 0; i < 8; i++){
		if(dict.next_chars[i]){
			iterate_dictionary(*dict.next_chars[i], func);
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x7534
callq *%rbx
leaq 0x70(%rsp), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rsi
testq %rsi, %rsi
je 0x7558
movl $0x9, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x7519
incq %r15
cmpq $0x8, %r15
jne 0x753c
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/types.c
// Function: add_type_entry
void add_type_entry(type *t, type_entry entry){
	t->d0 <<= 1;
	if(entry&1){
		t->d0 |= 1;
	}
	t->d1 <<= 1;
	if(entry&2){
		t->d1 |= 1;
	}
	t->d2 <<= 1;
	if(entry&4){
		t->d2 |= 1;
	}
}

// Assembly:
movl %esi, %eax
shrl %eax
movdqu (%rdi), %xmm0
paddq %xmm0, %xmm0
movd %esi, %xmm1
movd %eax, %xmm2
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
pand 0x2a44(%rip), %xmm1     # 0xa010
pxor %xmm2, %xmm2
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
por %xmm0, %xmm1
movdqu %xmm1, (%rdi)
movq 0x10(%rdi), %rax
shrl $0x2, %esi
andl $0x1, %esi
leaq (%rsi,%rax,2), %rax
movq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/types.c
// Function: poke_type_entry
void poke_type_entry(type *t, type_entry entry, unsigned int position){
	if(entry&1){
		t->d0 |= 1ULL<<position;
	}
	if(entry&2){
		t->d1 |= 1ULL<<position;
	}
	if(entry&4){
		t->d2 |= 1ULL<<position;
	}
}

// Assembly:
movl %edx, %ecx
testb $0x1, %sil
je 0x7602
movl $0x1, %eax
shlq %cl, %rax
orq %rax, (%rdi)
testb $0x2, %sil
je 0x7614
movl $0x1, %eax
shlq %cl, %rax
orq %rax, 0x8(%rdi)
testb $0x4, %sil
je 0x7626
movl $0x1, %eax
shlq %cl, %rax
orq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/types.c
// Function: append_type
void append_type(type *t, type d){
	uint64_t d_mask;
	int shift_amount = 1;

	d_mask = d.d0 | d.d1 | d.d2;

	if(!d_mask){
		return;
	}

	if(d_mask&0xFFFFFFFF00000000ULL){
		shift_amount += 32;
		d_mask >>= 32;
	}
	if(d_mask&0xFFFF0000U){
		shift_amount += 16;
		d_mask >>= 16;
	}
	if(d_mask&0xFF00U){
		shift_amount += 8;
		d_mask >>= 8;
	}
	if(d_mask&0xF0U){
		shift_amount += 4;
		d_mask >>= 4;
	}
	if(d_mask&0xCU){
		shift_amount += 2;
		d_mask >>= 2;
	}
	if(d_mask&0x2){
		shift_amount++;
	}

	t->d0 = (t->d0<<shift_amount) | d.d0;
	t->d1 = (t->d1<<shift_amount) | d.d1;
	t->d2 = (t->d2<<shift_amount) | d.d2;
	while(d.current_index){
		d.current_index--;
		t->list_indicies[t->current_index] = d.list_indicies[d.current_index];
		t->current_index++;
	}
}

// Assembly:
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rdx, %rcx
orq %rsi, %rcx
movq 0x18(%rsp), %rax
orq %rax, %rcx
je 0x7728
xorl %r8d, %r8d
movq %rcx, %r9
shrq $0x20, %r9
setne %r8b
cmoveq %rcx, %r9
shll $0x5, %r8d
leal 0x1(%r8), %ecx
orl $0x11, %r8d
movq %r9, %r10
shrq $0x10, %r10
cmpq $0x10000, %r9           # imm = 0x10000
cmovbq %r9, %r10
cmovbl %ecx, %r8d
leal 0x8(%r8), %ecx
movq %r10, %r9
shrq $0x8, %r9
testl $0xff00, %r10d          # imm = 0xFF00
cmoveq %r10, %r9
cmovel %r8d, %ecx
leal 0x4(%rcx), %r8d
movq %r9, %r10
shrq $0x4, %r10
testb $-0x10, %r9b
cmoveq %r9, %r10
cmovel %ecx, %r8d
leal 0x2(%r8), %ecx
movl %r10d, %r9d
shrl $0x2, %r9d
testb $0xc, %r10b
cmovel %r8d, %ecx
cmovel %r10d, %r9d
btl $0x1, %r9d
adcl $0x0, %ecx
leaq 0x8(%rsp), %r8
movq (%rdi), %r9
movq 0x8(%rdi), %r10
shlq %cl, %r9
orq %rsi, %r9
shlq %cl, %r10
movq %r9, (%rdi)
orq %rdx, %r10
movq %r10, 0x8(%rdi)
movq 0x10(%rdi), %rdx
shlq %cl, %rdx
orq %rax, %rdx
movq %rdx, 0x10(%rdi)
movl 0x38(%r8), %eax
testl %eax, %eax
je 0x7728
movl 0x38(%rdi), %ecx
decl %eax
leaq (%r8,%rax,4), %rdx
addq $0x18, %rdx
movl %eax, 0x38(%r8)
movl (%rdx), %esi
movl %ecx, %ecx
movl %esi, 0x18(%rdi,%rcx,4)
movl 0x38(%rdi), %ecx
incl %ecx
movl %ecx, 0x38(%rdi)
addq $-0x4, %rdx
addl $-0x1, %eax
jb 0x770b
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/types.c
// Function: parse_identifier
unsigned char parse_identifier(char **c, char *identifier_name, unsigned int identifier_length){
	if(!alpha(**c)){
		return 0;
	}
	if(!strncmp(*c, "void", 4) && !alphanumeric((*c)[4])){
		return 0;
	}
	if(!strncmp(*c, "int", 3) && !alphanumeric((*c)[3])){
		return 0;
	}
	if(!strncmp(*c, "char", 4) && !alphanumeric((*c)[4])){
		return 0;
	}

	if(identifier_length){
		identifier_length--;
	}

	while(alphanumeric(**c)){
		if(identifier_length && identifier_name){
			*identifier_name = **c;
			identifier_name++;
			identifier_length--;
		}
		++*c;
	}

	if(identifier_name){
		*identifier_name = '\0';
	}
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r15
movb (%r15), %r12b
movl %r12d, %r13d
andb $-0x21, %r13b
addb $-0x5b, %r13b
cmpb $-0x1a, %r13b
setb %al
cmpb $0x5f, %r12b
setne %cl
testb %al, %cl
je 0x775e
xorl %eax, %eax
jmp 0x7835
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28e3(%rip), %rsi      # 0xa050
movl $0x4, %edx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x7844
cmpb $0x69, %r12b
jne 0x77ae
cmpb $0x6e, 0x1(%r15)
jne 0x77ae
cmpb $0x74, 0x2(%r15)
jne 0x77ae
movb 0x3(%r15), %al
cmpb $0x5f, %al
je 0x77ae
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x77ae
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x7757
leaq 0x28a0(%rip), %rsi      # 0xa055
movl $0x4, %edx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x786d
cmpb $0x5f, %r12b
je 0x77df
leal -0x3a(%r12), %eax
cmpb $-0xb, %al
ja 0x77df
cmpb $-0x1a, %r13b
jb 0x782b
xorl %eax, %eax
subl $0x1, %ebp
cmovbl %eax, %ebp
testl %ebp, %ebp
setne %al
testq %rbx, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x7804
movb %r12b, (%rbx)
incq %rbx
decl %ebp
movq (%r14), %r15
movq %r15, %rax
incq %r15
movq %r15, (%r14)
movb 0x1(%rax), %r12b
cmpb $0x5f, %r12b
je 0x77e7
leal -0x3a(%r12), %eax
cmpb $-0xb, %al
ja 0x77e7
movl %r12d, %eax
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
ja 0x77e7
movb $0x1, %al
testq %rbx, %rbx
je 0x7835
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb 0x4(%r15), %al
cmpb $0x5f, %al
je 0x7782
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x7782
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x7757
jmp 0x7782
movb 0x4(%r15), %al
cmpb $0x5f, %al
je 0x77ca
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x77ca
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x7757
jmp 0x77ca
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/types.c
// Function: parse_datatype
unsigned char parse_datatype(type *t, char **c){
	if(!strncmp(*c, "void", 4) && !alphanumeric((*c)[4])){
		if(t){
			add_type_entry(t, type_void);
		}
		*c += 4;
		return 1;
	} else if(!strncmp(*c, "int", 3) && !alphanumeric((*c)[3])){
		if(t){
			add_type_entry(t, type_int);
		}
		*c += 3;
		return 1;
	} else if(!strncmp(*c, "char", 4) && !alphanumeric((*c)[4])){
		if(t){
			add_type_entry(t, type_char);
		}
		*c += 4;
		return 1;
	} else {
		return 0;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r14
leaq 0x27a5(%rip), %rsi      # 0xa050
movl $0x4, %edx
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x7929
cmpb $0x69, (%r14)
jne 0x790d
cmpb $0x6e, 0x1(%r14)
jne 0x790d
cmpb $0x74, 0x2(%r14)
jne 0x790d
movb 0x3(%r14), %al
cmpb $0x5f, %al
je 0x790d
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x790d
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
ja 0x790d
addq $0x3, %r14
testq %r15, %r15
je 0x79a3
shlq (%r15)
movq 0x8(%r15), %rax
leaq 0x1(,%rax,2), %rax
movq %rax, 0x8(%r15)
jmp 0x799f
leaq 0x2741(%rip), %rsi      # 0xa055
movl $0x4, %edx
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x7962
xorl %eax, %eax
jmp 0x79a8
movb 0x4(%r14), %al
cmpb $0x5f, %al
je 0x78bc
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x78bc
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
ja 0x78bc
addq $0x4, %r14
testq %r15, %r15
je 0x79a3
movq (%r15), %rax
leaq 0x1(,%rax,2), %rax
movq %rax, (%r15)
shlq 0x8(%r15)
jmp 0x799f
movb 0x4(%r14), %cl
xorl %eax, %eax
cmpb $0x5f, %cl
je 0x79a8
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
ja 0x79a8
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1b, %cl
ja 0x79a8
addq $0x4, %r14
testq %r15, %r15
je 0x79a3
movdqu (%r15), %xmm0
paddq %xmm0, %xmm0
por 0x2686(%rip), %xmm0     # 0xa020
movdqu %xmm0, (%r15)
shlq 0x10(%r15)
movq %r14, (%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/types.c
// Function: skip_whitespace
void skip_whitespace(char **c){
	while(**c == ' ' || **c == '\t' || **c == '\n' || **c == '\r' || (**c == '/' && ((*c)[1] == '/' || (*c)[1] == '*'))){
		if(**c == '/' && (*c)[1] == '/'){
			while(**c && **c != '\n'){
				++*c;
			}
		} else if(**c == '/' && (*c)[1] == '*'){
			while(**c && (**c != '*' || (*c)[1] != '/')){
				if(**c == '\n'){
					current_line++;
				}
				++*c;
			}
			++*c;
		}
		if(**c == '\n'){
			current_line++;
		}
		if(**c){
			++*c;
		}
	}
}

// Assembly:
movq (%rdi), %rax
leaq 0x5c14(%rip), %rcx      # 0xd600
movl (%rcx), %edx
movabsq $0x100002600, %rsi      # imm = 0x100002600
movzbl (%rax), %r8d
cmpq $0x2f, %r8
ja 0x7a9b
btq %r8, %rsi
jae 0x7a26
cmpb $0xa, %r8b
jne 0x7a19
incl %edx
movl %edx, (%rcx)
movb (%rax), %r8b
testb %r8b, %r8b
je 0x79f8
incq %rax
movq %rax, (%rdi)
jmp 0x79f8
cmpq $0x2f, %r8
jne 0x7a9b
movzbl 0x1(%rax), %r8d
cmpl $0x2f, %r8d
je 0x7a76
cmpl $0x2a, %r8d
jne 0x7a9b
incq %rax
movb $0x2f, %r8b
cmpb $0xa, %r8b
je 0x7a61
movzbl %r8b, %r8d
cmpl $0x2a, %r8d
je 0x7a5a
testl %r8d, %r8d
jne 0x7a65
jmp 0x7a90
cmpb $0x2f, (%rax)
jne 0x7a65
jmp 0x7a90
incl %edx
movl %edx, (%rcx)
movq %rax, (%rdi)
movb (%rax), %r8b
incq %rax
jmp 0x7a43
movq %rax, (%rdi)
movb (%rax), %r8b
incq %rax
testb %r8b, %r8b
je 0x7a88
movzbl %r8b, %r9d
cmpl $0xa, %r9d
jne 0x7a70
decq %rax
jmp 0x7a0c
movq %rax, (%rdi)
movb (%rax), %r8b
jmp 0x7a0c
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/types.c
// Function: types_equal
unsigned char types_equal(type *t0, type *t1){
	unsigned char i;
	unsigned int t0_index;
	unsigned int t1_index;

	if(t0->d0 != t1->d0 || t0->d1 != t1->d1 || t0->d2 != t1->d2){
		return 0;
	}
	if(t0->current_index == 0 && t1->current_index != 0 && t1->list_indicies[t1->current_index - 1] != 0){
		return 0;
	}
	if(t1->current_index == 0 && t0->current_index != 0 && t0->list_indicies[t0->current_index - 1] != 0){
		return 0;
	}
	if(!t0->current_index || !t1->current_index){
		return 1;
	}
	t0_index = t0->current_index;
	t1_index = t1->current_index;
	for(i = 0; i < 8; i++){
		t0_index--;
		t1_index--;
		if(t0->list_indicies[t0_index] != t1->list_indicies[t1_index]){
			return 0;
		}
		if(t0_index == 0 && t1_index != 0 && t1->list_indicies[t1_index - 1] != 0){
			return 0;
		}
		if(t1_index == 0 && t0_index != 0 && t0->list_indicies[t0_index - 1] != 0){
			return 0;
		}
		if(!t0_index || !t1_index){
			break;
		}
	}

	return 1;
}

// Assembly:
movq (%rdi), %rax
cmpq (%rsi), %rax
jne 0x7ba9
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x7ba9
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x7ba9
movl 0x38(%rdi), %edx
movl 0x38(%rsi), %ecx
testl %edx, %edx
je 0x7b9b
testq %rcx, %rcx
je 0x7bac
pushq %rbp
pushq %r14
pushq %rbx
movl $0x1, %r8d
subq %rcx, %r8
leaq (%rsi,%rcx,4), %r10
addq $0x14, %r10
movl $0x1, %r11d
subl %edx, %r11d
leal -0x1(%rdx), %ebx
xorl %r9d, %r9d
leal (%rbx,%r9), %eax
movl 0x18(%rdi,%rax,4), %eax
cmpl (%r10,%r9,4), %eax
sete %al
jne 0x7bd7
cmpl %r9d, %r11d
setne %bpl
cmpq %r9, %r8
sete %r14b
orb %bpl, %r14b
je 0x7bba
cmpq %r9, %r8
setne %bpl
cmpl %r9d, %r11d
sete %r14b
orb %bpl, %r14b
je 0x7bc8
cmpq %r9, %r8
je 0x7bd7
cmpl %r9d, %r11d
je 0x7bd7
leaq -0x1(%r9), %r14
cmpb $-0x7, %r9b
movq %r14, %r9
jne 0x7b4b
jmp 0x7bd7
testq %rcx, %rcx
je 0x7bb7
decl %ecx
cmpl $0x0, 0x18(%rsi,%rcx,4)
je 0x7bb7
xorl %eax, %eax
retq
decl %edx
cmpl $0x0, 0x18(%rdi,%rdx,4)
sete %al
retq
movb $0x1, %al
retq
leal (%rcx,%r9), %eax
addl $-0x2, %eax
cmpl $0x0, 0x18(%rsi,%rax,4)
jmp 0x7bd4
leal (%rdx,%r9), %eax
addl $-0x2, %eax
cmpl $0x0, 0x18(%rdi,%rax,4)
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/been-jamming[P]MinimalCC/types.c
// Function: get_argument_type
type get_argument_type(type *t){
	type_entry next_type_entry;
	type output;
	unsigned int function_count = 0;
	unsigned int current_entry_index = 0;

	output = EMPTY_TYPE;
	output.current_index = MAX_LISTS - 1;//Have to put indicies in reverse order
	while((next_type_entry = pop_type(t)) >= 4 || function_count){
		poke_type_entry(&output, next_type_entry, current_entry_index);
		current_entry_index++;
		if(next_type_entry == type_function){
			function_count++;
		} else if(function_count && next_type_entry == type_returns){
			function_count--;
		}
		if(next_type_entry == type_list){
			t->current_index--;
			output.list_indicies[output.current_index] = t->list_indicies[t->current_index];
			output.current_index--;
		}
	}
	poke_type_entry(&output, next_type_entry, current_entry_index);
	output.current_index = MAX_LISTS;

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movups 0x5b97(%rip), %xmm0     # 0xd788
movups %xmm0, 0x30(%rdi)
movups 0x5b7c(%rip), %xmm0     # 0xd778
movups %xmm0, 0x20(%rdi)
movups 0x5b61(%rip), %xmm0     # 0xd768
movups %xmm0, 0x10(%rdi)
movups 0x5b46(%rip), %xmm0     # 0xd758
movups %xmm0, (%rdi)
movq %rdi, 0x8(%rsp)
movl $0x7, 0x38(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r13
movq %rsi, 0x10(%rsp)
movq 0x10(%rsi), %r12
movl %r14d, %eax
andl $0x1, %eax
movl %r13d, %ecx
andl $0x1, %ecx
leal (%rax,%rcx,2), %r15d
leal (,%r12,4), %eax
andl $0x4, %eax
orl %eax, %r15d
shrq %r14
shrq %r13
shrq %r12
xorl %ebp, %ebp
testl %eax, %eax
je 0x7cf7
xorl %ebx, %ebx
xorl %ebp, %ebp
xorl %esi, %esi
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x75ef
cmpl $0x5, %r15d
jne 0x7c89
movl 0x4(%rsp), %esi
incl %esi
jmp 0x7cc1
cmpl $0x6, %r15d
sete %al
andb %al, %bl
movzbl %bl, %eax
movl 0x4(%rsp), %esi
subl %eax, %esi
cmpl $0x7, %r15d
jne 0x7cc1
movq 0x10(%rsp), %rcx
movl 0x38(%rcx), %eax
decl %eax
movl %eax, 0x38(%rcx)
movl 0x18(%rcx,%rax,4), %eax
movq 0x8(%rsp), %rdx
movl 0x38(%rdx), %ecx
movl %eax, 0x18(%rdx,%rcx,4)
decl 0x38(%rdx)
movl %r14d, %eax
andl $0x1, %eax
movl %r13d, %ecx
andl $0x1, %ecx
leal (%rax,%rcx,2), %r15d
leal (,%r12,4), %eax
andl $0x4, %eax
orl %eax, %r15d
shrq %r14
shrq %r13
shrq %r12
testl %esi, %esi
setne %bl
incl %ebp
orl %esi, %eax
jne 0x7c68
movq 0x10(%rsp), %rax
movq %r14, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x75ef
movl $0x8, 0x38(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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), %r13
movq 0x8(%rdi), %rbp
movq 0x10(%rdi), %r14
movq %rbp, %rax
orq %r13, %rax
orq %r14, %rax
je 0x7df9
movq %rdi, %rbx
movl 0x38(%rdi), %r15d
leaq 0x22cb(%rip), %r12      # 0xa030
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 0x231d(%rip), %rdi      # 0xa0a9
jmp 0x7dda
leaq 0x22d9(%rip), %rdi      # 0xa06e
jmp 0x7dda
leaq 0x22c3(%rip), %rdi      # 0xa061
jmp 0x7dda
leaq 0x22c0(%rip), %rdi      # 0xa067
jmp 0x7dda
decl %r15d
movl 0x18(%rbx,%r15,4), %esi
leaq 0x22db(%rip), %rdi      # 0xa093
xorl %eax, %eax
callq 0x10a0
jmp 0x7de1
leaq 0x2292(%rip), %rdi      # 0xa05a
jmp 0x7dda
leaq 0x22a9(%rip), %rdi      # 0xa07a
jmp 0x7dda
leaq 0x22ac(%rip), %rdi      # 0xa086
xorl %eax, %eax
callq 0x10a0
shrq %r13
shrq %rbp
shrq %r14
movq %rbp, %rax
orq %r13, %rax
orq %r14, %rax
jne 0x7d65
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79e2
movq %r13, %rdi
movq %r12, %rsi
callq 0x7896
testb %al, %al
jne 0x7e68
movups 0x227f(%rip), %xmm0     # 0xa0c2
leaq 0x5696(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x225d(%rip), %xmm0     # 0xa0b2
movaps %xmm0, (%rax)
movw $0x27, 0x20(%rax)
movl $0x1, %edi
callq 0x5b10
movq %r12, %rdi
callq 0x79e2
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 0x7e92
// File: /workspace/github_c_makefile_star2_O3/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
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq (%rsi), %rax
cmpb $0x29, (%rax)
je 0x833d
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 0x822c
movups 0x1ae0(%rip), %xmm0     # 0x9cf1
leaq 0x52c8(%rip), %rax      # 0xd4e0
movaps %xmm0, (%rax)
movl $0x217374, 0x10(%rax)   # imm = 0x217374
movl $0x1, %edi
callq 0x5b10
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
movl %r14d, %r8d
xorl %r9d, %r9d
callq 0x7e08
movq (%r13), %rcx
movq 0x8(%r13), %rax
movl %ecx, %edx
andl $0x1, %edx
movl %eax, %esi
andl $0x1, %esi
leal (%rdx,%rsi,2), %esi
movq 0x10(%r13), %rdx
movl %edx, %edi
andl $0x1, %edi
leal (%rsi,%rdi,4), %esi
cmpl $0x7, %esi
jne 0x828c
decl 0x78(%rsp)
andq $-0x2, %rcx
movq %rcx, 0x40(%rsp)
andq $-0x2, %rax
movq %rax, 0x48(%rsp)
orq $0x1, %rdx
movq %rdx, 0x50(%rsp)
movq %r15, %rdi
callq 0x79e2
movq (%r15), %rax
movzbl (%rax), %ecx
cmpl $0x29, %ecx
je 0x830e
cmpl $0x2c, %ecx
jne 0x82e5
testl %ebp, %ebp
setne %r13b
incq %rax
movq %rax, (%r15)
movq %r15, %rdi
callq 0x79e2
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 0x81b7
jmp 0x830e
movups 0x1de8(%rip), %xmm0     # 0xa0d4
leaq 0x51ed(%rip), %rax      # 0xd4e0
movaps %xmm0, (%rax)
movabsq $0xa27292720726f, %rcx  # imm = 0xA27292720726F
movq %rcx, 0xd(%rax)
movl $0x1, %edi
callq 0x5b10
movaps 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)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x7627
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %esi
movl $0x11, %edi
callq 0x2210
leaq 0x425d(%rip), %rdi      # 0x72a0
leaq 0x20b3(%rip), %rsi      # 0x50fd
movl $0x5, %edx
callq 0x21f0
testl %eax, %eax
jne 0x3092
leaq 0x4281(%rip), %rdi      # 0x72e0
leaq 0x20ff(%rip), %rsi      # 0x5165
movl $0x5, %edx
callq 0x21f0
testl %eax, %eax
jne 0x3097
leaq 0x42a5(%rip), %rdi      # 0x7320
leaq 0x213b(%rip), %rsi      # 0x51bd
movl $0x5, %edx
callq 0x21f0
testl %eax, %eax
jne 0x309c
popq %rax
retq
callq 0x2480
callq 0x24a5
callq 0x24ca
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edi
movl $0x98, %esi
callq 0x2140
testq %rax, %rax
je 0x3199
movq %rax, %rbx
movl $0xffffffff, 0x64(%rax) # imm = 0xFFFFFFFF
movq %r15, 0x90(%rax)
movl $0x3f, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2150
callq 0x2040
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x3158
movq %rsp, %rdx
movl $0x1c, (%rdx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x3164
leaq 0xaf(%rip), %rsi        # 0x31f0
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x4040
movq %rax, 0x88(%rbx)
testq %rax, %rax
jne 0x318c
movq %rbx, %rdi
callq 0x31a7
xorl %ebx, %ebx
jmp 0x318c
movzwl 0x4(%rsp), %eax
movw %ax, 0x44(%rbx)
cmpw $0xa, %ax
jne 0x317e
movups 0xc(%rsp), %xmm0
movups %xmm0, 0x4c(%rbx)
jmp 0x3185
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 0x1f47(%rip), %rdi      # 0x50e7
callq 0x2180
jmp 0x3160
// File: /workspace/github_c_makefile_star2_O3/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 0x31b7
callq 0x23e0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x31c5
callq 0x2390
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x31d6
callq 0x4144
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x31e7
callq 0x2090
movq %rbx, %rdi
popq %rbx
jmp 0x2220
// File: /workspace/github_c_makefile_star2_O3/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 0x326b
cmpl $0x2, %ebp
je 0x323c
cmpl $0xa, %ebp
jne 0x327b
cmpw $0xa, 0x44(%r14)
jne 0x322b
movdqu 0x4c(%r14), %xmm0
movdqu (%rbx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x3290
movw $0xa, 0x44(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x4c(%r14)
jmp 0x3259
cmpw $0x2, 0x44(%r14)
jne 0x324c
movl 0x48(%r14), %eax
cmpl (%rbx), %eax
je 0x3290
movw $0x2, 0x44(%r14)
movl (%rbx), %eax
movl %eax, 0x48(%r14)
movq %r14, %rdi
callq 0x36d0
movl $0x1, 0x40(%r14)
jmp 0x327b
movl $0x0, 0x40(%r14)
movq %r14, %rdi
callq 0x36d0
movq 0x90(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x278a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
leaq 0x15c7(%rip), %rdi      # 0x314c
movl $0x2e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1130
leaq 0x15dd(%rip), %rdi      # 0x317b
movl $0x27, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1130
leaq 0x15ec(%rip), %rdi      # 0x31a3
movl $0x27, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1130
leaq 0x15fb(%rip), %rdi      # 0x31cb
movl $0x2d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1130
leaq 0x1610(%rip), %rdi      # 0x31f9
movl $0x2c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1130
leaq 0x1624(%rip), %rdi      # 0x3226
movl $0x2a, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1130
leaq 0x1636(%rip), %rdi      # 0x3251
movl $0x2d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1130
leaq 0x164b(%rip), %rdi      # 0x327f
movl $0x34, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x1130
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x5b, %edi
callq 0x1040
movq $-0x3, %r15
leaq 0x1376(%rip), %r14      # 0x32b4
movsbl 0xf(%rbx,%r15), %esi
movl 0xc(%rbx,%r15,4), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1070
incq %r15
jne 0x1f3e
movsbl 0xf(%rbx), %esi
leaq 0x135c(%rip), %rdi      # 0x32bf
xorl %eax, %eax
callq 0x1070
movq 0x3067(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl $0x100000, %edi         # imm = 0x100000
callq 0x10e0
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x1080
imulq $0xf4240, (%r15), %rax  # imm = 0xF4240
addq 0x8(%r15), %rax
movq %rax, (%rbx)
leaq -0x3b(%rip), %rax       # 0x2128
movq %rax, 0x8(%rbx)
movq %rbx, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1c47
// File: /workspace/github_c_makefile_star2_O3/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 0x4fe1
movq %rax, %rbx
cmpl $0x1, %r15d
jne 0x342d
leaq 0x6be1(%rip), %rsi      # 0xa004
movq %rbx, %rdi
callq 0x5058
jmp 0x3439
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x509e
movq %rbx, %rdi
callq 0x501a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x38ae
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x390a
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x394e
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x8217
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_O3/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 0x3909
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rsi
callq 0x38ae
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x8217
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x4cee
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x4d32
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4e19
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_O3/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 0x394d
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0x390a
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x8217
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4f04
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_O3/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 0x3991
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0x394e
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x8217
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4f48
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_O3/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 0x57fc
cmpl %r14d, %eax
jne 0x39b5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x51ea
leaq 0x6705(%rip), %rdi      # 0xa0c1
leaq 0x6700(%rip), %rsi      # 0xa0c3
leaq 0x6707(%rip), %rcx      # 0xa0d1
movl $0x18, %edx
callq 0x3120
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x26, %esi
callq 0x57da
testb %al, %al
je 0x3a51
leaq -0x20(%rbp), %r15
movq $0x0, (%r15)
xorl %edi, %edi
movl $0x10, %esi
callq *(%r14)
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x589c
movq %r14, %rdi
movq %rax, %rsi
callq 0x8040
movq (%r15), %rcx
movq %rax, (%rcx)
movq (%r15), %r15
addq $0x8, %r15
movq %rbx, %rdi
movl $0x9, %esi
callq 0x57da
testb %al, %al
jne 0x3a00
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x3992
movq -0x20(%rbp), %rax
jmp 0x3a53
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
xorl %edi, %edi
movl $0x10, %esi
callq *(%r14)
movq %rax, %rbx
movq $0x0, (%rax)
movq %r15, %rdi
callq 0x589c
movq %r14, %rdi
movq %rax, %rsi
callq 0x8040
movq %rax, 0x8(%rbx)
movq %r15, %rdi
movl $0x8, %esi
callq 0x57da
testb %al, %al
je 0x3ac8
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
movq %r15, %rdi
callq 0x589c
movq %r14, %rdi
movq %rax, %rsi
callq 0x8040
movq %rax, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq