LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1c4d8
testq %r14, %r14
je 0x302a1
cmpl $0x1, %eax
jne 0x302a7
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 0x302e7
addq $0x38, %rsp
jmp 0x302dc
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 0xa76a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_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 0x304dc
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
movq %rcx, 0x10(%rsp)
movl 0x80(%rsp), %eax
movq %rax, 0x8(%rsp)
movl 0x78(%rsp), %r14d
movl 0x70(%rsp), %ebx
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movzwl (%rdx), %edi
movl %ebx, %esi
movl %r14d, %edx
callq 0x1c518
leaq 0x27d41(%rip), %rcx     # 0x58180
testb $0x40, (%rcx)
jne 0x30479
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq 0x18(%rsp), %rcx
movl $0x2010, %r8d           # imm = 0x2010
xorl %r9d, %r9d
pushq 0x10(%rsp)
pushq %r14
pushq %rbx
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0xa76a
addq $0x30, %rsp
jmp 0x304ce
leaq 0x11517(%rip), %rsi     # 0x41997
movq %r15, %rdi
movq %rax, %rdx
callq 0x17f99
movq %rax, %r15
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq 0x18(%rsp), %rcx
movl $0x2010, %r8d           # imm = 0x2010
movq %rax, %r9
pushq 0x10(%rsp)
pushq %r14
pushq %rbx
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0xa76a
addq $0x30, %rsp
testq %r15, %r15
je 0x304ce
movq %r15, %rdi
callq 0x3050
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %edi, %edi
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/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 0x30935
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
movq %rcx, 0x10(%rsp)
movl 0x80(%rsp), %eax
movq %rax, 0x8(%rsp)
movl 0x78(%rsp), %r14d
movl 0x70(%rsp), %ebx
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movzwl (%rdx), %edi
movl %ebx, %esi
movl %r14d, %edx
callq 0x1c518
leaq 0x278e8(%rip), %rcx     # 0x58180
testb $0x40, (%rcx)
jne 0x308d2
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq 0x18(%rsp), %rcx
movl $0x2030, %r8d           # imm = 0x2030
xorl %r9d, %r9d
pushq 0x10(%rsp)
pushq %r14
pushq %rbx
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0xa76a
addq $0x30, %rsp
jmp 0x30927
leaq 0x110be(%rip), %rsi     # 0x41997
movq %r15, %rdi
movq %rax, %rdx
callq 0x17f99
movq %rax, %r15
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq 0x18(%rsp), %rcx
movl $0x2030, %r8d           # imm = 0x2030
movq %rax, %r9
pushq 0x10(%rsp)
pushq %r14
pushq %rbx
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0xa76a
addq $0x30, %rsp
testq %r15, %r15
je 0x30927
movq %r15, %rdi
callq 0x3050
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %edi, %edi
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/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 0x27a74(%rip), %r15     # 0x58610
movq (%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x30be1
movq %rdi, %r14
addq $0x18, %r15
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x30bcb
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x30bad
jmp 0x30be1
movl -0xc(%r15), %ebx
movl -0x8(%r15), %edi
callq 0x1c4bf
movl -0x4(%r15), %edi
callq 0x1c4f0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x30c32
leaq 0x27587(%rip), %r14     # 0x58180
testb $0x30, (%r14)
je 0x30c32
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
cmpl $0x1, %eax
jne 0x30c3a
testb $0x30, (%r14)
je 0x30c23
leaq 0x170bb(%rip), %rsi     # 0x47cd6
movq %rbx, %rdi
callq 0x634b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x30c6e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x17095(%rip), %rsi     # 0x47cd6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x634b
// File: /workspace/github_c_makefile_star2_O3/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 0x1c4d8
testq %rbx, %rbx
je 0x313f4
movl %eax, %ebp
leaq 0x26db8(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x313f4
leaq 0x16902(%rip), %rsi     # 0x47cd6
movq %rbx, %rdi
callq 0x634b
cmpl $0x1, %ebp
je 0x313fb
cmpl $0x2, %ebp
jne 0x313f4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x31427
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3178f
// File: /workspace/github_c_makefile_star2_O3/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 0x1c4d8
testq %r12, %r12
je 0x31b3c
cmpl $0x2, %eax
je 0x31b42
cmpl $0x1, %eax
jne 0x31b67
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 0x31b9e
addq $0x58, %rsp
jmp 0x31b93
addq $0x28, %rsp
jmp 0x31b93
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 0x31ead
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 0x19706
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_casio.c
// Function: maker_casio_tagname
char *
maker_casio_tagname(unsigned short tag,int model)
{
    char *tagname = (char *)0;
    int noteversion = 0;

    if((noteversion = getnoteversion()) == 0)
    {
        noteversion = set_casio_noteversion();
        setnoteversion(noteversion);
    }

    /* Check noteversions first                                       */
    switch(noteversion)
    {
        case 1:
            tagname = maker_casio1_tagname(tag,model);
            break;
        case 2:
            tagname = maker_casio2_tagname(tag,model);
            break;
        default:
            break;
    }

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %eax, %eax
callq 0x1c4d8
movl %eax, %ebp
testl %eax, %eax
jne 0x3241e
callq 0x3136d
movl %eax, %ebp
movl %eax, %edi
callq 0x1c4bf
movzwl %bx, %ebx
cmpl $0x2, %ebp
je 0x32434
cmpl $0x1, %ebp
jne 0x3243d
movl %ebx, %edi
callq 0x32461
jmp 0x3243f
movl %ebx, %edi
callq 0x3248b
jmp 0x3243f
xorl %eax, %eax
testq %rax, %rax
leaq 0x10e79(%rip), %rcx     # 0x432c2
cmovneq %rax, %rcx
cmpl $0xe00, %ebx            # imm = 0xE00
cmovneq %rax, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_minolta.c
// Function: print_minolta_makervalue
void
print_minolta_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_minolta1_makervalue(entry_ptr,make,model,prefix);
                minolta1_interpret_value(entry_ptr,model);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
testq %rbx, %rbx
je 0x32706
leaq 0x25a9c(%rip), %rcx     # 0x58180
testb $0x30, (%rcx)
je 0x32706
cmpl $0x1, %eax
jne 0x3270d
movq %rbx, %rdi
callq 0x32722
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3278f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x155c2(%rip), %rsi     # 0x47cd6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x634b
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_minolta.c
// Function: print_minolta1_makervalue
void
print_minolta1_makervalue(struct ifd_entry *entry_ptr,int make, int model,
                                                            char *prefix)
{
    int chpr = 0;
    if(entry_ptr && (PRINT_VALUE))
    {
        switch(entry_ptr->tag) 
        {
                case 0x0040:    /* ImageByteSize                      */
                    chpr += printf("%lu ",entry_ptr->value);
                    if(entry_ptr->count > 1)
                    {
                        printred("# BAD COUNT");
                        setcharsprinted(chpr);
                    }
                    break;
                default:
                    print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x32773
leaq 0x25a4f(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x32773
movq %rdi, %rbx
cmpw $0x40, (%rdi)
jne 0x3277a
movq 0x10(%rbx), %rsi
leaq 0x1617f(%rip), %rdi     # 0x488c9
xorl %eax, %eax
callq 0x3120
cmpq $0x2, 0x8(%rbx)
jb 0x32773
movl %eax, %ebp
leaq 0x194cf(%rip), %rdi     # 0x4bc30
callq 0x5c26
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x17a82
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x15555(%rip), %rsi     # 0x47cd6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x634b
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_minolta.c
// Function: print_minolta_offset_makervalue
void
print_minolta_offset_makervalue(FILE *inptr,unsigned short byteorder,
    struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
    struct image_summary *summary_entry,char *parent_name,char*prefix,
    int indent,int make,int model,int at_offset)
{
    int noteversion = 0;


    if(entry_ptr)
    {
        noteversion = getnoteversion();
        switch(noteversion)
        {
            case 1:
                minolta1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                minolta1_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
testq %rdx, %rdx
je 0x32ab6
movq %r9, %r12
movq %r8, %rbp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %r15
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 0x1c4d8
cmpl $0x1, %eax
jne 0x32abc
subq $0x8, %rsp
movzwl %r13w, %r13d
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %rbp, %r8
movq %r12, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x30(%rsp)
pushq 0x40(%rsp)
pushq 0x38(%rsp)
callq 0x32af4
addq $0x30, %rsp
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x332d5
addq $0x28, %rsp
jmp 0x32ae9
movzwl %r13w, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movq %r12, %r8
movq 0x10(%rsp), %r9
pushq (%rsp)
pushq 0x10(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x19706
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_sanyo.c
// Function: sanyo_model_number
int
sanyo_model_number(char *model,char *software)
{
    struct camera_id *model_id;
    int number = NO_MODEL;

    for(model_id = &sanyo_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 0x23df8(%rip), %r15     # 0x59000
movq (%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x3524d
movq %rdi, %r14
addq $0x18, %r15
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x35237
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x35219
jmp 0x3524d
movl -0xc(%r15), %ebx
movl -0x8(%r15), %edi
callq 0x1c4bf
movl -0x4(%r15), %edi
callq 0x1c4f0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_sanyo.c
// Function: print_sanyo_makervalue
void
print_sanyo_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_sanyo1_makervalue(entry_ptr,make,model,prefix);
                sanyo1_interpret_value(entry_ptr);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
testq %rbx, %rbx
je 0x35297
movl %eax, %ebp
leaq 0x22f10(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x35297
leaq 0x12a5a(%rip), %rsi     # 0x47cd6
movq %rbx, %rdi
callq 0x634b
cmpl $0x1, %ebp
jne 0x35297
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x352bc
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_sanyo.c
// Function: print_sanyo_offset_makervalue
void
print_sanyo_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:
                sanyo1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                sanyo1_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 0x1c4d8
testq %r14, %r14
je 0x356eb
cmpl $0x1, %eax
jne 0x356f1
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 0x35727
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 0x35c95
addq $0x28, %rsp
jmp 0x3571c
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 0x19706
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_canon.c
// Function: print_canon1_makervalue
void
print_canon1_makervalue(struct ifd_entry *entry_ptr,int make, int model,
                                                            char *prefix)
{
    if(entry_ptr && (PRINT_VALUE))
    {
        switch(entry_ptr->tag) 
        {
            case 0x000C:    /* Camera serial number                   */
                print_value(entry_ptr,PREFIX);
                /* ###%%%                                             */
                /* perhaps this should be in canon1_interpret_value() */
                (void)print_canon_serialno(entry_ptr->value);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3605e
leaq 0x2214e(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x3605e
movq %rdi, %rbx
movzwl (%rdi), %ebp
leaq 0x11c92(%rip), %rsi     # 0x47cd6
callq 0x634b
cmpw $0xc, %bp
jne 0x3605e
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36066
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_canon.c
// Function: print_canon_serialno
int
print_canon_serialno(unsigned long value)
{
    unsigned long tmp;
    int chpr = 0;

    print_startvalue();
    tmp = (value & 0xffff0000) >> 16;
    chpr += printf("%04lX",value & 0xffff);
    tmp = value & 0xffff;
    chpr += printf("%05lu",value & 0xffff);
    print_endvalue();
    setcharsprinted(chpr);
    return(chpr);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x96fd
movzwl %bx, %ebx
leaq 0x16c9f(%rip), %rdi     # 0x4cd1c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
leaq 0x16c92(%rip), %rdi     # 0x4cd22
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
addl %ebp, %ebx
xorl %eax, %eax
callq 0x971e
movl %ebx, %edi
callq 0x17a82
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_canon.c
// Function: print_canon_offset_makervalue
void
print_canon_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)
        {
            /* noteversion 1 assumes the single known tagset is       */
            /* correct, but imposes a "generic" routine for           */
            /* CustomFunctions (which presents values but interprets  */
            /* nothing) for unrecognized models or those for which no */
            /* information is available.                              */
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                canon1_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, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r13
movl 0x80(%rsp), %eax
movq %rax, (%rsp)
movl 0x78(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x70(%rsp), %eax
movq %rax, 0x18(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %r12
xorl %eax, %eax
callq 0x1c4d8
testq %r15, %r15
je 0x3613b
decl %eax
movzwl %bp, %esi
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
cmpl $0x4, %eax
ja 0x36141
movq 0x8(%rsp), %r8
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3616a
addq $0x28, %rsp
jmp 0x3615f
movq %rbx, %r8
movq %r12, %r9
pushq (%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
callq 0x19706
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_canon.c
// Function: canon_customfunctions
unsigned long
canon_customfunctions(FILE *inptr,unsigned short byteorder,
    char *tagprefix,unsigned long offset,
    unsigned long dirlength,int model,int indent)
{
    unsigned long max_offset;
    int noteversion = 0;

    noteversion = getnoteversion();

    switch(noteversion)
    {
    case 5:  /* 20 entries (or 21,22) */
        max_offset = canon_customfunctions1D(inptr,byteorder,tagprefix,offset,dirlength,indent);
        break;
    case 4:  /* 18 entries                                            */
        max_offset = canon_customfunctions20D(inptr,byteorder,tagprefix,offset,dirlength,indent);
        break;
    case 3:  /* 17 entries starting at 1*/
        max_offset = canon_customfunctions10D(inptr,byteorder,tagprefix,offset,dirlength,indent);
        break;
    case 2:  /* 16 entries                                            */
        max_offset = canon_customfunctionsD30(inptr,byteorder,tagprefix,offset,dirlength,indent);
        break;
    case 1:  /* unknown customfuctions                                */
    default:
        max_offset = canon_customfunctions_unk(inptr,byteorder,tagprefix,offset,dirlength,indent);
        break;
    }
    return(max_offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %r13d
movq %rdi, %r12
movl 0x40(%rsp), %ebp
xorl %eax, %eax
callq 0x1c4d8
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x3882b
leaq 0x1415e(%rip), %rcx     # 0x4c8e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movzwl %r13w, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b6de
movzwl %r13w, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3a07f
movzwl %r13w, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x392dd
movzwl %r13w, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3ab3c
movzwl %r13w, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3c025
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_leica.c
// Function: print_leica_makervalue
void
print_leica_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_leica1_makervalue(entry_ptr,make,model,PREFIX);
                leica1_interpret_value(entry_ptr);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
testq %rbx, %rbx
je 0x3cc0b
movl %eax, %ebp
leaq 0x1b59c(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x3cc0b
leaq 0xb0e6(%rip), %rsi      # 0x47cd6
movq %rbx, %rdi
callq 0x634b
cmpl $0x1, %ebp
jne 0x3cc0b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3cc30
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_leica.c
// Function: maker_leica1_tagname
char *
maker_leica1_tagname(unsigned short tag,int model)
{
    char *tagname = CNULL;

    switch(tag)
    {
        case 0x0000: tagname = "Version"; break;
        case 0x1000: tagname = "Quality"; break;
        case 0x1001: tagname = "Sharpness"; break;
        case 0x1002: tagname = "WhiteBalance"; break;
        case 0x1003: tagname = "Color"; break;
        case 0x1004: tagname = "Tone"; break;
        case 0x1010: tagname = "FlashMode"; break;
        case 0x1011: tagname = "FlashStrength"; break;
        case 0x1020: tagname = "Macro"; break;
        case 0x1021: tagname = "FocusMode"; break;
        case 0x1030: tagname = "SlowSync"; break;
        case 0x1031: tagname = "PictureMode"; break;
        case 0x1100: tagname = "ContTake-Bracket"; break;
        case 0x1300: tagname = "BlurWarning"; break;
        case 0x1301: tagname = "FocusWarning"; break;
        case 0x1302: tagname = "AEWarning"; break;
        default: break;
    }
    setnotetagset(1);
    return(tagname);
}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
cmpl $0x101f, %edi           # imm = 0x101F
jg 0x3d16e
cmpl $0x100f, %edi           # imm = 0x100F
jg 0x3d1ce
leal -0x1000(%rdi), %eax
cmpl $0x4, %eax
ja 0x3d220
leaq 0x1101b(%rip), %rcx     # 0x4e174
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xeb3a(%rip), %rbx      # 0x4bca3
jmp 0x3d27c
cmpl $0x10ff, %edi           # imm = 0x10FF
jg 0x3d1a2
cmpl $0x102f, %edi           # imm = 0x102F
jg 0x3d1ee
cmpl $0x1020, %edi           # imm = 0x1020
je 0x3d248
cmpl $0x1021, %edi           # imm = 0x1021
jne 0x3d27c
leaq 0xcfd7(%rip), %rbx      # 0x4a174
jmp 0x3d27c
cmpl $0x1300, %edi           # imm = 0x1300
jg 0x3d207
cmpl $0x1100, %edi           # imm = 0x1100
je 0x3d251
cmpl $0x1300, %edi           # imm = 0x1300
jne 0x3d27c
leaq 0xe141(%rip), %rbx      # 0x4b30a
jmp 0x3d27c
cmpl $0x1010, %edi           # imm = 0x1010
je 0x3d236
cmpl $0x1011, %edi           # imm = 0x1011
jne 0x3d27c
leaq 0xe0ed(%rip), %rbx      # 0x4b2d6
jmp 0x3d27c
cmpl $0x1030, %edi           # imm = 0x1030
je 0x3d25a
cmpl $0x1031, %edi           # imm = 0x1031
jne 0x3d27c
leaq 0xe0e8(%rip), %rbx      # 0x4b2ed
jmp 0x3d27c
cmpl $0x1301, %edi           # imm = 0x1301
je 0x3d263
cmpl $0x1302, %edi           # imm = 0x1302
jne 0x3d27c
leaq 0xe105(%rip), %rbx      # 0x4b323
jmp 0x3d27c
testl %edi, %edi
jne 0x3d27c
leaq 0x60cf(%rip), %rbx      # 0x432fa
jmp 0x3d27c
leaq 0xe09d(%rip), %rbx      # 0x4b2d1
jmp 0x3d27c
leaq 0xd8b5(%rip), %rbx      # 0x4aaf2
jmp 0x3d27c
leaq 0x5fa5(%rip), %rbx      # 0x431eb
jmp 0x3d27c
leaq 0x94c8(%rip), %rbx      # 0x46717
jmp 0x3d27c
leaq 0xe0a1(%rip), %rbx      # 0x4b2f9
jmp 0x3d27c
leaq 0xe083(%rip), %rbx      # 0x4b2e4
jmp 0x3d27c
leaq 0xe0ac(%rip), %rbx      # 0x4b316
jmp 0x3d27c
leaq 0xeefc(%rip), %rbx      # 0x4c16f
jmp 0x3d27c
leaq 0x6209(%rip), %rbx      # 0x43485
movl $0x1, %edi
callq 0x1c4f0
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_agfa.c
// Function: print_agfa_makervalue
void
print_agfa_makervalue(struct ifd_entry *entry_ptr,int make, int model,
                    char *prefix)
{
    int noteversion;

    noteversion = getnoteversion();

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
testq %rbx, %rbx
je 0x3d327
movl %eax, %ebp
leaq 0x1ae80(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x3d327
leaq 0xa9ca(%rip), %rsi      # 0x47cd6
movq %rbx, %rdi
callq 0x634b
cmpl $0x1, %ebp
jne 0x3d327
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3d34c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_agfa.c
// Function: agfa1_interpret_value
void
agfa1_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();
                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; /* TIFF  */
                    case 34:    /* not sure about this one ###%%%         */
                                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;
                    case 2: chpr += printf("View"); break;
                    default: printred("undefined"); break;
                }
                print_endvalue();
                break;
            default:
                break;
        }
    }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3d39e
leaq 0x1ae27(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x3d39e
movq %rdi, %rbx
movzwl (%rdi), %eax
cmpl $0x202, %eax            # imm = 0x202
je 0x3d3a0
cmpl $0x201, %eax            # imm = 0x201
jne 0x3d39e
xorl %eax, %eax
callq 0x96fd
movq 0x10(%rbx), %rax
cmpq $0x2, %rax
jle 0x3d3c5
cmpq $0x3, %rax
je 0x3d3fa
cmpq $0x21, %rax
je 0x3d395
cmpq $0x22, %rax
jne 0x3d3da
leaq 0xd2fb(%rip), %rdi      # 0x4a697
jmp 0x3d40a
popq %rbx
retq
xorl %eax, %eax
callq 0x96fd
movq 0x10(%rbx), %rax
cmpq $0x2, %rax
je 0x3d3f1
cmpq $0x1, %rax
je 0x3d3e8
testq %rax, %rax
jne 0x3d3da
leaq 0xe036(%rip), %rdi      # 0x4b3f9
jmp 0x3d40a
cmpq $0x1, %rax
je 0x3d403
cmpq $0x2, %rax
jne 0x3d3da
leaq 0xd2bc(%rip), %rdi      # 0x4a694
jmp 0x3d40a
leaq 0xba88(%rip), %rdi      # 0x48e69
callq 0x5c26
jmp 0x3d411
leaq 0x9328(%rip), %rdi      # 0x46717
jmp 0x3d40a
leaq 0xd7da(%rip), %rdi      # 0x4abd2
jmp 0x3d40a
leaq 0xd292(%rip), %rdi      # 0x4a693
jmp 0x3d40a
leaq 0xd286(%rip), %rdi      # 0x4a690
xorl %eax, %eax
callq 0x3120
xorl %eax, %eax
popq %rbx
jmp 0x971e
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_agfa.c
// Function: print_agfa_offset_makervalue
void
print_agfa_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;

    noteversion = getnoteversion();

    if(entry_ptr)
    {
        switch(noteversion)
        {
            case 1:
                agfa1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                agfa1_interpret_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base);
                break;
            default: 
                /* Insufficent information about other models to do   */
                /* anything but generic.                              */
                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 0x1c4d8
testq %r14, %r14
je 0x3d4ca
cmpl $0x1, %eax
jne 0x3d4d0
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 0x3d506
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 0x3d9e4
addq $0x28, %rsp
jmp 0x3d4fb
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 0x19706
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_agfa.c
// Function: maker_agfa1_tagname
char *
maker_agfa1_tagname(unsigned short tag)
{
    char *tagname = CNULL;

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

// Assembly:
pushq %rbx
xorl %ebx, %ebx
leal -0x200(%rdi), %eax
cmpl $0xc, %eax
ja 0x3db9d
leaq 0x1061d(%rip), %rcx     # 0x4e1a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xca9d(%rip), %rbx      # 0x4a638
jmp 0x3dc05
cmpl $0xf00, %edi            # imm = 0xF00
je 0x3dbfe
cmpl $0x100, %edi            # imm = 0x100
jne 0x3dc05
leaq 0x63b1(%rip), %rbx      # 0x43f65
jmp 0x3dc05
leaq 0xcab1(%rip), %rbx      # 0x4a66e
jmp 0x3dc05
leaq 0x8b51(%rip), %rbx      # 0x46717
jmp 0x3dc05
leaq 0x10325(%rip), %rbx     # 0x4def4
jmp 0x3dc05
leaq 0xc572(%rip), %rbx      # 0x4a14a
jmp 0x3dc05
leaq 0xe0c2(%rip), %rbx      # 0x4bca3
jmp 0x3dc05
leaq 0xca6a(%rip), %rbx      # 0x4a654
jmp 0x3dc05
leaq 0x102ef(%rip), %rbx     # 0x4dee2
jmp 0x3dc05
leaq 0x62b6(%rip), %rbx      # 0x43eb2
jmp 0x3dc05
leaq 0x6d50(%rip), %rbx      # 0x44955
movl $0x1, %edi
callq 0x1c4f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_asahi.c
// Function: print_asahi_makervalue
void
print_asahi_makervalue(struct ifd_entry *entry_ptr,int make,int model,
                                                        char *prefix)
{
    int noteversion = 0;

    noteversion = getnoteversion();

    if(entry_ptr)
    {
        switch(noteversion)
        {
            case 3:
                print_asahi1_makervalue(entry_ptr,make,model,prefix);
                asahi3_interpret_value(entry_ptr);
                break;
            case 2:
                print_asahi1_makervalue(entry_ptr,make,model,prefix);
                asahi2_interpret_value(entry_ptr);
                break;
            case 1:
                print_asahi1_makervalue(entry_ptr,make,model,prefix);
                asahi1_interpret_value(entry_ptr);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
testq %rbx, %rbx
je 0x3dcf5
movl %eax, %ebp
leaq 0xa006(%rip), %rsi      # 0x47cd6
movq %rbx, %rdi
callq 0x634b
cmpl $0x1, %ebp
je 0x3dd0a
cmpl $0x2, %ebp
je 0x3dcfc
cmpl $0x3, %ebp
jne 0x3dcf5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3dd2a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3e134
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3e4b7
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_asahi.c
// Function: print_asahi_offset_makervalue
void
print_asahi_offset_makervalue(FILE *inptr,unsigned short byteorder,
    struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
    struct image_summary *summary_entry,char *parent_name,
    char *prefix,int indent,int make,int model,int at_offset)
{
    int noteversion = 0;

    noteversion = getnoteversion();

    if(entry_ptr)
    {
        switch(noteversion)
        {
            case 3:
                asahi2_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                break;
            case 2:
                asahi1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                break;
            case 1:
                asahi1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r13
movl 0x80(%rsp), %eax
movq %rax, (%rsp)
movl 0x78(%rsp), %eax
movq %rax, 0x8(%rsp)
movl 0x70(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
callq 0x1c4d8
testq %r12, %r12
je 0x3e74c
cmpl $0x1, %eax
je 0x3e790
cmpl $0x2, %eax
je 0x3e752
cmpl $0x3, %eax
jne 0x3e7b5
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0x3e7d2
jmp 0x3e781
addq $0x28, %rsp
jmp 0x3e785
subq $0x8, %rsp
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
pushq 0x8(%rsp)
pushq 0x18(%rsp)
pushq 0x28(%rsp)
pushq 0x38(%rsp)
pushq 0x48(%rsp)
callq 0x3eb72
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl %bp, %esi
movq %r13, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3eb72
leaq 0x951a(%rip), %rsi      # 0x47cd6
movq %r12, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x634b