LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1707a
movl %eax, %ebx
leaq 0x2ccc6(%rip), %rdi     # 0x46baa
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
movl %ebx, %edi
callq 0x1707a
movl %eax, %ebp
leaq 0x3f563(%rip), %rax     # 0x59460
movq (%rax), %rbx
testq %rbx, %rbx
je 0x19fc6
movq %rbx, %rdi
movl $0x2b, %esi
callq 0x3110
testq %rax, %rax
je 0x19f26
movq %rax, %r14
incq %r14
movb $0x0, (%rax)
jmp 0x19f29
xorl %r14d, %r14d
leaq 0x3f270(%rip), %r13     # 0x591a0
movq (%r13), %r12
testq %r12, %r12
je 0x19fc6
addq $0xc, %r13
leaq 0x2cc70(%rip), %r15     # 0x46bb8
movzbl (%rbx), %eax
testl %eax, %eax
je 0x19f82
cmpl $0x2d, %eax
jne 0x19f72
movl (%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x1707a
movl %eax, %ebp
jmp 0x19fb9
movq %r12, %rdi
movq %rbx, %rsi
callq 0x19fd5
testq %rax, %rax
je 0x19fb9
movl (%r13), %edx
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x1707a
movl %eax, %ebp
testq %r14, %r14
je 0x19fb9
cmpb $0x0, (%r14)
movq 0x4(%r13), %rdi
je 0x19fb2
movq %r14, %rsi
jmp 0x19fb4
xorl %esi, %esi
callq 0x1a046
movq 0xc(%r13), %r12
addq $0x18, %r13
testq %r12, %r12
jne 0x19f48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1a037
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3100
movq %rax, %r15
testl %r15d, %r15d
je 0x1a039
movq %rbx, %rdi
callq 0x3100
movq %rax, %r12
cmpl %r15d, %r12d
jl 0x1a037
movslq %r15d, %r13
incl %r12d
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x31f0
testl %eax, %eax
je 0x1a039
incq %rbx
decl %r12d
cmpl %r15d, %r12d
jg 0x1a01a
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1707a
testq %r14, %r14
je 0x1a0cc
movq (%r14), %r13
testq %r13, %r13
je 0x1a0cc
movl %eax, %ebp
addq $0x18, %r14
leaq 0x2cb4f(%rip), %r15     # 0x46bc7
leaq 0x2cb54(%rip), %r12     # 0x46bd3
testq %rbx, %rbx
je 0x1a094
movq %r13, %rdi
movq %rbx, %rsi
callq 0x19fd5
testq %rax, %rax
je 0x1a0c0
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 0x1707a
movl %eax, %ebp
movq (%r14), %r13
addq $0x18, %r14
testq %r13, %r13
jne 0x1a07f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x3da4f(%rip), %rsi     # 0x591a0
testq %rsi, %rsi
sete %cl
xorl %ebx, %ebx
orb %al, %cl
jne 0x1b789
movq %rdi, %r14
leaq 0x3da51(%rip), %r15     # 0x591b8
movslq -0x10(%r15), %rdx
movq %r14, %rdi
callq 0x31f0
testl %eax, %eax
je 0x1b785
movq (%r15), %rsi
addq $0x18, %r15
testq %rsi, %rsi
jne 0x1b767
jmp 0x1b789
movl -0xc(%r15), %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x4130a(%rip)    # 0x5d5d0
movq $0x0, 0x4130f(%rip) # 0x5d5e0
testq %rdi, %rdi
sete %al
cmpl $0x2, %esi
setl %cl
orb %al, %cl
jne 0x1c32e
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x18, %esi
movl $0x18, %r14d
cmovbl %esi, %r14d
callq 0x32d0
decq %r14
xorl %ecx, %ecx
leaq 0x412ca(%rip), %rdx     # 0x5d5d0
movq (%rax), %rdi
movsbq (%rbx,%rcx), %rsi
testb $0x40, 0x1(%rdi,%rsi,2)
je 0x1c323
movb %sil, (%rcx,%rdx)
incq %rcx
cmpq %rcx, %r14
jne 0x1c306
jmp 0x1c327
movb $0x0, (%rcx,%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
leaq 0x4129b(%rip), %rax     # 0x5d5d0
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %ebp, %ebp
orb %al, %cl
movl $0x0, %ebx
jne 0x1c3bf
movq %rsi, %r14
movq %rdi, %r15
testl %edx, %edx
je 0x1c39b
leaq 0x2b729(%rip), %rdi     # 0x47a8e
xorl %ebp, %ebp
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
movq %r15, %rdi
movq %r14, %rsi
callq 0x41ac
testq %rax, %rax
je 0x1c3bf
movq %rax, %r14
movzwl (%rax), %esi
leaq 0x28f20(%rip), %rdi     # 0x452b0
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
jmp 0x1c3b0
movq %r15, %rdi
movq %r14, %rsi
callq 0x41ac
xorl %ebx, %ebx
testq %rax, %rax
je 0x1c3bd
movq %rax, %r14
cmpq $0x2a, 0x8(%r14)
jne 0x1c3bd
movzwl (%r14), %ebp
jmp 0x1c3bf
xorl %ebp, %ebp
movl %ebx, %edi
callq 0x17a82
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1c49e
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
movzwl %r8w, %r12d
movl %r12d, %esi
callq 0x4bcc
movq %rax, %r13
movzwl 0x2(%rax), %eax
addl $-0xd, %eax
movl $0x1, %ebx
cmpw $-0xc, %ax
jb 0x1c443
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x1c443
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
je 0x1c4af
xorl %eax, %eax
cmpl $0x2, %ebp
jl 0x1c497
movl $0x1, %ebx
testb %al, %al
je 0x1c49e
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %r12d, %esi
callq 0x4bcc
movq %rax, %r15
movzwl 0x2(%rax), %eax
addl $-0xd, %eax
cmpw $-0xc, %ax
jb 0x1c49e
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x1c49e
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
jne 0x1c49e
xorl %ebx, %ebx
cmpq $0x0, 0x8(%r15)
sete %bl
jmp 0x1c49e
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 0x1c445
// File: /workspace/github_c_makefile_star2_O3/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 0x2b189(%rip), %rdi     # 0x47cc2
callq 0x3030
testq %rax, %rax
je 0x1cbbe
movq %rax, %r14
cmpb $0x0, (%rax)
je 0x1cbbe
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 0x3b451(%rip), %r15     # 0x57fd0
movl $0x0, (%r15)
leaq 0x2b147(%rip), %rdx     # 0x47cd4
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
movl $0x100, %r8d            # imm = 0x100
xorl %eax, %eax
callq 0x27854
movl %eax, %edi
movq %r14, %rsi
callq 0x1c664
movl $0x1, (%r15)
movq %rbx, %rdi
callq 0x3050
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/options.c
// Function: print_version
void
print_version()
{
    printf("\tProgram: '%s' version %s",Progname,Program_version);
    if(PATCHLEVEL > 0)
        printf(" patchlevel %d",PATCHLEVEL);
    (void)putchar('\n');
    if(Comptime)
        printf("\tCompiled: %s\n",Comptime);
    printf("\t%s\n",Copyright);
    printf("\t\t(open source; see LICENSE.EXIFPROBE)\n");
}

// Assembly:
pushq %rax
leaq 0x3c620(%rip), %rax     # 0x59468
movq (%rax), %rsi
movq 0x3c596(%rip), %rdx     # 0x593e8
leaq 0x2aea0(%rip), %rdi     # 0x47cf9
xorl %eax, %eax
callq 0x3120
movl $0xa, %edi
callq 0x3060
leaq 0x3c587(%rip), %rax     # 0x593f8
movq (%rax), %rsi
testq %rsi, %rsi
je 0x1ce87
leaq 0x2ae93(%rip), %rdi     # 0x47d13
xorl %eax, %eax
callq 0x3120
movq 0x3c552(%rip), %rsi     # 0x593e0
leaq 0x2ae8d(%rip), %rdi     # 0x47d22
xorl %eax, %eax
callq 0x3120
leaq 0x2b708(%rip), %rdi     # 0x485ab
popq %rax
jmp 0x30a0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/ciff.c
// Function: process_ciff
unsigned long
process_ciff(FILE *inptr,struct fileheader *header,unsigned long fileoffset_base,
                        unsigned long heaplength,struct image_summary *summary_entry,
                        char *parent_name,int level,int indent)
{
    struct ciff_header *ciffheader;
    unsigned long max_offset = 0UL;
    unsigned short byteorder = 0;
    unsigned long heap_start = 0UL;
    unsigned long offset_table_end = 0UL;

    if(inptr)
    {
        if(header)
        {
            if(header->ciff_header)
            {
                ciffheader = header->ciff_header;
                byteorder = ciffheader->byteorder;
                heap_start = fileoffset_base + ciffheader->headerlength;
                if(heaplength)
                    offset_table_end = fileoffset_base + heaplength;
                else if(fseek(inptr,0L,SEEK_END) == 0)
                    offset_table_end = ftell(inptr);
                if(ferror(inptr) == 0)
                {
                    max_offset = process_ciff_dir(inptr,heap_start,offset_table_end,
                                                    ciffheader->subtype,parent_name,
                                                    summary_entry,byteorder,
                                                    level,indent);
                    if(max_offset > 0L)
                        max_offset += 4;
                }
                else
                    fprintf(stderr,"%s: cannot read offset table\n",Progname);
            }
            else
                fprintf(stderr,"%s: null ciffheader to process_ciff()\n",Progname);
        }
        else
            fprintf(stderr,"%s: null fileheader to process_ciff()\n",Progname);
    }
    else
        fprintf(stderr,"%s: no open file pointer to read Print Image data\n",
                Progname);

    return(max_offset);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1cf6d
testq %rsi, %rsi
je 0x1cf74
movq 0x10(%rsi), %r13
testq %r13, %r13
je 0x1cf7b
movq %rcx, %r12
movq %rdi, %r15
movq %r9, %r14
movq %r8, (%rsp)
movzwl (%r13), %ebx
movq 0x8(%r13), %rbp
addq %rdx, %rbp
testq %rcx, %rcx
je 0x1cef9
addq %rdx, %r12
jmp 0x1cf1a
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3210
testl %eax, %eax
jne 0x1cf1a
movq %r15, %rdi
callq 0x3190
movq %rax, %r12
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x1cf82
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %r10d
addq $0x15, %r13
subq $0x8, %rsp
movzwl %bx, %r11d
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %r14, %r8
movq 0x8(%rsp), %r9
pushq %rax
pushq %r10
pushq %r11
callq 0x1cf98
addq $0x20, %rsp
movq %rax, %rcx
addq $0x4, %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
jmp 0x1cf89
callq 0x349f
jmp 0x1cf87
callq 0x347d
jmp 0x1cf87
callq 0x345b
jmp 0x1cf87
callq 0x3439
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/ciff.c
// Function: read_ciff_direntry
struct ciff_direntry *
read_ciff_direntry(FILE *inptr,struct ciff_direntry *entry,unsigned short byteorder,unsigned long offset)
{
    if(inptr)
    {
        if(entry == NULL)
            entry = (struct ciff_direntry *)malloc(sizeof(struct ciff_direntry));
        if(entry)
        {
            memset(entry,0,sizeof(struct ciff_direntry));
            entry->type = read_ushort(inptr,byteorder,offset);
            entry->length = read_ulong(inptr,byteorder,offset + 2);
            entry->offset = read_ulong(inptr,byteorder,offset + 6);
        }
    }
    return(entry);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x1d65c
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %r15
testq %rbx, %rbx
jne 0x1d614
movl $0x18, %edi
callq 0x31e0
movq %rax, %rbx
testq %rax, %rax
je 0x1d66a
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movzwl %bp, %ebp
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x45af
movw %ax, (%rbx)
leaq 0x2(%r14), %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x8(%rbx)
addq $0x6, %r14
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4707
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
jmp 0x1d65c
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/ciff.c
// Function: print_ciff_value
void
print_ciff_value(FILE *inptr,struct ciff_direntry *entry, unsigned short byteorder,
                            unsigned long fileoffset_base,unsigned long entry_offset,
                            char *dirname,struct image_summary *summary_entry,
                            int level,int indent)
{
    unsigned short location;
    unsigned long max_dir_offset = 0;
    int chpr = 0;

    location = entry->type & CIFF_LOCATIONMASK;
    if(location == CIFF_INREC)
    {
        /* chpr += printf("INREC"); */
        max_dir_offset = process_ciff_direntry(inptr,CIFF_INREC,byteorder,entry,
                                        entry_offset,dirname,summary_entry,level,
                                        indent);
    }
    else if(PRINT_SECTION)
    {
        if(PRINT_BOTH_OFFSET)
            chpr += printf("@%#lx=%lu",entry->offset + fileoffset_base,
                    entry->offset + fileoffset_base);
        else if(PRINT_HEX_OFFSET)
            chpr += printf("@%#lx",entry->offset + fileoffset_base);
        else /* default to decimal offset if nothing is selected      */
            chpr += printf("@%lu",entry->offset + fileoffset_base);

        if(fileoffset_base && (PRINT_ENTRY_RELOFFSET))
            chpr += printf(" (%lu) ",entry->offset);
        chpr = newline(chpr);
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzwl (%rsi), %eax
andl $0xc000, %eax           # imm = 0xC000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x1fd7d
movl 0x40(%rsp), %eax
movl 0x38(%rsp), %r10d
subq $0x8, %rsp
movzwl %dx, %edx
movl $0x4000, %esi           # imm = 0x4000
movq %rbx, %rcx
pushq %rax
pushq %r10
pushq 0x48(%rsp)
callq 0x1d66e
addq $0x20, %rsp
xorl %edi, %edi
jmp 0x1fe07
leaq 0x383fc(%rip), %r15     # 0x58180
movq (%r15), %rax
xorl %edi, %edi
btl $0x12, %eax
jae 0x1fe07
movq %rcx, %r14
movl %eax, %ecx
notl %ecx
testl $0x300, %ecx            # imm = 0x300
jne 0x1fdb8
movq 0x10(%rbx), %rdx
addq %r14, %rdx
leaq 0x254a5(%rip), %rdi     # 0x45251
movq %rdx, %rsi
xorl %eax, %eax
callq 0x3120
jmp 0x1fddc
movq 0x10(%rbx), %rsi
addq %r14, %rsi
btl $0x8, %eax
jb 0x1fdce
leaq 0x28a60(%rip), %rdi     # 0x4882c
jmp 0x1fdd5
leaq 0x25489(%rip), %rdi     # 0x4525e
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
testq %r14, %r14
je 0x1fdfe
testb $0x4, 0x3(%r15)
je 0x1fdfe
movq 0x10(%rbx), %rsi
leaq 0x217fb(%rip), %rdi     # 0x415f0
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x1707a
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/ciff.c
// Function: print_ciffinrecdata
unsigned long
print_ciffinrecdata(FILE *inptr,unsigned short byteorder,char *tagname,
                                unsigned long offset,unsigned long dirlength,
                                unsigned short data_format,int indent)
{
    unsigned long end_offset = 0UL;
    unsigned short count;
    int chpr = 0;

    if(inptr)
    {
        end_offset = offset + dirlength;
        if((PRINT_VALUE))
        {
            count = dirlength;
            chpr = count;
            switch(data_format)
            {
                case 0x1000:    /* DC_USHORT                          */
                            print_ushort(inptr,count/2,byteorder,offset);
                            break;
                case 0x1800:    /* DC_UINT32:                         */
                            print_ulong(inptr,count/4,byteorder,offset);
                            break;
                case 0x0800:    /* DC_ASCII:                          */
                            print_ascii(inptr,count,offset); 
                            break;
                case 0x0000:    /* DC_BYTE:                           */
                            print_ubytes(inptr,count,offset);
                            break;
                default:
                            chpr += printf("(data format %#x)",data_format);
                            break;
            }
            setcharsprinted(chpr);
        }
    }
    return(end_offset);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x20458
leaq (%r8,%rcx), %rbx
leaq 0x37d5d(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x204a6
movzwl %r8w, %ebp
movzwl %r9w, %eax
movl %eax, %edx
roll $0x15, %edx
cmpl $0x3, %edx
ja 0x2048d
leaq 0x28263(%rip), %rax     # 0x486a4
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movzwl %r8w, %esi
movq %rcx, %rdx
callq 0x79c7
jmp 0x2049f
xorl %ebx, %ebx
jmp 0x204a6
movl %ebp, %eax
shrl %eax
movzwl %si, %edx
movq %rax, %rsi
callq 0x7dcb
jmp 0x2049f
movl %ebp, %eax
shrl $0x2, %eax
movzwl %si, %edx
movq %rax, %rsi
callq 0x8302
jmp 0x2049f
movzwl %r8w, %esi
movq %rcx, %rdx
callq 0x77d6
jmp 0x2049f
leaq 0x284ca(%rip), %rdi     # 0x4895e
movl %eax, %esi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x17a82
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/ciff.c
// Function: is_compressed_crw
int
is_compressed_crw(FILE *inptr,unsigned long start_offset,unsigned long imagelength)
{
    int is_compressed = 0;
    int maxcheck = 16384;   /* 0x4000                                 */
    int count = 0;
    int ch,lastch;

    if((inptr) && (fseek(inptr,start_offset + 512,SEEK_SET) != -1))
    {
        if(imagelength < maxcheck)
            maxcheck = imagelength;
        lastch = 0;
        while(((ch = fgetc(inptr)) != EOF) && (count++ < maxcheck))
        {
            if(lastch == 0xff)
            {
                is_compressed = 1;
                if(ch)
                {
                    is_compressed = 0;
                    break;
                }
            }
            lastch = ch;
        }
    }
    return(is_compressed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x20524
movq %rdx, %r14
movq %rdi, %rbx
addq $0x200, %rsi            # imm = 0x200
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x20526
movl $0x4000, %r15d          # imm = 0x4000
cmpq %r15, %r14
cmovbq %r14, %r15
movq %rbx, %rdi
callq 0x3150
cmpl $-0x1, %eax
je 0x20526
incl %r15d
xorl %ecx, %ecx
xorl %ebp, %ebp
decl %r15d
je 0x20526
movl %eax, %r14d
cmpl $0xff, %ecx
jne 0x20512
movl $0x1, %ebp
testl %r14d, %r14d
jne 0x20524
movq %rbx, %rdi
callq 0x3150
movl %r14d, %ecx
cmpl $-0x1, %eax
jne 0x204f8
jmp 0x20526
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/ciff.c
// Function: read_ciffheader
struct ciff_header *
read_ciffheader(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    static struct ciff_header header;
    struct ciff_header *headerptr = NULL;
    unsigned char *string;

    memset(&header,0,sizeof(struct ciff_header));
    if(inptr)
    {
        header.byteorder = read_ushort(inptr,byteorder,offset);
        header.headerlength = read_ulong(inptr,byteorder,HERE);
        string = read_bytes(inptr,4,HERE);
        if(string)
        {
            strncpy(header.type,(char *)string,4);
            string = read_bytes(inptr,4,HERE);
            if(string)
                strncpy(header.subtype,(char *)string,4);
        }
        header.version = read_ulong(inptr,byteorder,HERE);
        header.reserved1 = read_ulong(inptr,byteorder,HERE);
        header.reserved2 = read_ulong(inptr,byteorder,HERE);
        if((header.byteorder == byteorder) &&
                (strncmp(header.type,"HEAP",4) == 0) &&
                                    (header.headerlength > 0))
        {
            headerptr = &header;
        }
    }
    return(headerptr);
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, 0x3cffe(%rip)    # 0x5d698
movups %xmm0, 0x3cfe7(%rip)    # 0x5d688
movups %xmm0, 0x3cfd0(%rip)    # 0x5d678
movq $0x0, 0x3cff5(%rip) # 0x5d6a8
testq %rdi, %rdi
je 0x207b7
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl %si, %ebp
movl %ebp, %esi
callq 0x45af
movw %ax, 0x3cfa5(%rip)      # 0x5d678
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x3cf97(%rip)     # 0x5d680
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x4865
testq %rax, %rax
je 0x2073f
leaq 0x3cf81(%rip), %rdi     # 0x5d688
movl $0x4, %edx
movq %rax, %rsi
callq 0x3080
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x4865
testq %rax, %rax
je 0x2073f
leaq 0x3cf5b(%rip), %rdi     # 0x5d68d
movl $0x4, %edx
movq %rax, %rsi
callq 0x3080
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x3cf43(%rip)     # 0x5d698
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x3cf35(%rip)     # 0x5d6a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4707
movq %rax, 0x3cf27(%rip)     # 0x5d6a8
cmpw %bp, 0x3cef0(%rip)      # 0x5d678
leaq 0x8(%rsp), %rsp
popq %rbx
popq %rbp
jne 0x207b7
leaq 0x3cee0(%rip), %rcx     # 0x5d678
movq 0x3cee1(%rip), %rax     # 0x5d680
testq %rax, %rax
cmoveq %rax, %rcx
xorl %eax, %eax
cmpl $0x50414548, 0x3ced6(%rip) # imm = 0x50414548
cmoveq %rcx, %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/jp2000.c
// Function: read_jp2box
struct jp2box *
read_jp2box(FILE *inptr,unsigned long offset)
{
    static struct jp2box box;
    struct jp2box *newbox = NULL; 

    if(inptr)
    {
        box.boxoffset = offset;
        box.lbox = read_ulong(inptr,TIFF_MOTOROLA,offset);
        if(!feof(inptr) && !(ferror(inptr)))
        {
            box.tbox = read_ulong(inptr,TIFF_MOTOROLA,HERE);
            if(!feof(inptr) && !(ferror(inptr)))
            {
                if(box.lbox == 1)
                {
#if 0
                    box.boxlength = read_ulong64(inptr,TIFF_MOTOROLA,HERE);
                    box.dataoffset = 16;
#else
                    PUSHCOLOR(RED);
                    printf("%s: cannot read 64 bit sizes/offsets yet",Progname);
                    POPCOLOR();
                    newbox = NULL;
#endif
                }
                else
                {
                    box.boxlength = box.lbox;
                    box.dataoffset = 8;
                }
                newbox = &box;
            }
            else
                newbox = NULL;
        }
        else
            newbox = NULL;
    }
    return(newbox);
}

// Assembly:
testq %rdi, %rdi
je 0x2082d
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsi, 0x3cef9(%rip)     # 0x5d6c8
movl $0x4d4d, %esi           # imm = 0x4D4D
callq 0x4707
movq %rax, 0x3ced0(%rip)     # 0x5d6b0
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
jne 0x20829
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x20829
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0x4d4d, %esi           # imm = 0x4D4D
callq 0x4707
movq %rax, 0x3cea7(%rip)     # 0x5d6b8
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
jne 0x20829
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
je 0x20830
xorl %eax, %eax
popq %rbx
retq
xorl %eax, %eax
retq
movq 0x3ce79(%rip), %rax     # 0x5d6b0
cmpq $0x1, %rax
jne 0x2085e
leaq 0x38c24(%rip), %rax     # 0x59468
movq (%rax), %rsi
leaq 0x283e2(%rip), %rdi     # 0x48c30
xorl %eax, %eax
callq 0x3120
leaq 0x3ce54(%rip), %rax     # 0x5d6b0
jmp 0x2082b
movq %rax, 0x3ce6b(%rip)     # 0x5d6d0
leaq 0x3ce44(%rip), %rax     # 0x5d6b0
movq $0x8, 0x3ce49(%rip) # 0x5d6c0
jmp 0x2082b
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/jp2000.c
// Function: print_jp2_header
int
print_jp2_header(struct fileheader *fileheader,unsigned long section_id)
{
    struct jp2_header jp2header;
    int status = -1;
    int chpr = 0;

    if(Print_options & section_id)
    {
        if(fileheader && (fileheader->probe_magic == PROBE_JP2MAGIC))
        {
            jp2header = fileheader->jp2_header;
            if(jp2header.magic == PROBE_JP2MAGIC)
            {
                /* Ok, I'm convinced...                               */
                print_jp2type(jp2header.type,0);
                chpr += printf(" <%#lx> magic %#lx, length %lu",jp2header.type,
                                            jp2header.magic,jp2header.length);
                chpr = newline(chpr);
                status = 0;
            }
            else 
                chpr += printf(" NOT A JP2 HEADER");
        }
        else
            chpr += printf(" NOT A JP2 HEADER");
    }
    chpr = newline(chpr);
    return(status);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x378fb(%rip), %rax     # 0x58180
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rsi, (%rax)
je 0x208f0
testq %rdi, %rdi
je 0x208de
cmpq $0xd0a870a, 0x8(%rdi)   # imm = 0xD0A870A
jne 0x208de
cmpq $0xd0a870a, 0x28(%rdi)  # imm = 0xD0A870A
jne 0x208de
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq 0x208ff
leaq 0x28396(%rip), %rdi     # 0x48c59
movl $0xd0a870a, %edx        # imm = 0xD0A870A
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x1707a
jmp 0x208ec
leaq 0x28393(%rip), %rdi     # 0x48c78
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
jmp 0x208f2
xorl %edi, %edi
callq 0x1707a
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/jp2000.c
// Function: print_jp2type
void
print_jp2type(unsigned long type,int atend)
{
    int i;
    char *p;
    int chpr = 0;

    p = (char *)&type + 3;

    if(!(LIST_MODE))
    {
        putchar('[');
        ++chpr;
    }
    /* 'atend' declares that the output marks the last byte of the    */
    /* box; this is indicated by prepending a '/' to the box name     */
    if(atend)
    {
        putchar('/');
        ++chpr;
    }
    for(i = 0; i < 4; ++i,--p)
    {
        if(isascii(*p) && isprint(*p))
        {
            putchar(*p);
            ++chpr;
        }
        else if(*p)
            chpr += printf("\\%03u",*p & 0xff);
        else
            chpr += printf("\\0");
    }
    if(!(LIST_MODE))
    {
        putchar(']');
        ++chpr;
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, (%rsp)
leaq 0x37869(%rip), %rax     # 0x58180
movzwl 0x2(%rax), %eax
testl $0x104, %eax            # imm = 0x104
je 0x20933
movl $0x5b, %edi
callq 0x3060
movl $0x1, %ebx
jmp 0x20935
xorl %ebx, %ebx
testl %ebp, %ebp
je 0x20945
movl $0x2f, %edi
callq 0x3060
incl %ebx
leaq 0x3(%rsp), %r13
movl $0x4, %r12d
leaq 0x28362(%rip), %r15     # 0x48cb9
movsbl (%r13), %ebp
testl %ebp, %ebp
js 0x20978
movslq %ebp, %r14
callq 0x32d0
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r14,2)
jne 0x2098a
testb %bpl, %bpl
je 0x2099d
movzbl %bpl, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
jmp 0x20993
movl %ebp, %edi
callq 0x3060
incl %ebx
decq %r13
decl %r12d
jne 0x20957
jmp 0x209ad
leaq 0x20ea5(%rip), %rdi     # 0x41849
xorl %eax, %eax
callq 0x3120
jmp 0x20986
leaq 0x377cc(%rip), %rax     # 0x58180
movzwl 0x2(%rax), %eax
testl $0x104, %eax            # imm = 0x104
je 0x209cb
movl $0x5d, %edi
callq 0x3060
incl %ebx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/jp2000.c
// Function: print_jp2box
void
print_jp2box(FILE *inptr,struct jp2box *box,int indent)
{
    unsigned long boxlength = 0UL;
    int chpr = 0;

    if(box)
    {
        if(box->boxlength == 0UL)
            box->boxlength = get_filesize(inptr) - box->boxoffset;
        else
            boxlength = box->boxlength;
        if(PRINT_SECTION)
        {
            print_tag_address(SECTION,box->boxoffset,indent,"@");
            print_jp2type(box->tbox,0);
            chpr += printf(" <%#lx>",box->tbox);
            chpr += printf(" length %lu",boxlength);
            /* Indicate that this is lastbox                          */
            if(box->boxlength == 0UL)
                chpr += printf(" (0)");
            chpr += printf(" data offset %lu",box->dataoffset);
        }
    }
    chpr = newline(chpr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %r15d, %r15d
testq %rsi, %rsi
je 0x20a97
movl %edx, %ebp
movq %rsi, %rbx
movq 0x20(%rsi), %r14
testq %r14, %r14
jne 0x20a0e
callq 0x50f3
subq 0x18(%rbx), %rax
movq %rax, 0x20(%rbx)
leaq 0x3776b(%rip), %rax     # 0x58180
testb $0x4, 0x2(%rax)
je 0x20a97
movq 0x18(%rbx), %rsi
leaq 0x206b6(%rip), %rcx     # 0x410dc
movl $0x40000, %edi          # imm = 0x40000
movl %ebp, %edx
callq 0x55eb
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x208ff
movq 0x8(%rbx), %rsi
leaq 0x28242(%rip), %rdi     # 0x48c8a
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
leaq 0x27d01(%rip), %rdi     # 0x4875a
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
addl %r15d, %ebp
cmpq $0x0, 0x20(%rbx)
jne 0x20a7f
leaq 0x2821c(%rip), %rdi     # 0x48c92
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movq 0x10(%rbx), %rsi
leaq 0x2820d(%rip), %rdi     # 0x48c97
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
addl %ebp, %r15d
movl %r15d, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1707a
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/jp2000.c
// Function: list_jp2box
int
list_jp2box(FILE *inptr,struct jp2box *box,char *parent_name,int indent,int donl)
{
    unsigned long boxlength = 0UL;
    int chpr = 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x20aee
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r14
movq 0x20(%rsi), %r15
testq %r15, %r15
jne 0x20adc
callq 0x50f3
movq %rax, %r15
subq 0x18(%r14), %r15
leaq 0x3769d(%rip), %rax     # 0x58180
movzwl 0x2(%rax), %eax
testl $0x104, %eax            # imm = 0x104
je 0x20b18
testl %ebx, %ebx
je 0x20b07
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1707a
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rsi
leaq 0x205b9(%rip), %rcx     # 0x410dc
movl $0x4003333, %edi        # imm = 0x4003333
movl %r13d, %edx
callq 0x55eb
leaq 0x37649(%rip), %rax     # 0x58180
movq (%rax), %rax
testl $0x3003, %eax           # imm = 0x3003
je 0x20b6b
testb $0x40, %al
je 0x20b56
leaq 0x2054b(%rip), %rdi     # 0x41097
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x208ff
leaq 0x37618(%rip), %rax     # 0x58180
movq (%rax), %rax
testb $0x30, %al
je 0x20aee
movq 0x18(%r14), %rsi
leaq 0x2812a(%rip), %rdi     # 0x48ca8
movq %r15, %rdx
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
cmpq $0x0, 0x20(%r14)
jne 0x20aee
leaq 0x2811a(%rip), %rdi     # 0x48cb6
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
jmp 0x20aee
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/jp2000.c
// Function: process_jp2_xml
unsigned long
process_jp2_xml(FILE *inptr,struct jp2box *box,int indent)
{
    unsigned long boxoffset,max_offset,dataoffset;
    unsigned long readsize;
    unsigned long boxlength,size;
    int chpr = 0;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
callq 0x209e0
movq 0x18(%r14), %r8
movq 0x20(%r14), %r15
leaq 0x36fc3(%rip), %rbx     # 0x58180
movq (%rbx), %rax
btl $0x12, %eax
jb 0x211fa
movq %rbp, %rcx
xorl %ebp, %ebp
btl $0x18, %eax
jb 0x212c1
leaq 0x27ae3(%rip), %rdx     # 0x48cbf
movq %r12, %rdi
movq %r14, %rsi
movq %r8, %rbx
movl $0x1, %r8d
callq 0x20aa9
movq %rbx, %r8
movl %eax, %ebp
jmp 0x212c1
movq 0x10(%r14), %r13
movq %r8, 0x8(%rsp)
addq %r8, %r13
leal 0xa(%rbp), %edx
leaq 0x237b5(%rip), %rcx     # 0x449c5
movl $0x30, %edi
movq %r13, %rsi
callq 0x55eb
testq %r12, %r12
movq %r15, 0x10(%rsp)
movq %rbp, (%rsp)
je 0x21285
movq (%rbx), %rax
andl $0x30, %eax
je 0x21285
addq $-0x8, %r15
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
setne %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x21285
movl $0x2000, %ebx           # imm = 0x2000
cmpq %rbx, %r15
movl $0x2000, %ebp           # imm = 0x2000
cmovbq %r15, %rbp
xorl %edi, %edi
callq 0x17a82
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x77d6
addq %rbp, %r13
subq %rbp, %r15
jne 0x2125c
xorl %edi, %edi
callq 0x1707a
movl %eax, %ebp
decq %r13
leaq 0x2372d(%rip), %rcx     # 0x449c5
movl $0x40000, %edi          # imm = 0x40000
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x55eb
movq 0x8(%r14), %rdi
movl $0x1, %esi
callq 0x208ff
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %r8
addq %r8, %r15
movl %ebp, %edi
callq 0x1707a
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/jp2000.c
// Function: process_jp2_jp2i
unsigned long
process_jp2_jp2i(FILE *inptr,struct jp2box *box,int indent)
{
    unsigned long boxoffset,max_offset,dataoffset;
    unsigned long readsize;
    unsigned long boxlength,size;
    int chpr = 0;

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
callq 0x209e0
movq 0x18(%r14), %r15
movq 0x20(%r14), %rbx
leaq 0x36e79(%rip), %rax     # 0x58180
movq (%rax), %rax
btl $0x12, %eax
jb 0x2133e
movq %rbp, %rcx
xorl %ebp, %ebp
btl $0x18, %eax
jb 0x213fb
leaq 0x27999(%rip), %rdx     # 0x48cbf
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x20aa9
movl %eax, %ebp
jmp 0x213fb
movq 0x10(%r14), %r13
addq %r15, %r13
leal 0x8(%rbp), %edx
leaq 0x23676(%rip), %rcx     # 0x449c5
movl $0x40000, %edi          # imm = 0x40000
movq %r13, %rsi
callq 0x55eb
testq %r12, %r12
movq %rbx, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq %rbp, (%rsp)
je 0x213bf
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
setne %al
addq $-0x8, %rbx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x213bf
movl $0x2000, %r15d          # imm = 0x2000
cmpq %r15, %rbx
movl $0x2000, %ebp           # imm = 0x2000
cmovbq %rbx, %rbp
xorl %edi, %edi
callq 0x17a82
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x77d6
addq %rbp, %r13
subq %rbp, %rbx
jne 0x21396
xorl %edi, %edi
callq 0x1707a
movl %eax, %ebp
decq %r13
leaq 0x235f3(%rip), %rcx     # 0x449c5
movl $0x40000, %edi          # imm = 0x40000
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x55eb
movq 0x8(%r14), %rdi
movl $0x1, %esi
callq 0x208ff
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r15
addq %r15, %rbx
movl %ebp, %edi
callq 0x1707a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/jp2000.c
// Function: process_jp2_jp2c
unsigned long
process_jp2_jp2c(FILE *inptr,struct jp2box *box,struct image_summary *summary_entry,
                                                        int indent)
{
    unsigned long boxoffset,dataoffset;
    unsigned long boxlength;
    unsigned long tbox;
    int chpr = 0;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
leaq 0x367fe(%rip), %rax     # 0x58180
movzwl 0x2(%rax), %eax
testl $0x104, %eax            # imm = 0x104
je 0x2199e
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x209e0
xorl %ebp, %ebp
jmp 0x219ba
leaq 0x2731a(%rip), %rdx     # 0x48cbf
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %ecx
movl $0x1, %r8d
callq 0x20aa9
movl %eax, %ebp
movq 0x8(%r13), %r12
movq 0x10(%r13), %rsi
addq 0x18(%r13), %rsi
movq 0x20(%r13), %rdx
leal 0x8(%rbx), %r8d
movq %r15, %rdi
movq %r14, %rcx
callq 0x23652
movq %rax, %r14
movl %ebp, %edi
callq 0x1707a
movl %eax, %ebp
leaq 0x36794(%rip), %rax     # 0x58180
testb $0x4, 0x2(%rax)
je 0x21a18
movq %r14, %rsi
decq %rsi
leaq 0x1f6dd(%rip), %rcx     # 0x410dc
movl $0x40000, %edi          # imm = 0x40000
movl %ebx, %edx
callq 0x55eb
movq %r12, %rdi
movl $0x1, %esi
callq 0x208ff
movl %ebp, %edi
callq 0x1707a
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq