LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e5c1
leaq 0x38c2b(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x30, %rax
cmpq $0x0, %rax
je 0x3e5c1
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x1, %eax
je 0x3e579
jmp 0x3e56f
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x3e594
jmp 0x3e5af
movq -0x8(%rbp), %rdi
leaq 0x2bd96(%rip), %rsi     # 0x6a31a
callq 0x71d0
movq -0x8(%rbp), %rdi
callq 0x3e5d0
jmp 0x3e5bf
movq -0x8(%rbp), %rdi
leaq 0x2bd7b(%rip), %rsi     # 0x6a31a
callq 0x71d0
movq -0x8(%rbp), %rdi
callq 0x3eab0
jmp 0x3e5bf
movq -0x8(%rbp), %rdi
leaq 0x2bd60(%rip), %rsi     # 0x6a31a
callq 0x71d0
jmp 0x3e5c1
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_nikon.c
// Function: maker_nikon_tagname
char *
maker_nikon_tagname(unsigned short tag,int model)
{
    char *tagname = CNULL;
    int noteversion = 0;

    if((noteversion = getnoteversion()) == 0)
        noteversion = set_nikon_noteversion();

    switch(noteversion)
    {
        case 1:
            tagname = maker_nikon1_tagname(tag,model);
            break;

        case 2:
            tagname = maker_nikon2_tagname(tag,model);
            break;
        default:
            break;
    }
    return(tagname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x40c88
callq 0x3e470
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0x40c9f
jmp 0x40c95
movl -0x18(%rbp), %eax
subl $0x2, %eax
je 0x40cb4
jmp 0x40cc9
movw -0x2(%rbp), %ax
movl -0x8(%rbp), %esi
movzwl %ax, %edi
callq 0x40ce0
movq %rax, -0x10(%rbp)
jmp 0x40ccb
movw -0x2(%rbp), %ax
movl -0x8(%rbp), %esi
movzwl %ax, %edi
callq 0x40e10
movq %rax, -0x10(%rbp)
jmp 0x40ccb
jmp 0x40ccb
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x3, %eax
je 0x40d69
jmp 0x40d08
movl -0x14(%rbp), %eax
subl $0x4, %eax
je 0x40d76
jmp 0x40d12
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0x40d83
jmp 0x40d1c
movl -0x14(%rbp), %eax
subl $0x6, %eax
je 0x40d90
jmp 0x40d26
movl -0x14(%rbp), %eax
subl $0x7, %eax
je 0x40d9d
jmp 0x40d30
movl -0x14(%rbp), %eax
subl $0x8, %eax
je 0x40daa
jmp 0x40d3a
movl -0x14(%rbp), %eax
subl $0xa, %eax
je 0x40db7
jmp 0x40d44
movl -0x14(%rbp), %eax
subl $0xb, %eax
je 0x40dc4
jmp 0x40d4e
movl -0x14(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0x40dd1
jmp 0x40d5a
movl -0x14(%rbp), %eax
subl $0xf00, %eax            # imm = 0xF00
je 0x40dde
jmp 0x40deb
leaq 0x2d423(%rip), %rax     # 0x6e193
movq %rax, -0x10(%rbp)
jmp 0x40ded
leaq 0x2b0a2(%rip), %rax     # 0x6be1f
movq %rax, -0x10(%rbp)
jmp 0x40ded
leaq 0x2bb01(%rip), %rax     # 0x6c88b
movq %rax, -0x10(%rbp)
jmp 0x40ded
leaq 0x2bb04(%rip), %rax     # 0x6c89b
movq %rax, -0x10(%rbp)
jmp 0x40ded
leaq 0x24c4f(%rip), %rax     # 0x659f3
movq %rax, -0x10(%rbp)
jmp 0x40ded
leaq 0x2e8c2(%rip), %rax     # 0x6f673
movq %rax, -0x10(%rbp)
jmp 0x40ded
leaq 0x2bae8(%rip), %rax     # 0x6c8a6
movq %rax, -0x10(%rbp)
jmp 0x40ded
leaq 0x2bae7(%rip), %rax     # 0x6c8b2
movq %rax, -0x10(%rbp)
jmp 0x40ded
leaq 0x25995(%rip), %rax     # 0x6676d
movq %rax, -0x10(%rbp)
jmp 0x40ded
leaq 0x261fe(%rip), %rax     # 0x66fe3
movq %rax, -0x10(%rbp)
jmp 0x40ded
jmp 0x40ded
movl $0x1, %edi
callq 0x28100
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_nikon.c
// Function: maker_nikon_value_is_offset
int
maker_nikon_value_is_offset(struct ifd_entry *entry_ptr,int model)
{
    int is_offset = 0;

    /* There is currently no need for a switch on noteversion         */
    if(entry_ptr)
    {
        switch(entry_ptr->tag)
        {
            case 0x0011: is_offset = 1; break; 
            case 0x0097: is_offset = 1; break; 
            case 0x0100: is_offset = 1; break; 
            default: break;
        }
    }
    return(is_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x41451
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x11, %eax
je 0x41432
jmp 0x4141a
movl -0x14(%rbp), %eax
subl $0x97, %eax
je 0x4143b
jmp 0x41426
movl -0x14(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0x41444
jmp 0x4144d
movl $0x1, -0x10(%rbp)
jmp 0x4144f
movl $0x1, -0x10(%rbp)
jmp 0x4144f
movl $0x1, -0x10(%rbp)
jmp 0x4144f
jmp 0x4144f
jmp 0x41451
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x36112(%rip), %rax     # 0x77590
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x4149c
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x414a5
jmp 0x414f6
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movslq 0x8(%rax), %rdx
callq 0x31e0
cmpl $0x0, %eax
jne 0x414e6
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x28080
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x28100
jmp 0x414f6
jmp 0x414e8
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x41482
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4157c
leaq 0x35c4b(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x30, %rax
cmpq $0x0, %rax
je 0x4157c
movl -0x1c(%rbp), %eax
subl $0x1, %eax
jne 0x4156a
jmp 0x4154c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x41590
movq -0x8(%rbp), %rdi
callq 0x415e0
jmp 0x4157a
movq -0x8(%rbp), %rdi
leaq 0x28da5(%rip), %rsi     # 0x6a31a
callq 0x71d0
jmp 0x4157c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movw %si, %ax
movl 0x30(%rbp), %esi
movl 0x28(%rbp), %esi
movl 0x20(%rbp), %esi
movl 0x18(%rbp), %esi
movq 0x10(%rbp), %rsi
movq %rdi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x44(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4186f
movl -0x44(%rbp), %eax
subl $0x1, %eax
jne 0x4182e
jmp 0x417cc
movq -0x18(%rbp), %rdi
movw -0x1a(%rbp), %si
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq 0x10(%rbp), %r14
movl 0x18(%rbp), %ebx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x30(%rbp), %eax
movzwl %si, %esi
movq %r14, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x41880
movq -0x18(%rbp), %rdi
movw -0x1a(%rbp), %ax
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movzwl %ax, %esi
callq 0x42370
jmp 0x4186d
movq -0x18(%rbp), %rdi
movw -0x1a(%rbp), %si
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %r8
movq 0x10(%rbp), %r9
movl 0x18(%rbp), %ebx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x30(%rbp), %eax
movzwl %si, %esi
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x23f60
jmp 0x4186f
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_epson.c
// Function: maker_epson_tagname
char *
maker_epson_tagname(unsigned short tag,int model)
{
    char *tagname = CNULL;
    int noteversion = 0;

    /* Should have to do this only once, and only for unrecognized    */
    /* models. If the model is recognized (or the user has forced a   */
    /* noteversion) noteversion will already be set.                  */
    if((noteversion = getnoteversion()) == 0)
    {
        noteversion = 1;
        setnoteversion(1);
    }

    switch(noteversion)
    {
        case 1 :
            tagname = maker_epson1_tagname(tag,model);
            break;
        default:
            break;
    }

    if(tagname == NULL)
    {
        switch(tag)
        {
            case 0x0e00: tagname = "PrintIM"; break;
            case 0x0100: tagname = "JpegThumbnail"; break;
            default: break;
        }
    }
    return(tagname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x425d1
movl $0x1, -0x14(%rbp)
movl $0x1, %edi
callq 0x28080
movl -0x14(%rbp), %eax
subl $0x1, %eax
jne 0x425f0
jmp 0x425db
movw -0x2(%rbp), %ax
movl -0x8(%rbp), %esi
movzwl %ax, %edi
callq 0x42640
movq %rax, -0x10(%rbp)
jmp 0x425f2
jmp 0x425f2
cmpq $0x0, -0x10(%rbp)
jne 0x42633
movzwl -0x2(%rbp), %eax
movl %eax, -0x18(%rbp)
subl $0x100, %eax            # imm = 0x100
je 0x42622
jmp 0x42609
movl -0x18(%rbp), %eax
subl $0xe00, %eax            # imm = 0xE00
jne 0x4262f
jmp 0x42615
leaq 0x234ae(%rip), %rax     # 0x65aca
movq %rax, -0x10(%rbp)
jmp 0x42631
leaq 0x24144(%rip), %rax     # 0x6676d
movq %rax, -0x10(%rbp)
jmp 0x42631
jmp 0x42631
jmp 0x42633
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x35552(%rip), %rax     # 0x77d70
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x4283c
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x42845
jmp 0x42896
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movslq 0x8(%rax), %rdx
callq 0x31e0
cmpl $0x0, %eax
jne 0x42886
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x28080
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x28100
jmp 0x42896
jmp 0x42888
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x42822
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4291f
leaq 0x348ab(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x30, %rax
cmpq $0x0, %rax
je 0x4291f
movl -0x1c(%rbp), %eax
subl $0x1, %eax
jne 0x4290d
jmp 0x428ec
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0x27a1d(%rip), %rcx     # 0x6a31a
callq 0x42930
movq -0x8(%rbp), %rdi
callq 0x42970
jmp 0x4291d
movq -0x8(%rbp), %rdi
leaq 0x27a02(%rip), %rsi     # 0x6a31a
callq 0x71d0
jmp 0x4291f
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movw %si, %ax
movl 0x30(%rbp), %esi
movl 0x28(%rbp), %esi
movl 0x20(%rbp), %esi
movl 0x18(%rbp), %esi
movq 0x10(%rbp), %rsi
movq %rdi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x44(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x42c4f
movl -0x44(%rbp), %eax
subl $0x1, %eax
jne 0x42c0e
jmp 0x42bac
movq -0x18(%rbp), %rdi
movw -0x1a(%rbp), %si
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movq -0x40(%rbp), %r9
movq 0x10(%rbp), %r14
movl 0x18(%rbp), %ebx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x30(%rbp), %eax
movzwl %si, %esi
movq %r14, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0x42c60
movq -0x18(%rbp), %rdi
movw -0x1a(%rbp), %ax
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movzwl %ax, %esi
callq 0x43480
jmp 0x42c4d
movq -0x18(%rbp), %rdi
movw -0x1a(%rbp), %si
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %r8
movq 0x10(%rbp), %r9
movl 0x18(%rbp), %ebx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x30(%rbp), %eax
movzwl %si, %esi
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x23f60
jmp 0x42c4f
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x436e1
movl $0x1, -0x14(%rbp)
movl $0x1, %edi
callq 0x28080
movl -0x14(%rbp), %eax
subl $0x1, %eax
jne 0x43700
jmp 0x436eb
movw -0x2(%rbp), %ax
movl -0x8(%rbp), %esi
movzwl %ax, %edi
callq 0x43710
movq %rax, -0x10(%rbp)
jmp 0x43702
jmp 0x43702
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_private_tagname
char *
olympus_private_tagname(unsigned short tag,unsigned short subifd_ident)
{
    char *tagname = CNULL;

    switch(subifd_ident)
    {
        case 0x2010:
            tagname = olympus_private_2010_tagname(tag);
            break;
        case 0x2020:
            tagname = olympus_private_2020_tagname(tag);
            break;
        case 0x2030:
            tagname = olympus_private_2030_tagname(tag);
            break;
        case 0x2040:
            tagname = olympus_private_2040_tagname(tag);
            break;
        case 0x2050:
            tagname = olympus_private_2050_tagname(tag);
            break;
        default:
            break;
    }
    return(tagname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movq $0x0, -0x10(%rbp)
movzwl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x2010, %eax           # imm = 0x2010
je 0x43d4e
jmp 0x43d1e
movl -0x14(%rbp), %eax
subl $0x2020, %eax           # imm = 0x2020
je 0x43d5d
jmp 0x43d2a
movl -0x14(%rbp), %eax
subl $0x2030, %eax           # imm = 0x2030
je 0x43d6c
jmp 0x43d36
movl -0x14(%rbp), %eax
subl $0x2040, %eax           # imm = 0x2040
je 0x43d7b
jmp 0x43d42
movl -0x14(%rbp), %eax
subl $0x2050, %eax           # imm = 0x2050
je 0x43d8a
jmp 0x43d99
movzwl -0x2(%rbp), %edi
callq 0x43db0
movq %rax, -0x10(%rbp)
jmp 0x43d9b
movzwl -0x2(%rbp), %edi
callq 0x44000
movq %rax, -0x10(%rbp)
jmp 0x43d9b
movzwl -0x2(%rbp), %edi
callq 0x44390
movq %rax, -0x10(%rbp)
jmp 0x43d9b
movzwl -0x2(%rbp), %edi
callq 0x44560
movq %rax, -0x10(%rbp)
jmp 0x43d9b
movzwl -0x2(%rbp), %edi
callq 0x446f0
movq %rax, -0x10(%rbp)
jmp 0x43d9b
jmp 0x43d9b
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq $0x0, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x44637
jmp 0x44584
movl -0x14(%rbp), %eax
subl $0x100, %eax            # imm = 0x100
je 0x44647
jmp 0x44594
movl -0x14(%rbp), %eax
subl $0x200, %eax            # imm = 0x200
je 0x44657
jmp 0x445a4
movl -0x14(%rbp), %eax
subl $0x300, %eax            # imm = 0x300
je 0x44664
jmp 0x445b4
movl -0x14(%rbp), %eax
subl $0x310, %eax            # imm = 0x310
je 0x44671
jmp 0x445c4
movl -0x14(%rbp), %eax
subl $0x600, %eax            # imm = 0x600
je 0x4467e
jmp 0x445d4
movl -0x14(%rbp), %eax
subl $0x610, %eax            # imm = 0x610
je 0x4468b
jmp 0x445e4
movl -0x14(%rbp), %eax
subl $0x611, %eax            # imm = 0x611
je 0x44698
jmp 0x445f4
movl -0x14(%rbp), %eax
subl $0x614, %eax            # imm = 0x614
je 0x446a5
jmp 0x44604
movl -0x14(%rbp), %eax
subl $0x615, %eax            # imm = 0x615
je 0x446b2
jmp 0x44614
movl -0x14(%rbp), %eax
subl $0x1010, %eax           # imm = 0x1010
je 0x446bf
jmp 0x44624
movl -0x14(%rbp), %eax
subl $0x1012, %eax           # imm = 0x1012
je 0x446cc
jmp 0x446d9
leaq 0x28f0a(%rip), %rax     # 0x6d548
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28f11(%rip), %rax     # 0x6d55f
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28b11(%rip), %rax     # 0x6d16f
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28f00(%rip), %rax     # 0x6d56b
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28f07(%rip), %rax     # 0x6d57f
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28f0e(%rip), %rax     # 0x6d593
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28f15(%rip), %rax     # 0x6d5a7
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28af3(%rip), %rax     # 0x6d192
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28f0f(%rip), %rax     # 0x6d5bb
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28f0e(%rip), %rax     # 0x6d5c7
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28f0e(%rip), %rax     # 0x6d5d4
movq %rax, -0x10(%rbp)
jmp 0x446db
leaq 0x28f0e(%rip), %rax     # 0x6d5e1
movq %rax, -0x10(%rbp)
jmp 0x446db
jmp 0x446db
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movq $0x0, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0x14(%rbp)
testl %eax, %eax
je 0x4474c
jmp 0x44710
movl -0x14(%rbp), %eax
subl $0x209, %eax            # imm = 0x209
je 0x44759
jmp 0x4471c
movl -0x14(%rbp), %eax
subl $0x300, %eax            # imm = 0x300
je 0x44766
jmp 0x44728
movl -0x14(%rbp), %eax
subl $0x305, %eax            # imm = 0x305
je 0x44773
jmp 0x44734
movl -0x14(%rbp), %eax
subl $0x1201, %eax           # imm = 0x1201
je 0x44780
jmp 0x44740
movl -0x14(%rbp), %eax
subl $0x1208, %eax           # imm = 0x1208
je 0x4478d
jmp 0x4479a
leaq 0x28ea3(%rip), %rax     # 0x6d5f6
movq %rax, -0x10(%rbp)
jmp 0x4479c
leaq 0x28ea7(%rip), %rax     # 0x6d607
movq %rax, -0x10(%rbp)
jmp 0x4479c
leaq 0x28ea5(%rip), %rax     # 0x6d612
movq %rax, -0x10(%rbp)
jmp 0x4479c
leaq 0x2822c(%rip), %rax     # 0x6c9a6
movq %rax, -0x10(%rbp)
jmp 0x4479c
leaq 0x28e98(%rip), %rax     # 0x6d61f
movq %rax, -0x10(%rbp)
jmp 0x4479c
leaq 0x28e99(%rip), %rax     # 0x6d62d
movq %rax, -0x10(%rbp)
jmp 0x4479c
jmp 0x4479c
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_interpret_pe_value
void
olympus_interpret_pe_value(struct ifd_entry *entry_ptr,unsigned short subifd_ident,
                                                                    char *prefix)
{
    if(entry_ptr)
    {
        switch(subifd_ident)
        {
            case 0x2010:
                olympus2010_interpret_value(entry_ptr,prefix);
                break;
            case 0x2020:
                olympus2020_interpret_value(entry_ptr,prefix);
                break;
            case 0x2030:
                olympus2030_interpret_value(entry_ptr,prefix);
                break;
            case 0x2040:
                olympus2040_interpret_value(entry_ptr,prefix);
                break;
            case 0x2050:
                olympus2050_interpret_value(entry_ptr,prefix);
                break;
            default:
                break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x44861
movzwl -0xa(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0x2010, %eax           # imm = 0x2010
je 0x44812
jmp 0x447e2
movl -0x1c(%rbp), %eax
subl $0x2020, %eax           # imm = 0x2020
je 0x44821
jmp 0x447ee
movl -0x1c(%rbp), %eax
subl $0x2030, %eax           # imm = 0x2030
je 0x44830
jmp 0x447fa
movl -0x1c(%rbp), %eax
subl $0x2040, %eax           # imm = 0x2040
je 0x4483f
jmp 0x44806
movl -0x1c(%rbp), %eax
subl $0x2050, %eax           # imm = 0x2050
je 0x4484e
jmp 0x4485d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44870
jmp 0x4485f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x44a40
jmp 0x4485f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x455d0
jmp 0x4485f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45600
jmp 0x4485f
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x45630
jmp 0x4485f
jmp 0x4485f
jmp 0x44861
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movw %r8w, %ax
movl 0x38(%rbp), %r8d
movl 0x30(%rbp), %r8d
movl 0x28(%rbp), %r8d
movl 0x20(%rbp), %r8d
movq 0x18(%rbp), %r8
movq 0x10(%rbp), %r8
movq %rdi, -0x20(%rbp)
movw %si, -0x22(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movw %ax, -0x3a(%rbp)
movq %r9, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x4c(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x4578b
movl -0x4c(%rbp), %eax
subl $0x1, %eax
jne 0x4573c
jmp 0x456c7
movq -0x20(%rbp), %rdi
movw -0x22(%rbp), %si
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movw -0x3a(%rbp), %r8w
movq -0x48(%rbp), %r9
movq 0x10(%rbp), %r15
movq 0x18(%rbp), %r14
movl 0x20(%rbp), %ebx
movl 0x28(%rbp), %r11d
movl 0x30(%rbp), %r10d
movl 0x38(%rbp), %eax
movzwl %si, %esi
movzwl %r8w, %r8d
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movl %r10d, 0x20(%rsp)
movl %eax, 0x28(%rsp)
callq 0x457a0
movq -0x20(%rbp), %rdi
movw -0x22(%rbp), %ax
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movzwl %ax, %esi
movzwl -0x3a(%rbp), %r8d
callq 0x45a20
jmp 0x45789
movq -0x20(%rbp), %rdi
movw -0x22(%rbp), %si
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movw -0x3a(%rbp), %r8w
movq 0x10(%rbp), %r9
movq 0x18(%rbp), %r14
movl 0x20(%rbp), %ebx
movl 0x28(%rbp), %r11d
movl 0x30(%rbp), %r10d
movl 0x38(%rbp), %eax
movzwl %si, %esi
movzwl %r8w, %r8d
movq %r14, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0xd160
jmp 0x4578b
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus1_interpret_offset_pe_value
void
olympus1_interpret_offset_pe_value(FILE *inptr,unsigned short byteorder,
                    struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
                    unsigned short subifd_ident)
{
    if(entry_ptr)
    {
        switch(subifd_ident)
        {
            case 0x2010:
                olympus2010_interpret_offset_value(inptr,byteorder,entry_ptr,fileoffset_base);
                break;
            case 0x2020:
                olympus2020_interpret_offset_value(inptr,byteorder,entry_ptr,fileoffset_base);
                break;
            case 0x2030:
                olympus2030_interpret_offset_value(inptr,byteorder,entry_ptr,fileoffset_base);
                break;
            case 0x2040:
                olympus2040_interpret_offset_value(inptr,byteorder,entry_ptr,fileoffset_base);
                break;
            case 0x2050:
                olympus2050_interpret_offset_value(inptr,byteorder,entry_ptr,fileoffset_base);
                break;
            default:
                break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movw %si, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x45b14
movzwl -0x22(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x2010, %eax           # imm = 0x2010
je 0x45a8e
jmp 0x45a5b
movl -0x28(%rbp), %eax
subl $0x2020, %eax           # imm = 0x2020
je 0x45aa8
jmp 0x45a67
movl -0x28(%rbp), %eax
subl $0x2030, %eax           # imm = 0x2030
je 0x45ac2
jmp 0x45a73
movl -0x28(%rbp), %eax
subl $0x2040, %eax           # imm = 0x2040
je 0x45adc
jmp 0x45a7f
movl -0x28(%rbp), %eax
subl $0x2050, %eax           # imm = 0x2050
je 0x45af6
jmp 0x45b10
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzwl %ax, %esi
callq 0x464b0
jmp 0x45b12
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzwl %ax, %esi
callq 0x464f0
jmp 0x45b12
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzwl %ax, %esi
callq 0x46530
jmp 0x45b12
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzwl %ax, %esi
callq 0x46570
jmp 0x45b12
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movzwl %ax, %esi
callq 0x465b0
jmp 0x45b12
jmp 0x45b12
jmp 0x45b14
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x80, %rsp
movw %si, %ax
movl 0x30(%rbp), %esi
movl 0x28(%rbp), %esi
movl 0x20(%rbp), %esi
movl 0x18(%rbp), %esi
movq 0x10(%rbp), %rsi
movq %rdi, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movq %rdx, -0x28(%rbp)
movq %rcx, -0x30(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
movq $0x0, -0x60(%rbp)
movl $0x0, -0x64(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x4623b
movq -0x28(%rbp), %rax
movw (%rax), %ax
movl 0x20(%rbp), %esi
movl 0x28(%rbp), %edx
movzwl %ax, %edi
callq 0x28160
movq %rax, -0x58(%rbp)
leaq 0x30fed(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x461c0
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x1e7b3(%rip), %rsi     # 0x64962
callq 0x20960
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
movw -0x1a(%rbp), %si
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x60(%rbp), %r9
movq 0x10(%rbp), %r14
movl 0x18(%rbp), %ebx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x30(%rbp), %eax
movl $0x2030, %r8d           # imm = 0x2030
movzwl %si, %esi
movq %r14, (%rsp)
movl %ebx, 0x8(%rsp)
movl %r11d, 0x10(%rsp)
movl %r10d, 0x18(%rsp)
movl %eax, 0x20(%rsp)
callq 0xd160
cmpq $0x0, -0x60(%rbp)
je 0x46239
movq -0x60(%rbp), %rdi
callq 0x3040
jmp 0x4623b
movl -0x64(%rbp), %edi
callq 0x1ff00
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_private_value_is_offset
int
olympus_private_value_is_offset(unsigned short subifd_ident,unsigned short tag)
{
    int is_offset = 0;

    switch(subifd_ident)
    {
        case 0x2010: break;
        case 0x2020: is_offset = olympus2020_value_is_offset(tag); break;
        case 0x2030: break;
        case 0x2040: break;
        case 0x2050: break;
        default: break;
    }
    return(is_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movw %di, %cx
movw %cx, -0x2(%rbp)
movw %ax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x2010, %eax           # imm = 0x2010
je 0x4664d
jmp 0x4661d
movl -0xc(%rbp), %eax
subl $0x2020, %eax           # imm = 0x2020
je 0x4664f
jmp 0x46629
movl -0xc(%rbp), %eax
subl $0x2030, %eax           # imm = 0x2030
je 0x4665d
jmp 0x46635
movl -0xc(%rbp), %eax
subl $0x2040, %eax           # imm = 0x2040
je 0x4665f
jmp 0x46641
movl -0xc(%rbp), %eax
subl $0x2050, %eax           # imm = 0x2050
je 0x46661
jmp 0x46663
jmp 0x46665
movzwl -0x4(%rbp), %edi
callq 0x46670
movl %eax, -0x8(%rbp)
jmp 0x46665
jmp 0x46665
jmp 0x46665
jmp 0x46665
jmp 0x46665
movl -0x8(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus2020_value_is_offset
int
olympus2020_value_is_offset(unsigned short tag)
{
    int is_offset = 0;

    switch(tag)
    {
        case 0x0100: is_offset = -1; break;
        case 0x0101: is_offset = 1; break;
        case 0x0102: is_offset = -1; break;
        default: break;
    }
    return(is_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl $0x0, -0x8(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x100, %eax            # imm = 0x100
je 0x466aa
jmp 0x46692
movl -0xc(%rbp), %eax
subl $0x101, %eax            # imm = 0x101
je 0x466b3
jmp 0x4669e
movl -0xc(%rbp), %eax
subl $0x102, %eax            # imm = 0x102
je 0x466bc
jmp 0x466c5
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x466c7
movl $0x1, -0x8(%rbp)
jmp 0x466c7
movl $0xffffffff, -0x8(%rbp) # imm = 0xFFFFFFFF
jmp 0x466c7
jmp 0x466c7
movl -0x8(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x30f22(%rip), %rax     # 0x77610
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x4670c
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x46715
jmp 0x46766
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movslq 0x8(%rax), %rdx
callq 0x31e0
cmpl $0x0, %eax
jne 0x46756
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x28080
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x28100
jmp 0x46766
jmp 0x46758
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x466f2
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x467ec
leaq 0x309e5(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x30, %rax
cmpq $0x0, %rax
je 0x467ec
xorl %eax, %eax
callq 0x280d0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
jne 0x467da
jmp 0x467bc
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
callq 0x46800
movq -0x8(%rbp), %rdi
callq 0x46850
jmp 0x467ea
movq -0x8(%rbp), %rdi
leaq 0x23b35(%rip), %rsi     # 0x6a31a
callq 0x71d0
jmp 0x467ec
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_fujifilm.c
// Function: print_fujifilm_offset_makervalue
void
print_fujifilm_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)
        {
            default:
                print_generic_offset_makervalue(inptr,byteorder,entry_ptr,
                                fileoffset_base,parent_name,prefix,indent,
                                make,model,at_offset);
                break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
movw %si, %ax
movl 0x30(%rbp), %esi
movl 0x28(%rbp), %esi
movl 0x20(%rbp), %esi
movl 0x18(%rbp), %esi
movq 0x10(%rbp), %rsi
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4724d
xorl %eax, %eax
callq 0x280d0
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
movw -0x12(%rbp), %si
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
movq 0x10(%rbp), %r9
movl 0x18(%rbp), %ebx
movl 0x20(%rbp), %r11d
movl 0x28(%rbp), %r10d
movl 0x30(%rbp), %eax
movzwl %si, %esi
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
callq 0x23f60
jmp 0x4724d
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_fujifilm.c
// Function: maker_fujifilm_tagname
char *
maker_fujifilm_tagname(unsigned short tag,int model)
{
    char *tagname = (char *)0;
    int noteversion = 0;

    /* Should have to do this only once, and only for unrecognized    */
    /* models. If the model is recognized (or the user has forced a   */
    /* noteversion) noteversion will already be set.                  */
    if((noteversion = getnoteversion()) == 0)
    {
        /* Only one tagset has been observed so far; it seems         */
        /* reasonable to default to that tagset (rather than none).   */
        noteversion = 1;
        setnoteversion(1);
    }

    switch(noteversion)
    {
        case 1:
            tagname = maker_fujifilm1_tagname(tag,model);
            break;
        default:
            break;
    }

    /* If no model-specific tag is found, check "generic" tags        */
    if(tagname == NULL)
    {
        switch(tag)
        {
            case 0x0e00: tagname = "PrintIM"; break;
            default: break;
        }
    }
    return(tagname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movb $0x0, %al
callq 0x280d0
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x472a1
movl $0x1, -0x14(%rbp)
movl $0x1, %edi
callq 0x28080
movl -0x14(%rbp), %eax
subl $0x1, %eax
jne 0x472c0
jmp 0x472ab
movw -0x2(%rbp), %ax
movl -0x8(%rbp), %esi
movzwl %ax, %edi
callq 0x472f0
movq %rax, -0x10(%rbp)
jmp 0x472c2
jmp 0x472c2
cmpq $0x0, -0x10(%rbp)
jne 0x472e6
movw -0x2(%rbp), %ax
subw $0xe00, %ax             # imm = 0xE00
jne 0x472e2
jmp 0x472d5
leaq 0x1e7ee(%rip), %rax     # 0x65aca
movq %rax, -0x10(%rbp)
jmp 0x472e4
jmp 0x472e4
jmp 0x472e6
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_casio.c
// Function: set_casio_noteversion
int
set_casio_noteversion()
{
    struct maker_scheme *scheme;
    int noteversion = 0;
    int tagset = 0;

    scheme = retrieve_makerscheme();
    if(scheme->note_version <= 0)
    {
        noteversion = -1;
        tagset = -1;
        switch(scheme->scheme_type)
        {
            case HAS_ID_SCHEME:     /* "QVC" */
                tagset = 2;
                noteversion = 2;
                break;
            case PLAIN_IFD_SCHEME:
                tagset = 1;
                noteversion = 1;
                break;
            case UNKNOWN_SCHEME:
                break;
            default: 
                break;
        }
        setnotetagset(tagset);
        setnoteversion(noteversion);
    }
    else
        noteversion = scheme->note_version;
    return(noteversion);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x0, %al
callq 0x28130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jg 0x47749
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
testq %rax, %rax
je 0x47733
jmp 0x476fb
movq -0x18(%rbp), %rax
subq $0x1, %rax
je 0x47723
jmp 0x47707
movq -0x18(%rbp), %rax
subq $0x2, %rax
jne 0x47735
jmp 0x47713
movl $0x2, -0x10(%rbp)
movl $0x2, -0xc(%rbp)
jmp 0x47737
movl $0x1, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
jmp 0x47737
jmp 0x47737
jmp 0x47737
movl -0x10(%rbp), %edi
callq 0x28100
movl -0xc(%rbp), %edi
callq 0x28080
jmp 0x47753
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)