LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/print.c
// Function: display_end_of_ifd
void
display_end_of_ifd(unsigned long max_ifd_offset,int ifdtype,int ifdnum,int subifdnum,
                                                int indent,char *ifdname,char *prefix)
{
    int chpr = 0;
    print_tag_address(SECTION,max_ifd_offset - 1,indent,prefix);
    switch(ifdtype)
    {
        case TIFF_IFD:
            if(PRINT_SECTION)
                chpr += printf("</IFD %d>",ifdnum);
            break;
        case TIFF_SUBIFD:
            if(PRINT_SECTION)
                chpr += printf("</SubIFD %d of IFD %d>",subifdnum,ifdnum);
            break;
        case INTEROP_IFD:
            if(PRINT_SECTION)
                chpr += printf("</Interoperability SubIFD>");
            break;
        case GPS_IFD:
            if(PRINT_SECTION)
                chpr += printf("</GPS SubIFD>");
            break;
        case EXIF_IFD:
            if(PRINT_SECTION)
                chpr += printf("</EXIF IFD>");
            break;
        case MAKER_SUBIFD:
            if(PRINT_SECTION)
                chpr += printf("</%s>",ifdname);
            break;
        default:
            if(PRINT_SECTION)
                chpr += printf("</UNKNOWN IFD TYPE %d>",ifdtype);
            break;
    }
    chpr = newline(chpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %r14
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r15d
movq 0x30(%rsp), %rcx
leaq -0x1(%rdi), %rsi
movl $0x40000, %edi          # imm = 0x40000
movl %r8d, %edx
callq 0x55eb
leaq 0x4e9d0(%rip), %rax     # 0x58180
movq (%rax), %rax
cmpl $0x6, %r15d
ja 0x9805
movl %r15d, %ecx
leaq 0x37c89(%rip), %rdx     # 0x4144c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
btl $0x12, %eax
jae 0x984d
leaq 0x38300(%rip), %rdi     # 0x41ad9
movl %ebx, %esi
jmp 0x9815
btl $0x12, %eax
jae 0x984d
leaq 0x38339(%rip), %rdi     # 0x41b23
jmp 0x9858
btl $0x12, %eax
jae 0x984d
leaq 0x38336(%rip), %rdi     # 0x41b2f
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
jmp 0x985f
btl $0x12, %eax
jae 0x984d
leaq 0x38323(%rip), %rdi     # 0x41b35
movl %r15d, %esi
xorl %eax, %eax
callq 0x3120
jmp 0x985f
btl $0x12, %eax
jae 0x984d
leaq 0x382b8(%rip), %rdi     # 0x41ae3
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3120
jmp 0x985f
btl $0x12, %eax
jae 0x984d
leaq 0x382b5(%rip), %rdi     # 0x41afa
jmp 0x9858
btl $0x12, %eax
jb 0x9851
xorl %edi, %edi
jmp 0x9861
leaq 0x382bd(%rip), %rdi     # 0x41b15
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1707a
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/print.c
// Function: dumpsection
void
dumpsection(FILE *inptr,unsigned long offset,unsigned long length,int indent)
{
    unsigned long dumplength;

    if(inptr)
    {
        if(Max_imgdump > 0L)
            dumplength = Max_imgdump;
        else
            dumplength = DEF_DUMPLENGTH;
        if(dumplength > length)
            dumplength = length;
        if(dumplength)
        {
            hexdump(inptr,offset,length,dumplength,16,indent,0);
            (void)newline(1);
        }
    }
}

// Assembly:
movl %ecx, %r9d
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
je 0x9884
retq
pushq %rax
leaq 0x4fb94(%rip), %rax     # 0x59420
movq (%rax), %rax
testq %rax, %rax
movl $0x40, %ecx
cmovneq %rax, %rcx
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
movl $0x0, (%rsp)
movl $0x10, %r8d
callq 0x7480
movl $0x1, %edi
popq %rax
jmp 0x1707a
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/print.c
// Function: print_private_taginfo
void
print_private_taginfo(struct ifd_entry *entry_ptr,unsigned short subifd_ident,
                                        char *parent_name,int make,int indent)
{
    char *nameoftag = CNULL;
    char *nameof_value_type = CNULL;
    int tagwidth = TAGWIDTH;
    int chpr = 0;

    if(entry_ptr && (PRINT_ENTRY))
    {
        extraindent(indent);
        if(PRINT_BOTH_TAGNO)
            chpr += printf("<%#06x=%5u> ",entry_ptr->tag & 0xffff,entry_ptr->tag & 0xffff);
        else if(PRINT_DEC_TAGNO)
            chpr += printf("<%5u> ",entry_ptr->tag & 0xffff);
        else if(PRINT_HEX_TAGNO)
            chpr += printf("<%#06x> ",entry_ptr->tag & 0xffff);
        if((PRINT_TAGNAME))
        {
            nameoftag = private_tagname(make,entry_ptr->tag,subifd_ident);
            if((PRINT_LONGNAMES))
                chpr += printf("%s.",parent_name);
            chpr += printf("%-*.*s",tagwidth,tagwidth,nameoftag ? nameoftag : "NULL");
        }
        if(PRINT_TYPE)
        {
            nameof_value_type = value_type_name(entry_ptr->value_type);
            chpr += printf(" [%-2u=%-9.9s %5lu] ",entry_ptr->value_type,
                                    nameof_value_type,entry_ptr->count);
        }
        if(PRINT_VALUE)
            chpr += printf(" = "); 
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
testq %rdi, %rdi
je 0xa5f0
leaq 0x4dc9e(%rip), %r13     # 0x58180
movq (%r13), %rax
testl $0x4003333, %eax        # imm = 0x4003333
je 0xa5f0
movl %ecx, %r15d
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
testl $0x30000000, %eax       # imm = 0x30000000
je 0xa510
movl %r8d, %edi
callq 0x5716
movq (%r13), %rax
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
jne 0xa52e
movzwl (%rbx), %edx
leaq 0x370fe(%rip), %rdi     # 0x41621
movl %edx, %esi
xorl %eax, %eax
callq 0x3120
jmp 0xa555
testb $0x2, %al
jne 0xa544
xorl %ebp, %ebp
testb $0x1, %al
je 0xa557
movzwl (%rbx), %esi
leaq 0x370f3(%rip), %rdi     # 0x41635
jmp 0xa54e
movzwl (%rbx), %esi
leaq 0x370e0(%rip), %rdi     # 0x4162e
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
movq (%r13), %rax
btl $0xc, %eax
jae 0xa5ae
movzwl (%rbx), %esi
movzwl %r12w, %edx
movl %r15d, %edi
callq 0xa621
movq %rax, %r15
testb $0x40, (%r13)
je 0xa58d
leaq 0x3af6a(%rip), %rdi     # 0x454eb
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
leaq 0x3e59d(%rip), %rdi     # 0x48b31
movl $0x1b, %esi
movl $0x1b, %edx
movq %r15, %rcx
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movq (%r13), %rax
btl $0xd, %eax
jae 0xa5dc
movzwl 0x2(%rbx), %edi
callq 0x16484
movzwl 0x2(%rbx), %esi
movq 0x8(%rbx), %rcx
leaq 0x37077(%rip), %rdi     # 0x41643
movq %rax, %rdx
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movq (%r13), %rax
testb $0x30, %al
je 0xa5f0
leaq 0x3ffc1(%rip), %rdi     # 0x4a5a8
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/print.c
// Function: private_tagname
char *
private_tagname(int make,unsigned short tag,unsigned short subifd_ident)
{
    static char unknown_buf[16];
    char *tagname = CNULL;

    switch(make)
    {
        case MAKER_OLYMPUS:
            tagname = olympus_private_tagname(tag,subifd_ident);
            break;
        default:
            break;
    }
    if(tagname == CNULL)
    {
        unknown_buf[0] = '\0';
        if(snprintf(unknown_buf,11,"TAG_%#06x",(int)tag) > 11)
        {
            printf(" bad tag %#x not converted\n",tag);
            why(stdout);
            tagname = "<BADTAG>";
        }
        else
            tagname = unknown_buf;
    }
    return(tagname);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movzwl %si, %ebx
cmpl $0xd, %edi
jne 0xa63f
movzwl %dx, %esi
movl %ebx, %edi
callq 0x2f8ba
movq %rax, %r14
testq %rax, %rax
jne 0xa690
movb $0x0, 0x52e8a(%rip)     # 0x5d4d0
leaq 0x52e83(%rip), %r14     # 0x5d4d0
leaq 0x37635(%rip), %rdx     # 0x41c89
movl $0xb, %esi
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3130
cmpl $0xc, %eax
jl 0xa690
leaq 0x37622(%rip), %rdi     # 0x41c93
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
movq 0x4d947(%rip), %rax     # 0x57fc8
movq (%rax), %rdi
callq 0x17ef7
leaq 0x3761f(%rip), %r14     # 0x41caf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/print.c
// Function: print_private_tagid
void
print_private_tagid(struct ifd_entry *entry_ptr,unsigned short subifd_ident,
                                                        int make,int indent)
{
    char *nameoftag;
    int chpr = 0;

    if(entry_ptr && (PRINT_ENTRY))
    {
        extraindent(indent);
        if(PRINT_TAGNAME || !(PRINT_TAGNO))
        {
            nameoftag = private_tagname(make,entry_ptr->tag,subifd_ident);
            chpr += printf("%-*.*s",TAGWIDTH,TAGWIDTH,nameoftag);
        }
        else if(PRINT_HEX_TAGNO)
            chpr += printf("<%#06x>",entry_ptr->tag & 0xffff);
        else if(PRINT_DEC_TAGNO)
            chpr += printf("<%5u>",entry_ptr->tag & 0xffff);
        /* ###%%% should be done just befor value is printed, not     */
        /* here                                                       */
        if(PRINT_VALUE)
            chpr += printf(" = ");
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebp, %ebp
testq %rdi, %rdi
je 0xa75b
leaq 0x4dacb(%rip), %r12     # 0x58180
movq (%r12), %rax
testl $0x4003333, %eax        # imm = 0x4003333
je 0xa75b
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
testl $0x30000000, %eax       # imm = 0x30000000
je 0xa6df
movl %ecx, %edi
callq 0x5716
movq (%r12), %rax
btl $0xc, %eax
setae %cl
testb $0x3, %al
setne %dl
testb %dl, %cl
jne 0xa71b
movzwl (%rbx), %esi
movzwl %r15w, %edx
movl %r14d, %edi
callq 0xa621
leaq 0x3e42c(%rip), %rdi     # 0x48b31
movl $0x1b, %esi
movl $0x1b, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3120
jmp 0xa742
testb $0x1, %al
jne 0xa731
xorl %ebp, %ebp
testb $0x2, %al
je 0xa744
movzwl (%rbx), %esi
leaq 0x36eec(%rip), %rdi     # 0x4161b
jmp 0xa73b
movzwl (%rbx), %esi
leaq 0x36ed8(%rip), %rdi     # 0x41613
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
testb $0x30, (%r12)
je 0xa75b
leaq 0x3fe56(%rip), %rdi     # 0x4a5a8
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/tagnames.c
// Function: interop_tagname
char *
interop_tagname(unsigned short tag)
{
    static char unknown_buf[16];
    char *tagname;

    switch(tag)
    {
        case 0x0001: tagname = "InteroperabilityIndex"; break;   /* EXIF */
        case 0x0002: tagname = "InteroperabilityVersion"; break; /* EXIF */
        case 0x1000: tagname = "RelatedImageFileFormat"; break;  /* EXIF */
        case 0x1001: tagname = "RelatedImageWidth"; break;       /* EXIF */
        case 0x1002: tagname = "RelatedImageLength"; break;      /* EXIF */
        default:
            if(snprintf(unknown_buf,11,"IOP_%#06x",(int)tag) > 11)
            {
                printf(" bad tag %#x not converted\n",tag);
                why(stdout);
                tagname = "<BADTAG>";
            }
            else
                tagname = unknown_buf;
            break;
    }
    return(tagname);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl $0xfff, %edi            # imm = 0xFFF
jle 0xc47d
cmpl $0x1000, %ebx           # imm = 0x1000
je 0xc490
cmpl $0x1001, %ebx           # imm = 0x1001
je 0xc499
cmpl $0x1002, %ebx           # imm = 0x1002
jne 0xc4ab
leaq 0x377b0(%rip), %r14     # 0x43c2b
jmp 0xc4f5
cmpl $0x1, %ebx
je 0xc4a2
cmpl $0x2, %ebx
jne 0xc4ab
leaq 0x3775c(%rip), %r14     # 0x43bea
jmp 0xc4f5
leaq 0x3776b(%rip), %r14     # 0x43c02
jmp 0xc4f5
leaq 0x37779(%rip), %r14     # 0x43c19
jmp 0xc4f5
leaq 0x3772b(%rip), %r14     # 0x43bd4
jmp 0xc4f5
leaq 0x5103e(%rip), %r14     # 0x5d4f0
leaq 0x37785(%rip), %rdx     # 0x43c3e
movl $0xb, %esi
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3130
cmpl $0xc, %eax
jl 0xc4f5
leaq 0x357bd(%rip), %rdi     # 0x41c93
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
movq 0x4bae2(%rip), %rax     # 0x57fc8
movq (%rax), %rdi
callq 0x17ef7
leaq 0x357ba(%rip), %r14     # 0x41caf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/process.c
// Function: last_summary_entry
struct image_summary *
last_summary_entry(struct image_summary *summary_entry)
{
    if(summary_entry)
    {
        while(summary_entry->next_entry)
            summary_entry = summary_entry->next_entry;
    }
    return(summary_entry);
}

// Assembly:
testq %rdi, %rdi
je 0xfee3
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0xfed6
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/process.c
// Function: lock_number
int
lock_number(struct image_summary *summary_entry)
{
    int number = 0;
    struct image_summary *prev_entry,*last_entry;

    if(summary_entry)
    {
        if(summary_entry->entry_lock)
            number = summary_entry->entry_lock;  /* don't change it */
        else if((last_entry = last_summary_entry(summary_entry)))
        {
            /* Find the highest existing lock number; go to the end   */
            /* and scan back to the head                              */
            if(last_entry->entry_lock > 0)
                number = last_entry->entry_lock + 1;
            prev_entry = last_entry->prev_entry;
            while(prev_entry)
            {
                if(prev_entry->entry_lock >= number)
                    number = prev_entry->entry_lock + 1;
                prev_entry = prev_entry->prev_entry;
            }
            if(number <= 0)
                number = 1;
        }
        else
            number = 1;
    }
    if(Debug & SCAN_DEBUG)
    {
        (void)newline(1);
        printred("DEBUG: LOCK SUMMARY");
        printf(" %#x ==> %d",(unsigned int)summary_entry,number);
        (void)newline(1);
        (void)newline(1);
    }
    return(number);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0xff29
movl 0x10(%rbx), %ebp
testl %ebp, %ebp
jne 0xff38
movq %rbx, %rax
movq %rax, %rcx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xfefb
movl 0x10(%rcx), %edx
leal 0x1(%rdx), %esi
xorl %eax, %eax
testl %edx, %edx
cmovgl %esi, %eax
movq (%rcx), %rcx
testq %rcx, %rcx
je 0xff2d
movl 0x10(%rcx), %edx
leal 0x1(%rdx), %esi
cmpl %eax, %edx
cmovgel %esi, %eax
jmp 0xff14
xorl %ebp, %ebp
jmp 0xff38
cmpl $0x2, %eax
movl $0x1, %ebp
cmovgel %eax, %ebp
leaq 0x4d731(%rip), %rax     # 0x5d670
testb $0x4, (%rax)
je 0xff80
movl $0x1, %edi
callq 0x1707a
leaq 0x34bd1(%rip), %rdi     # 0x44b26
callq 0x5c26
leaq 0x34bd9(%rip), %rdi     # 0x44b3a
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3120
movl $0x1, %edi
callq 0x1707a
movl $0x1, %edi
callq 0x1707a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/process.c
// Function: destroy_summary
struct image_summary *
destroy_summary(struct image_summary *summary_entry)
{
    struct image_summary *prev_entry = NULL;

    /* start at the end and work back to the head                     */
    if(Debug & SCAN_DEBUG)
        printred("DEBUG: DESTROY SUMMARY ");
    if(summary_entry)
    {
        while(summary_entry->next_entry)
            summary_entry = summary_entry->next_entry;
        while(summary_entry)
        {
            prev_entry = summary_entry->prev_entry;
            free(summary_entry);
            summary_entry = prev_entry;
        }
    }
    return(prev_entry);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x49b33(%rip), %rax     # 0x5d670
testb $0x4, (%rax)
je 0x13b4e
leaq 0x30ffd(%rip), %rdi     # 0x44b46
callq 0x5c26
testq %rbx, %rbx
je 0x13b6f
movq %rbx, %rdi
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x13b53
movq (%rdi), %rbx
callq 0x3050
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x13b5f
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/process.c
// Function: forward_scan_for_eoi
unsigned long
forward_scan_for_eoi(FILE *inptr,unsigned long start_of_data,
                            unsigned long end_of_section,char *prefix,int indent)
{
    int highbyte,lobyte;
    unsigned long eoi_offset = 0UL;
    unsigned long tagloc;
    int chpr = 0;

    if(inptr && (fseek(inptr,start_of_data,SEEK_SET) != -1))
    {
        if(Debug & JPEG_EOI_DEBUG)
            printf("DEBUG: start scan at %lu\n",start_of_data);
        while(((highbyte = fgetc(inptr)) != EOF) && (highbyte != EOF) && (ftell(inptr) < end_of_section))
        {
            if(highbyte != JPEG_HIBYTE)
                continue;
            tagloc = ftell(inptr) - 1;
            lobyte = fgetc(inptr);
            if(lobyte == EOI_LOBYTE)
            {
                eoi_offset = tagloc;
                if(Debug & JPEG_EOI_DEBUG)
                {
                    if(!(LIST_MODE) && (PRINT_SEGMENT))
                    {
                        print_tag_address(SEGMENT,eoi_offset,indent + SMALLINDENT,prefix);
                        PUSHCOLOR(RED);
                        putindent(2);
                        chpr += printf("possible JPEG_EOI found at %lu",eoi_offset);
                    }
                    POPCOLOR();
                    chpr = newline(chpr);
                }
                break;
            }
        }
    }
    if(Debug & JPEG_EOI_DEBUG)
        printf("DEBUG: end scan at %lu\n",ftell(inptr));
    return(eoi_offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x13c15
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x13c18
leaq 0x49ac1(%rip), %rax     # 0x5d670
testb $0x2, (%rax)
je 0x13bc5
leaq 0x314c0(%rip), %rdi     # 0x4507b
movq %r13, %rsi
xorl %eax, %eax
callq 0x3120
movq %rbx, %rdi
callq 0x3150
cmpl $-0x1, %eax
je 0x13c15
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3190
cmpq %r12, %rax
jae 0x13c15
cmpl $0xff, %r14d
jne 0x13c05
movq %rbx, %rdi
callq 0x3190
movq %rax, %r14
movq %rbx, %rdi
callq 0x3150
cmpl $0xd9, %eax
je 0x13c4f
movq %rbx, %rdi
callq 0x3150
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x13bd5
xorl %r14d, %r14d
leaq 0x49a51(%rip), %rax     # 0x5d670
testb $0x2, (%rax)
je 0x13c3d
movq %rbx, %rdi
callq 0x3190
leaq 0x31481(%rip), %rdi     # 0x450b4
movq %rax, %rsi
xorl %eax, %eax
callq 0x3120
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
decq %r14
leaq 0x49a17(%rip), %rax     # 0x5d670
testb $0x2, (%rax)
je 0x13c18
leaq 0x4451b(%rip), %rax     # 0x58180
movq (%rax), %rax
testl $0x1040000, %eax        # imm = 0x1040000
sete %cl
btl $0x13, %eax
setae %al
xorl %edi, %edi
orb %cl, %al
jne 0x13caf
addl $0x2, %ebp
movl $0x80000, %edi          # imm = 0x80000
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x55eb
movl $0x2, %edi
callq 0x5716
leaq 0x313f2(%rip), %rdi     # 0x45095
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x1707a
jmp 0x13c18
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/process.c
// Function: putword
int
putword(FILE *inptr,int firstch,unsigned long max_offset,int indent)
{
    int eol = 0;
    int chpr = 0;
    int ch = firstch;

    if(firstch)
        print_tag_address(APP_ENTRY,ftell(inptr),indent + SMALLINDENT,"@");
    if(firstch)
    {
        if(firstch != '[')
            extraindent(SMALLINDENT);
        putchar(firstch);
        ++chpr;
    }
    else
        ++eol;
    while(((unsigned long)ftell(inptr) < max_offset) && !eol)
    {
        ch = fgetc(inptr);
        switch(ch)
        {
        case '\r':
            break;
        case 0:
            ++eol;
            break;
        case '\n':
            ++eol;
            ch = fgetc(inptr);
            break;
        case EOF:
            ++eol;
            break;
        default:
            if(isprint(ch))
                putchar(ch);
            ++chpr;
            break;
        }
    }
    setcharsprinted(chpr);
    return(ch);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
callq 0x3190
testl %ebx, %ebx
je 0x163ef
addl $0x2, %ebp
leaq 0x2ad69(%rip), %rcx     # 0x410dc
movl $0x100000, %edi         # imm = 0x100000
movq %rax, %rsi
movl %ebp, %edx
callq 0x55eb
cmpl $0x5b, %ebx
je 0x16391
movl $0x2, %edi
callq 0x96eb
movl %ebx, %edi
callq 0x3060
movq %r14, %rdi
callq 0x3190
movl $0x1, %ebp
testl %ebx, %ebx
je 0x16407
cmpq %r15, %rax
jae 0x16407
movq %r14, %rdi
callq 0x3150
movl %eax, %ebx
cmpl $0xd, %eax
je 0x163e5
leal 0x1(%rbx), %eax
cmpl $0x2, %eax
jb 0x163ff
cmpl $0xa, %ebx
je 0x163f5
callq 0x32d0
movq (%rax), %rax
movslq %ebx, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
je 0x163e3
movl %ebx, %edi
callq 0x3060
incl %ebp
movq %r14, %rdi
callq 0x3190
jmp 0x163a9
xorl %ebp, %ebp
xorl %ebx, %ebx
jmp 0x16407
movq %r14, %rdi
callq 0x3150
movl %eax, %ebx
movq %r14, %rdi
callq 0x3190
movl %ebp, %edi
callq 0x17a82
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/process.c
// Function: skip_to_bracket
int
skip_to_bracket(FILE *inptr,unsigned long max_offset)
{
    int ch = EOF;

    while(((unsigned long)ftell(inptr) < max_offset) && ((ch = fgetc(inptr)) != '[') && ch != EOF)
        continue;
    if(ftell(inptr) >= max_offset)
        ch = 0;
    return(ch);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3190
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %rbx, %rax
jae 0x16452
movq %r14, %rdi
callq 0x3150
movl %eax, %ebp
cmpl $0x5b, %eax
je 0x16452
cmpl $-0x1, %ebp
je 0x16452
movq %r14, %rdi
callq 0x3190
jmp 0x1642f
movq %r14, %rdi
callq 0x3190
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovbl %ebp, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: strdup_value
char *
strdup_value(struct ifd_entry *entry, FILE *inptr,
                                        unsigned long fileoffset_base)
{
    char *val = NULL;
    if (is_offset(entry))
    {
        char *buf = (char *)read_bytes(inptr,
                                       entry->count,
                                       fileoffset_base +
                                       entry->value);
        if (buf) {
            val = strndup(buf, entry->count);
        }
        return val;
    }
    else
    {
        char *buf = (char *)&(entry->value);
        val = (char*)calloc(entry->count + 1, sizeof(char));
        for (int i = 0; i < entry->count; i++) {
          val[i] = buf[i];
        }
        return val;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0xff89
movq 0x8(%rbx), %r14
testl %eax, %eax
je 0x164f2
addq 0x10(%rbx), %r15
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4865
testq %rax, %rax
je 0x16522
movq 0x8(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3160
leaq 0x1(%r14), %rdi
movl $0x1, %esi
callq 0x3170
testq %r14, %r14
je 0x16524
addq $0x10, %rbx
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x31c0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: print_summary
void
print_summary(struct image_summary *summary_entry)
{
    int number_of_images = 0;
    int images_found = 0;
    int chpr = 0;
    char *plural;

    /* Pre-process the summary list; marks primary, reduced-res image */
    /* types and attempts to avoid kruft from imcomplete summary      */
    /* entries.                                                       */
    number_of_images = scan_summary(summary_entry);

    for( ; summary_entry; summary_entry = summary_entry->next_entry)
    {
        PUSHCOLOR(SUMMARY_COLOR);
        images_found += print_image_summary_entry(summary_entry,"@");
        POPCOLOR();
    }

    chpr = newline(chpr);
    plural = NULLSTRING;
    print_filename();
    if(LIST_MODE)
        chpr += printf("NumberOfImages = %d",number_of_images);
    else
        chpr += printf("Number of images = %d",number_of_images);
    if(number_of_images - images_found)
    {
        chpr = newline(chpr);
        print_filename();
        if(LIST_MODE)
            chpr += printf("ImagesNotFound = %d",number_of_images - images_found);
        else
            chpr += printf("Images not found = %d",number_of_images - images_found);
    }
    chpr = newline(chpr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x16608
movl %eax, %ebx
xorl %ebp, %ebp
testq %r14, %r14
je 0x16555
movq %r14, %rdi
callq 0x16dc6
addl %eax, %ebp
movq 0x8(%r14), %r14
jmp 0x16540
cmpl $0x0, 0x46fec(%rip)     # 0x5d548
je 0x16568
movl $0xa, %edi
callq 0x3060
movl $0x0, 0x46fd6(%rip)     # 0x5d548
callq 0x17ff9
leaq 0x41c02(%rip), %r14     # 0x58180
testl $0x1040000, (%r14)      # imm = 0x1040000
leaq 0x2f10a(%rip), %rax     # 0x45696
leaq 0x2f117(%rip), %rdi     # 0x456aa
cmoveq %rax, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
subl %ebp, %ebx
je 0x165e7
orl 0x46f9e(%rip), %eax     # 0x5d548
je 0x165b6
movl $0xa, %edi
callq 0x3060
movl $0x0, 0x46f88(%rip)     # 0x5d548
callq 0x17ff9
testl $0x1040000, (%r14)      # imm = 0x1040000
leaq 0x2f0ed(%rip), %rax     # 0x456c0
leaq 0x2f0fa(%rip), %rdi     # 0x456d4
cmoveq %rax, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
orl 0x46f5b(%rip), %eax     # 0x5d548
je 0x165f9
movl $0xa, %edi
callq 0x3060
movl $0x0, 0x46f45(%rip)     # 0x5d548
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: newline
int
newline(int charsprinted)
{
    if((charsprinted != 0) || (Charsprinted != 0))
        putchar('\n');
    Charsprinted = 0;
    return(Charsprinted);
}

// Assembly:
orl 0x464c8(%rip), %edi     # 0x5d548
je 0x17091
pushq %rax
movl $0xa, %edi
callq 0x3060
addq $0x8, %rsp
movl $0x0, 0x464ad(%rip)     # 0x5d548
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: print_imagesubformat
void
print_imagesubformat(struct image_summary *entry)
{
    char *subformat;
    unsigned long imagesubformat = 0;
    int chpr = 0;

    subformat = NULLSTRING;
    if(entry)
    {
        imagesubformat = entry->imagesubformat & ~IMGSUBFMT_ERRORMASK;
        switch(imagesubformat)
        {
        case IMGSUBFMT_CFA:
            subformat = "CFA";
            break;
        case IMGSUBFMT_RGB:
            subformat = "RGB";
            break;
        case IMGSUBFMT_YCBCR:
            subformat = "YCBCR";
            break;
        case IMGSUBFMT_PALETTE:
            subformat = "PALETTE";
            break;
        case IMGSUBFMT_LINEARRAW:
            subformat = "LinearRaw";
            break;
        case IMGSUBFMT_JPEGTABLES:
            subformat = "JPEGTables";
            break;
        case IMGSUBFMT_HUFF_COMPRESSED_RGB:
            subformat = "RGB";
            break;
        case IMGSUBFMT_JPEG_COMPRESSED_RGB:
            subformat = "RGB";
            break;
        case IMGSUBFMT_X3F_COMPRESSED:
            subformat = "RAW";
            break;
        case IMGSUBFMT_X3F_UNSPECIFIED:
            subformat = "Unspecified";
            break;
        default:
            break;
        }
    }
    if(*subformat)
        chpr += printf(" %s",subformat);
    setcharsprinted(chpr);
}

// Assembly:
leaq 0x30ac1(%rip), %rsi     # 0x47cd6
testq %rdi, %rdi
je 0x172c9
movq 0x88(%rdi), %rax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmpq $0x18022, %rax          # imm = 0x18022
jg 0x1724a
cmpq $0x10002, %rax          # imm = 0x10002
jg 0x17270
cmpl $0x15b, %eax            # imm = 0x15B
je 0x1729e
cmpl $0x10002, %eax          # imm = 0x10002
je 0x17267
jmp 0x172c9
leaq -0x20001(%rax), %rcx
cmpq $0x3, %rcx
ja 0x17287
leaq 0x2e2e2(%rip), %rax     # 0x45540
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x33e90(%rip), %rsi     # 0x4b0fe
jmp 0x172c9
cmpl $0x10003, %eax          # imm = 0x10003
je 0x172a7
cmpl $0x10006, %eax          # imm = 0x10006
jne 0x172c9
leaq 0x2ebf6(%rip), %rsi     # 0x45e7b
jmp 0x172c9
cmpl $0x1884c, %eax          # imm = 0x1884C
je 0x172c2
cmpl $0x18023, %eax          # imm = 0x18023
jne 0x172c9
leaq 0x2ebdb(%rip), %rsi     # 0x45e77
jmp 0x172c9
leaq 0x2b822(%rip), %rsi     # 0x42ac7
jmp 0x172c9
leaq 0x2ebd3(%rip), %rsi     # 0x45e81
jmp 0x172c9
leaq 0x2ebe0(%rip), %rsi     # 0x45e97
jmp 0x172c9
leaq 0x2ebd3(%rip), %rsi     # 0x45e93
jmp 0x172c9
leaq 0x2ebc0(%rip), %rsi     # 0x45e89
cmpb $0x0, (%rsi)
je 0x172e3
pushq %rax
leaq 0x29dc0(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addq $0x8, %rsp
jmp 0x172e5
xorl %eax, %eax
addl %eax, 0x4625d(%rip)     # 0x5d548
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: print_imagecompression
void
print_imagecompression(struct image_summary *entry)
{
    if(entry)
    {
        switch(entry->imageformat)
        {
        case IMGFMT_MRW:    /* gets it from a TIFF IFD                */
        case IMGFMT_TIFF:
            print_tiff_compression(entry);
            break;
        case IMGFMT_JPEG:
            print_jpeg_compression(entry);
            break;
        case IMGFMT_JPEG2000:
            print_jp2c_compression(entry);
            break;
        case IMGFMT_CRW:
            print_crw_compression(entry);
            break;
        case IMGFMT_RAF:
            print_raf_compression(entry);
            break;
        case IMGFMT_X3F:
            print_x3f_compression(entry);
            break;
        default:
            break;
        }
    }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x173b6
movq 0x80(%rdi), %rax
cmpq $0xffd7, %rax           # imm = 0xFFD7
jle 0x17326
cmpq $0xd0a8709, %rax        # imm = 0xD0A8709
jg 0x1734c
cmpq $0xffd8, %rax           # imm = 0xFFD8
je 0x173b8
cmpq $0x4d524d, %rax         # imm = 0x4D524D
je 0x17362
jmp 0x173b6
cmpq $0x1a, %rax
je 0x1737a
cmpq $0x2a, %rax
je 0x17362
cmpq $0x4655, %rax           # imm = 0x4655
jne 0x173b6
movl 0xc8(%rdi), %eax
cmpl $0x1, %eax
leaq 0x2eaec(%rip), %rcx     # 0x45e36
jmp 0x1738a
cmpq $0xd0a870a, %rax        # imm = 0xD0A870A
je 0x173be
cmpq $0x62564f46, %rax       # imm = 0x62564F46
jne 0x173b6
popq %rax
jmp 0x17de8
movslq 0xc8(%rdi), %rdi
callq 0x17aaf
leaq 0x29d21(%rip), %rdi     # 0x41096
movq %rax, %rsi
jmp 0x173a9
movl 0xc8(%rdi), %eax
cmpl $0x1, %eax
leaq 0x2e87e(%rip), %rcx     # 0x45c08
leaq 0x30945(%rip), %rdx     # 0x47cd6
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x2e673(%rip), %rsi     # 0x45a11
cmovneq %rdx, %rsi
leaq 0x29ced(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addl %eax, 0x46192(%rip)     # 0x5d548
popq %rax
retq
popq %rax
jmp 0x17c88
popq %rax
jmp 0x17cd6
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: print_imagesize
void
print_imagesize(struct image_summary *entry)
{
    int chpr = 0;
    char *maybeshort = NULLSTRING;

    if(entry)
    {
        if(entry->imagesubformat & IMGSUBFMT_JPEG_EARLY_EOI)
            maybeshort = "<= ";
        chpr += printf(" image [%ldx%ld",entry->pixel_width,entry->pixel_height);
        if(entry->subfiletype == PRIMARY_TYPE)
        {
            if((entry->primary_width > entry->pixel_width) ||
                       (entry->primary_height > entry->pixel_height)) 
            {
                chpr += printf("<=%ldx%ld",entry->primary_width,entry->primary_height);
            }
        }
        chpr += printf("] length %s%lu",maybeshort,entry->length);
    }
    setcharsprinted(chpr);
}

// Assembly:
testq %rdi, %rdi
je 0x1749d
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
btl $0x1d, 0x88(%rdi)
leaq 0x308aa(%rip), %rax     # 0x47cd6
leaq 0x2eaa1(%rip), %rbx     # 0x45ed4
cmovaeq %rax, %rbx
movq 0x70(%rdi), %rsi
movq 0x78(%rdi), %rdx
leaq 0x2ea92(%rip), %rdi     # 0x45ed8
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
cmpl $0x1, 0xc4(%r14)
jne 0x1747d
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
cmpq 0x70(%r14), %rsi
ja 0x1746d
cmpq 0x78(%r14), %rdx
jbe 0x1747d
leaq 0x2ea74(%rip), %rdi     # 0x45ee8
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movq 0x98(%r14), %rdx
leaq 0x2ea67(%rip), %rdi     # 0x45ef2
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3120
addl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x1749f
xorl %eax, %eax
addl %eax, 0x460a3(%rip)     # 0x5d548
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: print_location
void
print_location(struct image_summary *entry)
{
    char *space = NULL;
    int chpr = 0;

    if(entry)
    {
        space = " (";
        if((entry->fileformat == FILEFMT_TIFF) || 
                    entry->filesubformat & FILESUBFMT_TIFFUSED ||
                                            entry->filesubformatAPPN[1])
        {
            if(entry->ifdnum >= 0)
                chpr += printf("%sIFD %d",space,entry->ifdnum),space = " ";
            if(entry->subifdnum >= 0)
                chpr += printf("%sSubIFD %d",space,entry->subifdnum),space = " ";
            /* could use filesubformat here?                          */
            if(entry->datatype == MAKER_IFD)
                chpr += printf("%sMakerNote",space),space = " ";
            if(entry->datatype == MAKER_SUBIFD)
                chpr += printf("%sMakerNote SubIFD",space),space = " ";
        }
        else if(entry->fileformat == FILEFMT_JPEG)
        {
            if(entry->filesubformatAPPN[0])
            {
                chpr += printf("%sAPP0",space),space = " ";
                if(entry->filesubformat & FILESUBFMT_JFXX)
                    chpr += printf("%sJFXX",space),space = " ";
            }
        }
        if(chpr)
            chpr += printf(")");
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x175bc
movq %rdi, %r14
movl 0x14(%rdi), %eax
cmpl $0x2a, %eax
je 0x174d6
movzwl 0x18(%r14), %ecx
testl $0x3ff, %ecx            # imm = 0x3FF
jne 0x174d6
cmpl $0x0, 0x20(%r14)
je 0x17580
movl 0x11c(%r14), %edx
testl %edx, %edx
js 0x17501
leaq 0x2ea19(%rip), %rdi     # 0x45f01
leaq 0x29d19(%rip), %rsi     # 0x41208
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
leaq 0x29c97(%rip), %rsi     # 0x41196
jmp 0x1750a
xorl %ebx, %ebx
leaq 0x29cfe(%rip), %rsi     # 0x41208
movl 0x120(%r14), %edx
testl %edx, %edx
js 0x1752c
leaq 0x2e9ee(%rip), %rdi     # 0x45f0a
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
leaq 0x29c6a(%rip), %rsi     # 0x41196
movl 0x118(%r14), %eax
cmpl $0x5, %eax
jne 0x17556
leaq 0x2e9d7(%rip), %rdi     # 0x45f16
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
movl 0x118(%r14), %eax
leaq 0x29c40(%rip), %rsi     # 0x41196
cmpl $0x6, %eax
jne 0x1756b
leaq 0x2e9c0(%rip), %rdi     # 0x45f22
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
testl %ebx, %ebx
je 0x175bc
movl $0x29, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3060
cmpl $0xffd8, %eax           # imm = 0xFFD8
jne 0x175bc
cmpl $0x0, 0x1c(%r14)
je 0x175bc
leaq 0x2e369(%rip), %rdi     # 0x458fe
leaq 0x29c6c(%rip), %rsi     # 0x41208
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
testb $0x20, 0x19(%r14)
je 0x1756b
leaq 0x2e359(%rip), %rdi     # 0x4590c
leaq 0x29bdc(%rip), %rsi     # 0x41196
jmp 0x17562
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: find_camera_name
char *
find_camera_name(int make)
{
    struct camera_name *maker_id;
    char *camera_name = UNKNOWN_CAMERA_STRING;

    /* 'Camera_make' is a global parameter                            */
    for(maker_id = Camera_make; maker_id && maker_id->name; ++maker_id)
    {
        if(make == maker_id->id)
        {
            camera_name = maker_id->name;
            break;
        }
    }
    return(camera_name);
}

// Assembly:
leaq 0x4174f(%rip), %rdx     # 0x591a0
movq (%rdx), %rax
leaq 0x2df55(%rip), %rcx     # 0x459b0
testq %rax, %rax
je 0x17a7e
cmpl %edi, 0xc(%rdx)
je 0x17a7d
addq $0x24, %rdx
movq -0xc(%rdx), %rax
testq %rax, %rax
je 0x17a7e
leaq 0x18(%rdx), %rsi
cmpl %edi, (%rdx)
movq %rsi, %rdx
jne 0x17a69
retq
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: print_jp2c_compression
void
print_jp2c_compression(struct image_summary *entry)
{
    char *transform;
    char *quantization;
    int chpr = 0;

    transform = quantization = NULLSTRING;
    if(entry)
    {
        if((entry->compression & 0xff) == 1)
            transform = "5/3 reversible";
        else
            transform = "9/7 irreversible";
        switch((entry->compression & 0xff00) >> 8)
        {
            case 0:
                quantization = "no quantization";
                break;
            case 1:
                quantization = "implicit quantization";
                break;
            case 2:
                quantization = "explicit quantization";
                break;
            default:
                quantization = "unknown quantization";
                break;
        }
    }
    chpr += printf(" (%s compression with %s)",transform,quantization);
    setcharsprinted(chpr);
}

// Assembly:
testq %rdi, %rdi
je 0x17d12
movl 0xc8(%rdi), %eax
cmpb $0x1, %al
leaq 0x314d5(%rip), %rcx     # 0x491bf
leaq 0x314e0(%rip), %rsi     # 0x491d1
cmoveq %rcx, %rsi
shrl $0x8, %eax
testb %al, %al
je 0x17d27
movzbl %al, %eax
cmpl $0x2, %eax
je 0x17d1e
cmpl $0x1, %eax
jne 0x17d30
leaq 0x2e0cb(%rip), %rdx     # 0x45ddb
jmp 0x17d37
leaq 0x2ffbd(%rip), %rsi     # 0x47cd6
movq %rsi, %rdx
jmp 0x17d37
leaq 0x2e0cc(%rip), %rdx     # 0x45df1
jmp 0x17d37
leaq 0x2e09d(%rip), %rdx     # 0x45dcb
jmp 0x17d37
leaq 0x2e0d0(%rip), %rdx     # 0x45e07
pushq %rax
leaq 0x2e0dd(%rip), %rdi     # 0x45e1c
xorl %eax, %eax
callq 0x3120
addl %eax, 0x457fc(%rip)     # 0x5d548
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: print_crw_compression
void
print_crw_compression(struct image_summary *entry)
{
    char *compression;
    int chpr = 0;

    compression = NULLSTRING;
    if(entry)
    {
        switch(entry->compression)
        {
            case 0: compression = "uncompressed"; break;
            case 1: compression = "compressed"; break;
            default: break;
        }
    }
    chpr += printf(" %s",compression);
    setcharsprinted(chpr);
}

// Assembly:
testq %rdi, %rdi
je 0x17d7d
movl 0xc8(%rdi), %eax
cmpl $0x1, %eax
leaq 0x2dea5(%rip), %rcx     # 0x45c08
leaq 0x2ff6c(%rip), %rdx     # 0x47cd6
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x2dc9a(%rip), %rsi     # 0x45a11
cmovneq %rdx, %rsi
jmp 0x17d84
leaq 0x2ff52(%rip), %rsi     # 0x47cd6
pushq %rax
leaq 0x2930a(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addl %eax, 0x457af(%rip)     # 0x5d548
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: print_raf_compression
void
print_raf_compression(struct image_summary *entry)
{
    char *compression;
    int chpr = 0;

    compression = NULLSTRING;
    if(entry)
    {
        switch(entry->compression)
        {
            case 0: compression = "uncompressed"; break;
            case 1: compression = "uncompressed (with secondary)"; break;
            default: break;
        }
    }
    chpr += printf(" %s",compression);
    setcharsprinted(chpr);
}

// Assembly:
testq %rdi, %rdi
je 0x17dca
movl 0xc8(%rdi), %eax
cmpl $0x1, %eax
leaq 0x2e086(%rip), %rcx     # 0x45e36
leaq 0x2ff1f(%rip), %rdx     # 0x47cd6
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x2dc4d(%rip), %rsi     # 0x45a11
cmovneq %rdx, %rsi
jmp 0x17dd1
leaq 0x2ff05(%rip), %rsi     # 0x47cd6
pushq %rax
leaq 0x292bd(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addl %eax, 0x45762(%rip)     # 0x5d548
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: print_x3f_compression
void
print_x3f_compression(struct image_summary *entry)
{
    char *compression;
    int chpr = 0;

    compression = NULLSTRING;
    if(entry)
    {
        switch(entry->imagesubformat)
        {
            case IMGSUBFMT_HUFF_COMPRESSED_RGB: compression = "Huffman compressed"; break;
            case IMGSUBFMT_JPEG_COMPRESSED_RGB: compression = "Jpeg compressed"; break;
            case IMGSUBFMT_X3F_COMPRESSED: compression = "compressed"; break;
            case IMGSUBFMT_RGB: compression = "uncompressed"; break;
            default: break;
        }
    }
    chpr += printf(" %s",compression);
    setcharsprinted(chpr);
}

// Assembly:
leaq 0x2fee7(%rip), %rsi     # 0x47cd6
testq %rdi, %rdi
je 0x17e45
movq 0x88(%rdi), %rax
cmpq $0x20001, %rax          # imm = 0x20001
jg 0x17e1c
cmpq $0x10002, %rax          # imm = 0x10002
je 0x17e35
cmpq $0x20001, %rax          # imm = 0x20001
jne 0x17e45
leaq 0x2e03a(%rip), %rsi     # 0x45e54
jmp 0x17e45
cmpq $0x20002, %rax          # imm = 0x20002
je 0x17e3e
cmpq $0x20004, %rax          # imm = 0x20004
jne 0x17e45
leaq 0x2ddd5(%rip), %rsi     # 0x45c08
jmp 0x17e45
leaq 0x2dbd5(%rip), %rsi     # 0x45a11
jmp 0x17e45
leaq 0x2e022(%rip), %rsi     # 0x45e67
pushq %rax
leaq 0x29249(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addl %eax, 0x456ee(%rip)     # 0x5d548
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: sum_strip_bytecounts
unsigned long
sum_strip_bytecounts(FILE *inptr,unsigned short byteorder,unsigned long offset,
    unsigned long count,unsigned short value_type)
{
    int i;
    unsigned long sum = 0L;

    if(count)
    {
        /* Some use SHORT, some use LONG. If anyone uses some other   */
        /* type, just ignore 'em.                                     */
        if(value_type == SHORT)
        {
            sum = read_ushort(inptr,byteorder,offset);
            for(i = 1; i < count; ++i)
                sum += read_ushort(inptr,byteorder,HERE);
        }
        else if(value_type == LONG)
        {
            sum = read_ulong(inptr,byteorder,offset);
            for(i = 1; i < count; ++i)
                sum += read_ulong(inptr,byteorder,HERE);
        }
    }
    return(sum);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rcx, %rcx
je 0x17eb4
movq %rcx, %rbx
movq %rdi, %r14
cmpw $0x4, %r8w
je 0x17ec5
movzwl %r8w, %eax
cmpl $0x3, %eax
jne 0x17eb4
movzwl %si, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x45af
movzwl %ax, %r15d
cmpq $0x1, %rbx
je 0x17eb7
decq %rbx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x45af
movzwl %ax, %eax
addq %rax, %r15
decq %rbx
jne 0x17e98
jmp 0x17eb7
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movzwl %si, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, %r15
cmpq $0x1, %rbx
je 0x17eb7
decq %rbx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x4707
addq %rax, %r15
decq %rbx
jne 0x17ede
jmp 0x17eb7
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: clear_memory
void
clear_memory()
{
    if(Make_name)
        free(Make_name);
    if(Model_name)
        free(Model_name);
    if(Software_name)
        free(Software_name);
    Make_name = Model_name = Software_name = (char *)0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x414dd(%rip), %rbx     # 0x59430
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17f60
callq 0x3050
leaq 0x414d1(%rip), %r14     # 0x59438
movq (%r14), %rdi
testq %rdi, %rdi
je 0x17f74
callq 0x3050
leaq 0x414c5(%rip), %r15     # 0x59440
movq (%r15), %rdi
testq %rdi, %rdi
je 0x17f88
callq 0x3050
xorl %eax, %eax
movq %rax, (%r15)
movq %rax, (%r14)
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/misc.c
// Function: splice
char *
splice(char *string1,char *sep,char *string2)
{
    char splicebuf[1024];
    char *result = NULL;

    if(string1 == NULL)
        sep = string1 = NULLSTRING;
    if(string2 == NULL)
        string2 = NULLSTRING;
    snprintf(splicebuf,1024,"%s%s%s",string1,sep,string2);
    result = strdup(splicebuf);
    return(result);
}

// Assembly:
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rsi, %r8
movq %rdi, %rcx
testq %rdi, %rdi
leaq 0x2fd25(%rip), %r9      # 0x47cd6
cmoveq %r9, %rcx
cmoveq %r9, %r8
testq %rdx, %rdx
cmovneq %rdx, %r9
leaq 0x2df7d(%rip), %rdx     # 0x45f44
movq %rsp, %rbx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3130
movq %rbx, %rdi
callq 0x32b0
addq $0x400, %rsp            # imm = 0x400
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/print_maker.c
// Function: print_makertagid
void
print_makertagid(struct ifd_entry *entry_ptr,int width, char *sep,
                                                int make,int model)
{
    char *nameoftag;
    int chpr = 0;

    if(entry_ptr)
    {
        if((PRINT_TAGNAME))
        {
            nameoftag = maker_tagname(entry_ptr->tag,make,model);
            chpr = printf("%-*.*s",width,width,nameoftag);
        }
        else if(PRINT_HEX_TAGNO)
            chpr = printf("<%#06x>",entry_ptr->tag & 0xffff);
        else if(PRINT_DEC_TAGNO)
            chpr = printf("<%5u>",entry_ptr->tag & 0xffff);
        if(PRINT_VALUE)
            chpr += printf("%s",sep ? sep : " = ");
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1969a
movq %rdx, %rbx
leaq 0x3eb05(%rip), %r14     # 0x58180
movq (%r14), %rax
btl $0xc, %eax
jb 0x1969e
testb $0x1, %al
jne 0x196c4
xorl %ebp, %ebp
testb $0x2, %al
je 0x196d7
movzwl (%rdi), %esi
leaq 0x27f83(%rip), %rdi     # 0x4161b
jmp 0x196ce
xorl %ebp, %ebp
jmp 0x196fb
movl %esi, %ebp
movzwl (%rdi), %edi
movl %ecx, %esi
movl %r8d, %edx
callq 0x1c518
leaq 0x2f47d(%rip), %rdi     # 0x48b31
movl %ebp, %esi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3120
jmp 0x196d5
movzwl (%rdi), %esi
leaq 0x27f45(%rip), %rdi     # 0x41613
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
testb $0x30, (%r14)
je 0x196fb
testq %rbx, %rbx
leaq 0x30ec1(%rip), %rsi     # 0x4a5a8
cmovneq %rbx, %rsi
leaq 0x279a5(%rip), %rdi     # 0x41097
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x17a82