LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_sigma.c
// Function: print_sigma_offset_makervalue
void
print_sigma_offset_makervalue(FILE *inptr,unsigned short byteorder,
	struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
    struct image_summary *summary_entry,char *parent_name,char *prefix,
    int indent,int make,int model,int at_offset)
{
    int noteversion = 0;

    if(entry_ptr)
    {
        noteversion = getnoteversion();
        switch(noteversion)
        {
            case 1:
                sigma1_offset_makervalue(inptr,byteorder,entry_ptr,
                                        fileoffset_base,summary_entry,
                                        parent_name,prefix,indent,
                                        make,model,at_offset);
                break;
            default:
                    print_generic_offset_makervalue(inptr,byteorder,entry_ptr,
                                        fileoffset_base,parent_name,prefix,
                                        indent,make,model,at_offset);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdx, %rdx
je 0x3fb1f
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movl 0x80(%rsp), %eax
movq %rax, 0x8(%rsp)
movl 0x78(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x70(%rsp), %eax
movq %rax, 0x18(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %r13
xorl %eax, %eax
callq 0x1bfe0
movzwl %bp, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
cmpl $0x1, %eax
jne 0x3fb25
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3fb4f
addq $0x28, %rsp
jmp 0x3fb44
movq %rbx, %r8
movq %r13, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x191ac
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_sigma.c
// Function: sigma1_offset_makervalue
void
sigma1_offset_makervalue(FILE *inptr,unsigned short byteorder,
	struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
    struct image_summary *summary_entry,char *parent_name,char *prefix,
    int indent,int make,int model,int at_offset)
{
	char *nameoftag;
    char *fulldirname = NULL;

	if(entry_ptr)
	{
		nameoftag = maker_tagname(entry_ptr->tag,make,model); 
        fulldirname = splice(parent_name,".",nameoftag);

		switch(entry_ptr->tag)
		{
			default:
				print_generic_offset_makervalue(inptr,byteorder,entry_ptr,
										fileoffset_base,fulldirname,prefix,indent,
										make,model,at_offset);
				break;
		}
        if(fulldirname)
            free(fulldirname);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdx, %rdx
je 0x3fc08
movq %r9, %rbx
movq %rdx, %r15
movl %esi, %ebp
movl 0x80(%rsp), %eax
movq %rax, 0x18(%rsp)
movl 0x78(%rsp), %r12d
movl 0x70(%rsp), %r14d
movl 0x68(%rsp), %eax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movzwl (%rdx), %edi
movl %r14d, %esi
movl %r12d, %edx
movq %rcx, %r13
callq 0x1c020
leaq 0x1de3(%rip), %rsi      # 0x41997
movq %rbx, %rdi
movq %rax, %rdx
callq 0x17a47
movq %rax, %rbx
movzwl %bp, %esi
movq 0x8(%rsp), %rdi
movq %r15, %rdx
movq %r13, %rcx
movq %rax, %r8
movq 0x10(%rsp), %r9
pushq 0x18(%rsp)
pushq %r12
pushq %r14
pushq 0x38(%rsp)
callq 0x191ac
addq $0x20, %rsp
testq %rbx, %rbx
je 0x3fc08
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3050
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_sony.c
// Function: print_sony_offset_makervalue
void
print_sony_offset_makervalue(FILE *inptr,unsigned short byteorder,
    struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
    struct image_summary *summary_entry,char *parent_name,char *prefix,
    int indent,int make,int model,int at_offset)
{
    int noteversion = 0;

    if(entry_ptr)
    {
        noteversion = getnoteversion();
        switch(noteversion)
        {
            case 1:
                sony1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                break;
            default:
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x3fd70
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
xorl %eax, %eax
callq 0x1bfe0
cmpl $0x1, %eax
jne 0x3fd70
movzwl %bp, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3fd79
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_konica.c
// Function: print_konica_makervalue
void
print_konica_makervalue(struct ifd_entry *entry_ptr,int make,int model,
                    char *prefix)
{
    int noteversion = 0;

    if(entry_ptr && (PRINT_VALUE))
    {
        noteversion = getnoteversion();
        switch(noteversion)
        {
            case 1:
                print_konica_makervalue(entry_ptr,make,model,prefix);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18205(%rip), %r14     # 0x58180
testq %rbx, %rbx
je 0x3ffa8
testb $0x30, (%r14)
je 0x3ffa8
xorl %eax, %eax
callq 0x1bfe0
cmpl $0x1, %eax
je 0x3ff7b
leaq 0x7cfd(%rip), %rsi      # 0x47c96
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x62c7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_konica.c
// Function: print_konica_offset_makervalue
void
print_konica_offset_makervalue(FILE *inptr,unsigned short byteorder,
    struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
    struct image_summary *summary_entry, char *parent_name,char *prefix,
    int indent,int make,int model,int at_offset)
{
    int noteversion = 0;

    noteversion = getnoteversion();

    if(entry_ptr)
    {
        switch(noteversion)
        {
            case 1:
                konica1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
            default:
                print_generic_offset_makervalue(inptr,byteorder,entry_ptr,
                                        fileoffset_base,parent_name,prefix,indent,
                                        make,model,at_offset);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
xorl %eax, %eax
callq 0x1bfe0
testq %r15, %r15
je 0x4006c
movl 0x50(%rsp), %r11d
movl 0x48(%rsp), %r10d
movq 0x40(%rsp), %r13
movzwl %bp, %ebp
cmpl $0x1, %eax
jne 0x40042
subq $0x8, %rsp
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r9
movl 0x68(%rsp), %eax
pushq %rax
movl 0x68(%rsp), %eax
pushq %rax
pushq %r11
pushq %r10
pushq %r13
callq 0x4007b
movl 0x80(%rsp), %r11d
movl 0x78(%rsp), %r10d
addq $0x30, %rsp
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %r13, %r9
movl 0x60(%rsp), %eax
pushq %rax
movl 0x60(%rsp), %eax
pushq %rax
pushq %r11
pushq %r10
callq 0x191ac
addq $0x28, %rsp
jmp 0x40070
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/gadget114514[P]fatfs-example/rd.c
// Function: main
void main()
{
  FILINFO fn;
  FATFS fs;
  FCHK(f_mount(&fs, "", 0)); 
  
  FCHK(f_opendir(&d, "/abc"));
  printf("d.fn %s\n", d.fn);
  
  for (;;) {
    if (f_readdir(&d, &fn) != FR_OK || fn.fname[0] == '\0') break;
    printf("fn.name %s\n", fn.fname);
  }
  
  FCHK(f_closedir(&d));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x280, %rsp            # imm = 0x280
leaq 0x42cf(%rip), %rsi      # 0x5484
leaq -0x298(%rbp), %rdi
xorl %edx, %edx
callq 0x144c
movl %eax, %ebx
movl %eax, %edi
callq 0x12c2
leaq 0x3e31(%rip), %r14      # 0x5004
leaq 0x3e3d(%rip), %rsi      # 0x5017
movq %r14, %rdi
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
leaq 0x5e80(%rip), %rbx      # 0x7070
leaq 0x3e34(%rip), %rsi      # 0x502b
movq %rbx, %rdi
callq 0x2d0b
movl %eax, %r15d
movl %eax, %edi
callq 0x12c2
leaq 0x3e20(%rip), %rsi      # 0x5030
movq %r14, %rdi
movl %r15d, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
leaq 0x3e1f(%rip), %rdi      # 0x5046
leaq 0x5e82(%rip), %rsi      # 0x70b0
xorl %eax, %eax
callq 0x1050
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x2ec4
testl %eax, %eax
jne 0x1283
cmpb $0x0, -0x33(%rbp)
je 0x1283
leaq -0x33(%rbp), %rbx
leaq 0x3df9(%rip), %r14      # 0x504f
leaq 0x5e13(%rip), %r15      # 0x7070
leaq -0x40(%rbp), %r12
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ec4
testl %eax, %eax
jne 0x1283
cmpb $0x0, -0x33(%rbp)
jne 0x1261
leaq 0x5de6(%rip), %rdi      # 0x7070
callq 0x2ea0
movl %eax, %ebx
movl %eax, %edi
callq 0x12c2
leaq 0x3d65(%rip), %rdi      # 0x5004
leaq 0x3db5(%rip), %rsi      # 0x505b
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1050
addq $0x280, %rsp            # imm = 0x280
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/main.c
// Function: load_file
int _load_file(const char *argv[]) {
	/* The file we're going to load in: */
	const char *file_path = argv[1];
	/* Where we're going to store our loaded buffer: */
	char *buf = NULL;
	size_t buf_siz = 0;

	buf = lair_load_file(file_path, &buf_siz);
	if (buf == NULL) {
		error_and_die(ERR_RUNTIME, "Could not load file.");
		return 1;
	}

	int rc = lair_execute(buf, buf_siz);
	if (rc != 0) {
		error_and_die(ERR_RUNTIME, "Could not execute.");
		return 1;
	}

	lair_unload_file(buf, buf_siz);
	return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
callq 0x3640
testq %rax, %rax
je 0x1338
movq %rax, %rbx
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x36d7
testl %eax, %eax
je 0x1350
leaq 0x2ce3(%rip), %rsi      # 0x4019
jmp 0x133f
leaq 0x2cc5(%rip), %rsi      # 0x4004
movl $0x2, %edi
callq 0x164b
movl $0x1, %eax
jmp 0x135f
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x377a
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/main.c
// Function: repl_mode
int _repl_mode() {
	size_t text_size = 1;
	char *text = calloc(text_size, 1);
	char buf[256] = {0};

	printf(">>> ");
	while (fgets(buf, sizeof(buf), stdin)) {
		text_size += strnlen(buf, sizeof(buf));
		text = realloc(text, text_size);
		if (!text)
			return 1;
		strncat(text, buf, text_size);
	}
	printf("%s\n", text);
	free(text);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl $0x1, %r15d
movl $0x1, %edi
movl $0x1, %esi
callq 0x1130
movq %rax, %r14
movq %rsp, %r12
xorl %ebx, %ebx
movl $0x100, %edx            # imm = 0x100
movq %r12, %rdi
xorl %esi, %esi
callq 0x10d0
leaq 0x2c83(%rip), %rdi      # 0x402c
xorl %eax, %eax
callq 0x10a0
movq 0x5c29(%rip), %r13      # 0x6fe0
movq (%r13), %rdx
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x1110
testq %rax, %rax
je 0x141d
movq %rsp, %r12
movq %r15, %rbp
movl $0x100, %esi            # imm = 0x100
movq %r12, %rdi
callq 0x10e0
movq %rax, %r15
addq %rbp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1180
testq %rax, %rax
je 0x142f
movq %rax, %r14
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x10f0
movq (%r13), %rdx
movq %r12, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x1110
testq %rax, %rax
jne 0x13d0
movq %r14, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1030
jmp 0x1434
movl $0x1, %ebx
movl %ebx, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/main.c
// Function: main
int main(const int argc, const char *argv[]) {
	if (argc < 1) {
		_print_usage(argv[0]);
		exit(0);
	}

	if (argc >= 2)
		return _load_file(argv);
	return _repl_mode();
}

// Assembly:
testl %edi, %edi
jle 0x145e
cmpl $0x1, %edi
jne 0x1456
jmp 0x1365
movq %rsi, %rdi
jmp 0x12fc
pushq %rax
movq (%rsi), %rdi
callq 0x146e
xorl %edi, %edi
callq 0x11e0
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/vector.c
// Function: vector_new
vector *vector_new(const size_t item_size, const size_t initial_element_count) {
	vector _vec = {
		.item_size = item_size,
		.max_size = initial_element_count,
		.count = 0,
		.items = malloc(initial_element_count * item_size + 1)
	};

	vector *to_return = malloc(sizeof(vector));
	memcpy(to_return, &_vec, sizeof(vector));

	return to_return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
imulq %r14, %rdi
incq %rdi
callq 0x1170
movq %rax, %r15
movl $0x20, %edi
callq 0x1170
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/vector.c
// Function: vector_append_ptr
inline int vector_append_ptr(vector *vec, const void *pointer) {
	if (vec->item_size != sizeof(pointer))
		return 0;

	if (vec->count == vec->max_size) {
		vec->max_size *= 2;
		void *array = realloc(vec->items, (vec->max_size * vec->item_size));
		if (!array)
			return 0;
		vec->items = array;
	}

	memcpy(nth(vec->count), &pointer, sizeof(void *));
	vec->count++;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rax
xorl %ebp, %ebp
cmpq $0x8, %rax
jne 0x15cf
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rsi, 0x10(%rdi)
jne 0x15b6
addq %rsi, %rsi
movq %rsi, 0x8(%rbx)
movq 0x18(%rbx), %rdi
imulq %rax, %rsi
callq 0x1180
testq %rax, %rax
je 0x15cf
movq %rax, 0x18(%rbx)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
imulq 0x10(%rbx), %rax
movq %r14, (%rcx,%rax)
incq 0x10(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/error.c
// Function: print_error
void print_error(const ERROR_TYPE err_type, const char *msg) {
	const char *friendly_err = _friendly_err(err_type);
	char buf[256] = {0};

	snprintf(buf, sizeof(buf), "%c[%dm%s%c[%dm", 0x1B, 31, friendly_err, 0x1B, 0x0);
	snprintf(buf + strlen(buf), sizeof(buf), ": %s\n", msg);
	printf("%s", buf);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rbx
cmpl $0x2, %edi
ja 0x1681
movl %edi, %eax
leaq 0x2a34(%rip), %rcx      # 0x40ac
movslq (%rcx,%rax,4), %r15
addq %rcx, %r15
jmp 0x1688
leaq 0x2a1b(%rip), %r15      # 0x40a3
movq %rsp, %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x10d0
leaq 0x29cc(%rip), %rdx      # 0x406d
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movl $0x1b, %ecx
movl $0x1f, %r8d
movq %r15, %r9
xorl %eax, %eax
pushq $0x0
pushq $0x1b
callq 0x10b0
addq $0x10, %rsp
movq %r14, %rdi
callq 0x1080
leaq (%rsp,%rax), %rdi
leaq 0x29a3(%rip), %rdx      # 0x407c
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10b0
leaq 0x305f(%rip), %rdi      # 0x474e
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/lair_std.c
// Function: lair_builtin_operator_minus
const struct _lair_type *_lair_builtin_operator_minus(LAIR_FUNCTION_SIG) {
	check(r, argc == 2, ERR_RUNTIME, "Incorrect number of arguments to `-` function.");
	check(r, argv[0] != NULL, ERR_RUNTIME, "Argument to `-` function was NULL.");
	check(r, argv[1] != NULL, ERR_RUNTIME, "Argument to `-` function was NULL.");
	check(r, argv[0]->type == argv[1]->type, ERR_RUNTIME, "Cannot add variables of different types together.");
	check(r, argv[0]->type != LR_STRING, ERR_RUNTIME, "Cannot subtract strings");
	check(r, argv[1]->type != LR_STRING, ERR_RUNTIME, "Cannot subtract strings");

	/* We already know (probably) that the types are the same. */
	const LAIR_TOKEN first_arg_type = argv[0]->type;
	switch (first_arg_type) {
		/* Integer addition. */
		case LR_NUM: {
			struct _lair_type _stack = {
				.type = LR_NUM,
				.value = {
					.num = argv[0]->value.num - argv[1]->value.num
				}
			};
			struct _lair_type *to_return = calloc(1, sizeof(struct _lair_type));
			memcpy(to_return, &_stack, sizeof(struct _lair_type));
			return to_return;
		}
		default:
			throw_exception(r, ERR_RUNTIME, "Don't know how to subtract these things.");
	}
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
xorl %eax, %eax
cmpl $0x2, %esi
sete %al
leaq 0x28da(%rip), %rcx      # 0x4169
movl %eax, %esi
movl $0x2, %edx
callq 0x1600
xorl %esi, %esi
cmpq $0x0, (%rbx)
setne %sil
leaq 0x28ec(%rip), %r15      # 0x4198
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1600
xorl %esi, %esi
cmpq $0x0, 0x8(%rbx)
setne %sil
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1600
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl (%rax), %eax
xorl %esi, %esi
cmpl (%rcx), %eax
sete %sil
leaq 0x281b(%rip), %rcx      # 0x410a
movq %r14, %rdi
movl $0x2, %edx
callq 0x1600
movq (%rbx), %rax
xorl %esi, %esi
cmpl $0xa, (%rax)
setne %sil
leaq 0x28ac(%rip), %r15      # 0x41bb
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1600
movq 0x8(%rbx), %rax
xorl %esi, %esi
cmpl $0xa, (%rax)
setne %sil
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1600
movq (%rbx), %rax
cmpl $0xf, (%rax)
jne 0x1968
movl 0x8(%rax), %ebp
movq 0x8(%rbx), %rax
subl 0x8(%rax), %ebp
movl $0x1, %edi
movl $0x10, %esi
callq 0x1130
movl $0xf, (%rax)
movl %ebp, 0x8(%rax)
jmp 0x197e
leaq 0x2864(%rip), %rdx      # 0x41d3
movq %r14, %rdi
movl $0x2, %esi
callq 0x1628
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/lair_std.c
// Function: lair_builtin_operator_eq
const struct _lair_type *_lair_builtin_operator_eq(LAIR_FUNCTION_SIG) {
	check(r, argc == 2, ERR_RUNTIME, "Incorrect number of arguments to `=` function.");
	check(r, argv[0] != NULL, ERR_RUNTIME, "Argument to `=` function was NULL.");
	check(r, argv[1] != NULL, ERR_RUNTIME, "Argument to `=` function was NULL.");
	check(r, argv[0]->type == argv[1]->type, ERR_RUNTIME, "Cannot compare disparate types.");

	const LAIR_TOKEN first_arg_type = argv[0]->type;
	switch (first_arg_type) {
		case LR_BOOL:
			if (argv[0]->value.bool == argv[1]->value.bool)
				return _lair_canonical_true();
			return _lair_canonical_false();
		case LR_NUM:
			if (argv[0]->value.num == argv[1]->value.num)
				return _lair_canonical_true();
			return _lair_canonical_false();
		case LR_STRING: {
			const char *str0 = argv[0]->value.str;
			const char *str1 = argv[1]->value.str;
			const size_t str_siz = strlen(str0) + strlen(str1);
			if (strncmp(str0, str1, str_siz) == 0)
				return _lair_canonical_true();
			return _lair_canonical_false();
		}
		default:
			throw_exception(r, ERR_RUNTIME, "Don't know how to compare these two things.");
	}
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
xorl %eax, %eax
cmpl $0x2, %esi
sete %al
leaq 0x2859(%rip), %rcx      # 0x41fc
movl %eax, %esi
movl $0x2, %edx
callq 0x1600
xorl %esi, %esi
cmpq $0x0, (%rbx)
setne %sil
leaq 0x286b(%rip), %r15      # 0x422b
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1600
xorl %esi, %esi
cmpq $0x0, 0x8(%rbx)
setne %sil
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1600
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl (%rax), %eax
xorl %esi, %esi
cmpl (%rcx), %eax
sete %sil
leaq 0x284b(%rip), %rcx      # 0x424e
movq %r14, %rdi
movl $0x2, %edx
callq 0x1600
movq (%rbx), %rax
movl (%rax), %ecx
cmpl $0xa, %ecx
je 0x1a4a
cmpl $0xf, %ecx
je 0x1a32
cmpl $0xd, %ecx
jne 0x1a8a
movb 0x8(%rax), %al
movq 0x8(%rbx), %rcx
cmpb 0x8(%rcx), %al
je 0x1a3e
jmp 0x1a7e
movl 0x8(%rax), %eax
movq 0x8(%rbx), %rcx
cmpl 0x8(%rcx), %eax
jne 0x1a7e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1d00
movq 0x8(%rax), %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rbx
movq %r14, %rdi
callq 0x1080
movq %rax, %r15
movq %rbx, %rdi
callq 0x1080
addq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1060
testl %eax, %eax
je 0x1a3e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1cf8
leaq 0x27dd(%rip), %rdx      # 0x426e
movq %r14, %rdi
movl $0x2, %esi
callq 0x1628
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/lair_std.c
// Function: lair_builtin_print
const struct _lair_type *_lair_builtin_print(LAIR_FUNCTION_SIG) {
	check(r, argc == 1, ERR_RUNTIME, "Incorrect number of arguments to 'print' function.");

	if (argv[0] == NULL) {
		printf("(null)");
		return NULL;
	}

	switch (argv[0]->type) {
	case LR_STRING:
		printf("%s", argv[0]->value.str);
		break;
	case LR_NUM:
		printf("%i", argv[0]->value.num);
		break;
	case LR_FUNCTION_DEF:
	case LR_FUNCTION_CALL:
		printf("<%s!: %s>", _friendly_enum(argv[0]->type), argv[0]->value.str);
		break;
	default:
		printf("<%s: %p>", _friendly_enum(argv[0]->type), argv[0]);
		break;
	}

	return NULL;
}

// Assembly:
pushq %rbx
movq %rdx, %rbx
xorl %eax, %eax
cmpl $0x1, %esi
sete %al
leaq 0x27e1(%rip), %rcx      # 0x429a
movl %eax, %esi
movl $0x2, %edx
callq 0x1600
movq (%rbx), %rax
testq %rax, %rax
je 0x1af5
movl (%rax), %edi
leal -0x1(%rdi), %ecx
cmpl $0x2, %ecx
jb 0x1b05
cmpl $0xf, %edi
je 0x1b1a
cmpl $0xa, %edi
jne 0x1b2d
movq 0x8(%rax), %rsi
leaq 0x2c62(%rip), %rdi      # 0x474e
xorl %eax, %eax
callq 0x10a0
jmp 0x1b46
leaq 0x2855(%rip), %rdi      # 0x4351
xorl %eax, %eax
callq 0x10a0
jmp 0x1b46
callq 0x2b90
movq (%rbx), %rcx
movq 0x8(%rcx), %rdx
leaq 0x27b5(%rip), %rdi      # 0x42cd
jmp 0x1b3c
movl 0x8(%rax), %esi
leaq 0x27f9(%rip), %rdi      # 0x431d
xorl %eax, %eax
callq 0x10a0
jmp 0x1b46
callq 0x2b90
movq (%rbx), %rdx
leaq 0x279b(%rip), %rdi      # 0x42d7
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/lair_std.c
// Function: lair_builtin_println
const struct _lair_type *_lair_builtin_println(LAIR_FUNCTION_SIG) {
	check(r, argc == 1, ERR_RUNTIME, "Incorrect number of arguments to 'println' function.");
	_lair_builtin_print(r, argc, argv);
	printf("\n");

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %esi, %esi
cmpl $0x1, %ebp
sete %sil
leaq 0x277a(%rip), %rcx      # 0x42e0
movl $0x2, %edx
callq 0x1600
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1aa6
movl $0xa, %edi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/eval.c
// Function: lair_standard_env
struct _lair_env *_lair_standard_env(struct _lair_runtime *r) {
	struct _lair_env *std_env = calloc(1, sizeof(struct _lair_env));

	int rc = 0;
	ADD_TO_STD_ENV(r, "print", 1, &_lair_builtin_print);
	ADD_TO_STD_ENV(r, "println", 1, &_lair_builtin_println);
	ADD_TO_STD_ENV(r, "+", 2, &_lair_builtin_operator_plus);
	ADD_TO_STD_ENV(r, "-", 2, &_lair_builtin_operator_minus);
	ADD_TO_STD_ENV(r, "=", 2, &_lair_builtin_operator_eq);
	ADD_TO_STD_ENV(r, "str", 2, &_lair_builtin_str);

	return std_env;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x1, %edi
movl $0x30, %esi
callq 0x1130
movq %rax, %rbx
leaq 0x26d8(%rip), %rdx      # 0x4400
leaq -0x289(%rip), %r8       # 0x1aa6
movq %r14, %rdi
movq %rax, %rsi
movl $0x1, %ecx
callq 0x1e5e
testl %eax, %eax
je 0x1d54
leaq 0x26bc(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x164b
leaq 0x26c9(%rip), %rdx      # 0x4424
leaq -0x218(%rip), %r8       # 0x1b4a
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x1e5e
testl %eax, %eax
je 0x1d87
leaq 0x2689(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x164b
leaq 0x269e(%rip), %rdx      # 0x442c
leaq -0x68d(%rip), %r8       # 0x1708
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %ecx
callq 0x1e5e
testl %eax, %eax
je 0x1dba
leaq 0x2656(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x164b
leaq 0x2a1b(%rip), %rdx      # 0x47dc
leaq -0x555(%rip), %r8       # 0x1873
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %ecx
callq 0x1e5e
testl %eax, %eax
je 0x1ded
leaq 0x2623(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x164b
leaq 0x263a(%rip), %rdx      # 0x442e
leaq -0x472(%rip), %r8       # 0x1989
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %ecx
callq 0x1e5e
testl %eax, %eax
je 0x1e20
leaq 0x25f0(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x164b
leaq 0x2609(%rip), %rdx      # 0x4430
leaq -0x2a0(%rip), %r8       # 0x1b8e
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %ecx
callq 0x1e5e
testl %eax, %eax
je 0x1e53
leaq 0x25bd(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x164b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/eval.c
// Function: lair_add_builtin_function
int _lair_add_builtin_function(
		struct _lair_runtime *r,
		struct _lair_env *env,
		const char *name,
		const int argc,
		const struct _lair_type *(*func_ptr)(LAIR_FUNCTION_SIG)) {
	check(r, name != NULL, ERR_RUNTIME, "Function name cannot be NULL.");
	check(r, env != NULL, ERR_RUNTIME, "Environment cannot be NULL.");
	check(r, strlen(name) > 0, ERR_RUNTIME, "Function name must be more than 0 chars.");

	/* Check to see if that function already exists: */
	const struct _lair_function *existing_func = _tst_map_get(env->c_functions, name, strlen(name));
	if (existing_func != NULL)
		throw_exception(r, ERR_RUNTIME, "Cannot override builtin functions.");

	struct _lair_function _stack_func = {
		.argc = argc,
		.argv = calloc(argc, sizeof(struct _lair_type)),
		.function_ptr = func_ptr
	};

	return _tst_map_insert(&(env->c_functions), name, strlen(name), &_stack_func, sizeof(struct _lair_function));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
xorl %esi, %esi
testq %rdx, %rdx
setne %sil
leaq 0x25aa(%rip), %rcx      # 0x4434
movl $0x2, %edx
callq 0x1600
xorl %esi, %esi
testq %r14, %r14
setne %sil
leaq 0x25ae(%rip), %rcx      # 0x4452
movq %r12, %rdi
movl $0x2, %edx
callq 0x1600
xorl %esi, %esi
cmpb $0x0, (%rbx)
setne %sil
leaq 0x25ad(%rip), %rcx      # 0x446e
movq %r12, %rdi
movl $0x2, %edx
callq 0x1600
movq 0x8(%r14), %r13
addq $0x8, %r14
movq %rbx, %rdi
callq 0x1080
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2a5e
testq %rax, %rax
je 0x1f05
leaq 0x259f(%rip), %rdx      # 0x4497
movq %r12, %rdi
movl $0x2, %esi
callq 0x1628
movq %rsp, %r12
movl %ebp, (%r12)
movslq %ebp, %rdi
movl $0x10, %esi
callq 0x1130
movq %rax, 0x8(%r12)
movq %r15, 0x10(%r12)
movq %rbx, %rdi
callq 0x1080
movl $0x18, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r12, %rcx
callq 0x296c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/eval.c
// Function: lair_add_simple_function
static int _lair_add_simple_function(struct _lair_env *env, const char *name, const struct _lair_type *value) {
	/* This is kind of dumb but whatever. */
	struct _lair_ast val = {
		.atom = {
			.type = value->type,
			/* HOLY SHIT UNIONS ARE AWESOME */
			.value = value->value
		}
	};

	return _tst_map_insert(&(env->not_variables), name, strlen(name), &val, sizeof(struct _lair_ast));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq $0x0, 0x30(%r15)
movl (%rdx), %eax
movl %eax, 0x28(%r15)
movq 0x8(%rdx), %rax
movq %rax, 0x30(%r15)
addq $0x18, %r14
movq %rsi, %rdi
callq 0x1080
movl $0x38, %r8d
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r15, %rcx
callq 0x296c
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/eval.c
// Function: lair_eval
int _lair_eval(struct _lair_runtime *r, const struct _lair_ast *root) {
	struct _lair_env *std_env = _lair_standard_env(r);
	const struct _lair_ast *cur_ast_node = root->children;

	while (cur_ast_node != NULL) {
		if (cur_ast_node->atom.type == LR_CALL) {
			_lair_env_eval(r, cur_ast_node, std_env);
		} else if (cur_ast_node->atom.type == LR_FUNCTION_DEF) {
			const char *func_name = cur_ast_node->atom.value.str;
			const size_t func_name_len = strlen(func_name);

			const void *is_std_func = _tst_map_get(
					std_env->functions, func_name, func_name_len);
			const void *is_c_func = _tst_map_get(
					std_env->c_functions, func_name, func_name_len);
			if (!is_std_func && !is_c_func) {
				/* We're defining a function so insert it. */
				_tst_map_insert(&std_env->functions,
						func_name,
						func_name_len,
						cur_ast_node,
						sizeof(struct _lair_ast));
			} else {
				/* Call the function instead of defining it. */
				_lair_call_function(r, cur_ast_node, std_env);
			}
		}

		cur_ast_node = cur_ast_node->sibling;
	}

	_lair_free_env(std_env);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1d08
movq %rax, %r14
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x26e8
movq %r14, %rax
addq $0x10, %rax
movq %rax, (%rsp)
movl 0x28(%r15), %eax
cmpl $0x1, %eax
je 0x267e
cmpl $0xb, %eax
jne 0x26db
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f69
jmp 0x26db
movq 0x30(%r15), %r13
movq %r13, %rdi
callq 0x1080
movq %rax, %rbp
movq 0x10(%r14), %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2a5e
movq %rax, %r12
movq 0x8(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x2a5e
orq %r12, %rax
je 0x26c3
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x22d8
jmp 0x26db
movl $0x38, %r8d
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x296c
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x2660
movq %r14, %rdi
callq 0x2701
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/map.c
// Function: tst_map_insert
int _tst_map_insert(struct _tst_map_node **root, const char *key, const size_t klen, const void *value, const size_t vsiz) {
	assert(key != NULL);
	assert(klen > 0);

	size_t _klen = klen;
	return _tst_insert(root, key, _klen, value, vsiz);
}

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x297a
testq %rdx, %rdx
je 0x2999
popq %rax
jmp 0x29b8
leaq 0x1cc0(%rip), %rdi      # 0x4641
leaq 0x1cc5(%rip), %rsi      # 0x464d
leaq 0x1cc8(%rip), %rcx      # 0x4657
movl $0x24, %edx
callq 0x10c0
leaq 0x1d1c(%rip), %rdi      # 0x46bc
leaq 0x1ca6(%rip), %rsi      # 0x464d
leaq 0x1ca9(%rip), %rcx      # 0x4657
movl $0x25, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/map.c
// Function: tst_insert
static int _tst_insert(struct _tst_map_node **cur_node, const char *key, size_t klen, const void *value, const size_t vsiz) {
	/* This function is just scary looking because we're passing around pointers
	 * to pointers. It's not that bad.
	 */
	const char current_char = key[0];

	if (*cur_node == NULL) {
		*cur_node = calloc(1, sizeof(struct _tst_map_node));
		(*cur_node)->node_char = current_char;
	}

	if (current_char < (*cur_node)->node_char) {
		return _tst_insert(&((*cur_node)->lokid), key, klen, value, vsiz);
	} else if (current_char == (*cur_node)->node_char) {
		if (klen > 1) {
			return _tst_insert(&(*cur_node)->eqkid, key + 1, klen - 1, value, vsiz);
		} else {
			if ((*cur_node)->value != NULL) // Duplicate?
				return 1;

			(*cur_node)->value = calloc(1, vsiz);
			memcpy((*cur_node)->value, value, vsiz);
			return 0;
		}
	} else {
		return _tst_insert(&((*cur_node)->hikid), key, klen, value, vsiz);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, (%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %r13, %rbp
movb (%r12), %r14b
cmpq $0x0, (%r13)
jne 0x29f8
movl $0x1, %edi
movl $0x28, %esi
callq 0x1130
movq %rax, (%rbp)
movb %r14b, 0x18(%rax)
movq (%rbp), %r13
cmpb 0x18(%r13), %r14b
jge 0x2a08
addq $0x10, %r13
jmp 0x29d3
jne 0x29d3
cmpq $0x2, %r15
jb 0x2a1c
addq $0x8, %r13
incq %r12
decq %r15
jmp 0x29d3
movl $0x1, %eax
cmpq $0x0, 0x20(%r13)
jne 0x2a4f
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1130
movq %rax, 0x20(%r13)
movq (%rbp), %rax
movq 0x20(%rax), %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x1160
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/map.c
// Function: tst_map_get
const void *_tst_map_get(struct _tst_map_node *current_node, const char *key, const size_t klen) {
	const char current_char = key[0];

	if (current_node == NULL)
		return NULL;

	if (current_char < current_node->node_char) {
		return _tst_map_get(current_node->lokid, key, klen);
	} else if (current_char == current_node->node_char) {
		if (klen > 1)
			return _tst_map_get(current_node->eqkid, key + 1, klen - 1);
		return current_node->value;
	} else {
		return _tst_map_get(current_node->hikid, key, klen);
	}
}

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
je 0x2a8f
movb 0x18(%rdi), %cl
cmpb %cl, (%rsi)
jge 0x2a72
movq 0x10(%rdi), %rdi
jmp 0x2a60
je 0x2a79
movq (%rdi), %rdi
jmp 0x2a60
cmpq $0x2, %rdx
jb 0x2a8b
movq 0x8(%rdi), %rdi
incq %rsi
decq %rdx
jmp 0x2a60
movq 0x20(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/map.c
// Function: tst_map_destroy
void _tst_map_destroy(struct _tst_map_node *root, void (*per_value_cleanup)(void *data)) {
	if (root == NULL)
		return;
	/* TODO: This whole function. */
	struct destroy_queue *top = calloc(1, sizeof(struct destroy_queue));
	dq_push(&top, root);

	while (top->next != NULL) {
		struct _tst_map_node *cur_node = (struct _tst_map_node *)dq_pop(&top);

		if (cur_node->lokid != NULL)
			dq_push(&top, (void *)cur_node->lokid);

		if (cur_node->eqkid != NULL)
			dq_push(&top, (void *)cur_node->eqkid);

		if (cur_node->hikid != NULL)
			dq_push(&top, (void *)cur_node->hikid);

		if (per_value_cleanup != NULL && cur_node->value != NULL)
			per_value_cleanup(cur_node->value);
		free(cur_node->value);
		free(cur_node);
	}

	free(top);
}

// Assembly:
testq %rdi, %rdi
je 0x2b8e
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x10, %esi
callq 0x1130
movq %rax, %r15
movl $0x1, %edi
movl $0x10, %esi
callq 0x1130
movq %rax, %r12
movq %r15, (%rax)
movq %r14, 0x8(%rax)
testq %r15, %r15
je 0x2b7d
movq 0x8(%r12), %r14
movq %r12, %rdi
callq 0x1030
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x2b0b
movl $0x1, %edi
movl $0x10, %esi
callq 0x1130
movq %r15, (%rax)
movq %r12, 0x8(%rax)
movq %rax, %r15
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x2b2d
movl $0x1, %edi
movl $0x10, %esi
callq 0x1130
movq %r15, (%rax)
movq %r12, 0x8(%rax)
movq %rax, %r15
movq (%r14), %r13
testq %r13, %r13
je 0x2b50
movl $0x1, %edi
movl $0x10, %esi
callq 0x1130
movq %rax, %r12
movq %r15, (%rax)
movq %r13, 0x8(%rax)
jmp 0x2b53
movq %r15, %r12
testq %rbx, %rbx
je 0x2b63
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x2b63
callq *%rbx
movq 0x20(%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq (%r12), %r15
jmp 0x2ad3
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1030
retq
nop
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/parse.c
// Function: lair_print_tokens
void lair_print_tokens(const struct _lair_token *tokens) {
	const struct _lair_token *cur_tok = tokens;
	unsigned int last_indent_level = 0;
	while (cur_tok != NULL) {
		const char *frnd = _friendly_enum(cur_tok->token_type);
		switch (cur_tok->token_type) {
			case LR_FUNCTION_DEF:
			case LR_FUNCTION_CALL:
				printf("%s %s ", frnd, cur_tok->token_str);
				break;
			case LR_DEDENT:
				printf("\n}\n");
				break;
			case LR_INDENT: {
				char lvl[cur_tok->indent_level + 1];
				memset(lvl, ' ', cur_tok->indent_level);
				lvl[cur_tok->indent_level] = '\0';
				if (last_indent_level < cur_tok->indent_level) {
					printf("{\n%s", lvl);
				} else {
					printf("\n%s", lvl);
				}
				last_indent_level = cur_tok->indent_level;
				break;
			}
			case LR_ERR:
			default:
				printf("%s ", frnd);
		}
		cur_tok = cur_tok->next;
	}
	printf("\n---\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2cb2
movq %rdi, %rbx
leaq 0x1b1a(%rip), %r15      # 0x46e8
leaq 0x4193(%rip), %r12      # 0x6d68
leaq 0x1b69(%rip), %r14      # 0x4745
xorl %r13d, %r13d
movl 0x8(%rbx), %eax
leal -0x1(%rax), %ecx
movq %r15, %rsi
cmpl $0xe, %ecx
ja 0x2bf3
movl %ecx, %edx
movq (%r12,%rdx,8), %rsi
cmpl $0x2, %ecx
jb 0x2c17
cmpl $0x7, %eax
je 0x2c26
cmpl $0x8, %eax
jne 0x2c97
leaq 0x1bd1(%rip), %rdi      # 0x47de
callq 0x1070
jmp 0x2ca5
movq (%rbx), %rdx
movq %r14, %rdi
xorl %eax, %eax
callq 0x10a0
jmp 0x2ca5
movq %r12, %r14
movq %rsp, %r12
movl 0xc(%rbx), %eax
incl %eax
movl %r13d, %r15d
movq %rsp, %r13
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
movl 0xc(%rbx), %edx
movq %r13, %rdi
movl $0x20, %esi
callq 0x10d0
movl 0xc(%rbx), %eax
movb $0x0, (%rax,%r13)
cmpl 0xc(%rbx), %r15d
leaq 0x1ae5(%rip), %rdi      # 0x474d
leaq 0x1add(%rip), %rax      # 0x474c
cmovbq %rax, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x10a0
movl 0xc(%rbx), %r13d
movq %r12, %rsp
movq %r14, %r12
leaq 0x1ab7(%rip), %r14      # 0x4745
leaq 0x1a53(%rip), %r15      # 0x46e8
jmp 0x2ca5
leaq 0x1aaa(%rip), %rdi      # 0x4748
xorl %eax, %eax
callq 0x10a0
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2bdf
leaq 0x1b20(%rip), %rdi      # 0x47d9
callq 0x1070
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/parse.c
// Function: intuit_token_type
void _intuit_token_type(
		struct _lair_runtime *r,
		struct _lair_token *new_token,
		const char *stripped) {
	const size_t stripped_len = strlen(stripped);
	if (stripped_len == 1) {
		if (stripped[0] == ':')
			new_token->token_type = LR_RETURN;
		else if (stripped[0] == '!')
			new_token->token_type = LR_CALL;
		else if (stripped[0] == '?')
			new_token->token_type = LR_IF;
		else if (_is_operator(stripped, stripped_len))
			new_token->token_type = LR_OPERATOR;
		else if (_is_valid_string(stripped, stripped_len))
			new_token->token_type = LR_STRING;
		else if (_is_all_numbers(stripped))
			new_token->token_type = LR_NUM;
		else
			new_token->token_type = LR_ATOM;
	} else {
		if (stripped[0] == '"') {
			if (!_is_valid_string(stripped, stripped_len))
				throw_exception(r, ERR_SYNTAX, "String has no ending \".");
			else
				new_token->token_type = LR_STRING;
		} else if (_is_all_numbers(stripped))
			new_token->token_type = LR_NUM;
		else
			new_token->token_type = LR_ATOM;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, %rdi
callq 0x1080
movzbl (%r14), %ecx
cmpq $0x1, %rax
jne 0x2d08
cmpl $0x39, %ecx
jg 0x2d25
cmpl $0x21, %ecx
je 0x2dbe
cmpl $0x22, %ecx
jne 0x2d6a
cmpb $0x22, (%r14)
je 0x2d19
jmp 0x2d6a
cmpl $0x22, %ecx
jne 0x2d3f
cmpb $0x22, -0x1(%r14,%rax)
jne 0x2da5
movl $0xa, 0x8(%rbx)
jmp 0x2dce
cmpl $0x3f, %ecx
je 0x2dc7
cmpl $0x3a, %ecx
jne 0x2d6a
movl $0x4, 0x8(%rbx)
jmp 0x2dce
movq %r14, %rdi
callq 0x1080
testq %rax, %rax
je 0x2d93
movl $0x1, %ecx
xorl %edx, %edx
movb (%r14,%rdx), %dl
addb $-0x3a, %dl
cmpb $-0xa, %dl
jb 0x2d9c
movl %ecx, %edx
incl %ecx
cmpq %rdx, %rax
ja 0x2d53
jmp 0x2d93
movq %r14, %rdi
callq 0x1080
testq %rax, %rax
je 0x2d93
movl $0x1, %ecx
xorl %edx, %edx
movb (%r14,%rdx), %dl
addb $-0x3a, %dl
cmpb $-0xa, %dl
jb 0x2d9c
movl %ecx, %edx
incl %ecx
cmpq %rdx, %rax
ja 0x2d7e
movl $0xf, 0x8(%rbx)
jmp 0x2dce
movl $0xe, 0x8(%rbx)
jmp 0x2dce
leaq 0x19a5(%rip), %rdx      # 0x4751
movq %r15, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1628
movl $0xb, 0x8(%rbx)
jmp 0x2dce
movl $0xc, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/parse.c
// Function: lair_atomize_token
struct _lair_type _lair_atomize_token(const struct _lair_token *token) {
	/* This is where we do parse-time type coersion into things that
	 * better represent the types we're eventually going to want out
	 * of whatever it is they are in.
	 */
	switch (token->token_type) {
		case LR_NUM: {
			struct _lair_type num = {
				.type = LR_NUM,
				.value = {
					.num = atoi(token->token_str)
				}
			};
			return num;
		}
		case LR_STRING: {
			struct _lair_type def = {
				.type = token->token_type,
				.value = {0}
			};
			if (token->token_str != NULL)
				def.value.str = _convert_str_token_to_str(token->token_str);
			return def;
		}
		default: {
			struct _lair_type def = {
				.type = token->token_type,
				.value = {0}
			};
			if (token->token_str != NULL) {
				def.value.str = calloc(1, strlen(token->token_str) + 1);
				memcpy(def.value.str, token->token_str, strlen(token->token_str));
			}
			return def;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x8(%rdi), %ebx
movq (%rdi), %r14
cmpl $0xa, %ebx
je 0x334b
cmpl $0xf, %ebx
jne 0x33db
movq %r14, %rdi
callq 0x11d0
movl %eax, %r15d
movl $0xf, %ebx
jmp 0x3418
movl $0xa, %ebx
testq %r14, %r14
je 0x340c
movq %r14, %rdi
callq 0x1080
movq %rax, %r12
leaq -0x2(%rax), %r13
leaq -0x1(%rax), %rdi
callq 0x1170
movq %rax, %r15
movb $0x0, -0x2(%rax,%r12)
testq %r13, %r13
je 0x3411
movl $0x1, %ecx
xorl %eax, %eax
movslq %ecx, %rsi
movb (%r14,%rsi), %dl
cmpb $0x5c, %dl
jne 0x33b7
movzbl 0x1(%r14,%rsi), %edx
incq %rsi
movl %esi, %ecx
cmpl $0x74, %edx
je 0x33ce
cmpl $0x72, %edx
je 0x33c7
cmpl $0x6e, %edx
jne 0x33d5
movb $0xa, (%r15,%rax)
jmp 0x33bb
movb %dl, (%r15,%rax)
incq %rax
incl %ecx
cmpq %rax, %r13
jne 0x338a
jmp 0x3413
movb $0xd, (%r15,%rax)
jmp 0x33bb
movb $0x9, (%r15,%rax)
jmp 0x33bb
movb %dl, (%r15,%rax)
jmp 0x33bb
testq %r14, %r14
je 0x340c
movq %r14, %rdi
callq 0x1080
movq %rax, %r12
leaq 0x1(%rax), %rsi
movl $0x1, %edi
callq 0x1130
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1160
jmp 0x3418
xorl %r15d, %r15d
jmp 0x3418
xorl %eax, %eax
movb $0x0, (%r15,%rax)
movl %ebx, %eax
movq %r15, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/parse.c
// Function: lair_free_tokens
void _lair_free_tokens(struct _lair_token *tokens) {
	while (tokens != NULL) {
		struct _lair_token *to_free = (struct _lair_token *)tokens;
		tokens = tokens->next;
		_lair_free_token(to_free);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x3456
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rbx), %rdi
movq 0x10(%rbx), %r14
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %r14, %rbx
testq %r14, %r14
jne 0x3433
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/parse.c
// Function: lair_parse_from_tokens
struct _lair_ast *_lair_parse_from_tokens(
		struct _lair_runtime *r,
		struct _lair_token **tokens) {
	check(r, tokens != NULL, ERR_PARSE, "No tokens to parse.");
	struct _lair_ast *ast_root = calloc(1, sizeof(struct _lair_ast));
	struct _lair_ast *child_loc = ast_root->children;

	while ((*tokens) != NULL) {
		struct _lair_ast *to_append = _parse_from_token(tokens);

		struct _lair_token *unused = _pop_token(tokens);
		if (unused != NULL)
			_lair_free_token(unused);

		if (ast_root->children == NULL) {
			ast_root->children = to_append;
			child_loc = ast_root->children;
		} else {
			child_loc->sibling = to_append;
			child_loc = child_loc->sibling;
		}
	}

	/* The root node should never have any siblings. */
	check(r, ast_root->next == NULL, ERR_PARSE, "The tree got messed up somehow.");
	return ast_root;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
xorl %esi, %esi
testq %r14, %r14
setne %sil
leaq 0x1330(%rip), %rcx      # 0x47a5
movq %rdi, (%rsp)
xorl %edx, %edx
callq 0x1600
movl $0x1, %edi
movl $0x38, %esi
callq 0x1130
movq %rax, %r15
cmpq $0x0, (%r14)
je 0x34f2
movq %r15, %rbp
addq $0x10, %rbp
movq (%rbp), %r12
movq %r14, %rdi
callq 0x3521
movq %rax, %rbx
movq (%r14), %r13
testq %r13, %r13
je 0x34bf
movq 0x10(%r13), %rax
movq %rax, (%r14)
jmp 0x34c2
xorl %r13d, %r13d
testq %r13, %r13
je 0x34d8
movq (%r13), %rdi
callq 0x1030
movq %r13, %rdi
callq 0x1030
addq $0x18, %r12
cmpq $0x0, (%rbp)
cmoveq %rbp, %r12
movq %rbx, (%r12)
cmpq $0x0, (%r14)
movq %rbx, %r12
jne 0x34a3
xorl %esi, %esi
cmpq $0x0, 0x8(%r15)
sete %sil
leaq 0x12b5(%rip), %rcx      # 0x47b9
movq (%rsp), %rdi
xorl %edx, %edx
callq 0x1600
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/lair.c
// Function: lair_load_file
char *lair_load_file(const char *file_path, size_t *buf_size) {
	struct stat st = {0};
	if (stat(file_path, &st) == -1)
		return NULL;

	int fd = open(file_path, O_RDONLY);
	if (fd <= 0)
		return NULL;

	*buf_size = st.st_size;
	char *loaded = mmap(NULL, *buf_size, PROT_READ, MAP_PRIVATE, fd, 0);
	if (loaded == MAP_FAILED || loaded == NULL)
		return NULL;

	close(fd);

	return loaded;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
xorl %ebx, %ebx
movl $0x90, %edx
movq %r12, %rdi
xorl %esi, %esi
callq 0x10d0
movq %r15, %rdi
movq %r12, %rsi
callq 0x1150
cmpl $-0x1, %eax
je 0x36c4
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x11b0
testl %eax, %eax
jle 0x36c4
movl %eax, %ebp
movq 0x30(%rsp), %rsi
movq %rsi, (%r14)
xorl %ebx, %ebx
xorl %edi, %edi
movl $0x1, %edx
movl $0x2, %ecx
movl %eax, %r8d
xorl %r9d, %r9d
callq 0x1090
movq %rax, %r14
incq %rax
cmpq $0x2, %rax
jb 0x36c4
movl %ebp, %edi
callq 0x1100
movq %r14, %rbx
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/qpfiffer[P]lair/src/lair.c
// Function: lair_execute
int lair_execute(const char *program, const size_t len) {
	struct _lair_runtime *runtime = _lair_runtime_start();
	if (setjmp(runtime->exception_buffer)) {
		if (runtime->exception_msg) {
			print_error(runtime->exception_type, runtime->exception_msg);
		}
		goto error;
	}

	struct _lair_token *tokens = _lair_tokenize(runtime, program, len);
	if (tokens == NULL)
		goto error;

#ifdef DEBUG
	lair_print_tokens(tokens);
#endif
	const struct _lair_ast *ast = _lair_parse_from_tokens(runtime, &tokens);
	if (ast == NULL)
		return 1;

	_lair_eval(runtime, ast);
	_lair_free_tokens(tokens);
	_lair_runtime_end(runtime);
	return 0;

error:
	_lair_free_tokens(tokens);
	_lair_runtime_end(runtime);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0xd8, %esi
callq 0x1130
movq %rax, %rbx
leaq 0x10(%rax), %rdi
callq 0x1120
testl %eax, %eax
je 0x371a
movq 0x8(%rbx), %rsi
movl $0x1, %ebp
testq %rsi, %rsi
je 0x3755
movl (%rbx), %edi
callq 0x165b
jmp 0x3755
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2dd4
movq %rax, (%rsp)
testq %rax, %rax
je 0x3750
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3457
testq %rax, %rax
je 0x3773
movq %rax, %rsi
movq %rbx, %rdi
callq 0x262f
xorl %ebp, %ebp
jmp 0x3755
movl $0x1, %ebp
movq (%rsp), %rdi
callq 0x3427
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %eax
jmp 0x3768