LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/mrw.c
// Function: print_mrw_header
int
print_mrw_header(struct fileheader *fileheader,unsigned long section_id)
{
    struct mrw_header mrwheader;
    int status = -1;
    int chpr = 0;

    if(Print_options & section_id)
    {
        if(fileheader && (fileheader->probe_magic == PROBE_MRWMAGIC))
        {
            mrwheader = fileheader->mrw_header;
            if(mrwheader.mrw_magic == PROBE_MRWMAGIC)
            {
                chpr += printf("MRW magic %#lx, length %u, offset to image data %lu",
                                            mrwheader.mrw_magic,8,mrwheader.mrw_dataoffset + 8);
                chpr = newline(chpr);
                status = 0;
            }
            else 
                chpr += printf(" MRW HEADER MAGIC BAD");
        }
        else
            chpr += printf(" NOT AN MRW HEADER");
    }
    chpr = newline(chpr);
    return(status);
}

// Assembly:
pushq %rbx
leaq 0x32a18(%rip), %rax     # 0x58180
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rsi, (%rax)
je 0x257c8
testq %rdi, %rdi
je 0x257b6
cmpq $0x4d524d, 0x8(%rdi)    # imm = 0x4D524D
jne 0x257b6
cmpq $0x4d524d, 0x30(%rdi)   # imm = 0x4D524D
jne 0x257d3
movq 0x38(%rdi), %rcx
addq $0x8, %rcx
leaq 0x23be6(%rip), %rdi     # 0x49380
xorl %ebx, %ebx
movl $0x4d524d, %esi         # imm = 0x4D524D
movl $0x8, %edx
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x1707a
jmp 0x257c4
leaq 0x23c0d(%rip), %rdi     # 0x493ca
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
jmp 0x257ca
xorl %edi, %edi
callq 0x1707a
movl %ebx, %eax
popq %rbx
retq
leaq 0x23bda(%rip), %rdi     # 0x493b4
jmp 0x257bd
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/lib/veclib.c
// Function: vector
int
vector(buf,wstart,sepchars,singlesep,maxent)
char *buf,**wstart,*sepchars;
int singlesep,maxent;
{
	char *bptr = buf;
	int pos = 0;

	if(!wstart)
		return(0);
	wstart[0] = bptr;
	if(!buf || (*buf == '\0'))
		return(0);
	bptr = buf;

	/* first word													*/
	wstart[0] = bptr;

	/* next_word() replaces the next separator with a null char     */
	/* and returns the start of the next word (which may be null    */
	/* if there are no more words.                                  */
	while(bptr && (bptr = next_word(wstart[pos],sepchars,singlesep)))
	{
		wstart[++pos] = bptr;
		if(pos >= (maxent - 1))
			break;
	}
	wstart[++pos] = CNULL;
	return(pos);
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x27925
movq %rdi, (%rsi)
testq %rdi, %rdi
je 0x27925
cmpb $0x0, (%rdi)
je 0x27925
pushq %rbp
pushq %rbx
decl %r8d
cmpl $0x2, %r8d
movl $0x1, %eax
cmovgel %r8d, %eax
leaq 0x1(%rdx), %r9
xorl %r8d, %r8d
movb (%rdi), %r10b
testb %r10b, %r10b
je 0x27912
movb (%rdx), %r11b
movq %r9, %rbx
movl %r11d, %ebp
testb %r11b, %r11b
je 0x278b3
cmpb %bpl, %r10b
je 0x278c1
movb (%rbx), %bpl
incq %rbx
testb %bpl, %bpl
jne 0x278a3
movb 0x1(%rdi), %r10b
incq %rdi
testb %r10b, %r10b
jne 0x27898
jmp 0x27912
leaq 0x1(%rdi), %r10
movb $0x0, (%rdi)
testl %ecx, %ecx
je 0x278de
movq %r10, 0x8(%rsi,%r8,8)
incq %r8
movq %r10, %rdi
cmpq %rax, %r8
jne 0x2788d
jmp 0x27915
movb (%r10), %dil
testb %dil, %dil
je 0x27912
movb (%rdx), %r11b
testb %r11b, %r11b
je 0x278cc
movq %r9, %rbx
movl %r11d, %ebp
cmpb %bpl, %dil
je 0x27906
movb (%rbx), %bpl
incq %rbx
testb %bpl, %bpl
jne 0x278f4
jmp 0x278cc
movb 0x1(%r10), %dil
incq %r10
testb %dil, %dil
jne 0x278ee
movl %r8d, %eax
movslq %eax, %rcx
incl %eax
movq $0x0, 0x8(%rsi,%rcx,8)
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/lib/veclib.c
// Function: prvector
void
prvector(ioptr,vec,nwords)
FILE * ioptr;
char **vec;
int nwords;
{
	int i = 0;

	fprintf(ioptr,"%d words:\n",nwords);
	if(vec)
	{
		while(*vec && (i < nwords))
			fprintf(ioptr,"\t[%d] \"%s\"\n",i++,*vec++);
	}
	else
		fprintf(ioptr,"no words (nwords = %d\n",nwords);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x21d2a(%rip), %rsi     # 0x49668
xorl %eax, %eax
callq 0x3180
testq %r15, %r15
je 0x27992
movq (%r15), %rcx
testq %rcx, %rcx
sete %al
testl %ebx, %ebx
setle %dl
orb %al, %dl
jne 0x27988
leaq 0x21d10(%rip), %r12     # 0x49673
xorl %r13d, %r13d
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x3180
movq 0x8(%r15,%r13,8), %rcx
testq %rcx, %rcx
je 0x27988
incq %r13
cmpl %ebx, %r13d
jl 0x27966
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x21ce6(%rip), %rsi     # 0x4967f
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3180
nop
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/raf.c
// Function: print_raf_header
int
print_raf_header(FILE *inptr,struct fileheader *fileheader,unsigned long section_id)
{
    int status = -1;
    int chpr = 0;

    if(Print_options & section_id)
    {
        /* ###%%% for now, the first 60 bytes are "header"            */
        if(fileheader && (fileheader->probe_magic == PROBE_RAFMAGIC))
        {
            print_ascii(inptr,28,0);
            chpr += printf(" Model = ");
            print_ascii(inptr,32,28);
            status = 0;
        }
        else
            chpr += printf(" NOT AN RAF HEADER");
    }
    chpr = newline(chpr);
    return(status);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x307c5(%rip), %rax     # 0x58180
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdx, (%rax)
je 0x27a1b
testq %rsi, %rsi
je 0x27a09
cmpq $0x4655, 0x8(%rsi)      # imm = 0x4655
jne 0x27a09
movq %rdi, %r14
xorl %ebx, %ebx
movl $0x1c, %esi
xorl %edx, %edx
callq 0x77d6
leaq 0x21caa(%rip), %rdi     # 0x49696
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
movl $0x20, %esi
movl $0x1c, %edx
movq %r14, %rdi
callq 0x77d6
jmp 0x27a1d
leaq 0x21c90(%rip), %rdi     # 0x496a0
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
jmp 0x27a1d
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x1707a
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/x3f.c
// Function: process_x3f
unsigned long
process_x3f(FILE *inptr,struct fileheader *header,unsigned long fileoffset_base,
                                        struct image_summary *summary_entry,
                                        char *parent_name,int level,int indent)
{
    struct x3f_header *x3fheader;
    unsigned long max_offset = 0UL;
    unsigned short byteorder = 0;
    unsigned long directory_pointer = 0UL;

    if(inptr)
    {
        if(header)
        {
            if(header->x3f_header)
            {
                x3fheader = header->x3f_header;
                /* X3F is always little-endian; nonetheless, pass it  */
                /* as an argument to lower-level functions. Just set  */
                /* it here.                                           */
                byteorder = TIFF_INTEL;
                if(fseek(inptr,-4L,SEEK_END) == 0)
                    directory_pointer = ftell(inptr);
                if(ferror(inptr) == 0)
                {
                    max_offset = process_x3f_dir(inptr,byteorder,x3fheader,
                                                    directory_pointer,summary_entry,
                                                    parent_name,level,indent);
                    if(max_offset > 0L)
                        max_offset += 4;
                }
                else
                    fprintf(stderr,"%s: cannot read directory offset\n",Progname);
            }
            else
                fprintf(stderr,"%s: null x3fheader to process_x3f()\n",Progname);
        }
        else
            fprintf(stderr,"%s: null fileheader to process_x3f()\n",Progname);
    }
    else
        fprintf(stderr,"%s: no open file pointer to read Print Image data\n",
                                                                        Progname);

    return(max_offset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x293a7
testq %rsi, %rsi
je 0x293ae
cmpq $0x0, 0x40(%rsi)
je 0x293b5
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq $-0x4, %rsi
movl $0x2, %edx
callq 0x3210
testl %eax, %eax
je 0x29362
xorl %r12d, %r12d
jmp 0x2936d
movq %r15, %rdi
callq 0x3190
movq %rax, %r12
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x293bc
movl 0x40(%rsp), %eax
movl %eax, 0x8(%rsp)
movq %r15, %rdi
movl $0x4949, %esi           # imm = 0x4949
movq %r12, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x293cf
movq %rax, %rcx
addq $0x4, %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
jmp 0x293c3
callq 0x35f8
jmp 0x293c1
callq 0x35d6
jmp 0x293c1
callq 0x35b4
jmp 0x293c1
callq 0x3592
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_direntry
struct x3f_direntry *
read_x3f_direntry(FILE *inptr,unsigned short byteorder,struct x3f_direntry *entry,
                                                            unsigned long offset)
{
    if(inptr)
    {
        if(entry == NULL)
            entry = (struct x3f_direntry *)malloc(sizeof(struct x3f_direntry));
        if(entry)
        {
            memset(entry,0,sizeof(struct x3f_direntry));
            entry->data_offset = read_ulong(inptr,byteorder,offset);
            entry->data_length = read_ulong(inptr,byteorder,HERE);
            entry->data_type = read_ulong(inptr,byteorder,HERE);
        }
    }
    else
        entry = (struct x3f_direntry *)0;
    return(entry);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2979a
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testq %rdx, %rdx
jne 0x29754
movl $0x20, %edi
callq 0x31e0
movq %rax, %rbx
testq %rax, %rax
je 0x2979a
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movzwl %bp, %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x4707
movq %rax, 0x8(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x10(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x18(%rbx)
jmp 0x2979c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/x3f.c
// Function: print_x3f_direntry
void 
print_x3f_direntry(FILE *inptr,struct x3f_direntry *entry,unsigned long offset,
                                        char *parent_name,int entry_num,int indent)
{
    int chpr = 0;

    if(entry)
    {
        print_tag_address(ENTRY,offset,indent + MEDIUMINDENT,"@");
        if((PRINT_TAGINFO))
        {
            if((PRINT_LONGNAMES))
                chpr += printf("%s.",parent_name);
            chpr += printf("%4.4s:%-2d",(char *)&entry->data_type,entry_num);
            if((PRINT_VALUE))
                putindent(X3FTAGWIDTH - 7);
        }
        if((PRINT_VALUE))
        {
            chpr += printf(" = ");
            chpr += printf("@%lu:%lu",entry->data_offset,entry->data_length);
        }
        chpr += newline(chpr);
    }
}

// Assembly:
testq %rsi, %rsi
je 0x2a1eb
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rsi, %rbx
addl $0x4, %r9d
leaq 0x16f5f(%rip), %rcx     # 0x410dc
movl $0x4003333, %edi        # imm = 0x4003333
movq %rdx, %rsi
movl %r9d, %edx
callq 0x55eb
leaq 0x2dfec(%rip), %r12     # 0x58180
movq (%r12), %rax
testl $0x3003, %eax           # imm = 0x3003
je 0x2a1ec
xorl %r15d, %r15d
testb $0x40, %al
je 0x2a1ba
leaq 0x1b33e(%rip), %rdi     # 0x454eb
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
leaq 0x18(%rbx), %rsi
leaq 0x1f979(%rip), %rdi     # 0x49b3e
movl %ebp, %edx
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
addl %r15d, %ebp
movq (%r12), %rax
testb $0x30, %al
je 0x2a1ee
movl $0xb, %edi
callq 0x5716
movq (%r12), %rax
jmp 0x2a1ee
retq
xorl %ebp, %ebp
testb $0x30, %al
je 0x2a221
leaq 0x203af(%rip), %rdi     # 0x4a5a8
xorl %eax, %eax
callq 0x3120
movl %eax, %r14d
addl %ebp, %r14d
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x1af91(%rip), %rdi     # 0x451a6
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
addl %r14d, %ebp
movl %ebp, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1707a
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_imag_header
struct x3f_imag_header *
read_x3f_imag_header(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    static struct x3f_imag_header header;
    struct x3f_imag_header *headerptr= (struct x3f_imag_header *)0;

    if(!feof(inptr) && !ferror(inptr))
    {
        header.section_id = read_ulong(inptr,byteorder,offset);
        header.version_minor = read_ushort(inptr,byteorder,HERE);
        header.version_major = read_ushort(inptr,byteorder,HERE);
        header.image_type = read_ulong(inptr,byteorder,HERE);
        header.image_format = read_ulong(inptr,byteorder,HERE);
        header.image_width = read_ulong(inptr,byteorder,HERE);
        header.image_height = read_ulong(inptr,byteorder,HERE);
        header.image_rowsize = read_ulong(inptr,byteorder,HERE);
            if(!feof(inptr) && !ferror(inptr))
                headerptr = &header;
    }
    return(headerptr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x31a0
testl %eax, %eax
jne 0x2a316
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x2a316
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4707
movq %rax, 0x335e8(%rip)     # 0x5d858
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x45af
movw %ax, 0x335da(%rip)      # 0x5d860
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x45af
movw %ax, 0x335c6(%rip)      # 0x5d862
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x335b6(%rip)     # 0x5d868
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x335a8(%rip)     # 0x5d870
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x3359a(%rip)     # 0x5d878
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x3358c(%rip)     # 0x5d880
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x3357e(%rip)     # 0x5d888
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
je 0x2a31d
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x30b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
leaq 0x33526(%rip), %rcx     # 0x5d858
cmoveq %rcx, %rax
jmp 0x2a318
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_prop_header
struct x3f_prop_header *
read_x3f_prop_header(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    static struct x3f_prop_header header;
    struct x3f_prop_header *headerptr = (struct x3f_prop_header *)0;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x31a0
testl %eax, %eax
jne 0x2a984
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x2a984
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4707
movq %rax, 0x32fd4(%rip)     # 0x5d8c8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x45af
movw %ax, 0x32fc6(%rip)      # 0x5d8d0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x45af
movw %ax, 0x32fb2(%rip)      # 0x5d8d2
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x32fa2(%rip)     # 0x5d8d8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x32f94(%rip)     # 0x5d8e0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x32f86(%rip)     # 0x5d8e8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x32f78(%rip)     # 0x5d8f0
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
je 0x2a98b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x30b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
leaq 0x32f28(%rip), %rcx     # 0x5d8c8
cmoveq %rcx, %rax
jmp 0x2a986
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_camf_header
struct x3f_camf_header *
read_x3f_camf_header(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    static struct x3f_camf_header header;
    struct x3f_camf_header *headerptr = (struct x3f_camf_header *)0;

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

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x31a0
testl %eax, %eax
jne 0x2b528
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x2b528
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4707
movq %rax, 0x3240e(%rip)     # 0x5d890
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x45af
movw %ax, 0x32400(%rip)      # 0x5d898
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x45af
movw %ax, 0x323ec(%rip)      # 0x5d89a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x323dc(%rip)     # 0x5d8a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x323ce(%rip)     # 0x5d8a8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x323c0(%rip)     # 0x5d8b0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x323b2(%rip)     # 0x5d8b8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x323a4(%rip)     # 0x5d8c0
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
je 0x2b52f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x30b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
leaq 0x3234c(%rip), %rcx     # 0x5d890
cmoveq %rcx, %rax
jmp 0x2b52a
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_nikon.c
// Function: nikon_model_number
int
nikon_model_number(char *model,char *software)
{
    struct camera_id *model_id;
    int number = NO_MODEL;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2cd88(%rip), %r15     # 0x58b60
movq (%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x2be1d
movq %rdi, %r14
addq $0x18, %r15
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x2be07
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x2bde9
jmp 0x2be1d
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_nikon.c
// Function: print_nikon_makervalue
void
print_nikon_makervalue(struct ifd_entry *entry_ptr,int make, int model,
                    char *prefix)
{
    int noteversion = 0;

    noteversion = getnoteversion();

    if(entry_ptr && (PRINT_VALUE))
    {
        switch(noteversion)
        {
            case 1:
                print_value(entry_ptr,PREFIX);
                nikon1_interpret_value(entry_ptr);
                break;
            case 2:
                print_value(entry_ptr,PREFIX);
                nikon2_interpret_value(entry_ptr);
                break;
            default:
                print_value(entry_ptr,PREFIX);
                break;
        }
    }
}

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

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

// Assembly:
pushq %rbx
xorl %ebx, %ebx
leal -0x3(%rdi), %eax
cmpl $0x8, %eax
ja 0x2daa6
leaq 0x1c468(%rip), %rcx     # 0x49efc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1e1ff(%rip), %rbx     # 0x4bca3
jmp 0x2db05
cmpl $0x100, %edi            # imm = 0x100
je 0x2dafe
cmpl $0xf00, %edi            # imm = 0xF00
jne 0x2db05
leaq 0x16e98(%rip), %rbx     # 0x44955
jmp 0x2db05
leaq 0x1f46d(%rip), %rbx     # 0x4cf33
jmp 0x2db05
leaq 0x1c67b(%rip), %rbx     # 0x4a14a
jmp 0x2db05
leaq 0x1c67e(%rip), %rbx     # 0x4a156
jmp 0x2db05
leaq 0x1bb5e(%rip), %rbx     # 0x4963f
jmp 0x2db05
leaq 0x15701(%rip), %rbx     # 0x431eb
jmp 0x2db05
leaq 0x1c63c(%rip), %rbx     # 0x4a12f
jmp 0x2db05
leaq 0x1c643(%rip), %rbx     # 0x4a13f
jmp 0x2db05
leaq 0x16460(%rip), %rbx     # 0x43f65
movl $0x1, %edi
callq 0x1c4f0
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_epson.c
// Function: epson_model_number
int
epson_model_number(char *model,char *software)
{
    struct camera_id *model_id;
    int number = NO_MODEL;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2a80c(%rip), %r15     # 0x58590
movq (%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x2ddc9
movq %rdi, %r14
addq $0x18, %r15
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x2ddb3
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x2dd95
jmp 0x2ddc9
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_epson.c
// Function: print_epson_makervalue
void
print_epson_makervalue(struct ifd_entry *entry_ptr,int make, int model,
                    char *prefix)
{
    int noteversion = 0;

    noteversion = getnoteversion();

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
testq %rbx, %rbx
je 0x2de13
movl %eax, %ebp
leaq 0x2a394(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x2de13
leaq 0x19ede(%rip), %rsi     # 0x47cd6
movq %rbx, %rdi
callq 0x634b
cmpl $0x1, %ebp
jne 0x2de13
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2de38
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_epson.c
// Function: epson1_interpret_value
void
epson1_interpret_value(struct ifd_entry *entry_ptr)
{
    int chpr = 0;

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x2df08
leaq 0x2a332(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x2df08
movq %rdi, %r14
movzwl (%rdi), %eax
cmpl $0x202, %eax            # imm = 0x202
je 0x2de9b
cmpl $0x201, %eax            # imm = 0x201
jne 0x2df08
xorl %eax, %eax
callq 0x96fd
movq 0x10(%r14), %rax
cmpq $0x2, %rax
jle 0x2deba
cmpq $0x3, %rax
je 0x2dee8
cmpq $0x21, %rax
je 0x2de92
cmpq $0x22, %rax
jne 0x2decf
leaq 0x1c7fe(%rip), %rdi     # 0x4a697
jmp 0x2def8
xorl %eax, %eax
callq 0x96fd
movq 0x10(%r14), %rax
cmpq $0x1, %rax
je 0x2dedf
testq %rax, %rax
jne 0x2decf
leaq 0x1d541(%rip), %rdi     # 0x4b3f9
jmp 0x2def8
cmpq $0x1, %rax
je 0x2def1
cmpq $0x2, %rax
jne 0x2decf
leaq 0x1c7c7(%rip), %rdi     # 0x4a694
jmp 0x2def8
leaq 0x1af93(%rip), %rdi     # 0x48e69
callq 0x5c26
xorl %ebx, %ebx
jmp 0x2df01
leaq 0x18831(%rip), %rdi     # 0x46717
jmp 0x2def8
leaq 0x1c7a4(%rip), %rdi     # 0x4a693
jmp 0x2def8
leaq 0x1c798(%rip), %rdi     # 0x4a690
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
xorl %eax, %eax
callq 0x971e
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_epson.c
// Function: print_epson_offset_makervalue
void
print_epson_offset_makervalue(FILE *inptr,unsigned short byteorder,
    struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
    struct image_summary *summary_entry,char *parent_name,char*prefix,
    int indent,int make,int model,int at_offset)
{
    int noteversion = 0;

    noteversion = getnoteversion();

    if(entry_ptr)
    {
        switch(noteversion)
        {
            case 1 :
                epson1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                epson1_interpret_offset_makervalue(inptr,byteorder,
                                            entry_ptr,fileoffset_base);
                break;
            default:
                print_generic_offset_makervalue(inptr,byteorder,entry_ptr,
                                        fileoffset_base,parent_name,prefix,
                                        indent,make,model,at_offset);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, 0x20(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl 0x80(%rsp), %r12d
movl 0x78(%rsp), %eax
movq %rax, (%rsp)
movl 0x70(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
callq 0x1c4d8
testq %r14, %r14
je 0x2dfc7
cmpl $0x1, %eax
jne 0x2dfcd
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 0x2e003
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 0x2e984
addq $0x28, %rsp
jmp 0x2dff8
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_epson.c
// Function: maker_epson1_tagname
char *
maker_epson1_tagname(unsigned short tag,int model)
{
    char *tagname = CNULL;

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

// Assembly:
pushq %rbx
xorl %ebx, %ebx
cmpl $0x300, %edi            # imm = 0x300
jg 0x2eb5d
addl $0xfffffe00, %edi       # imm = 0xFFFFFE00
cmpl $0xd, %edi
ja 0x2ebdf
leaq 0x1bab8(%rip), %rax     # 0x4a600
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x1bae0(%rip), %rbx     # 0x4a638
jmp 0x2ebdf
cmpl $0x301, %edi            # imm = 0x301
je 0x2ebcf
cmpl $0xe00, %edi            # imm = 0xE00
je 0x2ebd8
cmpl $0xf00, %edi            # imm = 0xF00
jne 0x2ebdf
leaq 0x15dd9(%rip), %rbx     # 0x44955
jmp 0x2ebdf
leaq 0x1babf(%rip), %rbx     # 0x4a644
jmp 0x2ebdf
leaq 0x15324(%rip), %rbx     # 0x43eb2
jmp 0x2ebdf
leaq 0x1b5b3(%rip), %rbx     # 0x4a14a
jmp 0x2ebdf
leaq 0x1f354(%rip), %rbx     # 0x4def4
jmp 0x2ebdf
leaq 0x1bac5(%rip), %rbx     # 0x4a66e
jmp 0x2ebdf
leaq 0x1baa2(%rip), %rbx     # 0x4a654
jmp 0x2ebdf
leaq 0x17b5c(%rip), %rbx     # 0x46717
jmp 0x2ebdf
leaq 0x1f31e(%rip), %rbx     # 0x4dee2
jmp 0x2ebdf
leaq 0x1ba90(%rip), %rbx     # 0x4a65d
jmp 0x2ebdf
leaq 0x1baa8(%rip), %rbx     # 0x4a67e
jmp 0x2ebdf
leaq 0x146e3(%rip), %rbx     # 0x432c2
movl $0x1, %edi
callq 0x1c4f0
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_model_number
int
olympus_model_number(char *model,char *software)
{
    struct camera_id *model_id;
    int number = NO_MODEL;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x2a174(%rip), %r15     # 0x58d70
movq (%r15), %rsi
xorl %ebx, %ebx
testq %rsi, %rsi
je 0x2ec41
movq %rdi, %r14
addq $0x18, %r15
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x2ec2b
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x2ec0d
jmp 0x2ec41
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_olympus.c
// Function: print_olympus_makervalue
void
print_olympus_makervalue(struct ifd_entry *entry_ptr,int make, int model,
                    char *prefix)
{
    int noteversion = 0;

    noteversion = getnoteversion();

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1c4d8
testq %rbx, %rbx
je 0x2ec8b
movl %eax, %ebp
leaq 0x2951c(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x2ec8b
leaq 0x19066(%rip), %rsi     # 0x47cd6
movq %rbx, %rdi
callq 0x634b
cmpl $0x1, %ebp
jne 0x2ec8b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2eca4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_olympus.c
// Function: print_olympus_offset_makervalue
void
print_olympus_offset_makervalue(FILE *inptr,unsigned short byteorder,
    struct ifd_entry *entry_ptr,unsigned long fileoffset_base,
    struct image_summary *summary_entry,char *parent_name,char*prefix,
    int indent,int make,int model,int at_offset)
{
    int noteversion = 0;

    noteversion = getnoteversion();

    if(entry_ptr)
    {
        switch(noteversion)
        {
            case 1:
                olympus1_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base,summary_entry,
                                            parent_name,prefix,indent,
                                            make,model,at_offset);
                olympus1_interpret_offset_makervalue(inptr,byteorder,entry_ptr,
                                            fileoffset_base);
                break;
            default:
                print_generic_offset_makervalue(inptr,byteorder,entry_ptr,
                                        fileoffset_base,parent_name,prefix,indent,
                                        make,model,at_offset);
                break;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, 0x20(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movl 0x80(%rsp), %r12d
movl 0x78(%rsp), %eax
movq %rax, (%rsp)
movl 0x70(%rsp), %eax
movq %rax, 0x10(%rsp)
movl 0x68(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
callq 0x1c4d8
testq %r14, %r14
je 0x2ee56
cmpl $0x1, %eax
jne 0x2ee5c
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 0x2ee92
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 0x2f49c
addq $0x28, %rsp
jmp 0x2ee87
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_olympus.c
// Function: olympus_private_2010_tagname
char *
olympus_private_2010_tagname(unsigned short tag)
{
    char *tagname = CNULL;

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

// Assembly:
xorl %eax, %eax
cmpl $0x300, %edi            # imm = 0x300
jg 0x2f930
leal -0x201(%rdi), %ecx
cmpl $0x7, %ecx
ja 0x2f95f
leaq 0x1af45(%rip), %rdx     # 0x4a864
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1b2f5(%rip), %rax     # 0x4ac24
retq
cmpl $0xfff, %edi            # imm = 0xFFF
jle 0x2f982
addl $0xfffff000, %edi       # imm = 0xFFFFF000
cmpl $0x4, %edi
ja 0x2f9ed
leaq 0x1af36(%rip), %rcx     # 0x4a884
movslq (%rcx,%rdi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
leaq 0x1a82d(%rip), %rax     # 0x4a18b
retq
leal -0x100(%rdi), %ecx
cmpl $0x4, %ecx
ja 0x2f9a2
leaq 0x1aedf(%rip), %rdx     # 0x4a850
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1b26b(%rip), %rax     # 0x4abec
retq
cmpl $0x301, %edi            # imm = 0x301
je 0x2f9ee
cmpl $0x302, %edi            # imm = 0x302
je 0x2f9f6
cmpl $0x304, %edi            # imm = 0x304
jne 0x2f9ed
leaq 0x1b2e1(%rip), %rax     # 0x4ac82
retq
testl %edi, %edi
jne 0x2f9ed
leaq 0x1b22a(%rip), %rax     # 0x4abd7
retq
leaq 0x1abbd(%rip), %rax     # 0x4a572
retq
leaq 0x1b26c(%rip), %rax     # 0x4ac29
retq
leaq 0x1b289(%rip), %rax     # 0x4ac4e
retq
leaq 0x1ab7b(%rip), %rax     # 0x4a548
retq
leaq 0x1b265(%rip), %rax     # 0x4ac3a
retq
leaq 0x1b2bd(%rip), %rax     # 0x4ac9a
retq
leaq 0x1b2c0(%rip), %rax     # 0x4aca5
retq
leaq 0x1b2ca(%rip), %rax     # 0x4acb7
retq
leaq 0x1b26f(%rip), %rax     # 0x4ac64
retq
leaq 0x1b270(%rip), %rax     # 0x4ac6d
retq
leaq 0x1b20b(%rip), %rax     # 0x4ac10
retq
leaq 0x1b1f0(%rip), %rax     # 0x4abfd
retq
leaq 0x13aa4(%rip), %rax     # 0x434b9
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_private_2030_tagname
char *
olympus_private_2030_tagname(unsigned short tag)
{
    char *tagname = CNULL;

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

    return(tagname);
}

// Assembly:
leal -0x100(%rdi), %eax
cmpl $0xc, %eax
ja 0x2fbe1
leaq 0x1ad18(%rip), %rcx     # 0x4a8e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b216(%rip), %rax     # 0x4adf6
retq
testl %edi, %edi
jne 0x2fc4d
leaq 0x1b1fc(%rip), %rax     # 0x4ade8
retq
leaq 0x1b2e8(%rip), %rax     # 0x4aedc
retq
leaq 0x1b251(%rip), %rax     # 0x4ae4d
retq
leaq 0x1b2e9(%rip), %rax     # 0x4aeed
retq
leaq 0x1b2ae(%rip), %rax     # 0x4aeba
retq
leaq 0x1b212(%rip), %rax     # 0x4ae26
retq
leaq 0x1b221(%rip), %rax     # 0x4ae3d
retq
leaq 0x1b270(%rip), %rax     # 0x4ae94
retq
leaq 0x1b1e2(%rip), %rax     # 0x4ae0e
retq
leaq 0x1b232(%rip), %rax     # 0x4ae66
retq
leaq 0x1b244(%rip), %rax     # 0x4ae80
retq
leaq 0x1b283(%rip), %rax     # 0x4aec7
retq
leaq 0x1b25d(%rip), %rax     # 0x4aea9
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_private_2040_tagname
char *
olympus_private_2040_tagname(unsigned short tag)
{
    char *tagname = CNULL;

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

    return(tagname);
}

// Assembly:
xorl %eax, %eax
cmpl $0x60f, %edi            # imm = 0x60F
jg 0x2fc8a
cmpl $0x2ff, %edi            # imm = 0x2FF
jg 0x2fcad
testl %edi, %edi
je 0x2fcfd
cmpl $0x100, %edi            # imm = 0x100
je 0x2fd0d
cmpl $0x200, %edi            # imm = 0x200
jne 0x2fd24
leaq 0x1ae9a(%rip), %rax     # 0x4ab23
retq
leal -0x610(%rdi), %ecx
cmpl $0x5, %ecx
ja 0x2fccd
leaq 0x1ac80(%rip), %rdx     # 0x4a91c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1b2af(%rip), %rax     # 0x4af5b
retq
cmpl $0x300, %edi            # imm = 0x300
je 0x2fd05
cmpl $0x310, %edi            # imm = 0x310
je 0x2fd15
cmpl $0x600, %edi            # imm = 0x600
jne 0x2fd24
leaq 0x1b27b(%rip), %rax     # 0x4af47
retq
cmpl $0x1010, %edi           # imm = 0x1010
je 0x2fd1d
cmpl $0x1012, %edi           # imm = 0x1012
jne 0x2fd24
leaq 0x1b2b1(%rip), %rax     # 0x4af95
retq
leaq 0x1b28f(%rip), %rax     # 0x4af7b
retq
leaq 0x1ae52(%rip), %rax     # 0x4ab46
retq
leaq 0x1b273(%rip), %rax     # 0x4af6f
retq
leaq 0x1b1f8(%rip), %rax     # 0x4aefc
retq
leaq 0x1b213(%rip), %rax     # 0x4af1f
retq
leaq 0x1b1ff(%rip), %rax     # 0x4af13
retq
leaq 0x1b217(%rip), %rax     # 0x4af33
retq
leaq 0x1b264(%rip), %rax     # 0x4af88
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus_private_2050_tagname
char *
olympus_private_2050_tagname(unsigned short tag)
{
    char *tagname = CNULL;

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

    return(tagname);
}

// Assembly:
xorl %eax, %eax
cmpl $0x304, %edi            # imm = 0x304
jg 0x2fd4b
testl %edi, %edi
je 0x2fd6b
cmpl $0x209, %edi            # imm = 0x209
je 0x2fd7b
cmpl $0x300, %edi            # imm = 0x300
jne 0x2fd8a
leaq 0x1b27c(%rip), %rax     # 0x4afc6
retq
cmpl $0x305, %edi            # imm = 0x305
je 0x2fd73
cmpl $0x1201, %edi           # imm = 0x1201
je 0x2fd83
cmpl $0x1208, %edi           # imm = 0x1208
jne 0x2fd8a
leaq 0x1b277(%rip), %rax     # 0x4afe1
retq
leaq 0x1b238(%rip), %rax     # 0x4afaa
retq
leaq 0x1a4d0(%rip), %rax     # 0x4a24a
retq
leaq 0x1b239(%rip), %rax     # 0x4afbb
retq
leaq 0x1b249(%rip), %rax     # 0x4afd3
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/maker_olympus.c
// Function: olympus2010_interpret_value
void
olympus2010_interpret_value(struct ifd_entry *entry_ptr,char *prefix)
{
    int chpr = 0;

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

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testq %rdi, %rdi
je 0x2fe2c
leaq 0x283c2(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x2fe2c
movq %rdi, %rbx
movzwl (%rdi), %eax
cmpl $0x1001, %eax           # imm = 0x1001
je 0x2fdf1
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x2fe2c
xorl %eax, %eax
callq 0x96fd
movq 0x10(%rbx), %rax
cmpq $0x4, %rax
jae 0x2fe15
leaq 0x27d91(%rip), %rcx     # 0x57b80
jmp 0x2fe0c
xorl %eax, %eax
callq 0x96fd
movq 0x10(%rbx), %rax
decq %rax
cmpq $0x5, %rax
jae 0x2fe15
leaq 0x27d94(%rip), %rcx     # 0x57ba0
leaq (%rcx,%rax,8), %rax
movq (%rax), %rdi
jmp 0x2fe1c
leaq 0x15b8c(%rip), %rdi     # 0x459a8
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
xorl %eax, %eax
callq 0x971e
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x17a82