LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_prop_header
struct x3f_prop_header *
read_x3f_prop_header(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    static struct x3f_prop_header header;
    struct x3f_prop_header *headerptr = (struct x3f_prop_header *)0;

    if(!feof(inptr) && !ferror(inptr))
    {
        header.section_id = read_ulong(inptr,byteorder,offset);
        header.version_minor = read_ushort(inptr,byteorder,HERE);
        header.version_major = read_ushort(inptr,byteorder,HERE);
        header.num_entries = read_ulong(inptr,byteorder,HERE);
        header.char_format = read_ulong(inptr,byteorder,HERE);
        header.reserved = read_ulong(inptr,byteorder,HERE);
        header.entry_length = read_ulong(inptr,byteorder,HERE);
        if(!feof(inptr) && !ferror(inptr))
            headerptr = &header;
    }
    return(headerptr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x31a0
testl %eax, %eax
jne 0x2a1fb
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x2a1fb
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x46cc
movq %rax, 0x3375d(%rip)     # 0x5d8c8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4574
movw %ax, 0x3374f(%rip)      # 0x5d8d0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4574
movw %ax, 0x3373b(%rip)      # 0x5d8d2
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x3372b(%rip)     # 0x5d8d8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x3371d(%rip)     # 0x5d8e0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x3370f(%rip)     # 0x5d8e8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x33701(%rip)     # 0x5d8f0
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
je 0x2a202
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x30b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
leaq 0x336b1(%rip), %rcx     # 0x5d8c8
cmoveq %rcx, %rax
jmp 0x2a1fd
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_camf_header
struct x3f_camf_header *
read_x3f_camf_header(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    static struct x3f_camf_header header;
    struct x3f_camf_header *headerptr = (struct x3f_camf_header *)0;

    if(!feof(inptr) && !ferror(inptr))
    {
        header.section_id = read_ulong(inptr,byteorder,offset);
        header.version_minor = read_ushort(inptr,byteorder,HERE);
        header.version_major = read_ushort(inptr,byteorder,HERE);
        header.item1 = read_ulong(inptr,byteorder,HERE);
        header.item2 = read_ulong(inptr,byteorder,HERE);
        header.item3 = read_ulong(inptr,byteorder,HERE);
        header.item4 = read_ulong(inptr,byteorder,HERE);
        header.item5 = read_ulong(inptr,byteorder,HERE);
        if(!feof(inptr) && !ferror(inptr))
            headerptr = &header;
    }
    return(headerptr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x31a0
testl %eax, %eax
jne 0x2ad91
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x2ad91
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x46cc
movq %rax, 0x32ba5(%rip)     # 0x5d890
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4574
movw %ax, 0x32b97(%rip)      # 0x5d898
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4574
movw %ax, 0x32b83(%rip)      # 0x5d89a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x32b73(%rip)     # 0x5d8a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x32b65(%rip)     # 0x5d8a8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x32b57(%rip)     # 0x5d8b0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x32b49(%rip)     # 0x5d8b8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x32b3b(%rip)     # 0x5d8c0
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
je 0x2ad98
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x30b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
leaq 0x32ae3(%rip), %rcx     # 0x5d890
cmoveq %rcx, %rax
jmp 0x2ad93
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_nikon.c
// Function: nikon_model_number
int
nikon_model_number(char *model,char *software)
{
    struct camera_id *model_id;
    int number = NO_MODEL;

    for(model_id = &nikon_model_id[0]; model_id && model_id->name; ++model_id)
    {
        if(strncasecmp(model,model_id->name,model_id->namelen) == 0)
        {
            number = model_id->id;
            setnoteversion(model_id->noteversion);
            setnotetagset(model_id->notetagset);    /* info only      */
            break;
        }
    }
    return(number);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2d530(%rip), %r15     # 0x58b60
movq (%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x2b675
movq %rdi, %r14
addq $0x18, %r15
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x2b65f
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x2b641
jmp 0x2b675
movl -0xc(%r15), %ebx
movl -0x8(%r15), %edi
callq 0x1bfc7
movl -0x4(%r15), %edi
callq 0x1bff7
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_nikon.c
// Function: print_nikon_makervalue
void
print_nikon_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_value(entry_ptr,PREFIX);
                nikon1_interpret_value(entry_ptr);
                break;
            case 2:
                print_value(entry_ptr,PREFIX);
                nikon2_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 0x1bfe0
testq %rbx, %rbx
je 0x2b702
movl %eax, %ebp
leaq 0x2caaa(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x2b702
leaq 0x1c5b4(%rip), %rsi     # 0x47c96
movq %rbx, %rdi
callq 0x62c7
cmpl $0x2, %ebp
je 0x2b709
cmpl $0x1, %ebp
jne 0x2b702
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2b717
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2b9ba
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_nikon.c
// Function: maker_nikon1_tagname
char *
maker_nikon1_tagname(unsigned short tag,int model)
{
    char *tagname = CNULL;

    switch(tag)
    {
        case 0x0003: tagname = "Quality"; break;
        case 0x0004: tagname = "ColorMode"; break;
        case 0x0005: tagname = "ImageAdjustment"; break;
        case 0x0006: tagname = "ISOSetting"; break;
        case 0x0007: tagname = "WhiteBalance"; break;
        case 0x0008: tagname = "Focus"; break;
        case 0x000a: tagname = "DigitalZoom"; break;
        case 0x000b: tagname = "LensConverter"; break;
        case 0x0100: tagname = "JpegThumbnail"; break;
        case 0x0f00: tagname = "Data"; break;
            default: break;
    }
    setnotetagset(1);
    return(tagname);
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
leal -0x3(%rdi), %eax
cmpl $0x8, %eax
ja 0x2d2ff
leaq 0x1cbcf(%rip), %rcx     # 0x49ebc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1e966(%rip), %rbx     # 0x4bc63
jmp 0x2d35e
cmpl $0x100, %edi            # imm = 0x100
je 0x2d357
cmpl $0xf00, %edi            # imm = 0xF00
jne 0x2d35e
leaq 0x175fb(%rip), %rbx     # 0x44911
jmp 0x2d35e
leaq 0x1fbd4(%rip), %rbx     # 0x4cef3
jmp 0x2d35e
leaq 0x1cde2(%rip), %rbx     # 0x4a10a
jmp 0x2d35e
leaq 0x1cde5(%rip), %rbx     # 0x4a116
jmp 0x2d35e
leaq 0x1c2c5(%rip), %rbx     # 0x495ff
jmp 0x2d35e
leaq 0x15ea8(%rip), %rbx     # 0x431eb
jmp 0x2d35e
leaq 0x1cda3(%rip), %rbx     # 0x4a0ef
jmp 0x2d35e
leaq 0x1cdaa(%rip), %rbx     # 0x4a0ff
jmp 0x2d35e
leaq 0x16c07(%rip), %rbx     # 0x43f65
movl $0x1, %edi
callq 0x1bff7
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_epson.c
// Function: epson_model_number
int
epson_model_number(char *model,char *software)
{
    struct camera_id *model_id;
    int number = NO_MODEL;

    for(model_id = &epson_model_id[0]; model_id && model_id->name; ++model_id)
    {
        if(strncasecmp(model,model_id->name,model_id->namelen) == 0)
        {
            number = model_id->id;
            setnoteversion(model_id->noteversion);
            setnotetagset(model_id->notetagset);    /* info only      */
            break;
        }
    }
    return(number);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2afb4(%rip), %r15     # 0x58590
movq (%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x2d621
movq %rdi, %r14
addq $0x18, %r15
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x2d60b
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x2d5ed
jmp 0x2d621
movl -0xc(%r15), %ebx
movl -0x8(%r15), %edi
callq 0x1bfc7
movl -0x4(%r15), %edi
callq 0x1bff7
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_epson.c
// Function: print_epson_makervalue
void
print_epson_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_epson1_makervalue(entry_ptr,make,model,prefix);
                epson1_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 0x1bfe0
testq %rbx, %rbx
je 0x2d66b
movl %eax, %ebp
leaq 0x2ab3c(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x2d66b
leaq 0x1a646(%rip), %rsi     # 0x47c96
movq %rbx, %rdi
callq 0x62c7
cmpl $0x1, %ebp
jne 0x2d66b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2d690
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_epson.c
// Function: epson1_interpret_value
void
epson1_interpret_value(struct ifd_entry *entry_ptr)
{
    int chpr = 0;

    if(entry_ptr && (PRINT_VALUE))
    {
        switch(entry_ptr->tag)
        {
            case 0x0201:    /* Compression Mode */
                print_startvalue();
                /* 'Quality' is a mix of this and image size.             */
                /* Interestingly, 'HyPict' (2544x1904) interpolated       */
                /* images are marked '34' (same as uncompressed 'tiff')   */
                /* but are in JPEG format with CompressedBitsPerPixel=1.  */
                /* The value '33' is used by Olympus cameras, which       */
                /* appear to use similar software. Of course, the Minolta */
                /* F100 looks a lot like this too, but uses '4' for       */
                /* uncompressed.                                          */
                switch(entry_ptr->value)
                {
                    case 1: chpr += printf("SQ"); break;
                    case 2: chpr += printf("HQ"); break;
                    case 3: chpr += printf("SHQ"); break;
                    case 33: chpr += printf("not compressed"); break;
                    case 34: chpr += printf("not compressed"); break;
                    default: printred("undefined"); break;
                }
                print_endvalue();
                break;
            case 0x0202:    /* Macro */
                print_startvalue();
                switch(entry_ptr->value)
                {
                    case 0: chpr += printf("Normal"); break;
                    case 1: chpr += printf("Macro"); break;
                    default: printred("undefined"); break;
                }
                print_endvalue();
                break;
            default:
                break;
        }
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x2d760
leaq 0x2aada(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x2d760
movq %rdi, %r14
movzwl (%rdi), %eax
cmpl $0x202, %eax            # imm = 0x202
je 0x2d6f3
cmpl $0x201, %eax            # imm = 0x201
jne 0x2d760
xorl %eax, %eax
callq 0x95d2
movq 0x10(%r14), %rax
cmpq $0x2, %rax
jle 0x2d712
cmpq $0x3, %rax
je 0x2d740
cmpq $0x21, %rax
je 0x2d6ea
cmpq $0x22, %rax
jne 0x2d727
leaq 0x1cf66(%rip), %rdi     # 0x4a657
jmp 0x2d750
xorl %eax, %eax
callq 0x95d2
movq 0x10(%r14), %rax
cmpq $0x1, %rax
je 0x2d737
testq %rax, %rax
jne 0x2d727
leaq 0x1dca9(%rip), %rdi     # 0x4b3b9
jmp 0x2d750
cmpq $0x1, %rax
je 0x2d749
cmpq $0x2, %rax
jne 0x2d727
leaq 0x1cf2f(%rip), %rdi     # 0x4a654
jmp 0x2d750
leaq 0x1b6fb(%rip), %rdi     # 0x48e29
callq 0x5c33
xorl %ebx, %ebx
jmp 0x2d759
leaq 0x18f99(%rip), %rdi     # 0x466d7
jmp 0x2d750
leaq 0x1cf0c(%rip), %rdi     # 0x4a653
jmp 0x2d750
leaq 0x1cf00(%rip), %rdi     # 0x4a650
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
xorl %eax, %eax
callq 0x95f3
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17530
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_epson.c
// Function: print_epson_offset_makervalue
void
print_epson_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 :
                epson1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                epson1_interpret_offset_makervalue(inptr,byteorder,
                                            entry_ptr,fileoffset_base);
                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, %r13
movq %r8, 0x20(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl 0x80(%rsp), %r12d
movl 0x78(%rsp), %eax
movq %rax, (%rsp)
movl 0x70(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
callq 0x1bfe0
testq %r14, %r14
je 0x2d81f
cmpl $0x1, %eax
jne 0x2d825
subq $0x8, %rsp
movzwl %bp, %ebp
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq 0x28(%rsp), %r8
movq %r13, %r9
pushq %r12
pushq 0x10(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
pushq 0x30(%rsp)
callq 0x2d85b
addq $0x30, %rsp
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2e17c
addq $0x28, %rsp
jmp 0x2d850
movzwl %bp, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
movq 0x8(%rsp), %r9
pushq %r12
pushq 0x8(%rsp)
pushq 0x20(%rsp)
pushq 0x30(%rsp)
callq 0x191ac
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_epson.c
// Function: maker_epson1_tagname
char *
maker_epson1_tagname(unsigned short tag,int model)
{
    char *tagname = CNULL;

    /* These are the Olympus tags; try them ###%%% ???                */
    /* Update: the SoftwareRelease tag on Olympus is 0x0207; here it  */
    /* is 0x020d.  One Epson model sports a hidden thumbnail (0x0301) */
    switch(tag)
    {
        case 0x0200: tagname = "SpecialMode"; break;
        case 0x0201: tagname = "CompressionMode"; break;
        case 0x0202: tagname = "Macro"; break;
        case 0x0204: tagname = "DigitalZoom"; break;
        case 0x0208: tagname = "PictureInfo"; break;
        case 0x0209: tagname = "CameraID"; break;
        case 0x020a: tagname = "MakerUserComment"; break;
        case 0x020b: tagname = "ImageWidth"; break;
        case 0x020c: tagname = "ImageHeight"; break;
        case 0x020d: tagname = "SoftwareRelease"; break;
        case 0x0301: tagname = "JpegThumbnailData"; break;
        case 0x0e00: tagname = "PrintIM"; break;
        case 0x0f00: tagname = "Data"; break;
        default: break;
    }
    setnotetagset(1);
    return(tagname);
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
cmpl $0x300, %edi            # imm = 0x300
jg 0x2e35e
addl $0xfffffe00, %edi       # imm = 0xFFFFFE00
cmpl $0xd, %edi
ja 0x2e3e0
leaq 0x1c277(%rip), %rax     # 0x4a5c0
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x1c29f(%rip), %rbx     # 0x4a5f8
jmp 0x2e3e0
cmpl $0x301, %edi            # imm = 0x301
je 0x2e3d0
cmpl $0xe00, %edi            # imm = 0xE00
je 0x2e3d9
cmpl $0xf00, %edi            # imm = 0xF00
jne 0x2e3e0
leaq 0x16594(%rip), %rbx     # 0x44911
jmp 0x2e3e0
leaq 0x1c27e(%rip), %rbx     # 0x4a604
jmp 0x2e3e0
leaq 0x15b23(%rip), %rbx     # 0x43eb2
jmp 0x2e3e0
leaq 0x1bd72(%rip), %rbx     # 0x4a10a
jmp 0x2e3e0
leaq 0x1fb13(%rip), %rbx     # 0x4deb4
jmp 0x2e3e0
leaq 0x1c284(%rip), %rbx     # 0x4a62e
jmp 0x2e3e0
leaq 0x1c261(%rip), %rbx     # 0x4a614
jmp 0x2e3e0
leaq 0x1831b(%rip), %rbx     # 0x466d7
jmp 0x2e3e0
leaq 0x1fadd(%rip), %rbx     # 0x4dea2
jmp 0x2e3e0
leaq 0x1c24f(%rip), %rbx     # 0x4a61d
jmp 0x2e3e0
leaq 0x1c267(%rip), %rbx     # 0x4a63e
jmp 0x2e3e0
leaq 0x14ee2(%rip), %rbx     # 0x432c2
movl $0x1, %edi
callq 0x1bff7
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_model_number
int
olympus_model_number(char *model,char *software)
{
    struct camera_id *model_id;
    int number = NO_MODEL;

    for(model_id = &olympus_model_id[0]; model_id && model_id->name; ++model_id)
    {
        if(strncasecmp(model,model_id->name,model_id->namelen) == 0)
        {
            number = model_id->id;
            setnoteversion(model_id->noteversion);
            setnotetagset(model_id->notetagset);    /* info only      */
            break;
        }
    }
    return(number);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2a974(%rip), %r15     # 0x58d70
movq (%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x2e441
movq %rdi, %r14
addq $0x18, %r15
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x2e42b
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x2e40d
jmp 0x2e441
movl -0xc(%r15), %ebx
movl -0x8(%r15), %edi
callq 0x1bfc7
movl -0x4(%r15), %edi
callq 0x1bff7
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: print_olympus_makervalue
void
print_olympus_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_olympus1_makervalue(entry_ptr,make,model,PREFIX);
                olympus1_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 0x1bfe0
testq %rbx, %rbx
je 0x2e48b
movl %eax, %ebp
leaq 0x29d1c(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x2e48b
leaq 0x19826(%rip), %rsi     # 0x47c96
movq %rbx, %rdi
callq 0x62c7
cmpl $0x1, %ebp
jne 0x2e48b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2e4a4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: print_olympus_offset_makervalue
void
print_olympus_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:
                olympus1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                olympus1_interpret_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base);
                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, %r13
movq %r8, 0x20(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl 0x80(%rsp), %r12d
movl 0x78(%rsp), %eax
movq %rax, (%rsp)
movl 0x70(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
callq 0x1bfe0
testq %r14, %r14
je 0x2e656
cmpl $0x1, %eax
jne 0x2e65c
subq $0x8, %rsp
movzwl %bp, %ebp
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq 0x28(%rsp), %r8
movq %r13, %r9
pushq %r12
pushq 0x10(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
pushq 0x30(%rsp)
callq 0x2e692
addq $0x30, %rsp
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ec9c
addq $0x28, %rsp
jmp 0x2e687
movzwl %bp, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
movq 0x8(%rsp), %r9
pushq %r12
pushq 0x8(%rsp)
pushq 0x20(%rsp)
pushq 0x30(%rsp)
callq 0x191ac
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: maker_olympus_tagname
char *
maker_olympus_tagname(unsigned short tag,int model)
{
    char *tagname = CNULL;
    int noteversion = 0;

    if((noteversion = getnoteversion()) == 0)
    {
        /* Need more model samples before it is safe to assume a      */
        /* default                                                    */
        noteversion = 1;
        setnoteversion(1);
    }

    /* Check specific models first                                    */
    switch(noteversion)
    {
        case 1:
            tagname = maker_olympus1_tagname(tag,model);
            break;
        default:
            break;
    }
    return(tagname);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %eax, %eax
callq 0x1bfe0
movl %eax, %ebp
testl %eax, %eax
jne 0x2ee00
movl $0x1, %ebp
movl $0x1, %edi
callq 0x1bfc7
cmpl $0x1, %ebp
jne 0x2ee13
movzwl %bx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2ee1c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_private_2010_tagname
char *
olympus_private_2010_tagname(unsigned short tag)
{
    char *tagname = CNULL;

    switch(tag)
    {
        case 0x0000: tagname = "EquipmentInfoVersion"; break;
        case 0x0100: tagname = "FirmwareVersion2"; break;
        case 0x0101: tagname = "SerialNumber"; break;
        case 0x0103: tagname = "FocalPlaneDiagonal"; break;
        case 0x0104: tagname = "BodyFirmwareVersion"; break;
        case 0x0201: tagname = "Lens"; break;
        case 0x0202: tagname = "LensSerialNumber"; break;
        case  0x0204: tagname = "LensFirmwareVersion"; break;
        case 0x0206: tagname = "MaxApertureAtMaxFocal"; break;
        case 0x0207: tagname = "MinFocalLength"; break;
        case 0x0208: tagname = "MaxFocalLength"; break;
        case 0x0301: tagname = "Extender"; break;
        case 0x0302: tagname = "ExtenderSerialNumber"; break;
        case 0x0304: tagname = "ExtenderFirmwareVersion"; break;
        case 0x1000: tagname = "FlashType"; break;
        case 0x1001: tagname = "FlashModel"; break;
        case 0x1003: tagname = "FlashSerialNumber"; break;
        case 0x1004: tagname = "FlashFirmwareVersion"; break;
        default:
            break;
    }
    return(tagname);
}

// Assembly:
xorl %eax, %eax
cmpl $0x300, %edi            # imm = 0x300
jg 0x2f143
leal -0x201(%rdi), %ecx
cmpl $0x7, %ecx
ja 0x2f172
leaq 0x1b6f2(%rip), %rdx     # 0x4a824
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1baa2(%rip), %rax     # 0x4abe4
retq
cmpl $0xfff, %edi            # imm = 0xFFF
jle 0x2f195
addl $0xfffff000, %edi       # imm = 0xFFFFF000
cmpl $0x4, %edi
ja 0x2f200
leaq 0x1b6e3(%rip), %rcx     # 0x4a844
movslq (%rcx,%rdi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
leaq 0x1afda(%rip), %rax     # 0x4a14b
retq
leal -0x100(%rdi), %ecx
cmpl $0x4, %ecx
ja 0x2f1b5
leaq 0x1b68c(%rip), %rdx     # 0x4a810
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1ba18(%rip), %rax     # 0x4abac
retq
cmpl $0x301, %edi            # imm = 0x301
je 0x2f201
cmpl $0x302, %edi            # imm = 0x302
je 0x2f209
cmpl $0x304, %edi            # imm = 0x304
jne 0x2f200
leaq 0x1ba8e(%rip), %rax     # 0x4ac42
retq
testl %edi, %edi
jne 0x2f200
leaq 0x1b9d7(%rip), %rax     # 0x4ab97
retq
leaq 0x1b36a(%rip), %rax     # 0x4a532
retq
leaq 0x1ba19(%rip), %rax     # 0x4abe9
retq
leaq 0x1ba36(%rip), %rax     # 0x4ac0e
retq
leaq 0x1b328(%rip), %rax     # 0x4a508
retq
leaq 0x1ba12(%rip), %rax     # 0x4abfa
retq
leaq 0x1ba6a(%rip), %rax     # 0x4ac5a
retq
leaq 0x1ba6d(%rip), %rax     # 0x4ac65
retq
leaq 0x1ba77(%rip), %rax     # 0x4ac77
retq
leaq 0x1ba1c(%rip), %rax     # 0x4ac24
retq
leaq 0x1ba1d(%rip), %rax     # 0x4ac2d
retq
leaq 0x1b9b8(%rip), %rax     # 0x4abd0
retq
leaq 0x1b99d(%rip), %rax     # 0x4abbd
retq
leaq 0x14291(%rip), %rax     # 0x434b9
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_private_2030_tagname
char *
olympus_private_2030_tagname(unsigned short tag)
{
    char *tagname = CNULL;

    switch(tag)
    {
        case 0x0000: tagname = "RawDevVersion"; break;
        case 0x0100: tagname = "RawDevExposureBiasValue"; break;
        case 0x0101: tagname = "RawDevWhiteBalanceValue"; break;
        case 0x0102: tagname = "RawDevWBFineAdjustment"; break;
        case 0x0103: tagname = "RawDevGrayPoint"; break;
        case 0x0104: tagname = "RawDevSaturationEmphasis"; break;
        case 0x0105: tagname = "RawDevMemoryColorEmphasis"; break;
        case 0x0106: tagname = "RawDevContrastValue"; break;
        case 0x0107: tagname = "RawDevSharpnessValue"; break;
        case 0x0108: tagname = "RawDevColorSpace"; break;
        case 0x0109: tagname = "RawDevEngine"; break;
        case 0x010a: tagname = "RawDevNoiseReduction"; break;
        case 0x010b: tagname = "RawDevEditStatus"; break;
        case 0x010c: tagname = "RawDevSettings"; break;
        default:
            break;
    }

    return(tagname);
}

// Assembly:
leal -0x100(%rdi), %eax
cmpl $0xc, %eax
ja 0x2f3f4
leaq 0x1b4c5(%rip), %rcx     # 0x4a8a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b9c3(%rip), %rax     # 0x4adb6
retq
testl %edi, %edi
jne 0x2f460
leaq 0x1b9a9(%rip), %rax     # 0x4ada8
retq
leaq 0x1ba95(%rip), %rax     # 0x4ae9c
retq
leaq 0x1b9fe(%rip), %rax     # 0x4ae0d
retq
leaq 0x1ba96(%rip), %rax     # 0x4aead
retq
leaq 0x1ba5b(%rip), %rax     # 0x4ae7a
retq
leaq 0x1b9bf(%rip), %rax     # 0x4ade6
retq
leaq 0x1b9ce(%rip), %rax     # 0x4adfd
retq
leaq 0x1ba1d(%rip), %rax     # 0x4ae54
retq
leaq 0x1b98f(%rip), %rax     # 0x4adce
retq
leaq 0x1b9df(%rip), %rax     # 0x4ae26
retq
leaq 0x1b9f1(%rip), %rax     # 0x4ae40
retq
leaq 0x1ba30(%rip), %rax     # 0x4ae87
retq
leaq 0x1ba0a(%rip), %rax     # 0x4ae69
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_private_2040_tagname
char *
olympus_private_2040_tagname(unsigned short tag)
{
    char *tagname = CNULL;

    switch(tag)
    {
        case 0x0000: tagname = "ImageProcessingVersion"; break;
        case 0x0100: tagname = "RedBlueBias"; break;
        case 0x0200: tagname = "ColorMatrix"; break;
        case 0x0300: tagname = "SmoothingParameter1"; break;
        case 0x0310: tagname = "SmoothingParameter2"; break;
        case 0x0600: tagname = "SmoothingThresholds"; break;
        case 0x0610: tagname = "SmoothingThreshold2"; break;
        case 0x0611: tagname = "ValidBits"; break;
        case 0x0614: tagname = "ImageWidth2"; break;
        case 0x0615: tagname = "ImageHeight2"; break;
        case 0x1010: tagname = "NoiseFilter2"; break;
        case 0x1012: tagname = "ShadingCompensation2"; break;
        default:
            break;
    }

    return(tagname);
}

// Assembly:
xorl %eax, %eax
cmpl $0x60f, %edi            # imm = 0x60F
jg 0x2f49d
cmpl $0x2ff, %edi            # imm = 0x2FF
jg 0x2f4c0
testl %edi, %edi
je 0x2f510
cmpl $0x100, %edi            # imm = 0x100
je 0x2f520
cmpl $0x200, %edi            # imm = 0x200
jne 0x2f537
leaq 0x1b647(%rip), %rax     # 0x4aae3
retq
leal -0x610(%rdi), %ecx
cmpl $0x5, %ecx
ja 0x2f4e0
leaq 0x1b42d(%rip), %rdx     # 0x4a8dc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1ba5c(%rip), %rax     # 0x4af1b
retq
cmpl $0x300, %edi            # imm = 0x300
je 0x2f518
cmpl $0x310, %edi            # imm = 0x310
je 0x2f528
cmpl $0x600, %edi            # imm = 0x600
jne 0x2f537
leaq 0x1ba28(%rip), %rax     # 0x4af07
retq
cmpl $0x1010, %edi           # imm = 0x1010
je 0x2f530
cmpl $0x1012, %edi           # imm = 0x1012
jne 0x2f537
leaq 0x1ba5e(%rip), %rax     # 0x4af55
retq
leaq 0x1ba3c(%rip), %rax     # 0x4af3b
retq
leaq 0x1b5ff(%rip), %rax     # 0x4ab06
retq
leaq 0x1ba20(%rip), %rax     # 0x4af2f
retq
leaq 0x1b9a5(%rip), %rax     # 0x4aebc
retq
leaq 0x1b9c0(%rip), %rax     # 0x4aedf
retq
leaq 0x1b9ac(%rip), %rax     # 0x4aed3
retq
leaq 0x1b9c4(%rip), %rax     # 0x4aef3
retq
leaq 0x1ba11(%rip), %rax     # 0x4af48
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_private_2050_tagname
char *
olympus_private_2050_tagname(unsigned short tag)
{
    char *tagname = CNULL;

    switch(tag)
    {
        case 0x0000: tagname = "FocusInfoVersion"; break;
        case 0x0209: tagname = "AutoFocus?"; break; 
        case 0x0300: tagname = "ZoomPosition"; break;
        case 0x0305: tagname = "FocusDistance"; break; 
        case 0x1201: tagname = "ExternalFlash"; break;
        case 0x1208: tagname = "InternalFlash"; break;
        default:
            break;
    }

    return(tagname);
}

// Assembly:
xorl %eax, %eax
cmpl $0x304, %edi            # imm = 0x304
jg 0x2f55e
testl %edi, %edi
je 0x2f57e
cmpl $0x209, %edi            # imm = 0x209
je 0x2f58e
cmpl $0x300, %edi            # imm = 0x300
jne 0x2f59d
leaq 0x1ba29(%rip), %rax     # 0x4af86
retq
cmpl $0x305, %edi            # imm = 0x305
je 0x2f586
cmpl $0x1201, %edi           # imm = 0x1201
je 0x2f596
cmpl $0x1208, %edi           # imm = 0x1208
jne 0x2f59d
leaq 0x1ba24(%rip), %rax     # 0x4afa1
retq
leaq 0x1b9e5(%rip), %rax     # 0x4af6a
retq
leaq 0x1ac7d(%rip), %rax     # 0x4a20a
retq
leaq 0x1b9e6(%rip), %rax     # 0x4af7b
retq
leaq 0x1b9f6(%rip), %rax     # 0x4af93
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus2010_interpret_value
void
olympus2010_interpret_value(struct ifd_entry *entry_ptr,char *prefix)
{
    int chpr = 0;

    if(entry_ptr && (PRINT_VALUE))
    {
        switch(entry_ptr->tag)
        {
            case 0x1000: 
                print_startvalue();
                switch(entry_ptr->value)
                {
                    case 0: chpr += printf("None"); break;
                    case 2: chpr += printf("Simple E-System"); break;
                    case 3: chpr += printf("E-System"); break;
                    default: chpr += printf("unknown"); break;
                }
                print_endvalue();
                break;
            case 0x1001: 
                print_startvalue();
                switch(entry_ptr->value)
                {
                    case 1: chpr += printf("FL-20"); break;
                    case 2: chpr += printf("FL-50"); break;
                    case 3: chpr += printf("RF-11"); break;
                    case 4: chpr += printf("TF-22"); break;
                    case 5: chpr += printf("FL-36"); break;
                    default: chpr += printf("unknown"); break;
                }
                print_endvalue();
                break;
            default:
                break;
        }
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x2f63f
leaq 0x28baf(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x2f63f
movq %rdi, %rbx
movzwl (%rdi), %eax
cmpl $0x1001, %eax           # imm = 0x1001
je 0x2f604
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x2f63f
xorl %eax, %eax
callq 0x95d2
movq 0x10(%rbx), %rax
cmpq $0x3, %rax
ja 0x2f628
leaq 0x2857e(%rip), %rcx     # 0x57b80
jmp 0x2f61f
xorl %eax, %eax
callq 0x95d2
movq 0x10(%rbx), %rax
decq %rax
cmpq $0x4, %rax
ja 0x2f628
leaq 0x28581(%rip), %rcx     # 0x57ba0
leaq (%rcx,%rax,8), %rax
movq (%rax), %rdi
jmp 0x2f62f
leaq 0x16335(%rip), %rdi     # 0x45964
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
xorl %eax, %eax
callq 0x95f3
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x17530
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_offset_pe_value
void
olympus_offset_pe_value(FILE *inptr,unsigned short byteorder,
                struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
                unsigned short subifd_ident,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:
                olympus1_offset_pe_value(inptr,byteorder,entry_ptr,
                                            fileoffset_base,subifd_ident,
                                            summary_entry,parent_name,prefix,
                                            indent,make,model,at_offset);
                olympus1_interpret_offset_pe_value(inptr,byteorder,entry_ptr,
                                            fileoffset_base,subifd_ident);
                break;
            default:
                print_private_offset_value(inptr,byteorder,entry_ptr,
                                        fileoffset_base,subifd_ident,
                                        parent_name,prefix,indent,
                                        make,model,at_offset);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x18(%rsp)
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %r12
movl 0x98(%rsp), %eax
movq %rax, 0x8(%rsp)
movl 0x90(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x88(%rsp), %eax
movq %rax, 0x20(%rsp)
movl 0x80(%rsp), %eax
movq %rax, 0x28(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %r15
xorl %eax, %eax
callq 0x1bfe0
testq %r14, %r14
je 0x2fab4
cmpl $0x1, %eax
jne 0x2faba
movzwl %r13w, %esi
movzwl %bp, %r8d
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movq 0x18(%rsp), %r9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fafa
addq $0x38, %rsp
jmp 0x2faef
subq $0x8, %rsp
movzwl %r13w, %esi
movzwl %bp, %r8d
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r9
pushq 0x10(%rsp)
pushq 0x20(%rsp)
pushq 0x38(%rsp)
pushq 0x48(%rsp)
pushq 0x58(%rsp)
callq 0xa60a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus2010_offset_value
void
olympus2010_offset_value(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)
{
    unsigned long value_offset;
    unsigned long count;
    char *nameoftag;
    char *fulldirname = CNULL;
    int chpr = 0;

    if(entry_ptr)
    {
        nameoftag = maker_tagname(entry_ptr->tag,make,model); 
        if((PRINT_LONGNAMES))
        {
            fulldirname = splice(parent_name,".",nameoftag);
            nameoftag = fulldirname;
        }
        value_offset = fileoffset_base + entry_ptr->value;
        count = entry_ptr->count;
        switch(entry_ptr->tag)
        {
            case 0x0100:
            case 0x0101:
            case 0x0102:
            case 0x0202:
            case 0x0301:
            case 0x0302:
            case 0x1003:
            default:
                print_private_offset_value(inptr,byteorder,entry_ptr,
                                        fileoffset_base,0x2010,
                                        fulldirname,prefix,indent,
                                        make,model,at_offset);
                break;
        }
        if(fulldirname)
            free(fulldirname);
    }
    setcharsprinted(chpr);
}

// Assembly:
testq %rdx, %rdx
je 0x2fcc1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r13
movq %rcx, 0x10(%rsp)
movl 0x80(%rsp), %eax
movq %rax, 0x8(%rsp)
movl 0x78(%rsp), %r12d
movl 0x70(%rsp), %r14d
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movzwl (%rdx), %edi
movl %r14d, %esi
movl %r12d, %edx
callq 0x1c020
leaq 0x2852c(%rip), %rcx     # 0x58180
testb $0x40, (%rcx)
jne 0x2fc5d
xorl %ebx, %ebx
jmp 0x2fc72
leaq 0x11d33(%rip), %rsi     # 0x41997
movq %rbx, %rdi
movq %rax, %rdx
callq 0x17a47
movq %rax, %rbx
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r15, %rdx
movq 0x18(%rsp), %rcx
movl $0x2010, %r8d           # imm = 0x2010
movq %rbx, %r9
pushq 0x10(%rsp)
pushq %r12
pushq %r14
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0xa60a
addq $0x30, %rsp
testq %rbx, %rbx
je 0x2fcb3
movq %rbx, %rdi
callq 0x3050
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %edi, %edi
jmp 0x17530
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus2030_offset_value
void
olympus2030_offset_value(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)
{
    unsigned long value_offset;
    unsigned long count;
    char *nameoftag;
    char *fulldirname = CNULL;
    int chpr = 0;

    if(entry_ptr)
    {
        nameoftag = maker_tagname(entry_ptr->tag,make,model); 
        if((PRINT_LONGNAMES))
        {
            fulldirname = splice(parent_name,".",nameoftag);
            nameoftag = fulldirname;
        }
        value_offset = fileoffset_base + entry_ptr->value;
        count = entry_ptr->count;
        switch(entry_ptr->tag)
        {
            default:
                print_private_offset_value(inptr,byteorder,entry_ptr,
                                        fileoffset_base,0x2030,
                                        fulldirname,prefix,indent,
                                        make,model,at_offset);
                break;
        }
        if(fulldirname)
            free(fulldirname);
    }
    setcharsprinted(chpr);
}

// Assembly:
testq %rdx, %rdx
je 0x300fb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r13
movq %rcx, 0x10(%rsp)
movl 0x80(%rsp), %eax
movq %rax, 0x8(%rsp)
movl 0x78(%rsp), %r12d
movl 0x70(%rsp), %r14d
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movzwl (%rdx), %edi
movl %r14d, %esi
movl %r12d, %edx
callq 0x1c020
leaq 0x280f2(%rip), %rcx     # 0x58180
testb $0x40, (%rcx)
jne 0x30097
xorl %ebx, %ebx
jmp 0x300ac
leaq 0x118f9(%rip), %rsi     # 0x41997
movq %rbx, %rdi
movq %rax, %rdx
callq 0x17a47
movq %rax, %rbx
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r15, %rdx
movq 0x18(%rsp), %rcx
movl $0x2030, %r8d           # imm = 0x2030
movq %rbx, %r9
pushq 0x10(%rsp)
pushq %r12
pushq %r14
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0xa60a
addq $0x30, %rsp
testq %rbx, %rbx
je 0x300ed
movq %rbx, %rdi
callq 0x3050
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %edi, %edi
jmp 0x17530
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_fujifilm.c
// Function: fujifilm_model_number
int
fujifilm_model_number(char *model,char *software)
{
    struct camera_id *model_id;
    int number = NO_MODEL;

    for(model_id = &fujifilm_model_id[0]; model_id && model_id->name; ++model_id)
    {
        if(strncasecmp(model,model_id->name,model_id->namelen) == 0)
        {
            number = model_id->id;
            setnoteversion(model_id->noteversion);
            setnotetagset(model_id->notetagset);    /* info only      */
            break;
        }
    }
    return(number);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x28308(%rip), %r15     # 0x58610
movq (%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x3034d
movq %rdi, %r14
addq $0x18, %r15
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x30337
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x30319
jmp 0x3034d
movl -0xc(%r15), %ebx
movl -0x8(%r15), %edi
callq 0x1bfc7
movl -0x4(%r15), %edi
callq 0x1bff7
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_fujifilm.c
// Function: print_fujifilm_makervalue
void
print_fujifilm_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_fujifilm1_makervalue(entry_ptr,make,model,prefix);
                fujifilm1_interpret_value(entry_ptr);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3039e
leaq 0x27e1b(%rip), %r14     # 0x58180
testb $0x30, (%r14)
je 0x3039e
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1bfe0
cmpl $0x1, %eax
jne 0x303a6
testb $0x30, (%r14)
je 0x3038f
leaq 0x1790f(%rip), %rsi     # 0x47c96
movq %rbx, %rdi
callq 0x62c7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x303da
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x178e9(%rip), %rsi     # 0x47c96
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x62c7
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_casio.c
// Function: print_casio_makervalue
void
print_casio_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 2:
                print_casio1_makervalue(entry_ptr,make,model,prefix);
                casio2_interpret_value(entry_ptr);
                break;
            case 1:
                print_casio1_makervalue(entry_ptr,make,model,prefix);
                casio1_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 0x1bfe0
testq %rbx, %rbx
je 0x30b64
movl %eax, %ebp
leaq 0x27648(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x30b64
leaq 0x17152(%rip), %rsi     # 0x47c96
movq %rbx, %rdi
callq 0x62c7
cmpl $0x1, %ebp
je 0x30b6b
cmpl $0x2, %ebp
jne 0x30b64
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30b97
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x30eff
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_casio.c
// Function: print_casio_offset_makervalue
void
print_casio_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:
                casio1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                break;
            case 2:
                casio2_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 %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, 0x18(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
callq 0x1bfe0
testq %r12, %r12
je 0x312ac
cmpl $0x2, %eax
je 0x312b2
cmpl $0x1, %eax
jne 0x312d7
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x30(%rsp)
pushq 0x40(%rsp)
pushq 0x38(%rsp)
callq 0x3130e
addq $0x58, %rsp
jmp 0x31303
addq $0x28, %rsp
jmp 0x31303
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 0x31621
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
movq 0x10(%rsp), %r9
pushq (%rsp)
pushq 0x10(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x191ac
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq