LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/readfile.c
// Function: read_double
double
read_double(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    unsigned char rbuf[sizeof(double)];
    unsigned long curoffset;
    double value = 0.0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
            chpr += printf(" seek failed to offset %lu to read unsigned long\n",
                    offset);
        else if(fread(rbuf,1,sizeof(double),inptr) == sizeof(double))
            value = to_double(rbuf,byteorder);
        else
        {
            if(offset == HERE)
                offset = curoffset;
            PUSHCOLOR(RED);
            chpr += printf(" failed to read double value at offset %lu\n",offset);
            POPCOLOR();
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
testq %rdi, %rdi
je 0x4bcf
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
callq 0x31b0
movq %r12, %rdi
callq 0x3190
movq %rax, %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x4b77
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x4bbc
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x8
popq %rdx
movq %r12, %rcx
callq 0x30d0
cmpq $0x8, %rax
jne 0x4ba4
movzwl %bp, %esi
leaq 0x8(%rsp), %rdi
callq 0x4be8
movsd %xmm0, (%rsp)
jmp 0x4bcf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
cmovneq %r14, %r15
leaq 0x3a724(%rip), %rdi     # 0x3f2db
movq %r15, %rsi
jmp 0x4bc6
leaq 0x3a6b4(%rip), %rdi     # 0x3f277
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
movl %ebx, %edi
callq 0x16a4f
movsd (%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/readfile.c
// Function: ateof
int
ateof(FILE *inptr)
{
    int atend = 0;
    if(feof(inptr))
        atend++;
    else if(fgetc(inptr) == -1)
        atend++;
    return(atend);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x31a0
testl %eax, %eax
je 0x4c59
pushq $0x1
popq %rax
jmp 0x4c6b
movq %rbx, %rdi
callq 0x3150
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/readfile.c
// Function: get_filesize
unsigned long
get_filesize(FILE *inptr)
{
    unsigned long size = 0L;
    long current_offset;

    if(inptr)
    {
        clearerr(inptr);
        /* move back here after getting the size                      */
        current_offset = ftell(inptr);
        if(fseek(inptr,0L,SEEK_END) == 0)
        {
            size = ftell(inptr);
            if(fseek(inptr,current_offset,SEEK_SET) != 0)
                clearerr(inptr);    /* silently                       */
        }
        else
            size = 0L;
    }
    return(size);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x4cc4
movq %rdi, %rbx
callq 0x31b0
movq %rbx, %rdi
callq 0x3190
movq %rax, %r15
xorl %r14d, %r14d
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3210
testl %eax, %eax
jne 0x4cc7
movq %rbx, %rdi
callq 0x3190
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3210
testl %eax, %eax
je 0x4cc7
movq %rbx, %rdi
callq 0x31b0
jmp 0x4cc7
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/print.c
// Function: print_tiff_header
int
print_tiff_header(unsigned short magic,unsigned short byteorder,unsigned long section_id)
{
    char *name = CNULL;
    int status = -1;
    int chpr = 0;

    if(Print_options & section_id)
    {
        switch(magic)
        {
            case TIFF_MAGIC: name = "TIFF"; break;
            case ORF1_MAGIC: name = "ORF1"; break;
            case ORF2_MAGIC: name = "ORF2"; break;
            case RW2_MAGIC:  name = "RW2"; break;
            default: break;
        }

        if(name)
        {
            chpr += printf("%s",name);
            switch(byteorder)
            {
                case TIFF_INTEL:
                case TIFF_MOTOROLA:
                    print_byteorder(byteorder,1);
                    print_magic((unsigned long)magic,2);
                    status = 0;
                    break;
                default:
                    chpr += printf("INVALID %s BYTEORDER ",name);
                    print_byteorder(byteorder,1);
                    print_magic((unsigned long)magic,2);
                    break;
            }
        }
        else
        {
            chpr += printf("INVALID TIFF IDENTIFIER, byteorder ");
            print_byteorder(byteorder,1);
            print_magic((unsigned long)magic,2);
        }
    }
    else
        status = 0;

    setcharsprinted(chpr);
    return(status);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x5235b(%rip), %rax     # 0x57180
testq %rdx, (%rax)
je 0x4e58
movl %esi, %r12d
movzwl %di, %ebx
movzwl %r12w, %ebp
cmpw $0x2a, %bx
je 0x4e75
cmpl $0x55, %ebx
je 0x4e63
cmpl $0x5352, %ebx           # imm = 0x5352
je 0x4e6c
cmpl $0x4f52, %ebx           # imm = 0x4F52
jne 0x4eb9
leaq 0x3a27c(%rip), %r13     # 0x3f0d2
jmp 0x4e7c
xorl %r15d, %r15d
xorl %r14d, %r14d
jmp 0x4ee3
leaq 0x3eb2a(%rip), %r13     # 0x43994
jmp 0x4e7c
leaq 0x3a264(%rip), %r13     # 0x3f0d7
jmp 0x4e7c
leaq 0x3e463(%rip), %r13     # 0x432df
leaq 0x3a214(%rip), %rdi     # 0x3f097
xorl %r15d, %r15d
movq %r13, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %r14d
cmpw $0x4949, %r12w          # imm = 0x4949
je 0x4ece
cmpl $0x4d4d, %ebp           # imm = 0x4D4D
je 0x4ece
leaq 0x3a6a8(%rip), %rdi     # 0x3f552
movq %r13, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %r14d
jmp 0x4eca
leaq 0x3a6a8(%rip), %rdi     # 0x3f568
xorl %eax, %eax
callq 0x3120
movl %eax, %r14d
pushq $-0x1
popq %r15
pushq $0x1
popq %rsi
movl %ebp, %edi
callq 0x4efd
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x4f9c
movl %r14d, %edi
callq 0x16a4f
movl %r15d, %eax
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/print.c
// Function: print_byteorder
void
print_byteorder(unsigned short byteorder,int verbose)
{
    int chpr = 0;

    if(verbose == 1)
        chpr += printf("(");
    else if(verbose == 2)
        chpr += printf("\'");
    (void)show_string((char *)&byteorder,2,1);

    /* Check for a legitimate TIFF byteorder                          */
    if(verbose == 1)
    {
        switch(byteorder)
        {
            case TIFF_INTEL:
            case TIFF_MOTOROLA:
                chpr += printf("=%#06x)",byteorder);
                break;
            default:
                chpr +=printf("=%#06x=unknown)",byteorder);
                break;
        }
    }
    else if(verbose == 2)
        chpr += printf("\'");
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movl %edi, %ebp
movw %bp, 0xe(%rsp)
cmpl $0x1, %esi
jne 0x4f1d
leaq 0x3a2ee(%rip), %rdi     # 0x3f209
jmp 0x4f2c
xorl %ebx, %ebx
cmpl $0x2, %r14d
jne 0x4f35
leaq 0x3e065(%rip), %rdi     # 0x42f91
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
leaq 0xe(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x8e0f
cmpl $0x1, %r14d
jne 0x4f66
movzwl %bp, %esi
cmpw $0x4d4d, %bp            # imm = 0x4D4D
je 0x4f5d
cmpl $0x4949, %esi           # imm = 0x4949
jne 0x4f7c
leaq 0x3aae7(%rip), %rdi     # 0x3fa4b
jmp 0x4f83
cmpl $0x2, %r14d
jne 0x4f8c
leaq 0x3e01e(%rip), %rdi     # 0x42f91
xorl %eax, %eax
callq 0x3120
jmp 0x4f8a
leaq 0x3aad0(%rip), %rdi     # 0x3fa53
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
movl %ebx, %edi
callq 0x16a4f
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/print.c
// Function: print_tag_address
void
print_tag_address(unsigned long section_id,unsigned long address,int indent,char *prefix)
{
    int chpr = 0;

    if(Print_options & section_id)
    {
        print_filename();
        if(PRINT_INDENT_BEFORE_ADDRESS)
            putindent(indent);
        if(!prefix)
            prefix = "@";
        if(address == HERE)
        {
            /* special case; bland address field                      */
            if(PRINT_BOTH_ADDRESS)
                chpr += printf("%*s:  ",(ADDRWIDTH * 2) + 3,prefix);
            else if(PRINT_HEX_ADDRESS)
                chpr += printf("%*s:  ",ADDRWIDTH + 1,prefix);
            else if(PRINT_DEC_ADDRESS)
                chpr += printf("%*s:  ",ADDRWIDTH,prefix);
        }
        else
        {
            if(PRINT_BOTH_ADDRESS)
                chpr += printf("%s%#0*lx=%-*lu:  ",prefix,ADDRWIDTH+1,address,ADDRWIDTH,address);
            else if(PRINT_HEX_ADDRESS)
                chpr += printf("%s%#0*lx:  ",prefix,ADDRWIDTH+1,address);
            else if(PRINT_DEC_ADDRESS)
                chpr += printf("%s%-*lu:  ",prefix,ADDRWIDTH,address);
        }
        if(PRINT_INDENT_AFTER_ADDRESS)
            putindent(indent);
        setcharsprinted(chpr);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x52071(%rip), %r12     # 0x57180
testq %rdi, (%r12)
je 0x516a
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r14
xorl %eax, %eax
callq 0x16f7d
testb $0x20, 0x3(%r12)
je 0x5133
movl %ebx, %edi
callq 0x521b
testq %r15, %r15
leaq 0x39f9f(%rip), %rdx     # 0x3f0dc
cmovneq %r15, %rdx
movq (%r12), %rax
movl %eax, %ecx
andl $0x30000, %ecx          # imm = 0x30000
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpq %rsi, %r14
jne 0x5173
cmpl $0x30000, %ecx          # imm = 0x30000
jne 0x519d
leaq 0x3a436(%rip), %rdi     # 0x3f59c
pushq $0x13
jmp 0x51cd
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x30000, %ecx          # imm = 0x30000
jne 0x51b4
leaq 0x3a421(%rip), %rdi     # 0x3f5a3
pushq $0x9
popq %rax
pushq $0x8
popq %r8
movq %rdx, %rsi
movl %eax, %edx
movq %r14, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0x3120
jmp 0x51fb
btl $0x10, %eax
jb 0x51c4
btl $0x11, %eax
jae 0x51c0
leaq 0x3a3ec(%rip), %rdi     # 0x3f59c
pushq $0x8
jmp 0x51cd
btl $0x10, %eax
jb 0x51d7
btl $0x11, %eax
jb 0x51e2
xorl %ebp, %ebp
jmp 0x51fd
leaq 0x3a3d1(%rip), %rdi     # 0x3f59c
pushq $0x9
popq %rsi
xorl %eax, %eax
callq 0x3120
jmp 0x51fb
leaq 0x3a3d7(%rip), %rdi     # 0x3f5b5
pushq $0x9
jmp 0x51eb
leaq 0x3a3d8(%rip), %rdi     # 0x3f5c1
pushq $0x8
popq %rax
movq %rdx, %rsi
movl %eax, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
testb $0x10, 0x3(%r12)
je 0x520c
movl %ebx, %edi
callq 0x521b
movl %ebp, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x16a4f
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/print.c
// Function: putindent
void
putindent(int spaces)
{
    int spaces_left;

    if(spaces > MAXINDENT)
        spaces = MAXINDENT;
    spaces_left = spaces;
    while(spaces_left-- > 0)
        (void)putchar(' ');
    setcharsprinted(spaces);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x50, %edi
pushq $0x50
popq %rbx
cmovll %edi, %ebx
pushq $0x20
popq %rbp
movl %ebx, %r14d
testl %r14d, %r14d
jle 0x523f
decl %r14d
movl %ebp, %edi
callq 0x3060
jmp 0x522e
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x16a4f
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/print.c
// Function: print_tagid
void
print_tagid(struct ifd_entry *entry_ptr,int indent,int ifdtype)
{
    char *nameoftag;
    int chpr = 0;

    if(entry_ptr && (PRINT_ENTRY))
    {
        if(PRINT_TAGNAME || !(PRINT_TAGNO))
        {
            switch(ifdtype)
            {
                case GPS_IFD:
                    nameoftag = gps_tagname(entry_ptr->tag);
                    break;
                case INTEROP_IFD:
                    nameoftag = interop_tagname(entry_ptr->tag);
                    break;
                case EXIF_IFD:
                case TIFF_IFD:
                case TIFF_SUBIFD:
                default:
                    nameoftag = tagname(entry_ptr->tag);
                    break;
            }
            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);
    }
    setcharsprinted(chpr);
}

// Assembly:
movq %rdi, %rax
xorl %edi, %edi
testq %rax, %rax
je 0x16a4f
pushq %rax
leaq 0x50eb8(%rip), %rcx     # 0x57180
movq (%rcx), %rcx
testl $0x4003333, %ecx        # imm = 0x4003333
je 0x634b
btl $0xc, %ecx
setae %sil
testb $0x3, %cl
setne %r8b
testb %r8b, %sil
jne 0x62fe
movzwl (%rax), %eax
movzwl %ax, %edi
cmpl $0x3, %edx
je 0x6327
cmpl $0x4, %edx
jne 0x632e
callq 0xba69
jmp 0x6333
testb $0x1, %cl
jne 0x6314
testb $0x2, %cl
je 0x634b
movzwl (%rax), %esi
leaq 0x39309(%rip), %rdi     # 0x3f61b
jmp 0x631e
movzwl (%rax), %esi
leaq 0x392f5(%rip), %rdi     # 0x3f613
xorl %eax, %eax
callq 0x3120
jmp 0x6349
callq 0xb9bd
jmp 0x6333
callq 0xa1c8
leaq 0x407a7(%rip), %rdi     # 0x46ae1
pushq $0x1b
popq %rdx
movl %edx, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
addq $0x8, %rsp
jmp 0x16a4f
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/print.c
// Function: print_unicode
int
print_unicode(FILE *inptr,unsigned long count,unsigned long offset,unsigned short byteorder)
{
    int remaining;
    int nread;
    int ch = 0;
    int chpr = 0;

    nread = 0;
    if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
    {
        chpr += printf(" seek failed to offset %lu to print unicode",offset);
        chpr = newline(chpr);
    }

    remaining = count / 2;
    putchar('\''); ++chpr;
    while((remaining > 0) && !feof(inptr))
    {
        if(ch == 0)
            chpr += printf("\\0");
        else
            ch = read_ushort(inptr,byteorder,HERE);
        ++nread;
        ++chpr;
        --remaining;
        /* Write both bytes iff requested by user                     */
        if((PRINT_UNICODE))
            (void)fwrite((char *)&ch,2,1,stdout);
        else
            putchar(ch);
    }
    putchar('\''); ++chpr;
    if(ferror(inptr))
        clearerr(inptr);

    setcharsprinted(chpr);
    return(nread);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rsi, %r14
andl $0x0, 0x4(%rsp)
movq %rdi, %rbx
pushq $0x1
popq %rbp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rdx
je 0x6dc3
movq %rdx, %r15
movq %rbx, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
jne 0x6dc3
leaq 0x38aa4(%rip), %rdi     # 0x3f852
movq %r15, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x160f7
movl %eax, %ebp
incl %ebp
shrq %r14
pushq $0x27
popq %rdi
callq 0x3060
xorl %r15d, %r15d
movzwl %r12w, %r12d
leal (%r14,%r15), %eax
testl %eax, %eax
jle 0x6e59
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
jne 0x6e59
cmpl $0x0, 0x4(%rsp)
je 0x6e0b
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %r12d, %esi
callq 0x416a
movzwl %ax, %r13d
movl %r13d, 0x4(%rsp)
jmp 0x6e1e
xorl %r13d, %r13d
leaq 0x38a34(%rip), %rdi     # 0x3f849
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
leaq 0x5035b(%rip), %rax     # 0x57180
testb $0x40, 0x1(%rax)
jne 0x6e35
movl %r13d, %edi
callq 0x3060
jmp 0x6e4f
movq 0x5018c(%rip), %rax     # 0x56fc8
movq (%rax), %rcx
leaq 0x4(%rsp), %rdi
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
callq 0x32a0
incl %ebp
decl %r15d
jmp 0x6dd5
pushq $0x27
popq %rdi
callq 0x3060
movq %rbx, %rdi
callq 0x30b0
negl %r15d
testl %eax, %eax
je 0x6e78
movq %rbx, %rdi
callq 0x31b0
incl %ebp
movl %ebp, %edi
callq 0x16a4f
movl %r15d, %eax
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/print.c
// Function: show_string
int
show_string(char *string,int maxchars,int noquotes)
{
    int lastch;
    int chpr = 0;
    int indent = 0;
    int printed = 0;
    char *ch;

    if(string)
    {
        indent = charsprinted();
        lastch = 'A';
        if(!noquotes)
        {
            (void)putchar('\'');
            chpr++;
        }
        ch = string;
        while(printed < maxchars)
        {
            if(*ch == '\0')
            {
                printf("\\0");
                break;
            }
            else if(isprint(*ch))
            {
                if(isdigit(*ch) && (lastch == '\0'))
                    chpr += printf("00");
                (void)putchar(*ch);
                chpr++;
            }
            else if(*ch == '\n')
            {
                chpr = newline(chpr);
                putindent(indent);
            }
            else if(*ch == '\011')
            {
                putchar(*ch);
                ++ch;
            }
            else
                chpr += printf("\\%03o",(unsigned int)(*ch & 0xff));
            lastch = *ch;
            ++printed;
            ++ch;
        }
        if(!noquotes)
        {
            (void)putchar('\'');
            chpr++;
        }
    }
    setcharsprinted(chpr);
    return(printed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8f03
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x16f6e
movl %eax, 0x4(%rsp)
movl $0x0, %ebx
movl %r14d, (%rsp)
testl %r14d, %r14d
jne 0x8e52
pushq $0x27
popq %rdi
callq 0x3060
pushq $0x1
popq %rbx
testl %r15d, %r15d
cmovlel %ebp, %r15d
pushq $0x41
popq %rbp
xorl %r14d, %r14d
cmpl %r14d, %r15d
je 0x8f0a
movsbq (%r12), %r13
testq %r13, %r13
je 0x8f0f
callq 0x32d0
movq (%rax), %rax
movzwl (%rax,%r13,2), %eax
btl $0xe, %eax
jb 0x8eab
movzbl %r13b, %esi
cmpl $0x9, %esi
je 0x8ed6
cmpl $0xa, %esi
jne 0x8ee3
movl %ebx, %edi
callq 0x160f7
movl %eax, %ebx
movl 0x4(%rsp), %edi
callq 0x521b
jmp 0x8ef3
btl $0xb, %eax
jae 0x8ec9
testl %ebp, %ebp
jne 0x8ec9
leaq 0x3daeb(%rip), %rdi     # 0x469a7
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
movb (%r12), %r13b
movsbl %r13b, %edi
callq 0x3060
incl %ebx
jmp 0x8ef3
pushq $0x9
popq %rdi
callq 0x3060
incq %r12
jmp 0x8ef3
leaq 0x36962(%rip), %rdi     # 0x3f84c
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
movsbl (%r12), %ebp
incl %r14d
incq %r12
jmp 0x8e5f
xorl %ebx, %ebx
xorl %r14d, %r14d
jmp 0x8f2d
movl %r15d, %r14d
jmp 0x8f1d
leaq 0x36933(%rip), %rdi     # 0x3f849
xorl %eax, %eax
callq 0x3120
cmpl $0x0, (%rsp)
jne 0x8f2d
pushq $0x27
popq %rdi
callq 0x3060
incl %ebx
movl %ebx, %edi
callq 0x16a4f
movl %r14d, %eax
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/print.c
// Function: print_jpeg_status
void
print_jpeg_status()
{
    int status = 0;

    /* get and clear the status                                       */
    status = jpeg_status(status);

    if((PRINT_SEGMENT))
    {
        if(status == JPEG_NO_SOI)
            printred(" ### (JPEG_SOI NOT FOUND)");
        if(status == JPEG_HAD_ERROR)
            printred(" ### (INVALID JPEG MARKER)");
        else if(status == JPEG_NO_EOI)
            printred(" ### (JPEG_EOI NOT FOUND)");
        else if(status == JPEG_EARLY_EOI)
            printred(" (JPEG_EOI FOUND EARLY)");
    }
}

// Assembly:
pushq %rax
xorl %edi, %edi
callq 0x1259b
leaq 0x4e1bf(%rip), %rcx     # 0x57180
testb $0x8, 0x2(%rcx)
je 0x8fee
decl %eax
cmpl $0x7, %eax
ja 0x8fee
movl $0x8b, %ecx
btl %eax, %ecx
jae 0x8fee
movl %eax, %eax
leaq 0x364d3(%rip), %rcx     # 0x3f4b4
movslq (%rcx,%rax,4), %rdi
addq %rcx, %rdi
popq %rax
jmp 0x56e2
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x5100
leaq 0x4e162(%rip), %rax     # 0x57180
movq (%rax), %rax
cmpl $0x6, %r15d
ja 0x9073
movl %r15d, %ecx
leaq 0x3641b(%rip), %rdx     # 0x3f44c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
btl $0x12, %eax
jae 0x90bb
leaq 0x36a92(%rip), %rdi     # 0x3fad9
movl %ebx, %esi
jmp 0x9083
btl $0x12, %eax
jae 0x90bb
leaq 0x36acb(%rip), %rdi     # 0x3fb23
jmp 0x90c6
btl $0x12, %eax
jae 0x90bb
leaq 0x36ac8(%rip), %rdi     # 0x3fb2f
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
jmp 0x90cd
btl $0x12, %eax
jae 0x90bb
leaq 0x36ab5(%rip), %rdi     # 0x3fb35
movl %r15d, %esi
xorl %eax, %eax
callq 0x3120
jmp 0x90cd
btl $0x12, %eax
jae 0x90bb
leaq 0x36a4a(%rip), %rdi     # 0x3fae3
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3120
jmp 0x90cd
btl $0x12, %eax
jae 0x90bb
leaq 0x36a47(%rip), %rdi     # 0x3fafa
jmp 0x90c6
btl $0x12, %eax
jb 0x90bf
xorl %edi, %edi
jmp 0x90cf
leaq 0x36a4f(%rip), %rdi     # 0x3fb15
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x160f7
// File: /workspace/github_c_makefile_star2_O2/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 0x90f2
retq
pushq %rax
leaq 0x4f326(%rip), %rax     # 0x58420
movq (%rax), %rax
testq %rax, %rax
pushq $0x40
popq %rcx
cmovneq %rax, %rcx
cmpq %rdx, %rcx
cmovaeq %rdx, %rcx
andl $0x0, (%rsp)
pushq $0x10
popq %r8
callq 0x6e93
pushq $0x1
popq %rdi
popq %rax
jmp 0x160f7
// File: /workspace/github_c_makefile_star2_O2/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 0x9d0f
leaq 0x4d572(%rip), %r13     # 0x57180
testl $0x4003333, (%r13)      # imm = 0x4003333
je 0x9d0f
movl %ecx, %r15d
movq %rdx, %r14
movl %esi, %r12d
movq %rdi, %rbx
movl %r8d, %edi
callq 0x8f6f
movq (%r13), %rax
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
jne 0x9c52
movzwl (%rbx), %edx
leaq 0x359da(%rip), %rdi     # 0x3f621
movl %edx, %esi
xorl %eax, %eax
callq 0x3120
jmp 0x9c79
testb $0x2, %al
jne 0x9c68
xorl %ebp, %ebp
testb $0x1, %al
je 0x9c7b
movzwl (%rbx), %esi
leaq 0x359cf(%rip), %rdi     # 0x3f635
jmp 0x9c72
movzwl (%rbx), %esi
leaq 0x359bc(%rip), %rdi     # 0x3f62e
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
movq (%r13), %rax
btl $0xc, %eax
jae 0x9ccd
movzwl (%rbx), %esi
movzwl %r12w, %edx
movl %r15d, %edi
callq 0x9d40
movq %rax, %r15
testb $0x40, (%r13)
je 0x9cb1
leaq 0x39802(%rip), %rdi     # 0x434a7
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
leaq 0x3ce29(%rip), %rdi     # 0x46ae1
pushq $0x1b
popq %rdx
movl %edx, %esi
movq %r15, %rcx
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movq (%r13), %rax
btl $0xd, %eax
jae 0x9cfb
movzwl 0x2(%rbx), %edi
callq 0x155e0
movzwl 0x2(%rbx), %esi
movq 0x8(%rbx), %rcx
leaq 0x35958(%rip), %rdi     # 0x3f643
movq %rax, %rdx
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movq (%r13), %rax
testb $0x30, %al
je 0x9d0f
leaq 0x3e852(%rip), %rdi     # 0x48558
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 0x16a4f
// File: /workspace/github_c_makefile_star2_O2/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 0x9d5e
movzwl %dx, %esi
movl %ebx, %edi
callq 0x2e09f
movq %rax, %r14
testq %rax, %rax
jne 0x9dad
movb $0x0, 0x5276b(%rip)     # 0x5c4d0
leaq 0x52764(%rip), %r14     # 0x5c4d0
leaq 0x35f16(%rip), %rdx     # 0x3fc89
pushq $0xb
popq %rsi
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3130
cmpl $0xc, %eax
jl 0x9dad
leaq 0x35f05(%rip), %rdi     # 0x3fc93
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
movq 0x4d22a(%rip), %rax     # 0x56fc8
movq (%rax), %rdi
callq 0x16e8c
leaq 0x35f02(%rip), %r14     # 0x3fcaf
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %ebx, %ebx
testq %rdi, %rdi
je 0x9e6c
leaq 0x4d3ae(%rip), %r12     # 0x57180
testl $0x4003333, (%r12)      # imm = 0x4003333
je 0x9e6c
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movl %ecx, %edi
callq 0x8f6f
movq (%r12), %rax
btl $0xc, %eax
setae %cl
testb $0x3, %al
setne %dl
testb %dl, %cl
jne 0x9e2a
movzwl (%r14), %esi
movzwl %r15w, %edx
movl %ebp, %edi
callq 0x9d40
leaq 0x3ccc8(%rip), %rdi     # 0x46ae1
pushq $0x1b
popq %rdx
movl %edx, %esi
movq %rax, %rcx
xorl %eax, %eax
callq 0x3120
jmp 0x9e53
testb $0x1, %al
jne 0x9e41
xorl %ebx, %ebx
testb $0x2, %al
je 0x9e55
movzwl (%r14), %esi
leaq 0x357dc(%rip), %rdi     # 0x3f61b
jmp 0x9e4c
movzwl (%r14), %esi
leaq 0x357c7(%rip), %rdi     # 0x3f613
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
testb $0x30, (%r12)
je 0x9e6c
leaq 0x3e6f5(%rip), %rdi     # 0x48558
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x16a4f
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x1, %edi
je 0xba57
movl %edi, %ebx
cmpl $0x1002, %edi           # imm = 0x1002
je 0xb9f2
cmpl $0x1000, %ebx           # imm = 0x1000
je 0xba04
cmpl $0x1001, %ebx           # imm = 0x1001
je 0xb9fb
cmpl $0x2, %ebx
jne 0xba0d
leaq 0x361fa(%rip), %r14     # 0x41bea
jmp 0xba5e
leaq 0x36232(%rip), %r14     # 0x41c2b
jmp 0xba5e
leaq 0x36217(%rip), %r14     # 0x41c19
jmp 0xba5e
leaq 0x361f7(%rip), %r14     # 0x41c02
jmp 0xba5e
leaq 0x50adc(%rip), %r14     # 0x5c4f0
leaq 0x36223(%rip), %rdx     # 0x41c3e
pushq $0xb
popq %rsi
movq %r14, %rdi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x3130
cmpl $0xc, %eax
jl 0xba5e
leaq 0x3425d(%rip), %rdi     # 0x3fc93
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
movq 0x4b582(%rip), %rax     # 0x56fc8
movq (%rax), %rdi
callq 0x16e8c
leaq 0x3425a(%rip), %r14     # 0x3fcaf
jmp 0xba5e
leaq 0x36176(%rip), %r14     # 0x41bd4
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf123
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0xf116
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xf168
movl 0x10(%rbx), %ebp
testl %ebp, %ebp
jne 0xf17a
movq %rbx, %rdi
callq 0xf111
testq %rax, %rax
je 0xf177
movl 0x10(%rax), %edx
leal 0x1(%rdx), %esi
xorl %ecx, %ecx
testl %edx, %edx
cmovgl %esi, %ecx
movq (%rax), %rax
testq %rax, %rax
je 0xf16c
movl 0x10(%rax), %edx
leal 0x1(%rdx), %esi
cmpl %ecx, %edx
cmovgel %esi, %ecx
jmp 0xf153
xorl %ebp, %ebp
jmp 0xf17a
cmpl $0x2, %ecx
pushq $0x1
popq %rbp
cmovgel %ecx, %ebp
jmp 0xf17a
pushq $0x1
popq %rbp
leaq 0x4d4ef(%rip), %rax     # 0x5c670
testb $0x4, (%rax)
je 0xf1c0
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x160f7
leaq 0x33949(%rip), %rdi     # 0x42ae2
callq 0x56e2
leaq 0x33951(%rip), %rdi     # 0x42af6
movl %ebx, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x3120
movl %r14d, %edi
callq 0x160f7
movl %r14d, %edi
callq 0x160f7
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4993c(%rip), %rax     # 0x5c670
testb $0x4, (%rax)
je 0x12d45
leaq 0x2fdc2(%rip), %rdi     # 0x42b02
callq 0x56e2
testq %rbx, %rbx
je 0x12d6a
movq %rbx, %rdi
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x12d4a
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x12d6c
movq (%rdi), %rbx
callq 0x3050
movq %rbx, %rdi
jmp 0x12d58
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12e74
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 0x12e77
leaq 0x498bf(%rip), %rax     # 0x5c670
testb $0x2, (%rax)
je 0x12dc7
leaq 0x3027a(%rip), %rdi     # 0x43037
movq %r13, %rsi
xorl %eax, %eax
callq 0x3120
movq %rbx, %rdi
callq 0x3150
cmpl $-0x1, %eax
je 0x12e74
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3190
cmpq %r12, %rax
jae 0x12e74
cmpl $0xff, %r14d
jne 0x12dc7
movq %rbx, %rdi
callq 0x3190
movq %rax, %r14
movq %rbx, %rdi
callq 0x3150
cmpl $0xd9, %eax
jne 0x12dc7
decq %r14
leaq 0x49857(%rip), %rax     # 0x5c670
testb $0x2, (%rax)
je 0x12e77
leaq 0x4435b(%rip), %rax     # 0x57180
movq (%rax), %rax
testl $0x1040000, %eax        # imm = 0x1040000
sete %cl
btl $0x13, %eax
setae %al
xorl %edi, %edi
orb %cl, %al
jne 0x12e6d
addl $0x2, %ebp
movl $0x80000, %edi          # imm = 0x80000
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x5100
pushq $0x2
popq %rdi
callq 0x521b
leaq 0x301f0(%rip), %rdi     # 0x43051
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x160f7
jmp 0x12e77
xorl %r14d, %r14d
leaq 0x497f2(%rip), %rax     # 0x5c670
testb $0x2, (%rax)
je 0x12e9c
movq %rbx, %rdi
callq 0x3190
leaq 0x301de(%rip), %rdi     # 0x43070
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
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testl %esi, %esi
setne %r12b
je 0x15509
movl %ecx, %r15d
movq %r14, %rdi
callq 0x3190
addl $0x2, %r15d
leaq 0x29bfd(%rip), %rcx     # 0x3f0dc
movl $0x100000, %edi         # imm = 0x100000
movq %rax, %rsi
movl %r15d, %edx
callq 0x5100
cmpl $0x5b, %ebp
je 0x154fc
pushq $0x2
popq %rdi
callq 0x8f6f
movl %ebp, %edi
callq 0x3060
pushq $0x1
popq %r15
jmp 0x1550c
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x3190
testb $0x1, %r12b
je 0x1556f
cmpq %rbx, %rax
jae 0x1556f
movq %r14, %rdi
callq 0x3150
movl %eax, %ebp
cmpl $-0x1, %eax
je 0x1556a
movb $0x1, %r12b
cmpl $0xd, %ebp
je 0x1550c
cmpl $0xa, %ebp
je 0x15560
testl %ebp, %ebp
je 0x1556a
callq 0x32d0
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
je 0x15558
movl %ebp, %edi
callq 0x3060
incl %r15d
movb $0x1, %r12b
jmp 0x1550c
movq %r14, %rdi
callq 0x3150
movl %eax, %ebp
xorl %r12d, %r12d
jmp 0x1550c
movl %r15d, %edi
callq 0x16a4f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rbp
movq %r14, %rdi
callq 0x3190
cmpq %rbx, %rax
jae 0x155b0
movq %r14, %rdi
callq 0x3150
movl %eax, %ebp
cmpl $0x5b, %eax
je 0x155b0
cmpl $-0x1, %ebp
jne 0x1558f
movq %r14, %rdi
callq 0x3190
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovbl %ebp, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0xf1c7
testl %eax, %eax
je 0x15642
movq 0x8(%rbx), %rsi
addq 0x10(%rbx), %r14
movq %r15, %rdi
movq %r14, %rdx
callq 0x4410
testq %rax, %rax
je 0x15665
movq 0x8(%rbx), %rsi
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3160
movq 0x8(%rbx), %r14
leaq 0x1(%r14), %rdi
pushq $0x1
popq %rsi
callq 0x3170
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x15667
movb 0x10(%rbx,%rcx), %dl
movb %dl, (%rax,%rcx)
incq %rcx
jmp 0x15654
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15704
movl %eax, %ebx
xorl %ebp, %ebp
testq %r14, %r14
je 0x15692
movq %r14, %rdi
callq 0x15e80
addl %eax, %ebp
movq 0x8(%r14), %r14
jmp 0x1567d
xorl %edi, %edi
callq 0x160f7
callq 0x16f7d
leaq 0x41adb(%rip), %r14     # 0x57180
testl $0x1040000, (%r14)      # imm = 0x1040000
leaq 0x2df9f(%rip), %rax     # 0x43652
leaq 0x2dfac(%rip), %rdi     # 0x43666
cmoveq %rax, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
subl %ebp, %ebx
je 0x156f9
movl %eax, %edi
callq 0x160f7
callq 0x16f7d
testl $0x1040000, (%r14)      # imm = 0x1040000
leaq 0x2df97(%rip), %rax     # 0x4367c
leaq 0x2dfa4(%rip), %rdi     # 0x43690
cmoveq %rax, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x160f7
// File: /workspace/github_c_makefile_star2_O2/hfiguiere[P]exifprobe/misc.c
// Function: newline
int
newline(int charsprinted)
{
    if((charsprinted != 0) || (Charsprinted != 0))
        putchar('\n');
    Charsprinted = 0;
    return(Charsprinted);
}

// Assembly:
orl 0x4644b(%rip), %edi     # 0x5c548
je 0x1610c
pushq %rax
pushq $0xa
popq %rdi
callq 0x3060
addq $0x8, %rsp
andl $0x0, 0x46435(%rip)     # 0x5c548
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2f9e9(%rip), %rsi     # 0x45c86
testq %rdi, %rdi
je 0x1633f
movq 0x88(%rdi), %rax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
leaq -0x20001(%rax), %rcx
cmpq $0x3, %rcx
jbe 0x162f2
cmpl $0x15b, %eax            # imm = 0x15B
je 0x16338
cmpl $0x10002, %eax          # imm = 0x10002
je 0x16302
cmpl $0x10003, %eax          # imm = 0x10003
je 0x1630b
cmpl $0x10006, %eax          # imm = 0x10006
je 0x1632f
cmpl $0x1884c, %eax          # imm = 0x1884C
je 0x1631d
cmpl $0x18023, %eax          # imm = 0x18023
jne 0x1633f
leaq 0x2db43(%rip), %rsi     # 0x43e33
jmp 0x1633f
leaq 0x2d203(%rip), %rax     # 0x434fc
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x32da5(%rip), %rsi     # 0x490ae
jmp 0x1633f
leaq 0x2db2b(%rip), %rsi     # 0x43e3d
jmp 0x1633f
leaq 0x2db38(%rip), %rsi     # 0x43e53
jmp 0x1633f
leaq 0x2db21(%rip), %rsi     # 0x43e45
jmp 0x1633f
leaq 0x2db22(%rip), %rsi     # 0x43e4f
jmp 0x1633f
leaq 0x2db01(%rip), %rsi     # 0x43e37
jmp 0x1633f
leaq 0x2a788(%rip), %rsi     # 0x40ac7
cmpb $0x0, (%rsi)
je 0x16359
pushq %rax
leaq 0x28d4a(%rip), %rdi     # 0x3f096
xorl %eax, %eax
callq 0x3120
addq $0x8, %rsp
jmp 0x1635b
xorl %eax, %eax
addl %eax, 0x461e7(%rip)     # 0x5c548
retq