LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x7073
movl %edi, %eax
xorl %r11d, %r11d
movl $0x1, %r9d
xorl %r10d, %r10d
movq (%rsi,%r9,8), %rdi
movb (%rdi), %bl
testl %r11d, %r11d
je 0x702f
cmpb $0x2d, %bl
je 0x7075
movq %rdi, (%r8)
jmp 0x7059
cmpb $0x2d, %bl
jne 0x704a
movzbl 0x1(%rdi), %ebx
movl $0x1, %r11d
cmpl $0x2d, %ebx
je 0x7066
cmpl $0x6f, %ebx
je 0x705c
jmp 0x707f
cmpl %ecx, %r10d
jae 0x707a
movl %r10d, %r11d
movq %rdi, (%rdx,%r11,8)
incl %r10d
xorl %r11d, %r11d
incq %r9
cmpq %r9, %rax
jne 0x701a
jmp 0x7073
cmpb $0x68, 0x2(%rdi)
je 0x7084
cmpb $0x6f, %bl
je 0x705c
jmp 0x709a
popq %rbx
retq
callq 0x12e4
callq 0x1309
cmpl $0x68, %ebx
jne 0x709a
leaq 0x2ebe(%rip), %rdi      # 0x9f49
callq 0x1060
movl $0x1, %edi
callq 0x1180
callq 0x132e
// File: /workspace/github_c_makefile_star2_O1/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 0x72d5
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7303
movq %rbx, %rdi
callq 0x1030
incq %r15
cmpq $0x8, %r15
jne 0x72b9
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x72f7
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_O1/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 0x732b
movq %r15, %rsi
callq 0x7303
movq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
cmpq $0x8, %r14
jne 0x7311
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x7347
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/dictionary.c
// Function: read_dictionary
void *read_dictionary(dictionary dict, char *string, 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 = *(dict.next_chars[zeros]);
		} else {
			return (void *) 0;
		}
	}
	
	return dict.value;
}

// Assembly:
leaq 0x8(%rsp), %rdx
movb (%rdi), %cl
testb %cl, %cl
je 0x7400
movl %esi, %r9d
movq %rdi, %r8
xorl %eax, %eax
movsbl %cl, %esi
movl %r9d, %ecx
sarl %cl, %esi
movzbl 0x1(%r8), %edi
movb $0x8, %cl
subb %r9b, %cl
shll %cl, %edi
orl %esi, %edi
movl %edi, %ecx
shrb $0x4, %cl
testb $0xf, %dil
sete %sil
movzbl %cl, %r10d
cmovnel %edi, %r10d
shlb $0x2, %sil
leal 0x2(%rsi), %ecx
movl %r10d, %edi
shrb $0x2, %dil
testb $0x3, %r10b
movzbl %sil, %esi
movzbl %cl, %r11d
cmovnel %esi, %r11d
movzbl %dil, %ecx
cmovnel %r10d, %ecx
andb $0x1, %cl
orb %r11b, %cl
xorb $0x1, %cl
movzbl %cl, %esi
movq (%rdx,%rsi,8), %rsi
testq %rsi, %rsi
je 0x7404
addb %cl, %r9b
incb %r9b
movl %r9d, %r10d
andb $0x7, %r10b
shrb $0x3, %r9b
movzbl %r9b, %r9d
andl $0x1, %r9d
movl $0x9, %ecx
movq %rdx, %rdi
rep  movsq (%rsi), %es:(%rdi)
movb (%r8,%r9), %cl
addq %r9, %r8
movl %r10d, %r9d
testb %cl, %cl
jne 0x7364
movq 0x40(%rdx), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movb (%rsi), %al
testb %al, %al
je 0x74c6
movl %ecx, %ebp
movq %rsi, %r15
movsbl %al, %eax
movl %ebp, %ecx
sarl %cl, %eax
movzbl 0x1(%r15), %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, %r15
movzbl %cl, %r12d
cmpq $0x0, (%r14,%r12,8)
jne 0x74b3
movl $0x48, %edi
callq 0x1140
movq %rax, (%r14,%r12,8)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq $0x0, 0x40(%rax)
andb $0x7, %bpl
movq (%r14,%r12,8), %r14
movb (%r15), %al
testb %al, %al
jne 0x7422
movq %rbx, 0x40(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x74ee
callq *%rbx
leaq 0x70(%rsp), %r14
xorl %r15d, %r15d
movq (%r14,%r15,8), %rsi
testq %rsi, %rsi
je 0x7512
movl $0x9, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x74d3
incq %r15
cmpq $0x8, %r15
jne 0x74f6
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x2a98(%rip), %xmm1     # 0xa020
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_O1/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 0x75be
movl $0x1, %eax
shlq %cl, %rax
orq %rax, (%rdi)
testb $0x2, %sil
je 0x75d0
movl $0x1, %eax
shlq %cl, %rax
orq %rax, 0x8(%rdi)
testb $0x4, %sil
je 0x75e2
movl $0x1, %eax
shlq %cl, %rax
orq %rax, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x76dd
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 0x76dd
decl %eax
leaq (%r8,%rax,4), %rcx
addq $0x18, %rcx
movl %eax, 0x38(%r8)
movl (%rcx), %edx
movl 0x38(%rdi), %esi
movl %edx, 0x18(%rdi,%rsi,4)
incl 0x38(%rdi)
addq $-0x4, %rcx
addl $-0x1, %eax
jb 0x76c4
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
movb (%r15), %al
cmpb $0x5f, %al
je 0x770c
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jae 0x770c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x294d(%rip), %rsi      # 0xa060
movl $0x4, %edx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x77d8
leaq 0x2936(%rip), %rsi      # 0xa065
movl $0x3, %edx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x7801
leaq 0x291e(%rip), %rsi      # 0xa069
movl $0x4, %edx
movq %r15, %rdi
callq 0x1040
testl %eax, %eax
je 0x782a
movq (%r14), %rax
movb (%rax), %al
cmpb $0x5f, %al
je 0x777e
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x777e
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1a, %cl
jb 0x77c5
xorl %ecx, %ecx
subl $0x1, %ebp
cmovbl %ecx, %ebp
testl %ebp, %ebp
setne %cl
testq %rbx, %rbx
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x779f
movb %al, (%rbx)
incq %rbx
decl %ebp
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movb 0x1(%rax), %al
cmpb $0x5f, %al
je 0x7786
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x7786
movl %eax, %ecx
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1b, %cl
ja 0x7786
movb $0x1, %al
testq %rbx, %rbx
je 0x7701
movb $0x0, (%rbx)
jmp 0x7701
movb 0x4(%r15), %al
cmpb $0x5f, %al
je 0x7728
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x7728
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x76ff
jmp 0x7728
movb 0x3(%r15), %al
cmpb $0x5f, %al
je 0x7744
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x7744
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x76ff
jmp 0x7744
movb 0x4(%r15), %al
cmpb $0x5f, %al
je 0x7760
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x7760
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1a, %al
jb 0x76ff
jmp 0x7760
// File: /workspace/github_c_makefile_star2_O1/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 0x27f8(%rip), %rsi      # 0xa060
movl $0x4, %edx
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x78b0
leaq 0x27e5(%rip), %rsi      # 0xa065
movl $0x3, %edx
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x78e9
leaq 0x27d1(%rip), %rsi      # 0xa069
movl $0x4, %edx
movq %r14, %rdi
callq 0x1040
testl %eax, %eax
je 0x791f
xorl %eax, %eax
jmp 0x7965
movb 0x4(%r14), %al
cmpb $0x5f, %al
je 0x7879
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x7879
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
ja 0x7879
addq $0x4, %r14
testq %r15, %r15
je 0x7960
movq (%r15), %rax
leaq 0x1(,%rax,2), %rax
movq %rax, (%r15)
shlq 0x8(%r15)
jmp 0x795c
movb 0x3(%r14), %al
cmpb $0x5f, %al
je 0x7891
leal -0x3a(%rax), %ecx
cmpb $-0xb, %cl
ja 0x7891
andb $-0x21, %al
addb $-0x5b, %al
cmpb $-0x1b, %al
ja 0x7891
addq $0x3, %r14
testq %r15, %r15
je 0x7960
shlq (%r15)
movq 0x8(%r15), %rax
leaq 0x1(,%rax,2), %rax
movq %rax, 0x8(%r15)
jmp 0x795c
movb 0x4(%r14), %cl
xorl %eax, %eax
cmpb $0x5f, %cl
je 0x7965
leal -0x3a(%rcx), %edx
cmpb $-0xb, %dl
ja 0x7965
andb $-0x21, %cl
addb $-0x5b, %cl
cmpb $-0x1b, %cl
ja 0x7965
addq $0x4, %r14
testq %r15, %r15
je 0x7960
movdqu (%r15), %xmm0
paddq %xmm0, %xmm0
por 0x26d9(%rip), %xmm0     # 0xa030
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_O1/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 0x5c57(%rip), %rcx      # 0xd600
movl (%rcx), %edx
movabsq $0x100002600, %rsi      # imm = 0x100002600
movzbl (%rax), %r8d
cmpq $0x2f, %r8
ja 0x7a60
btq %r8, %rsi
jae 0x7a27
cmpb $0x2f, %r8b
jne 0x7a43
cmpb $0x2f, 0x1(%rax)
jne 0x79ec
movzbl (%rax), %r8d
testl %r8d, %r8d
je 0x7a43
cmpl $0xa, %r8d
je 0x7a43
incq %rax
movq %rax, (%rdi)
jmp 0x79d5
cmpb $0x2f, %r8b
jne 0x7a43
cmpb $0x2a, 0x1(%rax)
jne 0x7a43
incq %rax
movzbl -0x1(%rax), %r8d
cmpl $0xa, %r8d
je 0x7a1e
cmpl $0x2a, %r8d
je 0x7a13
testl %r8d, %r8d
jne 0x7a22
jmp 0x7a40
cmpb $0x2f, (%rax)
je 0x7a40
cmpb $0xa, %r8b
jne 0x7a22
incl %edx
movl %edx, (%rcx)
movq %rax, (%rdi)
jmp 0x79f8
cmpq $0x2f, %r8
jne 0x7a60
movzbl 0x1(%rax), %r9d
cmpl $0x2f, %r9d
je 0x79c9
cmpl $0x2a, %r9d
je 0x79c9
jmp 0x7a60
movq %rax, (%rdi)
cmpb $0xa, (%rax)
jne 0x7a4c
incl %edx
movl %edx, (%rcx)
cmpb $0x0, (%rax)
je 0x79b5
incq %rax
movq %rax, (%rdi)
jmp 0x79b5
retq
// File: /workspace/github_c_makefile_star2_O1/been-jamming[P]MinimalCC/types.c
// Function: pop_type
int pop_type(type *t){
	int output = 0;

	if(t->d0&1){
		output |= 1;
	}
	if(t->d1&1){
		output |= 2;
	}
	if(t->d2&1){
		output |= 4;
	}

	t->d0 >>= 1;
	t->d1 >>= 1;
	t->d2 >>= 1;

	return output;
}

// Assembly:
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movl %ecx, %eax
andl $0x1, %eax
movl %edx, %esi
andl $0x1, %esi
leal (%rax,%rsi,2), %eax
movq 0x10(%rdi), %rsi
movl %esi, %r8d
andl $0x1, %r8d
leal (%rax,%r8,4), %eax
shrq %rcx
movq %rcx, (%rdi)
shrq %rdx
movq %rdx, 0x8(%rdi)
shrq %rsi
movq %rsi, 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7bcd
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jne 0x7bcd
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
jne 0x7bcd
movl 0x38(%rdi), %r10d
testq %r10, %r10
je 0x7bb5
testq %r10, %r10
sete %al
movl 0x38(%rsi), %r11d
testq %r11, %r11
setne %cl
orb %al, %cl
je 0x7ba8
testq %r11, %r11
sete %al
testq %r10, %r10
sete %cl
orb %al, %cl
movb $0x1, %al
jne 0x7bb4
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl $0xfffffffe, %ecx       # imm = 0xFFFFFFFE
leaq (%r10,%rcx), %rdx
movl $0x1, %r8d
movl $0x1, %r9d
subq %r10, %r9
leaq (%rdi,%r10,4), %r10
addq $0x14, %r10
addq %r11, %rcx
subq %r11, %r8
leaq (%rsi,%r11,4), %r11
addq $0x14, %r11
movb $0x8, %bl
xorl %r14d, %r14d
movl (%r10,%r14,4), %ebp
cmpl (%r11,%r14,4), %ebp
jne 0x7bd0
cmpq %r14, %r9
setne %bpl
cmpq %r14, %r8
sete %r15b
orb %bpl, %r15b
jne 0x7b76
leal (%rcx,%r14), %r15d
cmpl $0x0, 0x18(%rsi,%r15,4)
jne 0x7bd0
cmpq %r14, %r8
setne %bpl
cmpq %r14, %r9
sete %r15b
orb %bpl, %r15b
jne 0x7b95
leal (%rdx,%r14), %r15d
cmpl $0x0, 0x18(%rdi,%r15,4)
jne 0x7bd0
cmpq %r14, %r9
je 0x7bd2
cmpq %r14, %r8
je 0x7bd2
decq %r14
decb %bl
jne 0x7b4d
jmp 0x7bd2
decl %r10d
cmpl $0x0, 0x18(%rdi,%r10,4)
sete %al
retq
movl 0x38(%rsi), %eax
testl %eax, %eax
je 0x7ae6
decl %eax
cmpl $0x0, 0x18(%rsi,%rax,4)
je 0x7ae6
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x5b9a(%rip), %xmm0     # 0xd788
movups %xmm0, 0x30(%rdi)
movups 0x5b7f(%rip), %xmm0     # 0xd778
movups %xmm0, 0x20(%rdi)
movups 0x5b64(%rip), %xmm0     # 0xd768
movups %xmm0, 0x10(%rdi)
movups 0x5b49(%rip), %xmm0     # 0xd758
movups %xmm0, (%rdi)
movq %rdi, (%rsp)
movl $0x7, 0x38(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r13
movq %rsi, 0x8(%rsp)
movq 0x10(%rsi), %rdx
movl %r14d, %eax
andl $0x1, %eax
movl %r13d, %ecx
andl $0x1, %ecx
leal (%rax,%rcx,2), %r15d
leal (,%rdx,4), %eax
andl $0x4, %eax
orl %eax, %r15d
shrq %r14
shrq %r13
shrq %rdx
xorl %ebp, %ebp
testl %eax, %eax
je 0x7cf4
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %rdx, 0x10(%rsp)
movq (%rsp), %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x75ab
cmpl $0x6, %r15d
sete %al
andb %r12b, %al
movzbl %al, %eax
negl %eax
cmpl $0x5, %r15d
movl $0x1, %ecx
cmovel %ecx, %eax
cmpl $0x7, %r15d
jne 0x7cb7
movq 0x8(%rsp), %rdx
movl 0x38(%rdx), %ecx
decl %ecx
movl %ecx, 0x38(%rdx)
movl 0x18(%rdx,%rcx,4), %ecx
movq (%rsp), %rsi
movl 0x38(%rsi), %edx
movl %ecx, 0x18(%rsi,%rdx,4)
decl 0x38(%rsi)
addl %eax, %ebx
movl %r14d, %eax
andl $0x1, %eax
movl %r13d, %ecx
andl $0x1, %ecx
leal (%rax,%rcx,2), %r15d
movq 0x10(%rsp), %rdx
leal (,%rdx,4), %eax
andl $0x4, %eax
orl %eax, %r15d
shrq %r14
shrq %r13
shrq %rdx
testl %ebx, %ebx
setne %r12b
incl %ebp
orl %ebx, %eax
jne 0x7c64
movq 0x8(%rsp), %rax
movq %r14, (%rax)
movq %r13, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq (%rsp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0x75ab
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_O1/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 0x7df5
movq %rdi, %rbx
movl 0x38(%rdi), %r15d
leaq 0x22df(%rip), %r12      # 0xa040
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 0x2335(%rip), %rdi      # 0xa0bd
jmp 0x7dd6
leaq 0x22f1(%rip), %rdi      # 0xa082
jmp 0x7dd6
leaq 0x22db(%rip), %rdi      # 0xa075
jmp 0x7dd6
leaq 0x22d8(%rip), %rdi      # 0xa07b
jmp 0x7dd6
decl %r15d
movl 0x18(%rbx,%r15,4), %esi
leaq 0x22f3(%rip), %rdi      # 0xa0a7
xorl %eax, %eax
callq 0x10a0
jmp 0x7ddd
leaq 0x22aa(%rip), %rdi      # 0xa06e
jmp 0x7dd6
leaq 0x22c1(%rip), %rdi      # 0xa08e
jmp 0x7dd6
leaq 0x22c4(%rip), %rdi      # 0xa09a
xorl %eax, %eax
callq 0x10a0
shrq %r13
shrq %rbp
shrq %r14
movq %rbp, %rax
orq %r13, %rax
orq %r14, %rax
jne 0x7d61
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x799f
movq %r13, %rdi
movq %r12, %rsi
callq 0x7853
testb %al, %al
jne 0x7e64
movups 0x2297(%rip), %xmm0     # 0xa0d6
leaq 0x569a(%rip), %rax      # 0xd4e0
movaps %xmm0, 0x10(%rax)
movups 0x2275(%rip), %xmm0     # 0xa0c6
movaps %xmm0, (%rax)
movw $0x27, 0x20(%rax)
movl $0x1, %edi
callq 0x5ae0
movq %r12, %rdi
callq 0x799f
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 0x7e8e
// File: /workspace/github_c_makefile_star2_O1/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 0x8333
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 0x8222
movups 0x1aea(%rip), %xmm0     # 0x9cf1
leaq 0x52d2(%rip), %rax      # 0xd4e0
movaps %xmm0, (%rax)
movl $0x217374, 0x10(%rax)   # imm = 0x217374
movl $0x1, %edi
callq 0x5ae0
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
movl %r14d, %r8d
xorl %r9d, %r9d
callq 0x7e04
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 0x8282
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 0x799f
movq (%r15), %rax
movzbl (%rax), %ecx
cmpl $0x29, %ecx
je 0x8304
cmpl $0x2c, %ecx
jne 0x82db
testl %ebp, %ebp
setne %r13b
incq %rax
movq %rax, (%r15)
movq %r15, %rdi
callq 0x799f
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 0x81ad
jmp 0x8304
movups 0x1e06(%rip), %xmm0     # 0xa0e8
leaq 0x51f7(%rip), %rax      # 0xd4e0
movaps %xmm0, (%rax)
movabsq $0xa27292720726f, %rcx  # imm = 0xA27292720726F
movq %rcx, 0xd(%rax)
movl $0x1, %edi
callq 0x5ae0
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 0x75e3
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x4205(%rip), %rdi      # 0x72a0
leaq 0x205b(%rip), %rsi      # 0x50fd
movl $0x5, %edx
callq 0x21f0
testl %eax, %eax
jne 0x30ea
leaq 0x4229(%rip), %rdi      # 0x72e0
leaq 0x20a7(%rip), %rsi      # 0x5165
movl $0x5, %edx
callq 0x21f0
testl %eax, %eax
jne 0x30ef
leaq 0x424d(%rip), %rdi      # 0x7320
leaq 0x20e3(%rip), %rsi      # 0x51bd
movl $0x5, %edx
callq 0x21f0
testl %eax, %eax
jne 0x30f4
popq %rax
retq
callq 0x2480
callq 0x24a5
callq 0x24ca
// File: /workspace/github_c_makefile_star2_O1/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 0x31f1
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 0x31b0
movq %rsp, %rdx
movl $0x1c, (%rdx)
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0x20b0
testl %eax, %eax
je 0x31bc
leaq 0xaf(%rip), %rsi        # 0x3248
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x40d4
movq %rax, 0x88(%rbx)
testq %rax, %rax
jne 0x31e4
movq %rbx, %rdi
callq 0x31ff
xorl %ebx, %ebx
jmp 0x31e4
movzwl 0x4(%rsp), %eax
movw %ax, 0x44(%rbx)
cmpw $0xa, %ax
jne 0x31d6
movups 0xc(%rsp), %xmm0
movups %xmm0, 0x4c(%rbx)
jmp 0x31dd
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 0x1eef(%rip), %rdi      # 0x50e7
callq 0x2180
jmp 0x31b8
// File: /workspace/github_c_makefile_star2_O1/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 0x320f
callq 0x23e0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x321d
callq 0x2390
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x322e
callq 0x41d8
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x323f
callq 0x2090
movq %rbx, %rdi
popq %rbx
jmp 0x2220
// File: /workspace/github_c_makefile_star2_O1/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 0x32c3
cmpl $0x2, %ebp
je 0x3294
cmpl $0xa, %ebp
jne 0x32d3
cmpw $0xa, 0x44(%r14)
jne 0x3283
movdqu 0x4c(%r14), %xmm0
movdqu (%rbx), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x32e8
movw $0xa, 0x44(%r14)
movups (%rbx), %xmm0
movups %xmm0, 0x4c(%r14)
jmp 0x32b1
cmpw $0x2, 0x44(%r14)
jne 0x32a4
movl 0x48(%r14), %eax
cmpl (%rbx), %eax
je 0x32e8
movw $0x2, 0x44(%r14)
movl (%rbx), %eax
movl %eax, 0x48(%r14)
movq %r14, %rdi
callq 0x3750
movl $0x1, 0x40(%r14)
jmp 0x32d3
movl $0x0, 0x40(%r14)
movq %r14, %rdi
callq 0x3750
movq 0x90(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x2787
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/marcespie[P]unix-samples/lab/pollsig2.c
// Function: main
int
main()
{
	struct pollfd pfd[1];

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

	int pid;

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

	// now we "wait"

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

// Assembly:
subq $0x18, %rsp
leaq 0x8(%rsp), %rdi
callq 0x1040
cmpl $-0x1, %eax
je 0x127c
callq 0x10b0
testl %eax, %eax
je 0x1285
cmpl $-0x1, %eax
je 0x128a
leaq -0x29(%rip), %rsi       # 0x120c
movl $0x11, %edi
callq 0x1050
movl 0x8(%rsp), %eax
leaq 0x10(%rsp), %rdi
movl %eax, (%rdi)
movw $0x1, 0x4(%rdi)
movl $0x1, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x1070
cmpl $-0x1, %eax
jne 0x126e
callq 0x1030
cmpl $0x4, (%rax)
je 0x1275
xorl %eax, %eax
addq $0x18, %rsp
retq
callq 0x10fc
jmp 0x126e
leaq 0xd81(%rip), %rsi       # 0x2004
jmp 0x1291
callq 0x10d0
leaq 0xd7d(%rip), %rsi       # 0x200e
movl $0x1, %edi
xorl %eax, %eax
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/ramirezsebas[P]TP-LISTINGS/./src/capitulo_2/2.3/print-env.c
// Function: main
int main ()
{
  char** var;
  for (var = environ; *var != NULL; ++var)
    printf ("%s\n", *var);
  return 0;
}

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

	double fLO_in;

	fLO_in = atof(argv[1]);

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

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

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

	set_freq_tx(fLO_in, mapped_base);

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

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

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rdi
callq 0x1070
movsd %xmm0, (%rsp)
leaq 0xd9f(%rip), %rdi       # 0x2004
movl $0x101002, %esi         # imm = 0x101002
xorl %eax, %eax
callq 0x1100
cmpl $-0x1, %eax
je 0x12d3
movl %eax, %ebx
movl $0x40000000, %edi       # imm = 0x40000000
movl $0x400000, %esi         # imm = 0x400000
movl $0x64000000, %r9d       # imm = 0x64000000
movl $0x3, %edx
movl $0x11, %ecx
movl %eax, %r8d
callq 0x1090
cmpq $-0x1, %rax
je 0x12dc
movq %rax, %r14
movsd (%rsp), %xmm0
movq %rax, %rdi
callq 0x1c17
movl $0x400000, %esi         # imm = 0x400000
movq %r14, %rdi
callq 0x10f0
cmpl $-0x1, %eax
je 0x12e5
movl %ebx, %edi
callq 0x10d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xd7b(%rip), %rdi       # 0x2055
jmp 0x12ec
leaq 0xd4e(%rip), %rdi       # 0x2031
jmp 0x12ec
leaq 0xd21(%rip), %rdi       # 0x200d
callq 0x1060
xorl %edi, %edi
callq 0x1130
// File: /workspace/github_c_makefile_star2_O1/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 0x1530(%rip), %rdi      # 0x314f
movl $0x2e, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1140
leaq 0x1546(%rip), %rdi      # 0x317e
movl $0x27, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1140
leaq 0x1555(%rip), %rdi      # 0x31a6
movl $0x27, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1140
leaq 0x1564(%rip), %rdi      # 0x31ce
movl $0x2d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1140
leaq 0x1579(%rip), %rdi      # 0x31fc
movl $0x2c, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1140
leaq 0x158d(%rip), %rdi      # 0x3229
movl $0x2a, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1140
leaq 0x159f(%rip), %rdi      # 0x3254
movl $0x2d, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1140
leaq 0x15b4(%rip), %rdi      # 0x3282
movl $0x34, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
jmp 0x1140
// File: /workspace/github_c_makefile_star2_O1/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 0x12df(%rip), %r14      # 0x32b7
movsbl 0xf(%rbx,%r15), %esi
movl 0xc(%rbx,%r15,4), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1070
incq %r15
jne 0x1fd8
movsbl 0xf(%rbx), %esi
leaq 0x12c5(%rip), %rdi      # 0x32c2
xorl %eax, %eax
callq 0x1070
movq 0x2fcd(%rip), %rax      # 0x4fd8
movq (%rax), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O1/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 0x10f0
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       # 0x21ba
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 0x1ce1
// File: /workspace/github_c_makefile_star2_O1/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 0x4fd1
movq %rax, %rbx
cmpl $0x1, %r15d
jne 0x342d
leaq 0x6be1(%rip), %rsi      # 0xa004
movq %rbx, %rdi
callq 0x5048
jmp 0x3439
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x508e
movq %rbx, %rdi
callq 0x500a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x38a1
movq 0x18(%rbx), %rsi
movq %rbx, %rdi
callq 0x38fd
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x3941
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x82ed
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_O1/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 0x38fc
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rsi
callq 0x38a1
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x82ed
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x4cde
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x4d22
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4e09
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_O1/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 0x3940
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rsi
callq 0x38fd
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x82ed
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4ef4
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_O1/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 0x3984
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rsi
callq 0x3941
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x82ed
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4f38
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_O1/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 0x57a4
cmpl %r14d, %eax
jne 0x39a8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x51da
leaq 0x6712(%rip), %rdi      # 0xa0c1
leaq 0x670d(%rip), %rsi      # 0xa0c3
leaq 0x6714(%rip), %rcx      # 0xa0d1
movl $0x18, %edx
callq 0x3120
// File: /workspace/github_c_makefile_star2_O1/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 0x5782
testb %al, %al
je 0x3a44
leaq -0x20(%rbp), %r15
movq $0x0, (%r15)
xorl %edi, %edi
movl $0x10, %esi
callq *(%r14)
movq %rax, (%r15)
movq %rbx, %rdi
callq 0x5844
movq %r14, %rdi
movq %rax, %rsi
callq 0x80e4
movq (%r15), %rcx
movq %rax, (%rcx)
movq (%r15), %r15
addq $0x8, %r15
movq %rbx, %rdi
movl $0x9, %esi
callq 0x5782
testb %al, %al
jne 0x39f3
movq %rbx, %rdi
movl $0x2a, %esi
callq 0x3985
movq -0x20(%rbp), %rax
jmp 0x3a46
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq