LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/jp2000.c
// Function: list_jp2box
int
list_jp2box(FILE *inptr,struct jp2box *box,char *parent_name,int indent,int donl)
{
    unsigned long boxlength = 0UL;
    int chpr = 0;

    if(box)
    {
        if(box->boxlength == 0UL)
            boxlength = get_filesize(inptr) - box->boxoffset;
        else
            boxlength = box->boxlength;
        if((LIST_MODE))
        {
            print_tag_address(ENTRY,box->boxoffset,indent,"@");
            if((PRINT_TAGINFO))
            {
                if((PRINT_LONGNAMES))
                    printf("%s",parent_name);
                print_jp2type(box->tbox,0);
            }
            if((PRINT_VALUE))
            {
                chpr += printf(" = @%lu:%-4lu",box->boxoffset,boxlength);
                /* Indicate that this is lastbox                      */
                if(box->boxlength == 0UL)
                    chpr += printf(":0");
            }
        }
    }
    if(donl)
        chpr = newline(chpr);
    return(chpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x1f82a
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r14
movq 0x20(%rsi), %r15
testq %r15, %r15
jne 0x1f819
callq 0x4c6d
movq %rax, %r15
subq 0x18(%r14), %r15
leaq 0x37960(%rip), %rax     # 0x57180
movzwl 0x2(%rax), %eax
testw $0x104, %ax             # imm = 0x104
je 0x1f854
testl %ebx, %ebx
je 0x1f843
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x160f7
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rsi
leaq 0x1f87d(%rip), %rcx     # 0x3f0dc
movl $0x4003333, %edi        # imm = 0x4003333
movl %r13d, %edx
callq 0x5100
leaq 0x3790d(%rip), %rax     # 0x57180
movq (%rax), %rax
testw $0x3003, %ax            # imm = 0x3003
je 0x1f8a6
testb $0x40, %al
je 0x1f891
leaq 0x1f810(%rip), %rdi     # 0x3f097
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x1f649
leaq 0x378dd(%rip), %rax     # 0x57180
movq (%rax), %rax
testb $0x30, %al
je 0x1f82a
movq 0x18(%r14), %rsi
leaq 0x273a3(%rip), %rdi     # 0x46c58
movq %r15, %rdx
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
cmpq $0x0, 0x20(%r14)
jne 0x1f82a
leaq 0x27393(%rip), %rdi     # 0x46c66
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
jmp 0x1f82a
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/jp2000.c
// Function: process_jp2_xml
unsigned long
process_jp2_xml(FILE *inptr,struct jp2box *box,int indent)
{
    unsigned long boxoffset,max_offset,dataoffset;
    unsigned long readsize;
    unsigned long boxlength,size;
    int chpr = 0;

    print_jp2box(inptr,box,indent);
    boxoffset = box->boxoffset;
    boxlength = box->boxlength;

    dataoffset = boxoffset + box->dataoffset;
    max_offset = box->boxoffset + box->boxlength;
    size = boxlength - 8;

    if((PRINT_SECTION))
    {
        print_tag_address(VALUE,dataoffset,indent + 10,"=");
        if((PRINT_VALUE))
        {
            if((inptr && (fseek(inptr,dataoffset,SEEK_SET)) != -1))
            {
                while(size > 0ULL)
                {
                    if(size > READSIZE)
                        readsize = READSIZE;
                    else
                        readsize = size;
                    /* Print as ascii                                     */
                    setcharsprinted(chpr);
                    print_ascii(inptr,readsize,dataoffset);
                    dataoffset += readsize;
                    size -= readsize;
                }
            }
        }
        chpr = newline(chpr);
        print_tag_address(SECTION,dataoffset - 1,indent,"=");
        print_jp2type(box->tbox,1);
    }
    else if((LIST_MODE))
        chpr = list_jp2box(inptr,box,"JP2.",indent,1);
    chpr = newline(chpr);
    return(max_offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
callq 0x1f71d
movq 0x18(%r14), %r9
movq 0x20(%r14), %r15
leaq 0x372e5(%rip), %rbx     # 0x57180
movq (%rbx), %rax
btl $0x12, %eax
jb 0x1fed6
movq %rbp, %rcx
xorl %ebp, %ebp
btl $0x18, %eax
jb 0x1ff99
leaq 0x26db5(%rip), %rdx     # 0x46c6f
pushq $0x1
popq %r8
movq %r12, %rdi
movq %r14, %rsi
movq %r9, %rbx
callq 0x1f7e6
movq %rbx, %r9
movl %eax, %ebp
jmp 0x1ff99
movq 0x10(%r14), %r13
movq %r9, 0x8(%rsp)
addq %r9, %r13
leal 0xa(%rbp), %edx
leaq 0x22a95(%rip), %rcx     # 0x42981
pushq $0x30
popq %rdi
movq %r13, %rsi
callq 0x5100
testq %r12, %r12
movq %r15, 0x10(%rsp)
movq %rbp, (%rsp)
je 0x1ff5f
movq (%rbx), %rax
andl $0x30, %eax
je 0x1ff5f
addq $-0x8, %r15
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
setne %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1ff5f
movl $0x2000, %ebx           # imm = 0x2000
cmpq %rbx, %r15
movl $0x2000, %ebp           # imm = 0x2000
cmovbq %r15, %rbp
xorl %edi, %edi
callq 0x16a4f
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x71a9
addq %rbp, %r13
subq %rbp, %r15
jne 0x1ff36
xorl %edi, %edi
callq 0x160f7
movl %eax, %ebp
decq %r13
leaq 0x22a0f(%rip), %rcx     # 0x42981
movl $0x40000, %edi          # imm = 0x40000
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x5100
movq 0x8(%r14), %rdi
pushq $0x1
popq %rsi
callq 0x1f649
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %r9
addq %r9, %r15
movl %ebp, %edi
callq 0x160f7
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/jp2000.c
// Function: process_jp2_jp2i
unsigned long
process_jp2_jp2i(FILE *inptr,struct jp2box *box,int indent)
{
    unsigned long boxoffset,max_offset,dataoffset;
    unsigned long readsize;
    unsigned long boxlength,size;
    int chpr = 0;

    print_jp2box(inptr,box,indent);
    boxoffset = box->boxoffset;
    boxlength = box->boxlength;

    dataoffset = boxoffset + box->dataoffset;
    max_offset = boxoffset + boxlength;

    if((PRINT_SECTION))
    {
        print_tag_address(SECTION,dataoffset,indent + 8,"=");
        size = boxlength - 8;
        if((inptr && (fseek(inptr,dataoffset,SEEK_SET)) != -1))
        {
            while(size > 0ULL)
            {
                if(size > READSIZE)
                    readsize = READSIZE;
                else
                    readsize = size;
                /* Print as ascii...                                  */
                setcharsprinted(chpr);
                print_ascii(inptr,readsize,dataoffset);
                dataoffset += readsize;
                size -= readsize;
            }
        }
        chpr = newline(chpr);
        print_tag_address(SECTION,dataoffset - 1,indent,"=");
        print_jp2type(box->tbox,1);
    }
    else if((LIST_MODE))
        chpr = list_jp2box(inptr,box,"JP2.",indent,1);
    chpr = newline(chpr);
    return(max_offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
callq 0x1f71d
movq 0x18(%r14), %r15
movq 0x20(%r14), %rbx
leaq 0x371a1(%rip), %rax     # 0x57180
movq (%rax), %rax
btl $0x12, %eax
jb 0x20014
movq %rbp, %rcx
xorl %ebp, %ebp
btl $0x18, %eax
jb 0x200cf
leaq 0x26c71(%rip), %rdx     # 0x46c6f
pushq $0x1
popq %r8
movq %r12, %rdi
movq %r14, %rsi
callq 0x1f7e6
movl %eax, %ebp
jmp 0x200cf
movq 0x10(%r14), %r13
addq %r15, %r13
leal 0x8(%rbp), %edx
leaq 0x2295c(%rip), %rcx     # 0x42981
movl $0x40000, %edi          # imm = 0x40000
movq %r13, %rsi
callq 0x5100
testq %r12, %r12
movq %rbx, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq %rbp, (%rsp)
je 0x20095
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
setne %al
addq $-0x8, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x20095
movl $0x2000, %r15d          # imm = 0x2000
cmpq %r15, %rbx
movl $0x2000, %ebp           # imm = 0x2000
cmovbq %rbx, %rbp
xorl %edi, %edi
callq 0x16a4f
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x71a9
addq %rbp, %r13
subq %rbp, %rbx
jne 0x2006c
xorl %edi, %edi
callq 0x160f7
movl %eax, %ebp
decq %r13
leaq 0x228d9(%rip), %rcx     # 0x42981
movl $0x40000, %edi          # imm = 0x40000
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x5100
movq 0x8(%r14), %rdi
pushq $0x1
popq %rsi
callq 0x1f649
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r15
addq %r15, %rbx
movl %ebp, %edi
callq 0x160f7
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/jp2000.c
// Function: process_jp2_jp2c
unsigned long
process_jp2_jp2c(FILE *inptr,struct jp2box *box,struct image_summary *summary_entry,
                                                        int indent)
{
    unsigned long boxoffset,dataoffset;
    unsigned long boxlength;
    unsigned long tbox;
    int chpr = 0;

    if((LIST_MODE))
        chpr = list_jp2box(inptr,box,"JP2.",indent,1);
    else
        print_jp2box(inptr,box,indent);
    boxoffset = box->boxoffset;
    dataoffset = boxoffset + box->dataoffset;
    boxlength = box->boxlength;
    tbox = box->tbox;

    dataoffset = process_jpeg2000_codestream(inptr,dataoffset,boxlength,
                                                summary_entry,indent + 8);
    chpr = newline(chpr);
    if((PRINT_SECTION))
    {
        print_tag_address(SECTION,dataoffset - 1,indent,"@");
        print_jp2type(tbox,1);
    }
    chpr = newline(chpr);
    return(dataoffset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
leaq 0x36b50(%rip), %rax     # 0x57180
movzwl 0x2(%rax), %eax
testw $0x104, %ax             # imm = 0x104
je 0x2064b
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x1f71d
xorl %ebp, %ebp
jmp 0x20665
leaq 0x2661d(%rip), %rdx     # 0x46c6f
pushq $0x1
popq %r8
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %ecx
callq 0x1f7e6
movl %eax, %ebp
movq 0x8(%r13), %r12
movq 0x10(%r13), %rsi
addq 0x18(%r13), %rsi
movq 0x20(%r13), %rdx
leal 0x8(%rbx), %r8d
movq %r15, %rdi
movq %r14, %rcx
callq 0x22228
movq %rax, %r14
movl %ebp, %edi
callq 0x160f7
movl %eax, %ebp
leaq 0x36ae9(%rip), %rax     # 0x57180
testb $0x4, 0x2(%rax)
je 0x206c1
movq %r14, %rsi
decq %rsi
leaq 0x1ea32(%rip), %rcx     # 0x3f0dc
movl $0x40000, %edi          # imm = 0x40000
movl %ebx, %edx
callq 0x5100
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x1f649
movl %ebp, %edi
callq 0x160f7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x32e74(%rip), %rax     # 0x57180
pushq $-0x1
popq %rbx
testq %rsi, (%rax)
je 0x24368
testq %rdi, %rdi
je 0x24356
cmpq $0x4d524d, 0x8(%rdi)    # imm = 0x4D524D
jne 0x24356
cmpq $0x4d524d, 0x30(%rdi)   # imm = 0x4D524D
jne 0x24373
movq 0x38(%rdi), %rcx
addq $0x8, %rcx
leaq 0x22ff4(%rip), %rdi     # 0x47330
xorl %ebx, %ebx
pushq $0x8
popq %rdx
movl $0x4d524d, %esi         # imm = 0x4D524D
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x160f7
jmp 0x24364
leaq 0x2301d(%rip), %rdi     # 0x4737a
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
jmp 0x2436a
xorl %edi, %edi
callq 0x160f7
movl %ebx, %eax
popq %rbx
retq
leaq 0x22fea(%rip), %rdi     # 0x47364
jmp 0x2435d
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x26387
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, (%rsi)
testq %rdi, %rdi
je 0x26387
cmpb $0x0, (%r14)
je 0x26387
movq %rdx, %r15
movl %ecx, 0xc(%rsp)
decl %r8d
movslq %r8d, %rax
cmpl $0x2, %eax
pushq $0x1
popq %rbp
movq %rax, 0x10(%rsp)
cmovgel %eax, %ebp
xorl %r13d, %r13d
movsbl (%r14), %edi
testl %edi, %edi
je 0x26379
movq %r14, %r12
movq %r15, %rsi
callq 0x2640f
incq %r14
testl %eax, %eax
je 0x26323
movb $0x0, -0x1(%r14)
cmpl $0x0, 0xc(%rsp)
jne 0x26368
movq %r12, %r14
movb 0x1(%r14), %r12b
incq %r14
movsbl %r12b, %edi
movq %r15, %rsi
callq 0x2640f
testl %eax, %eax
jne 0x2634c
testb %r12b, %r12b
je 0x26379
movq %r14, 0x8(%rbx,%r13,8)
incq %r13
cmpq 0x10(%rsp), %r13
jl 0x26323
jmp 0x2637c
movl %r13d, %ebp
movslq %ebp, %rax
incl %ebp
andq $0x0, 0x8(%rbx,%rax,8)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x21268(%rip), %rsi     # 0x47618
xorl %eax, %eax
callq 0x3180
testq %r15, %r15
je 0x263f3
leaq 0x21260(%rip), %r12     # 0x47623
xorl %r13d, %r13d
movq (%r15,%r13,8), %rcx
testq %rcx, %rcx
je 0x263e9
cmpl %ebx, %r13d
jge 0x263e9
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x3180
incq %r13
jmp 0x263c6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x21235(%rip), %rsi     # 0x4762f
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3180
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x30d42(%rip), %rax     # 0x57180
pushq $-0x1
popq %rbx
testq %rdx, (%rax)
je 0x2649a
testq %rsi, %rsi
je 0x26488
cmpq $0x4655, 0x8(%rsi)      # imm = 0x4655
jne 0x26488
movq %rdi, %r14
xorl %ebx, %ebx
pushq $0x1c
popq %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x71a9
leaq 0x211d7(%rip), %rdi     # 0x47646
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
pushq $0x20
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x71a9
jmp 0x2649c
leaq 0x211c1(%rip), %rdi     # 0x47650
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
jmp 0x2649c
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x160f7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x28255
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testq %rdx, %rdx
jne 0x2820f
pushq $0x20
popq %rdi
callq 0x31e0
movq %rax, %rbx
testq %rax, %rax
je 0x28255
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movzwl %bp, %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x42ba
movq %rax, 0x8(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x10(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x18(%rbx)
jmp 0x28257
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x28c79
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rsi, %rbx
addl $0x4, %r9d
leaq 0x164ce(%rip), %rcx     # 0x3f0dc
movl $0x4003333, %edi        # imm = 0x4003333
movq %rdx, %rsi
movl %r9d, %edx
callq 0x5100
leaq 0x2e55b(%rip), %r12     # 0x57180
movq (%r12), %rax
testw $0x3003, %ax            # imm = 0x3003
je 0x28c7a
xorl %r15d, %r15d
testb $0x40, %al
je 0x28c4a
leaq 0x1a86a(%rip), %rdi     # 0x434a7
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
leaq 0x18(%rbx), %rsi
leaq 0x1ee99(%rip), %rdi     # 0x47aee
movl %ebp, %edx
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
addl %r15d, %ebp
movq (%r12), %rax
testb $0x30, %al
je 0x28c7c
pushq $0xb
popq %rdi
callq 0x521b
movq (%r12), %rax
jmp 0x28c7c
retq
xorl %ebp, %ebp
testb $0x30, %al
je 0x28caf
leaq 0x1f8d1(%rip), %rdi     # 0x48558
xorl %eax, %eax
callq 0x3120
movl %eax, %r14d
addl %ebp, %r14d
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x1a4bf(%rip), %rdi     # 0x43162
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 0x160f7
// File: /workspace/github_c_makefile_star2_O2/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 0x28da4
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x28da4
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x42ba
movq %rax, 0x33b5a(%rip)     # 0x5c858
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x416a
movw %ax, 0x33b4c(%rip)      # 0x5c860
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x416a
movw %ax, 0x33b38(%rip)      # 0x5c862
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x33b28(%rip)     # 0x5c868
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x33b1a(%rip)     # 0x5c870
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x33b0c(%rip)     # 0x5c878
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x33afe(%rip)     # 0x5c880
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x33af0(%rip)     # 0x5c888
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
je 0x28dab
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 0x33a98(%rip), %rcx     # 0x5c858
cmoveq %rcx, %rax
jmp 0x28da6
// File: /workspace/github_c_makefile_star2_O2/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 0x293f7
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x293f7
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x42ba
movq %rax, 0x33561(%rip)     # 0x5c8c8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x416a
movw %ax, 0x33553(%rip)      # 0x5c8d0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x416a
movw %ax, 0x3353f(%rip)      # 0x5c8d2
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x3352f(%rip)     # 0x5c8d8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x33521(%rip)     # 0x5c8e0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x33513(%rip)     # 0x5c8e8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x33505(%rip)     # 0x5c8f0
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
je 0x293fe
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 0x334b5(%rip), %rcx     # 0x5c8c8
cmoveq %rcx, %rax
jmp 0x293f9
// File: /workspace/github_c_makefile_star2_O2/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 0x29f7d
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x29f7d
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x42ba
movq %rax, 0x329b9(%rip)     # 0x5c890
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x416a
movw %ax, 0x329ab(%rip)      # 0x5c898
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x416a
movw %ax, 0x32997(%rip)      # 0x5c89a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x32987(%rip)     # 0x5c8a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x32979(%rip)     # 0x5c8a8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x3296b(%rip)     # 0x5c8b0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x3295d(%rip)     # 0x5c8b8
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x42ba
movq %rax, 0x3294f(%rip)     # 0x5c8c0
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
je 0x29f84
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 0x328f7(%rip), %rcx     # 0x5c890
cmoveq %rcx, %rax
jmp 0x29f7f
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2d3e6(%rip), %r14     # 0x57b60
addq $0x14, %r14
movq -0x14(%r14), %rsi
testq %rsi, %rsi
je 0x2a79d
movslq -0xc(%r14), %rdx
movq %rbx, %rdi
callq 0x31f0
testl %eax, %eax
je 0x2a7a1
addq $0x18, %r14
jmp 0x2a77e
xorl %ebx, %ebx
jmp 0x2a7b6
movl -0x8(%r14), %ebx
movl -0x4(%r14), %edi
callq 0x1b28c
movl (%r14), %edi
callq 0x1b2bd
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2a5
testq %rbx, %rbx
je 0x2a845
movl %eax, %ebp
leaq 0x2c967(%rip), %rax     # 0x57180
testb $0x30, (%rax)
je 0x2a845
leaq 0x1b461(%rip), %rsi     # 0x45c86
movq %rbx, %rdi
callq 0x5dd3
cmpl $0x2, %ebp
je 0x2a84c
cmpl $0x1, %ebp
jne 0x2a845
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2a85a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2aafd
// File: /workspace/github_c_makefile_star2_O2/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 0x2c3ac
leaq 0x1bb12(%rip), %rcx     # 0x47eac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1d8a9(%rip), %rbx     # 0x49c53
jmp 0x2c40b
cmpl $0x100, %edi            # imm = 0x100
je 0x2c404
cmpl $0xf00, %edi            # imm = 0xF00
jne 0x2c40b
leaq 0x1654e(%rip), %rbx     # 0x42911
jmp 0x2c40b
leaq 0x1eb17(%rip), %rbx     # 0x4aee3
jmp 0x2c40b
leaq 0x1bd25(%rip), %rbx     # 0x480fa
jmp 0x2c40b
leaq 0x1bd28(%rip), %rbx     # 0x48106
jmp 0x2c40b
leaq 0x1b208(%rip), %rbx     # 0x475ef
jmp 0x2c40b
leaq 0x14dfb(%rip), %rbx     # 0x411eb
jmp 0x2c40b
leaq 0x1bce6(%rip), %rbx     # 0x480df
jmp 0x2c40b
leaq 0x1bced(%rip), %rbx     # 0x480ef
jmp 0x2c40b
leaq 0x15b5a(%rip), %rbx     # 0x41f65
pushq $0x1
popq %rdi
callq 0x1b2bd
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2af02(%rip), %r14     # 0x57590
addq $0x14, %r14
movq -0x14(%r14), %rsi
testq %rsi, %rsi
je 0x2c6b1
movslq -0xc(%r14), %rdx
movq %rbx, %rdi
callq 0x31f0
testl %eax, %eax
je 0x2c6b5
addq $0x18, %r14
jmp 0x2c692
xorl %ebx, %ebx
jmp 0x2c6ca
movl -0x8(%r14), %ebx
movl -0x4(%r14), %edi
callq 0x1b28c
movl (%r14), %edi
callq 0x1b2bd
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
xorl %eax, %eax
callq 0x1b2a5
testq %rbx, %rbx
je 0x2c706
leaq 0x2aa95(%rip), %rcx     # 0x57180
testb $0x30, (%rcx)
je 0x2c706
cmpl $0x1, %eax
jne 0x2c708
movq %rbx, %rdi
callq 0x2c718
movq %rbx, %rdi
popq %rbx
jmp 0x2c736
popq %rbx
retq
leaq 0x19577(%rip), %rsi     # 0x45c86
movq %rbx, %rdi
popq %rbx
jmp 0x5dd3
// File: /workspace/github_c_makefile_star2_O2/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 0x2c800
leaq 0x2aa34(%rip), %rax     # 0x57180
testb $0x30, (%rax)
je 0x2c800
movq %rdi, %r14
movzwl (%rdi), %eax
cmpl $0x202, %eax            # imm = 0x202
je 0x2c79f
cmpl $0x201, %eax            # imm = 0x201
jne 0x2c800
xorl %eax, %eax
callq 0x8f81
movq 0x10(%r14), %rax
cmpq $0x22, %rax
je 0x2c7d7
cmpq $0x2, %rax
je 0x2c7e0
cmpq $0x3, %rax
je 0x2c7e9
cmpq $0x21, %rax
je 0x2c7d7
cmpq $0x1, %rax
jne 0x2c7be
leaq 0x1bea3(%rip), %rdi     # 0x48640
jmp 0x2c7f0
xorl %eax, %eax
callq 0x8f81
movq 0x10(%r14), %rax
cmpq $0x1, %rax
je 0x2c7ce
testq %rax, %rax
jne 0x2c7be
leaq 0x1cbed(%rip), %rdi     # 0x493a9
jmp 0x2c7f0
leaq 0x1a654(%rip), %rdi     # 0x46e19
callq 0x56e2
xorl %ebx, %ebx
jmp 0x2c7f9
leaq 0x17ef2(%rip), %rdi     # 0x446c7
jmp 0x2c7f0
leaq 0x1be69(%rip), %rdi     # 0x48647
jmp 0x2c7f0
leaq 0x1be5d(%rip), %rdi     # 0x48644
jmp 0x2c7f0
leaq 0x1be53(%rip), %rdi     # 0x48643
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
xorl %eax, %eax
callq 0x8fa0
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x16a4f
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2a5
testq %r14, %r14
je 0x2c8bf
cmpl $0x1, %eax
jne 0x2c8c5
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 0x2c8fb
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 0x2d1c4
addq $0x28, %rsp
jmp 0x2c8f0
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 0x185a8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/maker_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
leal -0x200(%rdi), %eax
cmpl $0xd, %eax
ja 0x2d38e
leaq 0x1b237(%rip), %rcx     # 0x485b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b25f(%rip), %rbx     # 0x485e8
jmp 0x2d410
cmpl $0x301, %edi            # imm = 0x301
je 0x2d409
cmpl $0xe00, %edi            # imm = 0xE00
je 0x2d400
cmpl $0xf00, %edi            # imm = 0xF00
jne 0x2d410
leaq 0x15564(%rip), %rbx     # 0x42911
jmp 0x2d410
leaq 0x14afc(%rip), %rbx     # 0x41eb2
jmp 0x2d410
leaq 0x1ad3b(%rip), %rbx     # 0x480fa
jmp 0x2d410
leaq 0x1eadc(%rip), %rbx     # 0x4bea4
jmp 0x2d410
leaq 0x172f6(%rip), %rbx     # 0x446c7
jmp 0x2d410
leaq 0x1b22a(%rip), %rbx     # 0x48604
jmp 0x2d410
leaq 0x1b22a(%rip), %rbx     # 0x4860d
jmp 0x2d410
leaq 0x1b232(%rip), %rbx     # 0x4861e
jmp 0x2d410
leaq 0x1ea9d(%rip), %rbx     # 0x4be92
jmp 0x2d410
leaq 0x1b1f6(%rip), %rbx     # 0x485f4
jmp 0x2d410
leaq 0x13ebb(%rip), %rbx     # 0x412c2
jmp 0x2d410
leaq 0x1b21e(%rip), %rbx     # 0x4862e
pushq $0x1
popq %rdi
callq 0x1b2bd
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2a942(%rip), %r14     # 0x57d70
addq $0x14, %r14
movq -0x14(%r14), %rsi
testq %rsi, %rsi
je 0x2d451
movslq -0xc(%r14), %rdx
movq %rbx, %rdi
callq 0x31f0
testl %eax, %eax
je 0x2d455
addq $0x18, %r14
jmp 0x2d432
xorl %ebx, %ebx
jmp 0x2d46a
movl -0x8(%r14), %ebx
movl -0x4(%r14), %edi
callq 0x1b28c
movl (%r14), %edi
callq 0x1b2bd
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2a5
testq %rbx, %rbx
je 0x2d4b6
movl %eax, %ebp
leaq 0x29cf1(%rip), %rax     # 0x57180
testb $0x30, (%rax)
je 0x2d4b6
leaq 0x187eb(%rip), %rsi     # 0x45c86
movq %rbx, %rdi
callq 0x5dd3
cmpl $0x1, %ebp
jne 0x2d4b6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2d4cf
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2a5
testq %r14, %r14
je 0x2d681
cmpl $0x1, %eax
jne 0x2d687
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 0x2d6bd
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 0x2dcad
addq $0x28, %rsp
jmp 0x2d6b2
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 0x185a8
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/maker_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
leal -0x201(%rdi), %ecx
cmpl $0x7, %ecx
jbe 0x2e13f
leal -0x100(%rdi), %ecx
cmpl $0x4, %ecx
jbe 0x2e157
leal -0x1000(%rdi), %ecx
cmpl $0x4, %ecx
jbe 0x2e16f
cmpl $0x304, %edi            # imm = 0x304
je 0x2e1df
cmpl $0x301, %edi            # imm = 0x301
je 0x2e1ef
cmpl $0x302, %edi            # imm = 0x302
je 0x2e1e7
testl %edi, %edi
jne 0x2e1de
leaq 0x1aa49(%rip), %rax     # 0x48b87
retq
leaq 0x1a6ce(%rip), %rdx     # 0x48814
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1aa7e(%rip), %rax     # 0x48bd4
retq
leaq 0x1a6a2(%rip), %rdx     # 0x48800
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x1aa2e(%rip), %rax     # 0x48b9c
retq
leaq 0x1a6be(%rip), %rdx     # 0x48834
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x19fb5(%rip), %rax     # 0x4813b
retq
leaq 0x1a36a(%rip), %rax     # 0x484f8
retq
leaq 0x1aa54(%rip), %rax     # 0x48bea
retq
leaq 0x1aa3b(%rip), %rax     # 0x48bd9
retq
leaq 0x1aa58(%rip), %rax     # 0x48bfe
retq
leaq 0x1a374(%rip), %rax     # 0x48522
retq
leaq 0x13303(%rip), %rax     # 0x414b9
retq
leaq 0x1a9ef(%rip), %rax     # 0x48bad
retq
leaq 0x1a9fa(%rip), %rax     # 0x48bc0
retq
leaq 0x1aa7c(%rip), %rax     # 0x48c4a
retq
leaq 0x1aa7f(%rip), %rax     # 0x48c55
retq
leaq 0x1aa89(%rip), %rax     # 0x48c67
retq
leaq 0x1aa4c(%rip), %rax     # 0x48c32
retq
leaq 0x1aa2f(%rip), %rax     # 0x48c1d
retq
leaq 0x1aa1e(%rip), %rax     # 0x48c14
retq