LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x137fe
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 0x13801
leaq 0x49ed8(%rip), %rax     # 0x5d670
testb $0x2, (%rax)
je 0x137ae
leaq 0x31893(%rip), %rdi     # 0x45037
movq %r13, %rsi
xorl %eax, %eax
callq 0x3120
movq %rbx, %rdi
callq 0x3150
cmpl $-0x1, %eax
je 0x137fe
movl %eax, %r14d
movq %rbx, %rdi
callq 0x3190
cmpq %r12, %rax
jae 0x137fe
cmpl $0xff, %r14d
jne 0x137ee
movq %rbx, %rdi
callq 0x3190
movq %rax, %r14
movq %rbx, %rdi
callq 0x3150
cmpl $0xd9, %eax
je 0x13838
movq %rbx, %rdi
callq 0x3150
movl %eax, %r14d
cmpl $-0x1, %eax
jne 0x137be
xorl %r14d, %r14d
leaq 0x49e68(%rip), %rax     # 0x5d670
testb $0x2, (%rax)
je 0x13826
movq %rbx, %rdi
callq 0x3190
leaq 0x31854(%rip), %rdi     # 0x45070
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 0x49e2e(%rip), %rax     # 0x5d670
testb $0x2, (%rax)
je 0x13801
leaq 0x44932(%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 0x13898
addl $0x2, %ebp
movl $0x80000, %edi          # imm = 0x80000
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x5605
movl $0x2, %edi
callq 0x5730
leaq 0x317c5(%rip), %rdi     # 0x45051
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x16b56
jmp 0x13801
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testl %esi, %esi
je 0x15e31
movl %ecx, %r15d
movq %r14, %rdi
callq 0x3190
addl $0x2, %r15d
leaq 0x2b2dc(%rip), %rcx     # 0x410dc
movl $0x100000, %edi         # imm = 0x100000
movq %rax, %rsi
movl %r15d, %edx
callq 0x5605
cmpl $0x5b, %ebp
je 0x15e1f
movl $0x2, %edi
callq 0x95c0
movl %ebp, %edi
callq 0x3060
movl $0x1, %r15d
xorl %r12d, %r12d
jmp 0x15e3a
xorl %r15d, %r15d
movl $0x1, %r12d
testl %ebp, %ebp
sete %r13b
movq %r14, %rdi
callq 0x3190
cmpq %rbx, %rax
setae %al
orb %r13b, %al
jne 0x15eb7
movq %r14, %rdi
callq 0x3150
movl %eax, %ebp
cmpl $0x9, %eax
jg 0x15e6d
cmpl $-0x1, %ebp
je 0x15e9f
testl %ebp, %ebp
je 0x15e9f
jmp 0x15e77
cmpl $0xa, %ebp
je 0x15e95
cmpl $0xd, %ebp
je 0x15ea5
callq 0x32d0
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x40, 0x1(%rax,%rcx,2)
je 0x15e90
movl %ebp, %edi
callq 0x3060
incl %r15d
jmp 0x15ea5
movq %r14, %rdi
callq 0x3150
movl %eax, %ebp
movl $0x1, %r12d
movq %r14, %rdi
callq 0x3190
cmpq %rbx, %rax
jae 0x15eb7
testl %r12d, %r12d
je 0x15e53
movl %r15d, %edi
callq 0x17530
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15f07
movq %r14, %rdi
callq 0x3150
movl %eax, %ebp
cmpl $0x5b, %eax
je 0x15f07
cmpl $-0x1, %ebp
je 0x15f07
movq %r14, %rdi
callq 0x3190
jmp 0x15ee4
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_O1/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 0xfe62
movq 0x8(%rbx), %r14
testl %eax, %eax
je 0x15fa6
addq 0x10(%rbx), %r15
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4832
testq %rax, %rax
je 0x15fd6
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 0x15fd8
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_O1/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 0x160bc
movl %eax, %ebx
xorl %ebp, %ebp
testq %r14, %r14
je 0x16009
movq %r14, %rdi
callq 0x168a2
addl %eax, %ebp
movq 0x8(%r14), %r14
jmp 0x15ff4
cmpl $0x0, 0x47538(%rip)     # 0x5d548
je 0x1601c
movl $0xa, %edi
callq 0x3060
movl $0x0, 0x47522(%rip)     # 0x5d548
callq 0x17aa7
leaq 0x4214e(%rip), %r14     # 0x58180
testl $0x1040000, (%r14)      # imm = 0x1040000
leaq 0x2f612(%rip), %rax     # 0x45652
leaq 0x2f61f(%rip), %rdi     # 0x45666
cmoveq %rax, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
subl %ebp, %ebx
je 0x1609b
orl 0x474ea(%rip), %eax     # 0x5d548
je 0x1606a
movl $0xa, %edi
callq 0x3060
movl $0x0, 0x474d4(%rip)     # 0x5d548
callq 0x17aa7
testl $0x1040000, (%r14)      # imm = 0x1040000
leaq 0x2f5f5(%rip), %rax     # 0x4567c
leaq 0x2f602(%rip), %rdi     # 0x45690
cmoveq %rax, %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0x3120
orl 0x474a7(%rip), %eax     # 0x5d548
je 0x160ad
movl $0xa, %edi
callq 0x3060
movl $0x0, 0x47491(%rip)     # 0x5d548
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/misc.c
// Function: newline
int
newline(int charsprinted)
{
    if((charsprinted != 0) || (Charsprinted != 0))
        putchar('\n');
    Charsprinted = 0;
    return(Charsprinted);
}

// Assembly:
orl 0x469ec(%rip), %edi     # 0x5d548
je 0x16b6d
pushq %rax
movl $0xa, %edi
callq 0x3060
addq $0x8, %rsp
movl $0x0, 0x469d1(%rip)     # 0x5d548
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30fa5(%rip), %rsi     # 0x47c96
testq %rdi, %rdi
je 0x16da5
movq 0x88(%rdi), %rax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
cmpq $0x18022, %rax          # imm = 0x18022
jg 0x16d26
cmpq $0x10002, %rax          # imm = 0x10002
jg 0x16d4c
cmpl $0x15b, %eax            # imm = 0x15B
je 0x16d7a
cmpl $0x10002, %eax          # imm = 0x10002
je 0x16d43
jmp 0x16da5
leaq -0x20001(%rax), %rcx
cmpq $0x3, %rcx
ja 0x16d63
leaq 0x2e7c2(%rip), %rax     # 0x454fc
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34374(%rip), %rsi     # 0x4b0be
jmp 0x16da5
cmpl $0x10003, %eax          # imm = 0x10003
je 0x16d83
cmpl $0x10006, %eax          # imm = 0x10006
jne 0x16da5
leaq 0x2f0d6(%rip), %rsi     # 0x45e37
jmp 0x16da5
cmpl $0x1884c, %eax          # imm = 0x1884C
je 0x16d9e
cmpl $0x18023, %eax          # imm = 0x18023
jne 0x16da5
leaq 0x2f0bb(%rip), %rsi     # 0x45e33
jmp 0x16da5
leaq 0x2bd46(%rip), %rsi     # 0x42ac7
jmp 0x16da5
leaq 0x2f0b3(%rip), %rsi     # 0x45e3d
jmp 0x16da5
leaq 0x2f0c0(%rip), %rsi     # 0x45e53
jmp 0x16da5
leaq 0x2f0b3(%rip), %rsi     # 0x45e4f
jmp 0x16da5
leaq 0x2f0a0(%rip), %rsi     # 0x45e45
cmpb $0x0, (%rsi)
je 0x16dbf
pushq %rax
leaq 0x2a2e4(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addq $0x8, %rsp
jmp 0x16dc1
xorl %eax, %eax
addl %eax, 0x46781(%rip)     # 0x5d548
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16e92
movq 0x80(%rdi), %rax
cmpq $0xffd7, %rax           # imm = 0xFFD7
jle 0x16e02
cmpq $0xd0a8709, %rax        # imm = 0xD0A8709
jg 0x16e28
cmpq $0xffd8, %rax           # imm = 0xFFD8
je 0x16e94
cmpq $0x4d524d, %rax         # imm = 0x4D524D
je 0x16e3e
jmp 0x16e92
cmpq $0x1a, %rax
je 0x16e56
cmpq $0x2a, %rax
je 0x16e3e
cmpq $0x4655, %rax           # imm = 0x4655
jne 0x16e92
movl 0xc8(%rdi), %eax
cmpl $0x1, %eax
leaq 0x2efcc(%rip), %rcx     # 0x45df2
jmp 0x16e66
cmpq $0xd0a870a, %rax        # imm = 0xD0A870A
je 0x16e9a
cmpq $0x62564f46, %rax       # imm = 0x62564F46
jne 0x16e92
popq %rax
jmp 0x17896
movslq 0xc8(%rdi), %rdi
callq 0x1755d
leaq 0x2a245(%rip), %rdi     # 0x41096
movq %rax, %rsi
jmp 0x16e85
movl 0xc8(%rdi), %eax
cmpl $0x1, %eax
leaq 0x2ed5e(%rip), %rcx     # 0x45bc4
leaq 0x30e29(%rip), %rdx     # 0x47c96
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x2eb53(%rip), %rsi     # 0x459cd
cmovneq %rdx, %rsi
leaq 0x2a211(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addl %eax, 0x466b6(%rip)     # 0x5d548
popq %rax
retq
popq %rax
jmp 0x17736
popq %rax
jmp 0x17784
// File: /workspace/github_c_makefile_star2_O1/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 0x16f7d
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
btl $0x1d, 0x88(%rdi)
leaq 0x30d8e(%rip), %rax     # 0x47c96
leaq 0x2ef81(%rip), %rbx     # 0x45e90
cmovaeq %rax, %rbx
movq 0x70(%rdi), %rsi
movq 0x78(%rdi), %rdx
leaq 0x2ef72(%rip), %rdi     # 0x45e94
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
cmpl $0x1, 0xc4(%r14)
jne 0x16f5d
movq 0x60(%r14), %rsi
cmpq 0x70(%r14), %rsi
ja 0x16f49
movq 0x68(%r14), %rax
cmpq 0x78(%r14), %rax
jbe 0x16f5d
movq 0x68(%r14), %rdx
leaq 0x2ef50(%rip), %rdi     # 0x45ea4
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movq 0x98(%r14), %rdx
leaq 0x2ef43(%rip), %rdi     # 0x45eae
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3120
addl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x16f7f
xorl %eax, %eax
addl %eax, 0x465c3(%rip)     # 0x5d548
retq
// File: /workspace/github_c_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x17055
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x14(%rdi), %eax
cmpl $0x2a, %eax
je 0x16fb3
movzwl 0x18(%rbx), %ecx
testl $0x3ff, %ecx            # imm = 0x3FF
jne 0x16fb3
cmpl $0x0, 0x20(%rbx)
je 0x17056
movl 0x11c(%rbx), %edx
testl %edx, %edx
js 0x16fdd
leaq 0x2eef9(%rip), %rdi     # 0x45ebd
leaq 0x2a23d(%rip), %rsi     # 0x41208
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
leaq 0x2a1bb(%rip), %rsi     # 0x41196
jmp 0x16fe6
xorl %ebp, %ebp
leaq 0x2a222(%rip), %rsi     # 0x41208
movl 0x120(%rbx), %edx
testl %edx, %edx
js 0x17007
leaq 0x2eecf(%rip), %rdi     # 0x45ec6
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
leaq 0x2a18f(%rip), %rsi     # 0x41196
cmpl $0x5, 0x118(%rbx)
jne 0x17027
leaq 0x2eebb(%rip), %rdi     # 0x45ed2
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
leaq 0x2a16f(%rip), %rsi     # 0x41196
cmpl $0x6, 0x118(%rbx)
jne 0x17040
leaq 0x2eea7(%rip), %rdi     # 0x45ede
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
testl %ebp, %ebp
leaq 0x8(%rsp), %rsp
popq %rbx
popq %rbp
je 0x17055
movl $0x29, %edi
jmp 0x3060
retq
xorl %ebp, %ebp
cmpl $0xffd8, %eax           # imm = 0xFFD8
jne 0x17040
cmpl $0x0, 0x1c(%rbx)
je 0x17040
leaq 0x2e84e(%rip), %rdi     # 0x458ba
leaq 0x2a195(%rip), %rsi     # 0x41208
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
testb $0x20, 0x19(%rbx)
je 0x17040
leaq 0x2e83f(%rip), %rdi     # 0x458c8
leaq 0x2a106(%rip), %rsi     # 0x41196
jmp 0x17037
// File: /workspace/github_c_makefile_star2_O1/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 0x41ca1(%rip), %rdx     # 0x591a0
movq (%rdx), %rax
leaq 0x2e463(%rip), %rcx     # 0x4596c
testq %rax, %rax
je 0x1752c
cmpl %edi, 0xc(%rdx)
je 0x1752b
addq $0x24, %rdx
movq -0xc(%rdx), %rax
testq %rax, %rax
je 0x1752c
leaq 0x18(%rdx), %rsi
cmpl %edi, (%rdx)
movq %rsi, %rdx
jne 0x17517
retq
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x177c0
movl 0xc8(%rdi), %eax
cmpb $0x1, %al
leaq 0x319e7(%rip), %rcx     # 0x4917f
leaq 0x319f2(%rip), %rsi     # 0x49191
cmoveq %rcx, %rsi
shrl $0x8, %eax
testb %al, %al
je 0x177d5
movzbl %al, %eax
cmpl $0x2, %eax
je 0x177cc
cmpl $0x1, %eax
jne 0x177de
leaq 0x2e5d9(%rip), %rdx     # 0x45d97
jmp 0x177e5
leaq 0x304cf(%rip), %rsi     # 0x47c96
movq %rsi, %rdx
jmp 0x177e5
leaq 0x2e5da(%rip), %rdx     # 0x45dad
jmp 0x177e5
leaq 0x2e5ab(%rip), %rdx     # 0x45d87
jmp 0x177e5
leaq 0x2e5de(%rip), %rdx     # 0x45dc3
pushq %rax
leaq 0x2e5eb(%rip), %rdi     # 0x45dd8
xorl %eax, %eax
callq 0x3120
addl %eax, 0x45d4e(%rip)     # 0x5d548
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1782b
movl 0xc8(%rdi), %eax
cmpl $0x1, %eax
leaq 0x2e3b3(%rip), %rcx     # 0x45bc4
leaq 0x3047e(%rip), %rdx     # 0x47c96
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x2e1a8(%rip), %rsi     # 0x459cd
cmovneq %rdx, %rsi
jmp 0x17832
leaq 0x30464(%rip), %rsi     # 0x47c96
pushq %rax
leaq 0x2985c(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addl %eax, 0x45d01(%rip)     # 0x5d548
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x17878
movl 0xc8(%rdi), %eax
cmpl $0x1, %eax
leaq 0x2e594(%rip), %rcx     # 0x45df2
leaq 0x30431(%rip), %rdx     # 0x47c96
cmoveq %rcx, %rdx
testl %eax, %eax
leaq 0x2e15b(%rip), %rsi     # 0x459cd
cmovneq %rdx, %rsi
jmp 0x1787f
leaq 0x30417(%rip), %rsi     # 0x47c96
pushq %rax
leaq 0x2980f(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addl %eax, 0x45cb4(%rip)     # 0x5d548
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x303f9(%rip), %rsi     # 0x47c96
testq %rdi, %rdi
je 0x178f3
movq 0x88(%rdi), %rax
cmpq $0x20001, %rax          # imm = 0x20001
jg 0x178ca
cmpq $0x10002, %rax          # imm = 0x10002
je 0x178e3
cmpq $0x20001, %rax          # imm = 0x20001
jne 0x178f3
leaq 0x2e548(%rip), %rsi     # 0x45e10
jmp 0x178f3
cmpq $0x20002, %rax          # imm = 0x20002
je 0x178ec
cmpq $0x20004, %rax          # imm = 0x20004
jne 0x178f3
leaq 0x2e2e3(%rip), %rsi     # 0x45bc4
jmp 0x178f3
leaq 0x2e0e3(%rip), %rsi     # 0x459cd
jmp 0x178f3
leaq 0x2e530(%rip), %rsi     # 0x45e23
pushq %rax
leaq 0x2979b(%rip), %rdi     # 0x41096
xorl %eax, %eax
callq 0x3120
addl %eax, 0x45c40(%rip)     # 0x5d548
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x17962
movq %rcx, %rbx
movq %rdi, %r14
cmpw $0x4, %r8w
je 0x17973
movzwl %r8w, %eax
cmpl $0x3, %eax
jne 0x17962
movzwl %si, %ebp
movq %r14, %rdi
movl %ebp, %esi
callq 0x4574
movzwl %ax, %r15d
cmpq $0x1, %rbx
je 0x17965
decq %rbx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x4574
movzwl %ax, %eax
addq %rax, %r15
decq %rbx
jne 0x17946
jmp 0x17965
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 0x46cc
movq %rax, %r15
cmpq $0x1, %rbx
je 0x17965
decq %rbx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x46cc
addq %rax, %r15
decq %rbx
jne 0x1798c
jmp 0x17965
// File: /workspace/github_c_makefile_star2_O1/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 0x41a2f(%rip), %rbx     # 0x59430
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17a0e
callq 0x3050
leaq 0x41a23(%rip), %r14     # 0x59438
movq (%r14), %rdi
testq %rdi, %rdi
je 0x17a22
callq 0x3050
leaq 0x41a17(%rip), %r15     # 0x59440
movq (%r15), %rdi
testq %rdi, %rdi
je 0x17a36
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_O1/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 0x30237(%rip), %r9      # 0x47c96
cmoveq %r9, %rcx
cmoveq %r9, %r8
testq %rdx, %rdx
cmovneq %rdx, %r9
leaq 0x2e48b(%rip), %rdx     # 0x45f00
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_O1/hfiguiere[P]exifprobe/print_maker.c
// Function: print_makertaginfo
void
print_makertaginfo(struct ifd_entry *entry_ptr,char *parent_name,
                                        int indent,int make,int model)
{
    char *nameoftag;
    char *nameof_value_type;
    int chpr = 0;

    if(entry_ptr)
    {
        if(PRINT_BOTH_TAGNO)
            chpr = printf("<%#06X=%5u> ",entry_ptr->tag & 0xffff,entry_ptr->tag & 0xffff);
        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_TAGNAME))
        {
            nameoftag = maker_tagname(entry_ptr->tag,make,model);
            if((PRINT_LONGNAMES))
                chpr += printf("%s.",parent_name);
            chpr += printf("%-*.*s",MAKERTAGWIDTH,MAKERTAGWIDTH,nameoftag);
        }
        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(Debug & NOTE_DEBUG)
        {
            chpr += printf(" %d:%d,%d ",model,getnoteversion(),getnotetagset());
        }
        if(PRINT_VALUE)
            chpr += printf(" = "); 
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18919
movl %r8d, %ebx
movl %ecx, %r12d
movq %rsi, %r15
movq %rdi, %r14
leaq 0x3f88a(%rip), %r13     # 0x58180
movq (%r13), %rax
movl %eax, %ecx
notl %ecx
testb $0x3, %cl
jne 0x18920
movzwl (%r14), %edx
leaq 0x2df13(%rip), %rdi     # 0x46821
movl %edx, %esi
xorl %eax, %eax
callq 0x3120
jmp 0x18949
xorl %ebp, %ebp
jmp 0x18a12
testb $0x1, %al
jne 0x18937
xorl %ebp, %ebp
testb $0x2, %al
je 0x1894b
movzwl (%r14), %esi
leaq 0x28cf9(%rip), %rdi     # 0x4162e
jmp 0x18942
movzwl (%r14), %esi
leaq 0x2deec(%rip), %rdi     # 0x4682e
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
testb $0x10, 0x1(%r13)
je 0x1899a
movzwl (%r14), %edi
movl %r12d, %esi
movl %ebx, %edx
callq 0x1c020
movq %rax, %r12
testb $0x40, (%r13)
je 0x1897d
leaq 0x2cb36(%rip), %rdi     # 0x454a7
movq %r15, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
leaq 0x3016d(%rip), %rdi     # 0x48af1
movl $0x19, %esi
movl $0x19, %edx
movq %r12, %rcx
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
testb $0x20, 0x1(%r13)
je 0x189c7
movzwl 0x2(%r14), %edi
callq 0x15f38
movzwl 0x2(%r14), %esi
movq 0x8(%r14), %rcx
leaq 0x2de7c(%rip), %rdi     # 0x46837
movq %rax, %rdx
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
leaq 0x44ca2(%rip), %rax     # 0x5d670
testb $0x8, (%rax)
je 0x189fb
xorl %eax, %eax
callq 0x1bfe0
movl %eax, %r14d
xorl %eax, %eax
callq 0x1bffe
leaq 0x2de60(%rip), %rdi     # 0x4684b
movl %ebx, %esi
movl %r14d, %edx
movl %eax, %ecx
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
testb $0x30, (%r13)
je 0x18a12
leaq 0x31b5f(%rip), %rdi     # 0x4a568
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 0x17530
// File: /workspace/github_c_makefile_star2_O1/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 0x19140
movq %rdx, %rbx
leaq 0x3f05f(%rip), %r14     # 0x58180
movq (%r14), %rax
btl $0xc, %eax
jb 0x19144
testb $0x1, %al
jne 0x1916a
xorl %ebp, %ebp
testb $0x2, %al
je 0x1917d
movzwl (%rdi), %esi
leaq 0x284dd(%rip), %rdi     # 0x4161b
jmp 0x19174
xorl %ebp, %ebp
jmp 0x191a1
movl %esi, %ebp
movzwl (%rdi), %edi
movl %ecx, %esi
movl %r8d, %edx
callq 0x1c020
leaq 0x2f997(%rip), %rdi     # 0x48af1
movl %ebp, %esi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3120
jmp 0x1917b
movzwl (%rdi), %esi
leaq 0x2849f(%rip), %rdi     # 0x41613
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
testb $0x30, (%r14)
je 0x191a1
testq %rbx, %rbx
leaq 0x313db(%rip), %rsi     # 0x4a568
cmovneq %rbx, %rsi
leaq 0x27eff(%rip), %rdi     # 0x41097
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x17530
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/print_maker.c
// Function: print_camera_makes
void
print_camera_makes()
{
    struct camera_name *maker_id;
    char *pattern,*model_pattern;
    int chpr = 0;

    chpr = newline(0);
    chpr += printf("Camera Makes:");
    chpr = newline(chpr);

    if(Camera_name_pattern)
    {
        pattern = Camera_name_pattern;
        if((model_pattern = strchr(pattern,'+')))
            *model_pattern++ = '\0';
        else
            model_pattern = NULL;

        /* 'Camera_make' is a global parameter                        */
        for(maker_id = Camera_make; maker_id && maker_id->name; ++maker_id)
        {
            if(pattern)
            {
                if(*pattern == '-')
                {
                    chpr += printf("\t%-32.32s [%d]",maker_id->name,maker_id->id);
                    chpr = newline(chpr);
                }
                else
                {
                    if((*pattern) && !STRCASESTR(maker_id->name,pattern))
                        continue;
                    chpr += printf("\t%-32.32s [%d]",maker_id->name,maker_id->id);
                    chpr = newline(chpr);
                    if(model_pattern)
                    {
                        if(*model_pattern)
                            print_camera_models(maker_id->model,model_pattern);
                        else
                            print_camera_models(maker_id->model,NULL);
                    }
                }
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %edi, %edi
callq 0x16b56
movl %eax, %ebx
leaq 0x2d1d0(%rip), %rdi     # 0x46b6a
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
movl %ebx, %edi
callq 0x16b56
movl %eax, %ebp
leaq 0x3faad(%rip), %rax     # 0x59460
movq (%rax), %rbx
testq %rbx, %rbx
je 0x19a7c
movq %rbx, %rdi
movl $0x2b, %esi
callq 0x3110
testq %rax, %rax
je 0x199dc
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x199df
xorl %r14d, %r14d
leaq 0x3f7ba(%rip), %r13     # 0x591a0
movq (%r13), %r12
testq %r12, %r12
je 0x19a7c
addq $0xc, %r13
leaq 0x2d17a(%rip), %r15     # 0x46b78
movzbl (%rbx), %eax
testl %eax, %eax
je 0x19a38
cmpl $0x2d, %eax
jne 0x19a28
movl (%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x16b56
movl %eax, %ebp
jmp 0x19a6f
movq %r12, %rdi
movq %rbx, %rsi
callq 0x19a8b
testq %rax, %rax
je 0x19a6f
movl (%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x16b56
movl %eax, %ebp
testq %r14, %r14
je 0x19a6f
cmpb $0x0, (%r14)
movq 0x4(%r13), %rdi
je 0x19a68
movq %r14, %rsi
jmp 0x19a6a
xorl %esi, %esi
callq 0x19afc
movq 0xc(%r13), %r12
addq $0x18, %r13
testq %r12, %r12
jne 0x199fe
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/print_maker.c
// Function: fake_strcasestr
char *
fake_strcasestr(char *string,char *pattern)
{
    char *match = CNULL;
    int plen,slen;

    if(string && pattern)
    {
        plen = strlen(pattern);
        if(plen == 0)
            match = string;
        else
        {
            slen = strlen(string);
            while(plen <= slen)
            {
                if(strncasecmp(string,pattern,plen) == 0)
                {
                    match = string;
                    break;
                }
                ++string;
                --slen;
            }
        }
    }
    return(match);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x19aed
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3100
movq %rax, %r15
testl %r15d, %r15d
je 0x19aef
movq %rbx, %rdi
callq 0x3100
movq %rax, %r12
cmpl %r15d, %r12d
jl 0x19aed
movslq %r15d, %r13
incl %r12d
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x31f0
testl %eax, %eax
je 0x19aef
incq %rbx
decl %r12d
cmpl %r15d, %r12d
jg 0x19ad0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/print_maker.c
// Function: print_camera_models
void
print_camera_models(struct camera_id *model_names,char *pattern)
{
    struct camera_id *maker_id;
    int chpr = 0;

    chpr = newline(0);
    for(maker_id = model_names ; maker_id && maker_id->name; ++maker_id)
    {
        if(pattern)
        {
            if(STRCASESTR(maker_id->name,pattern))
            {
                chpr += printf("\t\t%-32.32s ",maker_id->name);
                chpr += printf("\t[%2d,%d]",maker_id->id,
                                maker_id->noteversion);
                chpr = newline(chpr);
            }
        }
        else
        {
            chpr += printf("\t\t%-32.32s ",maker_id->name);
            chpr += printf("\t[%2d,%d]",maker_id->id,
                                maker_id->noteversion);
            chpr = newline(chpr);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x16b56
testq %r14, %r14
je 0x19b82
movq (%r14), %r13
testq %r13, %r13
je 0x19b82
movl %eax, %ebp
addq $0x18, %r14
leaq 0x2d059(%rip), %r15     # 0x46b87
leaq 0x2d05e(%rip), %r12     # 0x46b93
testq %rbx, %rbx
je 0x19b4a
movq %r13, %rdi
movq %rbx, %rsi
callq 0x19a8b
testq %rax, %rax
je 0x19b76
movq %r15, %rdi
movq %r13, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl -0xc(%r14), %esi
movl -0x8(%r14), %edx
movq %r12, %rdi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x16b56
movl %eax, %ebp
movq (%r14), %r13
addq $0x18, %r14
testq %r13, %r13
jne 0x19b35
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_generic.c
// Function: maker_number
int
maker_number(char *make)
{
    struct camera_name *maker_id;
    int number = NO_MAKE;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
sete %al
movq 0x3dfd4(%rip), %rsi     # 0x591a0
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x1b204
movq %rdi, %r14
leaq 0x3dfd6(%rip), %r15     # 0x591b8
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x1b200
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x1b1e2
jmp 0x1b204
movl -0xc(%r15), %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_generic.c
// Function: check_printable
char *
check_printable(char *id, int maxlen)
{
    static char buffer[MAX_IDLEN];
    char *idval,*bufval;
    int i = 0;

    memset(buffer,'\0',MAX_IDLEN);
    if(maxlen > MAX_IDLEN)
        maxlen = MAX_IDLEN;
    bufval = buffer;

    for(idval = id; idval && (i < maxlen - 1); ++idval,++bufval,++i)
        if(!isprint(*idval))
        {
            *bufval = '\0';
            break;
        }
        else
            *bufval = *idval;
    return(buffer);
}

// Assembly:
xorps %xmm0, %xmm0
movaps %xmm0, 0x417fa(%rip)    # 0x5d5d0
movq $0x0, 0x417ff(%rip) # 0x5d5e0
testq %rdi, %rdi
sete %al
cmpl $0x2, %esi
setl %cl
orb %al, %cl
jne 0x1be42
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x18, %esi
movl $0x18, %r14d
cmovll %esi, %r14d
callq 0x32d0
addl $-0x2, %r14d
incq %r14
xorl %ecx, %ecx
leaq 0x417b6(%rip), %rdx     # 0x5d5d0
movq (%rax), %rdi
movsbq (%rbx,%rcx), %rsi
testb $0x40, 0x1(%rdi,%rsi,2)
je 0x1be37
movb %sil, (%rcx,%rdx)
incq %rcx
cmpq %rcx, %r14
jne 0x1be1a
jmp 0x1be3b
movb $0x0, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
leaq 0x41787(%rip), %rax     # 0x5d5d0
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_generic.c
// Function: valid_tiffhdr
unsigned short
valid_tiffhdr(FILE *inptr,unsigned long offset,int print_marker)
{
    struct fileheader *header;
    unsigned short marker = 0;
    int chpr = 0;

    if(inptr && offset)
    {
        if(print_marker)
            chpr = printf(" read at offset %lu ",offset);
        header = read_imageheader(inptr,offset);
        if(header)
        {
            if(print_marker)
                chpr += printf(" %#x ",header->file_marker);
            switch(header->probe_magic)
            {
                case TIFF_MAGIC:
                    marker = header->file_marker;
                    break;
                default:
                    marker = 0;
                    break;
            }
        }
    }
    setcharsprinted(chpr);
    return(marker);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %r12d, %r12d
orb %al, %cl
movl $0x0, %ebx
jne 0x1bec8
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
je 0x1be8b
leaq 0x2bbd1(%rip), %rdi     # 0x47a4e
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
jmp 0x1be8d
xorl %ebx, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x418c
testq %rax, %rax
je 0x1bec5
movq %rax, %r14
testl %ebp, %ebp
je 0x1beb8
movzwl (%r14), %esi
leaq 0x293bd(%rip), %rdi     # 0x4526c
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
cmpq $0x2a, 0x8(%r14)
jne 0x1bec5
movzwl (%r14), %r12d
jmp 0x1bec8
xorl %r12d, %r12d
movl %ebx, %edi
callq 0x17530
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/maker_generic.c
// Function: invalid_ifd_entry
int
invalid_ifd_entry(FILE *inptr,unsigned long offset,unsigned long segment_size,
                    int nentries,unsigned short byteorder)
{
    struct ifd_entry *entry_ptr;
    int invalid = 0;

    if(inptr && offset && byteorder)
    {
        /* Read an entry at the given offset and see if has a valid   */
        /* type, and non-zero count.                                  */
        entry_ptr = read_ifd_entry(inptr,byteorder,offset);
        if((entry_ptr->value_type == 0) || (entry_ptr->value_type > DOUBLE) ||
            ferror(inptr) || feof(inptr))
                ++invalid;
        else if(entry_ptr->count == 0)
                ++invalid;
        
        /* If there is more than one entry, and the first appears     */
        /* valid, check the second entry.                             */
        /* If there is only one entry, and it appears valid, make     */
        /* sure that it's size fits within the note. This size check  */
        /* can fail on multi-entry notes when moronic makers write a  */
        /* thumbnail offset, then write the thumbnail outside the     */
        /* note...so we don't check size for multi.                   */
        if(nentries > 1)
        {
            if(invalid == 0)    /* double check                           */
            {
                entry_ptr = read_ifd_entry(inptr,byteorder,HERE);
                if((entry_ptr->value_type == 0) || (entry_ptr->value_type > DOUBLE) ||
                    ferror(inptr) || feof(inptr))
                        ++invalid;
                else if(entry_ptr->count == 0)
                        ++invalid;
            }
        }
        else if(entry_ptr->count > segment_size)
            ++invalid;
    }
    else
        ++invalid;
    return(invalid);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testl %r8d, %r8d
sete %al
movl $0x1, %ebx
orb %cl, %al
jne 0x1bfa6
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
movzwl %r8w, %r12d
movl %r12d, %esi
callq 0x4b9b
movq %rax, %r13
movzwl 0x2(%rax), %eax
addl $-0xd, %eax
movl $0x1, %ebx
cmpw $-0xc, %ax
jb 0x1bf4b
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x1bf4b
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
je 0x1bfb7
xorl %eax, %eax
cmpl $0x2, %ebp
jl 0x1bf9f
movl $0x1, %ebx
testb %al, %al
je 0x1bfa6
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %r12d, %esi
callq 0x4b9b
movq %rax, %r15
movzwl 0x2(%rax), %eax
addl $-0xd, %eax
cmpw $-0xc, %ax
jb 0x1bfa6
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x1bfa6
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
jne 0x1bfa6
xorl %ebx, %ebx
cmpq $0x0, 0x8(%r15)
sete %bl
jmp 0x1bfa6
cmpq 0x8(%r13), %r15
adcl $0x0, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
cmpq $0x0, 0x8(%r13)
setne %al
sete %bl
jmp 0x1bf4d
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/options.c
// Function: env_options
void
env_options()
{
    char *argv[MAXARGV];
    char *envopts;
    int argc;

    envopts = getenv("EXIFPROBE_OPTIONS");
    if(envopts && *envopts)
    {
        char *argstr = calloc(strlen(envopts) + 3, 1);
        strcpy(argstr, "e ");
        strcat(argstr, envopts);
        optind = 0;
        /* make an argument vector                                    */
        argc = vector(argstr, argv, " \t", 0, MAXARGV);
        (void)process_options(argc,argv);
        optind = 1;
        free(argstr);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
leaq 0x2b656(%rip), %rdi     # 0x47c82
callq 0x3030
testq %rax, %rax
je 0x1c6b1
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x1c6b1
movq %r14, %rdi
callq 0x3100
leaq 0x3(%rax), %rdi
movl $0x1, %esi
callq 0x3170
movq %rax, %rbx
movw $0x2065, (%rax)         # imm = 0x2065
movb $0x0, 0x2(%rax)
movq %rax, %rdi
movq %r14, %rsi
callq 0x3270
movq 0x3b95e(%rip), %r15     # 0x57fd0
movl $0x0, (%r15)
leaq 0x2b614(%rip), %rdx     # 0x47c94
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movl $0x100, %r8d            # imm = 0x100
xorl %eax, %eax
callq 0x270e8
movl %eax, %edi
movq %r14, %rsi
callq 0x1c16c
movl $0x1, (%r15)
movq %rbx, %rdi
callq 0x3050
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %r15
retq