LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/maker_agfa.c
// Function: maker_agfa1_tagname
char *
maker_agfa1_tagname(unsigned short tag)
{
    char *tagname = CNULL;

    switch(tag)
    {
        case 0x0100: tagname = "JpegThumbnail"; break;
        case 0x0200: tagname = "SpecialMode"; break;
        case 0x0201: tagname = "Quality"; break;
        case 0x0202: tagname = "Macro"; break;
        case 0x0204: tagname = "DigitalZoom"; break;
        case 0x0207: tagname = "SoftwareRelease"; break;
        case 0x0208: tagname = "PictureInfo"; break;
        case 0x0209: tagname = "CameraID"; break;
        case 0x020b: tagname = "ImageWidth"; break; /* ? */
        case 0x020c: tagname = "ImageHeight"; break; /* ? */
        case 0x0f00: tagname = "Data"; break;
        default: break;
    }
    setnotetagset(1);
    return(tagname);
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
leal -0x200(%rdi), %eax
cmpl $0xc, %eax
ja 0x3bbc5
leaq 0x105a5(%rip), %rcx     # 0x4c158
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xca25(%rip), %rbx      # 0x485e8
jmp 0x3bc2d
cmpl $0xf00, %edi            # imm = 0xF00
je 0x3bc26
cmpl $0x100, %edi            # imm = 0x100
jne 0x3bc2d
leaq 0x6389(%rip), %rbx      # 0x41f65
jmp 0x3bc2d
leaq 0xca39(%rip), %rbx      # 0x4861e
jmp 0x3bc2d
leaq 0x8ad9(%rip), %rbx      # 0x446c7
jmp 0x3bc2d
leaq 0x102ad(%rip), %rbx     # 0x4bea4
jmp 0x3bc2d
leaq 0xc4fa(%rip), %rbx      # 0x480fa
jmp 0x3bc2d
leaq 0xe04a(%rip), %rbx      # 0x49c53
jmp 0x3bc2d
leaq 0xc9f2(%rip), %rbx      # 0x48604
jmp 0x3bc2d
leaq 0x10277(%rip), %rbx     # 0x4be92
jmp 0x3bc2d
leaq 0x628e(%rip), %rbx      # 0x41eb2
jmp 0x3bc2d
leaq 0x6ce4(%rip), %rbx      # 0x42911
pushq $0x1
popq %rdi
callq 0x1b2bd
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/maker_asahi.c
// Function: print_asahi_makervalue
void
print_asahi_makervalue(struct ifd_entry *entry_ptr,int make,int model,
                                                        char *prefix)
{
    int noteversion = 0;

    noteversion = getnoteversion();

    if(entry_ptr)
    {
        switch(noteversion)
        {
            case 3:
                print_asahi1_makervalue(entry_ptr,make,model,prefix);
                asahi3_interpret_value(entry_ptr);
                break;
            case 2:
                print_asahi1_makervalue(entry_ptr,make,model,prefix);
                asahi2_interpret_value(entry_ptr);
                break;
            case 1:
                print_asahi1_makervalue(entry_ptr,make,model,prefix);
                asahi1_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 0x1b2a5
testq %rbx, %rbx
je 0x3bd16
movl %eax, %ebp
leaq 0x9f95(%rip), %rsi      # 0x45c86
movq %rbx, %rdi
callq 0x5dd3
cmpl $0x1, %ebp
je 0x3bd2b
cmpl $0x2, %ebp
je 0x3bd1d
cmpl $0x3, %ebp
jne 0x3bd16
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3bd4b
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3c13f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3c4a7
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/maker_asahi.c
// Function: print_asahi_offset_makervalue
void
print_asahi_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 3:
                asahi2_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                break;
            case 2:
                asahi1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                break;
            case 1:
                asahi1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
movl 0x80(%rsp), %eax
movq %rax, (%rsp)
movl 0x78(%rsp), %eax
movq %rax, 0x8(%rsp)
movl 0x70(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
callq 0x1b2a5
testq %r12, %r12
je 0x3c730
cmpl $0x1, %eax
je 0x3c774
cmpl $0x2, %eax
je 0x3c736
cmpl $0x3, %eax
jne 0x3c799
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0x3c7b6
jmp 0x3c765
addq $0x28, %rsp
jmp 0x3c769
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0x3cb4e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3cb4e
leaq 0x94e6(%rip), %rsi      # 0x45c86
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5dd3
// File: /workspace/github_c_makefile_star2_O2/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 0x3cf9c
leaq 0xf3d6(%rip), %rcx      # 0x4c360
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xf66a(%rip), %rbx      # 0x4c604
jmp 0x3d016
cmpl $0x1000, %edi           # imm = 0x1000
je 0x3d00f
cmpl $0x1001, %edi           # imm = 0x1001
jne 0x3d016
leaq 0xf66d(%rip), %rbx      # 0x4c620
jmp 0x3d016
leaq 0xf654(%rip), %rbx      # 0x4c610
jmp 0x3d016
leaq 0x4277(%rip), %rbx      # 0x4123c
jmp 0x3d016
leaq 0xbad4(%rip), %rbx      # 0x48aa2
jmp 0x3d016
leaq 0xb14d(%rip), %rbx      # 0x48124
jmp 0x3d016
leaq 0xcc73(%rip), %rbx      # 0x49c53
jmp 0x3d016
leaq 0xb111(%rip), %rbx      # 0x480fa
jmp 0x3d016
leaq 0x41f9(%rip), %rbx      # 0x411eb
jmp 0x3d016
leaq 0xd124(%rip), %rbx      # 0x4a11f
jmp 0x3d016
leaq 0xbd15(%rip), %rbx      # 0x48d19
jmp 0x3d016
leaq 0x4478(%rip), %rbx      # 0x41485
jmp 0x3d016
leaq 0xc6dd(%rip), %rbx      # 0x496f3
pushq $0x1
popq %rdi
callq 0x1b2bd
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1b2a5
testq %rbx, %rbx
je 0x3d3f2
leaq 0x19da9(%rip), %rcx     # 0x57180
testb $0x30, (%rcx)
je 0x3d3f2
cmpl $0x1, %eax
jne 0x3d3f4
movq %rbx, %rdi
callq 0x3d404
movq %rbx, %rdi
popq %rbx
jmp 0x3d422
popq %rbx
retq
leaq 0x888b(%rip), %rsi      # 0x45c86
movq %rbx, %rdi
popq %rbx
jmp 0x5dd3
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2a5
testq %r15, %r15
je 0x3d9a9
movzwl %bp, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
cmpl $0x1, %eax
jne 0x3d9af
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d9d9
addq $0x28, %rsp
jmp 0x3d9ce
movq %rbx, %r8
movq %r13, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x185a8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leal -0x1a(%rdi), %eax
cmpl $0x13, %eax
ja 0x3db94
leaq 0xed09(%rip), %rcx      # 0x4c888
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xed52(%rip), %rbx      # 0x4c8e1
jmp 0x3dc41
leal -0x1(%rdi), %eax
cmpl $0x6, %eax
ja 0x3dbb8
leaq 0xecc9(%rip), %rcx      # 0x4c86c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc0a0(%rip), %rbx      # 0x49c53
jmp 0x3dc41
cmpl $0xf, %edi
je 0x3dc3a
cmpl $0xe00, %edi            # imm = 0xE00
jne 0x3dc41
leaq 0x36f6(%rip), %rbx      # 0x412c2
jmp 0x3dc41
leaq 0x9a1a(%rip), %rbx      # 0x475ef
jmp 0x3dc41
leaq 0xed12(%rip), %rbx      # 0x4c8f0
jmp 0x3dc41
leaq 0xed22(%rip), %rbx      # 0x4c909
jmp 0x3dc41
leaq 0xb6ad(%rip), %rbx      # 0x4929d
jmp 0x3dc41
leaq 0xd77c(%rip), %rbx      # 0x4b375
jmp 0x3dc41
leaq 0xb684(%rip), %rbx      # 0x49286
jmp 0x3dc41
leaq 0xeceb(%rip), %rbx      # 0x4c8f6
jmp 0x3dc41
leaq 0x6ab3(%rip), %rbx      # 0x446c7
jmp 0x3dc41
leaq 0x361f(%rip), %rbx      # 0x4123c
jmp 0x3dc41
leaq 0xb046(%rip), %rbx      # 0x48c6c
jmp 0x3dc41
leaq 0x35bc(%rip), %rbx      # 0x411eb
jmp 0x3dc41
leaq 0xa4ec(%rip), %rbx      # 0x48124
jmp 0x3dc41
leaq 0xec97(%rip), %rbx      # 0x4c8d8
pushq $0x1
popq %rdi
callq 0x1b2bd
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/maker_kyocera.c
// Function: print_kyocera_makervalue
void
print_kyocera_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_kyocera1_makervalue(entry_ptr,make,model,prefix);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1b2a5
testq %rbx, %rbx
je 0x3dcce
leaq 0x194c5(%rip), %rcx     # 0x57180
testb $0x30, (%rcx)
je 0x3dcce
cmpl $0x1, %eax
jne 0x3dcd0
movq %rbx, %rdi
popq %rbx
jmp 0x3dce0
popq %rbx
retq
leaq 0x7faf(%rip), %rsi      # 0x45c86
movq %rbx, %rdi
popq %rbx
jmp 0x5dd3
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2a5
testq %r15, %r15
je 0x3dd79
movzwl %bp, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
cmpl $0x1, %eax
jne 0x3dd7f
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3dda9
addq $0x28, %rsp
jmp 0x3dd9e
movq %rbx, %r8
movq %r13, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x185a8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3e053
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 0x1b2a5
movzwl %bp, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
cmpl $0x1, %eax
jne 0x3e059
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3e083
addq $0x28, %rsp
jmp 0x3e078
movq %rbx, %r8
movq %r13, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x185a8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x3e282
leaq 0x18f1b(%rip), %rax     # 0x57180
testb $0x30, (%rax)
je 0x3e282
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1b2a5
cmpl $0x1, %eax
jne 0x3e284
movq %rbx, %rdi
popq %rbx
jmp 0x3e294
popq %rbx
retq
leaq 0x79fb(%rip), %rsi      # 0x45c86
movq %rbx, %rdi
popq %rbx
jmp 0x5dd3
// File: /workspace/github_c_makefile_star2_O2/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 0x3e32d
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 0x1b2a5
movzwl %bp, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
cmpl $0x1, %eax
jne 0x3e333
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3e35d
addq $0x28, %rsp
jmp 0x3e352
movq %rbx, %r8
movq %r13, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x185a8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdx, %rdx
je 0x3e411
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
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 0x1b2e4
leaq 0x15d5(%rip), %rsi      # 0x3f997
movq %rbx, %rdi
movq %rax, %rdx
callq 0x16f1d
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 0x185a8
addq $0x20, %rsp
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3050
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/maker_sony.c
// Function: print_sony_makervalue
void
print_sony_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_sony1_makervalue(entry_ptr,make,model,prefix);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1b2a5
testq %rbx, %rbx
je 0x3e4f6
leaq 0x18c9d(%rip), %rcx     # 0x57180
testb $0x30, (%rcx)
je 0x3e4f6
cmpl $0x1, %eax
jne 0x3e4f8
movq %rbx, %rdi
popq %rbx
jmp 0x3e508
popq %rbx
retq
leaq 0x7787(%rip), %rsi      # 0x45c86
movq %rbx, %rdi
popq %rbx
jmp 0x5dd3
// File: /workspace/github_c_makefile_star2_O2/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 0x3e569
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
xorl %eax, %eax
callq 0x1b2a5
cmpl $0x1, %eax
jne 0x3e569
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 0x3e572
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3e797
movq %rdi, %rbx
leaq 0x18a11(%rip), %r14     # 0x57180
testb $0x30, (%r14)
je 0x3e797
xorl %eax, %eax
callq 0x1b2a5
cmpl $0x1, %eax
je 0x3e76f
leaq 0x74fe(%rip), %rsi      # 0x45c86
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5dd3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2a5
testq %r15, %r15
je 0x3e85b
movl 0x50(%rsp), %r11d
movl 0x48(%rsp), %r10d
movq 0x40(%rsp), %r13
movzwl %bp, %ebp
cmpl $0x1, %eax
jne 0x3e831
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 0x3e86a
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 0x185a8
addq $0x28, %rsp
jmp 0x3e85f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x142c
movl %eax, %ebx
movl %eax, %edi
callq 0x12a7
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 0x2ba6
movl %eax, %r15d
movl %eax, %edi
callq 0x12a7
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 -0x33(%rbp), %r14
leaq -0x40(%rbp), %r15
leaq 0x3e0b(%rip), %r12      # 0x504f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2d20
testl %eax, %eax
jne 0x1268
cmpb $0x0, -0x33(%rbp)
je 0x1268
movq %r12, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1050
jmp 0x1244
leaq 0x6e01(%rip), %rdi      # 0x8070
callq 0x2cff
movl %eax, %ebx
movl %eax, %edi
callq 0x12a7
leaq 0x3d80(%rip), %rdi      # 0x5004
leaq 0x3dd0(%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_O2/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
andq $0x0, (%rsi)
callq 0x33c2
testq %rax, %rax
je 0x1335
movq %rax, %rbx
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x3455
testl %eax, %eax
je 0x1349
leaq 0x2ce6(%rip), %rsi      # 0x4019
jmp 0x133c
leaq 0x2cc8(%rip), %rsi      # 0x4004
pushq $0x2
popq %rdi
callq 0x15f9
pushq $0x1
popq %rax
jmp 0x1358
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x34ec
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
pushq $0x1
popq %rbx
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x1130
movq %rax, %r14
movq %rsp, %r15
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x10d0
leaq 0x2c95(%rip), %rdi      # 0x402c
xorl %eax, %eax
callq 0x10a0
movq 0x5c3b(%rip), %r12      # 0x6fe0
pushq $0x1
popq %rbp
movq (%r12), %rdx
movq %r15, %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x1110
testq %rax, %rax
je 0x13f1
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
callq 0x10e0
addq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1180
testq %rax, %rax
je 0x1403
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10f0
jmp 0x13a8
movq %r14, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1030
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x142b
cmpl $0x1, %edi
jne 0x1423
jmp 0x135e
movq %rsi, %rdi
jmp 0x12fc
pushq %rax
movq (%rsi), %rdi
callq 0x143b
xorl %edi, %edi
callq 0x11e0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rdi
callq 0x1170
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %r15, 0x18(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1594
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
cmpq 0x8(%rdi), %rsi
jne 0x157e
leaq (%rsi,%rsi), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rdi
shlq $0x4, %rsi
callq 0x1180
testq %rax, %rax
je 0x1594
movq %rax, 0x18(%rbx)
movq (%rbx), %rcx
movq 0x10(%rbx), %rsi
jmp 0x1585
movq 0x18(%rbx), %rax
pushq $0x8
popq %rcx
imulq %rsi, %rcx
movq %r14, (%rax,%rcx)
incq 0x10(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x162d
movl %edi, %eax
leaq 0x2a88(%rip), %rcx      # 0x40ac
movslq (%rcx,%rax,4), %r15
addq %rcx, %r15
jmp 0x1634
leaq 0x2a6f(%rip), %r15      # 0x40a3
movq %rsp, %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x10d0
leaq 0x2a20(%rip), %rdx      # 0x406d
pushq $0x1b
popq %rcx
pushq $0x1f
popq %r8
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
pushq $0x0
pushq $0x1b
callq 0x10b0
popq %rcx
popq %rdx
movq %r14, %rdi
callq 0x1080
leaq (%rsp,%rax), %rdi
leaq 0x29fd(%rip), %rdx      # 0x407c
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rcx
xorl %eax, %eax
callq 0x10b0
leaq 0x30f5(%rip), %rdi      # 0x478a
movq %r14, %rsi
xorl %eax, %eax
callq 0x10a0
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %rbx
xorl %eax, %eax
cmpl $0x2, %esi
sete %al
leaq 0x2940(%rip), %rcx      # 0x4169
pushq $0x2
popq %rbp
movl %eax, %esi
movl %ebp, %edx
callq 0x15c8
xorl %esi, %esi
cmpq $0x0, (%r14)
setne %sil
leaq 0x2952(%rip), %r15      # 0x4198
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
callq 0x15c8
xorl %esi, %esi
cmpq $0x0, 0x8(%r14)
setne %sil
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
callq 0x15c8
movq (%r14), %rax
movq 0x8(%r14), %rcx
movl (%rax), %eax
xorl %esi, %esi
cmpl (%rcx), %eax
sete %sil
leaq 0x2887(%rip), %rcx      # 0x410a
movq %rbx, %rdi
movl %ebp, %edx
callq 0x15c8
movq (%r14), %rax
xorl %esi, %esi
cmpl $0xa, (%rax)
setne %sil
leaq 0x291b(%rip), %r15      # 0x41bb
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
callq 0x15c8
movq 0x8(%r14), %rax
xorl %esi, %esi
cmpl $0xa, (%rax)
setne %sil
movq %rbx, %rdi
movl %ebp, %edx
movq %r15, %rcx
callq 0x15c8
movq (%r14), %rax
cmpl $0xf, (%rax)
jne 0x18ef
movl 0x8(%rax), %ebx
movq 0x8(%r14), %rax
subl 0x8(%rax), %ebx
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x1130
movl $0xf, (%rax)
movl %ebx, 0x8(%rax)
jmp 0x1903
leaq 0x28dd(%rip), %rdx      # 0x41d3
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x15d8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %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      # 0x41fc
pushq $0x2
popq %rbp
movl %eax, %esi
movl %ebp, %edx
callq 0x15c8
xorl %esi, %esi
cmpq $0x0, (%rbx)
setne %sil
leaq 0x28e4(%rip), %r15      # 0x422b
movq %r14, %rdi
movl %ebp, %edx
movq %r15, %rcx
callq 0x15c8
xorl %esi, %esi
cmpq $0x0, 0x8(%rbx)
setne %sil
movq %r14, %rdi
movl %ebp, %edx
movq %r15, %rcx
callq 0x15c8
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movl (%rax), %eax
xorl %esi, %esi
cmpl (%rcx), %eax
sete %sil
leaq 0x28ca(%rip), %rcx      # 0x424e
movq %r14, %rdi
movl %ebp, %edx
callq 0x15c8
movq (%rbx), %rax
movl (%rax), %ecx
cmpl $0xa, %ecx
je 0x19cd
cmpl $0xf, %ecx
je 0x19b0
cmpl $0xd, %ecx
jne 0x1a12
movb 0x8(%rax), %al
movq 0x8(%rbx), %rcx
cmpb 0x8(%rcx), %al
je 0x19bc
jmp 0x1a01
movl 0x8(%rax), %eax
movq 0x8(%rbx), %rcx
cmpl 0x8(%rcx), %eax
jne 0x1a01
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1c78
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 0x19bc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1c70
leaq 0x2855(%rip), %rdx      # 0x426e
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x15d8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2856(%rip), %rcx      # 0x429a
pushq $0x2
popq %rdx
movl %eax, %esi
callq 0x15c8
movq (%rbx), %rax
testq %rax, %rax
je 0x1a7e
movl (%rax), %edi
leal -0x1(%rdi), %ecx
cmpl $0x2, %ecx
jb 0x1a8e
cmpl $0xf, %edi
je 0x1aa3
cmpl $0xa, %edi
jne 0x1ab6
movq 0x8(%rax), %rsi
leaq 0x2d15(%rip), %rdi      # 0x478a
xorl %eax, %eax
callq 0x10a0
jmp 0x1acf
leaq 0x28cc(%rip), %rdi      # 0x4351
xorl %eax, %eax
callq 0x10a0
jmp 0x1acf
callq 0x2a50
movq (%rbx), %rcx
movq 0x8(%rcx), %rdx
leaq 0x282c(%rip), %rdi      # 0x42cd
jmp 0x1ac5
movl 0x8(%rax), %esi
leaq 0x2870(%rip), %rdi      # 0x431d
xorl %eax, %eax
callq 0x10a0
jmp 0x1acf
callq 0x2a50
movq (%rbx), %rdx
leaq 0x2812(%rip), %rdi      # 0x42d7
movq %rax, %rsi
xorl %eax, %eax
callq 0x10a0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x27f1(%rip), %rcx      # 0x42e0
pushq $0x2
popq %rdx
callq 0x15c8
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x1a31
pushq $0xa
popq %rdi
callq 0x1040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x1130
movq %rax, %rbx
leaq 0x2764(%rip), %rdx      # 0x4400
leaq -0x272(%rip), %r8       # 0x1a31
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rax, %rsi
callq 0x1dba
testl %eax, %eax
je 0x1cc4
leaq 0x274a(%rip), %rsi      # 0x4406
pushq $0x2
popq %rdi
callq 0x15f9
leaq 0x2759(%rip), %rdx      # 0x4424
leaq -0x1ff(%rip), %r8       # 0x1ad3
pushq $0x1
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1dba
testl %eax, %eax
je 0x1cf3
leaq 0x271b(%rip), %rsi      # 0x4406
pushq $0x2
popq %rdi
callq 0x15f9
leaq 0x2732(%rip), %rdx      # 0x442c
leaq -0x655(%rip), %r8       # 0x16ac
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1dba
testl %eax, %eax
je 0x1d22
leaq 0x26ec(%rip), %rsi      # 0x4406
pushq $0x2
popq %rdi
callq 0x15f9
leaq 0x2aef(%rip), %rdx      # 0x4818
leaq -0x523(%rip), %r8       # 0x180d
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1dba
testl %eax, %eax
je 0x1d51
leaq 0x26bd(%rip), %rsi      # 0x4406
pushq $0x2
popq %rdi
callq 0x15f9
leaq 0x26d6(%rip), %rdx      # 0x442e
leaq -0x451(%rip), %r8       # 0x190e
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1dba
testl %eax, %eax
je 0x1d80
leaq 0x268e(%rip), %rsi      # 0x4406
pushq $0x2
popq %rdi
callq 0x15f9
leaq 0x26a9(%rip), %rdx      # 0x4430
leaq -0x27b(%rip), %r8       # 0x1b13
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1dba
testl %eax, %eax
je 0x1daf
leaq 0x265f(%rip), %rsi      # 0x4406
pushq $0x2
popq %rdi
callq 0x15f9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x264e(%rip), %rcx      # 0x4434
pushq $0x2
popq %r13
movl %r13d, %edx
callq 0x15c8
xorl %esi, %esi
testq %r14, %r14
setne %sil
leaq 0x2650(%rip), %rcx      # 0x4452
movq %r12, %rdi
movl %r13d, %edx
callq 0x15c8
xorl %esi, %esi
cmpb $0x0, (%rbx)
setne %sil
leaq 0x2651(%rip), %rcx      # 0x446e
movq %r12, %rdi
movl %r13d, %edx
callq 0x15c8
movq 0x8(%r14), %r13
addq $0x8, %r14
movq %rbx, %rdi
callq 0x1080
movq %r13, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x293c
testq %rax, %rax
je 0x1e5d
leaq 0x2645(%rip), %rdx      # 0x4497
pushq $0x2
popq %rsi
movq %r12, %rdi
callq 0x15d8
movq %rsp, %r12
movl %ebp, (%r12)
movslq %ebp, %rdi
pushq $0x10
popq %rsi
callq 0x1130
movq %rax, 0x8(%r12)
movq %r15, 0x10(%r12)
movq %rbx, %rdi
callq 0x1080
pushq $0x18
popq %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r12, %rcx
callq 0x2844
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq