LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_asahi.c
// Function: maker_asahi1_tagname
char *
maker_asahi1_tagname(unsigned short tag,int model)
{
    char *tagname = CNULL;

    switch(tag)
    {
        case 0x0001: tagname = "CaptureMode"; break;
        case 0x0002: tagname = "Quality"; break;
        case 0x0003: tagname = "FocusMode"; break;
        case 0x0004: tagname = "FlashMode"; break;
        case 0x0007: tagname = "WhiteBalance"; break;
        case 0x000a: tagname = "DigitalZoom"; break;
        case 0x000b: tagname = "Sharpness"; break;
        case 0x000c: tagname = "Contrast"; break;
        case 0x000d: tagname = "Saturation"; break;
        case 0x0014: tagname = "ISOSpeedSetting"; break;
        case 0x0017: tagname = "Color"; break;
        case 0x1000: tagname = "TimeZone"; break;
        case 0x1001: tagname = "DaylightSavings"; break;
    }
    setnotetagset(1);
    return(tagname);
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
leal -0x1(%rdi), %eax
cmpl $0x16, %eax
ja 0x3efe2
leaq 0xf3e0(%rip), %rcx      # 0x4e3b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xf674(%rip), %rbx      # 0x4e654
jmp 0x3f05c
cmpl $0x1000, %edi           # imm = 0x1000
je 0x3f055
cmpl $0x1001, %edi           # imm = 0x1001
jne 0x3f05c
leaq 0xf677(%rip), %rbx      # 0x4e670
jmp 0x3f05c
leaq 0xf65e(%rip), %rbx      # 0x4e660
jmp 0x3f05c
leaq 0x4231(%rip), %rbx      # 0x4323c
jmp 0x3f05c
leaq 0xbade(%rip), %rbx      # 0x4aaf2
jmp 0x3f05c
leaq 0xb157(%rip), %rbx      # 0x4a174
jmp 0x3f05c
leaq 0xcc7d(%rip), %rbx      # 0x4bca3
jmp 0x3f05c
leaq 0xb11b(%rip), %rbx      # 0x4a14a
jmp 0x3f05c
leaq 0x41b3(%rip), %rbx      # 0x431eb
jmp 0x3f05c
leaq 0xd12e(%rip), %rbx      # 0x4c16f
jmp 0x3f05c
leaq 0xbd1f(%rip), %rbx      # 0x4ad69
jmp 0x3f05c
leaq 0x4432(%rip), %rbx      # 0x43485
jmp 0x3f05c
leaq 0xc6e7(%rip), %rbx      # 0x4b743
movl $0x1, %edi
callq 0x1c4f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_panasonic.c
// Function: print_panasonic_makervalue
void
print_panasonic_makervalue(struct ifd_entry *entry_ptr,int make,int model,
                    char *prefix)
{
    int noteversion = 0;

    noteversion = getnoteversion();

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
testq %rbx, %rbx
je 0x3f487
movl %eax, %ebp
leaq 0x18d20(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x3f487
leaq 0x886a(%rip), %rsi      # 0x47cd6
movq %rbx, %rdi
callq 0x634b
cmpl $0x1, %ebp
jne 0x3f487
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3f4ac
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_panasonic.c
// Function: print_panasonic_offset_makervalue
void
print_panasonic_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:
                panasonic1_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
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 0x1c4d8
testq %r15, %r15
je 0x3fa42
movzwl %bp, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
cmpl $0x1, %eax
jne 0x3fa48
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3fa72
addq $0x28, %rsp
jmp 0x3fa67
movq %rbx, %r8
movq %r13, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x19706
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_panasonic.c
// Function: maker_panasonic1_tagname
char *
maker_panasonic1_tagname(unsigned short tag,int model)
{
    char *tagname = CNULL;

    switch(tag)
    {
        case 0x0001: tagname = "Quality"; break;
        case 0x0002: tagname = "FirmwareVersion"; break;
        case 0x0003: tagname = "WhiteBalance"; break; 
        case 0x0007: tagname = "FocusMode"; break;
        case 0x000f: tagname = "SpotMode"; break;
        case 0x001a: tagname = "StabilizerMode"; break;
        case 0x001c: tagname = "Macro"; break;
        case 0x001f: tagname = "PictureMode"; break;
        case 0x0020: tagname = "Audio"; break;
        case 0x0023: tagname = "WhiteBalanceAdjust"; break;
        case 0x0024: tagname = "FlashStrength"; break;
        case 0x0028: tagname = "ColorMode"; break;
        case 0x0029: tagname = "TimeSincePowerOn"; break;
        case 0x002c: tagname = "Contrast"; break;
        case 0x002d: tagname = "NoiseReduction"; break;
        case 0x0e00: tagname = "PrintIM"; break;
        default: break;
    }
    setnotetagset(1);
    return(tagname);
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
cmpl $0x19, %edi
jle 0x3fc3f
leal -0x1a(%rdi), %eax
cmpl $0x13, %eax
ja 0x3fc63
leaq 0xecae(%rip), %rcx      # 0x4e8d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xecf7(%rip), %rbx      # 0x4e931
jmp 0x3fcf0
leal -0x1(%rdi), %eax
cmpl $0x6, %eax
ja 0x3fc78
leaq 0xec6e(%rip), %rcx      # 0x4e8bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc045(%rip), %rbx      # 0x4bca3
jmp 0x3fcf0
cmpl $0xe00, %edi            # imm = 0xE00
jne 0x3fcf0
leaq 0x364c(%rip), %rbx      # 0x432c2
jmp 0x3fcf0
cmpl $0xf, %edi
jne 0x3fcf0
leaq 0xeca4(%rip), %rbx      # 0x4e928
jmp 0x3fcf0
leaq 0x355e(%rip), %rbx      # 0x431eb
jmp 0x3fcf0
leaq 0xb026(%rip), %rbx      # 0x4acbc
jmp 0x3fcf0
leaq 0xa4d5(%rip), %rbx      # 0x4a174
jmp 0x3fcf0
leaq 0xd71d(%rip), %rbx      # 0x4d3c5
jmp 0x3fcf0
leaq 0xeca8(%rip), %rbx      # 0x4e959
jmp 0x3fcf0
leaq 0x9985(%rip), %rbx      # 0x4963f
jmp 0x3fcf0
leaq 0xb613(%rip), %rbx      # 0x4b2d6
jmp 0x3fcf0
leaq 0xb621(%rip), %rbx      # 0x4b2ed
jmp 0x3fcf0
leaq 0x3567(%rip), %rbx      # 0x4323c
jmp 0x3fcf0
leaq 0x6a39(%rip), %rbx      # 0x46717
jmp 0x3fcf0
leaq 0xec59(%rip), %rbx      # 0x4e940
jmp 0x3fcf0
leaq 0xec56(%rip), %rbx      # 0x4e946
movl $0x1, %edi
callq 0x1c4f0
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_kyocera.c
// Function: print_kyocera_offset_makervalue
void
print_kyocera_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:
                kyocera1_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
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 0x1c4d8
testq %r15, %r15
je 0x3fe20
movzwl %bp, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
cmpl $0x1, %eax
jne 0x3fe26
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3fe50
addq $0x28, %rsp
jmp 0x3fe45
movq %rbx, %r8
movq %r13, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x19706
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_toshiba.c
// Function: print_toshiba_makervalue
void
print_toshiba_makervalue(struct ifd_entry *entry_ptr,int make,int model,
                    char *prefix)
{
    int noteversion = 0;

    if(entry_ptr && (PRINT_VALUE))
    {
        noteversion = getnoteversion();
        switch(noteversion)
        {
            default:
                print_toshiba1_makervalue(entry_ptr,make,model,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4008d
leaq 0x1811f(%rip), %r14     # 0x58180
testb $0x30, (%r14)
je 0x4008d
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
testb $0x30, (%r14)
je 0x4008d
leaq 0x7c58(%rip), %rsi      # 0x47cd6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x634b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_toshiba.c
// Function: print_toshiba_offset_makervalue
void
print_toshiba_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:
                toshiba1_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 0x4012e
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 0x1c4d8
movzwl %bp, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
cmpl $0x1, %eax
jne 0x40134
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4015e
addq $0x28, %rsp
jmp 0x40153
movq %rbx, %r8
movq %r13, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x19706
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_sigma.c
// Function: print_sigma_makervalue
void
print_sigma_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_sigma1_makervalue(entry_ptr,make,model,prefix);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x40382
leaq 0x17e2f(%rip), %r14     # 0x58180
testb $0x30, (%r14)
je 0x40382
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
cmpl $0x1, %eax
jne 0x4036c
testb $0x30, (%r14)
je 0x40382
leaq 0x7963(%rip), %rsi      # 0x47cd6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x634b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4050c
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 0x1c518
leaq 0x14df(%rip), %rsi      # 0x41997
movq %rbx, %rdi
movq %rax, %rdx
callq 0x17f99
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 0x19706
addq $0x20, %rsp
testq %rbx, %rbx
je 0x4050c
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_O3/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 0x40670
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
xorl %eax, %eax
callq 0x1c4d8
cmpl $0x1, %eax
jne 0x40670
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 0x40679
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rdi, %rdi
je 0x408b4
movq %rdi, %rbx
leaq 0x178f4(%rip), %r14     # 0x58180
testb $0x30, (%r14)
je 0x408b4
xorl %eax, %eax
callq 0x1c4d8
cmpl $0x1, %eax
je 0x4088c
leaq 0x7431(%rip), %rsi      # 0x47cd6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x634b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1c4d8
testq %r15, %r15
je 0x40978
movl 0x50(%rsp), %r11d
movl 0x48(%rsp), %r10d
movq 0x40(%rsp), %r13
movzwl %bp, %ebp
cmpl $0x1, %eax
jne 0x4094e
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 0x40987
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 0x19706
addq $0x28, %rsp
jmp 0x4097c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1448
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 0x6e80(%rip), %rbx      # 0x8070
leaq 0x3e34(%rip), %rsi      # 0x502b
movq %rbx, %rdi
callq 0x2cfa
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 0x6e82(%rip), %rsi      # 0x80b0
xorl %eax, %eax
callq 0x1050
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x2e9d
testl %eax, %eax
jne 0x1283
cmpb $0x0, -0x33(%rbp)
je 0x1283
leaq -0x33(%rbp), %rbx
leaq 0x3df9(%rip), %r14      # 0x504f
leaq 0x6e13(%rip), %r15      # 0x8070
leaq -0x40(%rbp), %r12
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
movq %r15, %rdi
movq %r12, %rsi
callq 0x2e9d
testl %eax, %eax
jne 0x1283
cmpb $0x0, -0x33(%rbp)
jne 0x1261
leaq 0x6de6(%rip), %rdi      # 0x8070
callq 0x2e79
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_O3/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 0x3658
testq %rax, %rax
je 0x1338
movq %rax, %rbx
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x36ef
testl %eax, %eax
je 0x1350
leaq 0x2ce3(%rip), %rsi      # 0x4019
jmp 0x133f
leaq 0x2cc5(%rip), %rsi      # 0x4004
movl $0x2, %edi
callq 0x1653
movl $0x1, %eax
jmp 0x135f
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3796
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %ebp, %ebp
cmpq $0x8, (%rdi)
jne 0x15d7
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
cmpq 0x8(%rdi), %rsi
jne 0x15bd
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rdi
shlq $0x4, %rsi
callq 0x1180
testq %rax, %rax
je 0x15d7
movq %rax, 0x18(%rbx)
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
jmp 0x15c6
movq 0x18(%rbx), %rax
movl $0x8, %ecx
imulq %rsi, %rcx
movq %r14, (%rax,%rcx)
incq 0x10(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1689
movl %edi, %eax
leaq 0x2a2c(%rip), %rcx      # 0x40ac
movslq (%rcx,%rax,4), %r15
addq %rcx, %r15
jmp 0x1690
leaq 0x2a13(%rip), %r15      # 0x40a3
movq %rsp, %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x10d0
leaq 0x29c4(%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 0x299b(%rip), %rdx      # 0x407c
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10b0
leaq 0x30cf(%rip), %rdi      # 0x47c6
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_O3/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 0x28d2(%rip), %rcx      # 0x4169
movl %eax, %esi
movl $0x2, %edx
callq 0x1608
xorl %esi, %esi
cmpq $0x0, (%rbx)
setne %sil
leaq 0x28e4(%rip), %r15      # 0x4198
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1608
xorl %esi, %esi
cmpq $0x0, 0x8(%rbx)
setne %sil
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1608
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl (%rax), %eax
xorl %esi, %esi
cmpl (%rcx), %eax
sete %sil
leaq 0x2813(%rip), %rcx      # 0x410a
movq %r14, %rdi
movl $0x2, %edx
callq 0x1608
movq (%rbx), %rax
xorl %esi, %esi
cmpl $0xa, (%rax)
setne %sil
leaq 0x28a4(%rip), %r15      # 0x41bb
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1608
movq 0x8(%rbx), %rax
xorl %esi, %esi
cmpl $0xa, (%rax)
setne %sil
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1608
movq (%rbx), %rax
cmpl $0xf, (%rax)
jne 0x1970
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 0x1986
leaq 0x285c(%rip), %rdx      # 0x41d3
movq %r14, %rdi
movl $0x2, %esi
callq 0x1630
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2851(%rip), %rcx      # 0x41fc
movl %eax, %esi
movl $0x2, %edx
callq 0x1608
xorl %esi, %esi
cmpq $0x0, (%rbx)
setne %sil
leaq 0x2863(%rip), %r15      # 0x422b
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1608
xorl %esi, %esi
cmpq $0x0, 0x8(%rbx)
setne %sil
movq %r14, %rdi
movl $0x2, %edx
movq %r15, %rcx
callq 0x1608
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl (%rax), %eax
xorl %esi, %esi
cmpl (%rcx), %eax
sete %sil
leaq 0x2843(%rip), %rcx      # 0x424e
movq %r14, %rdi
movl $0x2, %edx
callq 0x1608
movq (%rbx), %rax
movl (%rax), %ecx
cmpl $0xa, %ecx
je 0x1a52
cmpl $0xf, %ecx
je 0x1a3a
cmpl $0xd, %ecx
jne 0x1a92
movb 0x8(%rax), %al
movq 0x8(%rbx), %rcx
cmpb 0x8(%rcx), %al
je 0x1a46
jmp 0x1a86
movl 0x8(%rax), %eax
movq 0x8(%rbx), %rcx
cmpl 0x8(%rcx), %eax
jne 0x1a86
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1d08
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 0x1a46
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1d00
leaq 0x27d5(%rip), %rdx      # 0x426e
movq %r14, %rdi
movl $0x2, %esi
callq 0x1630
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x27d9(%rip), %rcx      # 0x429a
movl %eax, %esi
movl $0x2, %edx
callq 0x1608
movq (%rbx), %rax
testq %rax, %rax
je 0x1afd
movl (%rax), %edi
leal -0x1(%rdi), %ecx
cmpl $0x2, %ecx
jb 0x1b0d
cmpl $0xf, %edi
je 0x1b22
cmpl $0xa, %edi
jne 0x1b35
movq 0x8(%rax), %rsi
leaq 0x2cd2(%rip), %rdi      # 0x47c6
xorl %eax, %eax
callq 0x10a0
jmp 0x1b4e
leaq 0x284d(%rip), %rdi      # 0x4351
xorl %eax, %eax
callq 0x10a0
jmp 0x1b4e
callq 0x2b4c
movq (%rbx), %rcx
movq 0x8(%rcx), %rdx
leaq 0x27ad(%rip), %rdi      # 0x42cd
jmp 0x1b44
movl 0x8(%rax), %esi
leaq 0x27f1(%rip), %rdi      # 0x431d
xorl %eax, %eax
callq 0x10a0
jmp 0x1b4e
callq 0x2b4c
movq (%rbx), %rdx
leaq 0x2793(%rip), %rdi      # 0x42d7
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2772(%rip), %rcx      # 0x42e0
movl $0x2, %edx
callq 0x1608
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1aae
movl $0xa, %edi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x26d0(%rip), %rdx      # 0x4400
leaq -0x289(%rip), %r8       # 0x1aae
movq %r14, %rdi
movq %rax, %rsi
movl $0x1, %ecx
callq 0x1e66
testl %eax, %eax
je 0x1d5c
leaq 0x26b4(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x1653
leaq 0x26c1(%rip), %rdx      # 0x4424
leaq -0x218(%rip), %r8       # 0x1b52
movq %r14, %rdi
movq %rbx, %rsi
movl $0x1, %ecx
callq 0x1e66
testl %eax, %eax
je 0x1d8f
leaq 0x2681(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x1653
leaq 0x2696(%rip), %rdx      # 0x442c
leaq -0x68d(%rip), %r8       # 0x1710
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %ecx
callq 0x1e66
testl %eax, %eax
je 0x1dc2
leaq 0x264e(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x1653
leaq 0x2a8b(%rip), %rdx      # 0x4854
leaq -0x555(%rip), %r8       # 0x187b
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %ecx
callq 0x1e66
testl %eax, %eax
je 0x1df5
leaq 0x261b(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x1653
leaq 0x2632(%rip), %rdx      # 0x442e
leaq -0x472(%rip), %r8       # 0x1991
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %ecx
callq 0x1e66
testl %eax, %eax
je 0x1e28
leaq 0x25e8(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x1653
leaq 0x2601(%rip), %rdx      # 0x4430
leaq -0x2a0(%rip), %r8       # 0x1b96
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %ecx
callq 0x1e66
testl %eax, %eax
je 0x1e5b
leaq 0x25b5(%rip), %rsi      # 0x4406
movl $0x2, %edi
callq 0x1653
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25a2(%rip), %rcx      # 0x4434
movl $0x2, %edx
callq 0x1608
xorl %esi, %esi
testq %r14, %r14
setne %sil
leaq 0x25a6(%rip), %rcx      # 0x4452
movq %r12, %rdi
movl $0x2, %edx
callq 0x1608
xorl %esi, %esi
cmpb $0x0, (%rbx)
setne %sil
leaq 0x25a5(%rip), %rcx      # 0x446e
movq %r12, %rdi
movl $0x2, %edx
callq 0x1608
movq 0x8(%r14), %r13
addq $0x8, %r14
movq %rbx, %rdi
callq 0x1080
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2a16
testq %rax, %rax
je 0x1f0d
leaq 0x2597(%rip), %rdx      # 0x4497
movq %r12, %rdi
movl $0x2, %esi
callq 0x1630
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 0x2910
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1d10
movq %rax, %r14
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x2692
movq %r14, %rax
addq $0x10, %rax
movq %rax, (%rsp)
movl 0x28(%r15), %eax
cmpl $0x1, %eax
je 0x2628
cmpl $0xb, %eax
jne 0x2685
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f71
jmp 0x2685
movq 0x30(%r15), %r13
movq %r13, %rdi
callq 0x1080
movq %rax, %rbp
movq 0x10(%r14), %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x2a16
movq %rax, %r12
movq 0x8(%r14), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x2a16
orq %r12, %rax
je 0x266d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2305
jmp 0x2685
movl $0x38, %r8d
movq (%rsp), %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r15, %rcx
callq 0x2910
movq 0x18(%r15), %r15
testq %r15, %r15
jne 0x260a
movq %r14, %rdi
callq 0x26ab
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_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x29d8
movq %rdx, %r15
movq %rcx, (%rsp)
testq %rdx, %rdx
je 0x29f7
movq %r8, %rbx
movq %rsi, %r12
movq %rdi, %r13
movb (%r12), %r14b
movq (%r13), %rbp
testq %rbp, %rbp
je 0x2967
cmpb 0x18(%rbp), %r14b
jge 0x2956
addq $0x10, %rbp
jmp 0x2958
je 0x2981
movq %rbp, %r13
movq (%rbp), %rax
movq %rax, %rbp
testq %rax, %rax
jne 0x294a
movl $0x1, %edi
movl $0x28, %esi
callq 0x1130
movq %rax, %rbp
movq %rax, (%r13)
movb %r14b, 0x18(%rax)
cmpq $0x2, %r15
jb 0x2996
addq $0x8, %rbp
incq %r12
decq %r15
movq %rbp, %r13
jmp 0x293d
movl $0x1, %eax
cmpq $0x0, 0x20(%rbp)
jne 0x29c9
movl $0x1, %edi
movq %rbx, %rsi
callq 0x1130
movq %rax, 0x20(%rbp)
movq (%r13), %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
leaq 0x1c62(%rip), %rdi      # 0x4641
leaq 0x1c67(%rip), %rsi      # 0x464d
leaq 0x1c6a(%rip), %rcx      # 0x4657
movl $0x24, %edx
callq 0x10c0
leaq 0x1cbe(%rip), %rdi      # 0x46bc
leaq 0x1c48(%rip), %rsi      # 0x464d
leaq 0x1c4b(%rip), %rcx      # 0x4657
movl $0x25, %edx
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/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 0x2a4c
movb (%rsi), %cl
cmpb 0x18(%rdi), %cl
jge 0x2a2a
addq $0x10, %rdi
jmp 0x2a2c
je 0x2a36
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x2a1f
jmp 0x2a4c
cmpq $0x2, %rdx
jb 0x2a48
movq 0x8(%rdi), %rdi
incq %rsi
decq %rdx
jmp 0x2a18
movq 0x20(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2b4b
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 0x2b3a
movq 0x8(%r12), %r14
movq %r12, %rdi
callq 0x1030
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x2ac8
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 0x2aea
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 0x2b0d
movl $0x1, %edi
movl $0x10, %esi
callq 0x1130
movq %rax, %r12
movq %r15, (%rax)
movq %r13, 0x8(%rax)
jmp 0x2b10
movq %r15, %r12
testq %rbx, %rbx
je 0x2b20
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x2b20
callq *%rbx
movq 0x20(%r14), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq (%r12), %r15
jmp 0x2a90
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1030
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2ced
movq %rdi, %rbx
leaq 0x1bef(%rip), %r12      # 0x477f
leaq 0x1bcd(%rip), %r15      # 0x4764
leaq 0x1c22(%rip), %r13      # 0x47c0
leaq 0x1b23(%rip), %r14      # 0x46c8
movl $0x0, -0x2c(%rbp)
movl 0x8(%rbx), %eax
decl %eax
cmpl $0xe, %eax
ja 0x2c21
movslq (%r14,%rax,4), %rcx
addq %r14, %rcx
movq %r15, %rax
movq %r12, %rsi
jmpq *%rcx
leaq 0x1ba6(%rip), %rax      # 0x4772
movq (%rbx), %rdx
leaq 0x1be7(%rip), %rdi      # 0x47bd
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
jmp 0x2ce0
leaq 0x1bc1(%rip), %rsi      # 0x47ad
jmp 0x2cd6
leaq 0x1bb9(%rip), %rsi      # 0x47b1
jmp 0x2cd6
leaq 0x1b8b(%rip), %rsi      # 0x478f
jmp 0x2cd6
leaq 0x1ba4(%rip), %rsi      # 0x47b4
jmp 0x2cd6
leaq 0x1b85(%rip), %rsi      # 0x47a1
jmp 0x2cd6
leaq 0x1b38(%rip), %rsi      # 0x4760
jmp 0x2cd6
leaq 0x1b58(%rip), %rsi      # 0x478c
jmp 0x2cd6
leaq 0x1c16(%rip), %rdi      # 0x4856
callq 0x1070
jmp 0x2ce0
leaq 0x1b45(%rip), %rsi      # 0x4796
jmp 0x2cd6
leaq 0x1b4b(%rip), %rsi      # 0x47a8
jmp 0x2cd6
movq %rsp, -0x38(%rbp)
movl 0xc(%rbx), %eax
incl %eax
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)
movl -0x2c(%rbp), %eax
cmpl 0xc(%rbx), %eax
leaq 0x1b27(%rip), %rdi      # 0x47c5
leaq 0x1b1f(%rip), %rax      # 0x47c4
cmovbq %rax, %rdi
movq %r13, %rsi
leaq 0x1b0d(%rip), %r13      # 0x47c0
xorl %eax, %eax
callq 0x10a0
movl 0xc(%rbx), %eax
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rsp
jmp 0x2ce0
leaq 0x1aa0(%rip), %rsi      # 0x476d
jmp 0x2cd6
leaq 0x1ae3(%rip), %rsi      # 0x47b9
movq %r13, %rdi
xorl %eax, %eax
callq 0x10a0
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x2bac
leaq 0x1b5d(%rip), %rdi      # 0x4851
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_O3/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 0x2d3d
cmpl $0x39, %ecx
jg 0x2d56
cmpl $0x21, %ecx
je 0x2def
cmpl $0x22, %ecx
je 0x2d4a
jmp 0x2db4
cmpl $0x22, %ecx
jne 0x2d70
cmpb $0x22, -0x1(%r14,%rax)
jne 0x2d9b
movl $0xa, 0x8(%rbx)
jmp 0x2dff
cmpl $0x3f, %ecx
je 0x2df8
cmpl $0x3a, %ecx
jne 0x2db4
movl $0x4, 0x8(%rbx)
jmp 0x2dff
movq %r14, %rdi
callq 0x1080
testq %rax, %rax
je 0x2ddd
movl $0x1, %ecx
xorl %edx, %edx
movb (%r14,%rdx), %dl
addb $-0x3a, %dl
cmpb $-0xa, %dl
jb 0x2de6
movl %ecx, %edx
incl %ecx
cmpq %rdx, %rax
ja 0x2d84
jmp 0x2ddd
leaq 0x1a27(%rip), %rdx      # 0x47c9
movq %r15, %rdi
movl $0x1, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1630
movq %r14, %rdi
callq 0x1080
testq %rax, %rax
je 0x2ddd
movl $0x1, %ecx
xorl %edx, %edx
movb (%r14,%rdx), %dl
addb $-0x3a, %dl
cmpb $-0xa, %dl
jb 0x2de6
movl %ecx, %edx
incl %ecx
cmpq %rdx, %rax
ja 0x2dc8
movl $0xf, 0x8(%rbx)
jmp 0x2dff
movl $0xe, 0x8(%rbx)
jmp 0x2dff
movl $0xb, 0x8(%rbx)
jmp 0x2dff
movl $0xc, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq