LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x3cb2d(%rip), %rax     # 0x59468
movq (%rax), %rsi
movq 0x3caa3(%rip), %rdx     # 0x593e8
leaq 0x2b36d(%rip), %rdi     # 0x47cb9
xorl %eax, %eax
callq 0x3120
movl $0xa, %edi
callq 0x3060
leaq 0x3ca94(%rip), %rax     # 0x593f8
movq (%rax), %rsi
testq %rsi, %rsi
je 0x1c97a
leaq 0x2b360(%rip), %rdi     # 0x47cd3
xorl %eax, %eax
callq 0x3120
movq 0x3ca5f(%rip), %rsi     # 0x593e0
leaq 0x2b35a(%rip), %rdi     # 0x47ce2
xorl %eax, %eax
callq 0x3120
leaq 0x2bbd5(%rip), %rdi     # 0x4856b
popq %rax
jmp 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x1ca5d
testq %rsi, %rsi
je 0x1ca64
movq 0x10(%rsi), %r13
testq %r13, %r13
je 0x1ca6b
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 0x1c9e9
addq %rdx, %r12
jmp 0x1ca0a
xorl %r12d, %r12d
movq %r15, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3210
testl %eax, %eax
jne 0x1ca0a
movq %r15, %rdi
callq 0x3190
movq %rax, %r12
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x1ca72
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 0x1ca88
addq $0x20, %rsp
movq %rax, %rcx
addq $0x4, %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
jmp 0x1ca79
callq 0x349f
jmp 0x1ca77
callq 0x347d
jmp 0x1ca77
callq 0x345b
jmp 0x1ca77
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_O1/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 0x1d149
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %r15
testq %rbx, %rbx
jne 0x1d0f8
movl $0x18, %edi
callq 0x31e0
movq %rax, %rbx
testq %rbx, %rbx
je 0x1d147
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movzwl %bp, %ebp
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x4574
movw %ax, (%rbx)
leaq 0x2(%r14), %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x8(%rbx)
addq $0x6, %r14
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x46cc
movq %rax, 0x10(%rbx)
jmp 0x1d149
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f7a5
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 0x1d157
addq $0x20, %rsp
xorl %edi, %edi
jmp 0x1f82f
leaq 0x389d4(%rip), %r15     # 0x58180
movq (%r15), %rax
xorl %edi, %edi
btl $0x12, %eax
jae 0x1f82f
movq %rcx, %r14
movl %eax, %ecx
notl %ecx
testl $0x300, %ecx            # imm = 0x300
jne 0x1f7e0
movq 0x10(%rbx), %rdx
addq %r14, %rdx
leaq 0x25a39(%rip), %rdi     # 0x4520d
movq %rdx, %rsi
xorl %eax, %eax
callq 0x3120
jmp 0x1f804
movq 0x10(%rbx), %rsi
addq %r14, %rsi
btl $0x8, %eax
jb 0x1f7f6
leaq 0x28ff8(%rip), %rdi     # 0x487ec
jmp 0x1f7fd
leaq 0x25a1d(%rip), %rdi     # 0x4521a
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
testq %r14, %r14
je 0x1f826
testb $0x4, 0x3(%r15)
je 0x1f826
movq 0x10(%rbx), %rsi
leaq 0x21dd3(%rip), %rdi     # 0x415f0
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x16b56
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x17530
// File: /workspace/github_c_makefile_star2_O1/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 0x1fe95
leaq (%r8,%rcx), %rbx
leaq 0x38320(%rip), %rax     # 0x58180
testb $0x30, (%rax)
je 0x1fee3
movzwl %r8w, %ebp
movzwl %r9w, %eax
movl %eax, %edx
roll $0x15, %edx
cmpl $0x3, %edx
ja 0x1feca
leaq 0x287e6(%rip), %rax     # 0x48664
movslq (%rax,%rdx,4), %rdx
addq %rax, %rdx
jmpq *%rdx
movzwl %r8w, %esi
movq %rcx, %rdx
callq 0x798e
jmp 0x1fedc
xorl %ebx, %ebx
jmp 0x1fee3
movl %ebp, %eax
shrl %eax
movzwl %si, %edx
movq %rax, %rsi
callq 0x7d7a
jmp 0x1fedc
movl %ebp, %eax
shrl $0x2, %eax
movzwl %si, %edx
movq %rax, %rsi
callq 0x8272
jmp 0x1fedc
movzwl %r8w, %esi
movq %rcx, %rdx
callq 0x7793
jmp 0x1fedc
leaq 0x28a4d(%rip), %rdi     # 0x4891e
movl %eax, %esi
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x17530
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ff61
movq %rdx, %r14
movq %rdi, %rbx
addq $0x200, %rsi            # imm = 0x200
xorl %ebp, %ebp
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x1ff63
movl $0x4000, %r15d          # imm = 0x4000
cmpq %r15, %r14
cmovbq %r14, %r15
movq %rbx, %rdi
callq 0x3150
cmpl $-0x1, %eax
je 0x1ff63
incl %r15d
xorl %ecx, %ecx
xorl %ebp, %ebp
decl %r15d
je 0x1ff63
movl %eax, %r14d
cmpl $0xff, %ecx
jne 0x1ff4f
movl $0x1, %ebp
testl %r14d, %r14d
jne 0x1ff61
movq %rbx, %rdi
callq 0x3150
movl %r14d, %ecx
cmpl $-0x1, %eax
jne 0x1ff35
jmp 0x1ff63
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x3d5c1(%rip)    # 0x5d698
movups %xmm0, 0x3d5aa(%rip)    # 0x5d688
movups %xmm0, 0x3d593(%rip)    # 0x5d678
movq $0x0, 0x3d5b8(%rip) # 0x5d6a8
testq %rdi, %rdi
je 0x201f4
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl %si, %ebp
movl %ebp, %esi
callq 0x4574
movw %ax, 0x3d568(%rip)      # 0x5d678
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x3d55a(%rip)     # 0x5d680
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x4832
testq %rax, %rax
je 0x2017c
leaq 0x3d544(%rip), %rdi     # 0x5d688
movl $0x4, %edx
movq %rax, %rsi
callq 0x3080
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
callq 0x4832
testq %rax, %rax
je 0x2017c
leaq 0x3d51e(%rip), %rdi     # 0x5d68d
movl $0x4, %edx
movq %rax, %rsi
callq 0x3080
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x3d506(%rip)     # 0x5d698
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x3d4f8(%rip)     # 0x5d6a0
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x3d4ea(%rip)     # 0x5d6a8
cmpw %bp, 0x3d4b3(%rip)      # 0x5d678
leaq 0x8(%rsp), %rsp
popq %rbx
popq %rbp
jne 0x201f4
leaq 0x3d4a3(%rip), %rcx     # 0x5d678
movq 0x3d4a4(%rip), %rax     # 0x5d680
testq %rax, %rax
cmoveq %rax, %rcx
xorl %eax, %eax
cmpl $0x50414548, 0x3d499(%rip) # imm = 0x50414548
cmoveq %rcx, %rax
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x20269
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsi, 0x3d4bd(%rip)     # 0x5d6c8
movl $0x4d4d, %esi           # imm = 0x4D4D
callq 0x46cc
movq %rax, 0x3d494(%rip)     # 0x5d6b0
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
jne 0x20265
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x20265
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl $0x4d4d, %esi           # imm = 0x4D4D
callq 0x46cc
movq %rax, 0x3d46b(%rip)     # 0x5d6b8
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
jne 0x20265
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
je 0x2026c
xorl %eax, %eax
popq %rbx
retq
xorl %eax, %eax
retq
movq 0x3d43d(%rip), %rax     # 0x5d6b0
cmpq $0x1, %rax
jne 0x2029a
leaq 0x391e8(%rip), %rax     # 0x59468
movq (%rax), %rsi
leaq 0x28966(%rip), %rdi     # 0x48bf0
xorl %eax, %eax
callq 0x3120
leaq 0x3d418(%rip), %rax     # 0x5d6b0
jmp 0x20267
movq %rax, 0x3d42f(%rip)     # 0x5d6d0
leaq 0x3d408(%rip), %rax     # 0x5d6b0
movq $0x8, 0x3d40d(%rip) # 0x5d6c0
jmp 0x20267
// File: /workspace/github_c_makefile_star2_O1/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 0x37ebf(%rip), %rax     # 0x58180
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rsi, (%rax)
je 0x2032c
testq %rdi, %rdi
je 0x2031a
cmpq $0xd0a870a, 0x8(%rdi)   # imm = 0xD0A870A
jne 0x2031a
cmpq $0xd0a870a, 0x28(%rdi)  # imm = 0xD0A870A
jne 0x2031a
movq 0x18(%rdi), %r14
movq 0x20(%rdi), %r15
xorl %ebx, %ebx
movq %r15, %rdi
xorl %esi, %esi
callq 0x2033b
leaq 0x2891a(%rip), %rdi     # 0x48c19
movl $0xd0a870a, %edx        # imm = 0xD0A870A
movq %r15, %rsi
movq %r14, %rcx
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x16b56
jmp 0x20328
leaq 0x28917(%rip), %rdi     # 0x48c38
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
jmp 0x2032e
xorl %edi, %edi
callq 0x16b56
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x37e2d(%rip), %rax     # 0x58180
movzwl 0x2(%rax), %eax
testl $0x104, %eax            # imm = 0x104
je 0x2036f
movl $0x5b, %edi
callq 0x3060
movl $0x1, %ebx
jmp 0x20371
xorl %ebx, %ebx
testl %ebp, %ebp
je 0x20381
movl $0x2f, %edi
callq 0x3060
incl %ebx
leaq 0x3(%rsp), %r13
movl $0x4, %r12d
leaq 0x288e6(%rip), %r15     # 0x48c79
movsbl (%r13), %ebp
testl %ebp, %ebp
js 0x203af
movslq %ebp, %r14
callq 0x32d0
movq (%rax), %rax
testb $0x40, 0x1(%rax,%r14,2)
jne 0x203c4
testb %bpl, %bpl
je 0x203cf
movzbl %bpl, %esi
movq %r15, %rdi
xorl %eax, %eax
callq 0x3120
jmp 0x203dd
movl %ebp, %edi
callq 0x3060
incl %ebx
jmp 0x203df
leaq 0x21473(%rip), %rdi     # 0x41849
xorl %eax, %eax
callq 0x3120
addl %eax, %ebx
decq %r13
decl %r12d
jne 0x20393
leaq 0x37d92(%rip), %rax     # 0x58180
movzwl 0x2(%rax), %eax
testl $0x104, %eax            # imm = 0x104
je 0x20405
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 0x17530
// File: /workspace/github_c_makefile_star2_O1/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 0x204d4
movl %edx, %ebp
movq %rsi, %rbx
movq 0x20(%rsi), %r14
testq %r14, %r14
jne 0x2044b
callq 0x5131
subq 0x18(%rbx), %rax
movq %rax, 0x20(%rbx)
xorl %r14d, %r14d
leaq 0x37d2e(%rip), %rax     # 0x58180
testb $0x4, 0x2(%rax)
je 0x204d4
movq 0x18(%rbx), %rsi
leaq 0x20c79(%rip), %rcx     # 0x410dc
movl $0x40000, %edi          # imm = 0x40000
movl %ebp, %edx
callq 0x5605
movq 0x8(%rbx), %rdi
xorl %esi, %esi
callq 0x2033b
movq 0x8(%rbx), %rsi
leaq 0x287c5(%rip), %rdi     # 0x48c4a
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
leaq 0x28284(%rip), %rdi     # 0x4871a
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
addl %r15d, %ebp
cmpq $0x0, 0x20(%rbx)
jne 0x204bc
leaq 0x2879f(%rip), %rdi     # 0x48c52
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movq 0x10(%rbx), %rsi
leaq 0x28790(%rip), %rdi     # 0x48c57
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 0x16b56
// File: /workspace/github_c_makefile_star2_O1/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 0x2052b
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r14
movq 0x20(%rsi), %r15
testq %r15, %r15
jne 0x20519
callq 0x5131
movq %rax, %r15
subq 0x18(%r14), %r15
leaq 0x37c60(%rip), %rax     # 0x58180
movzwl 0x2(%rax), %eax
testl $0x104, %eax            # imm = 0x104
je 0x20555
testl %ebx, %ebx
je 0x20544
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x16b56
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rsi
leaq 0x20b7c(%rip), %rcx     # 0x410dc
movl $0x4003333, %edi        # imm = 0x4003333
movl %r13d, %edx
callq 0x5605
leaq 0x37c0c(%rip), %rcx     # 0x58180
movq (%rcx), %rax
testl $0x3003, %eax           # imm = 0x3003
je 0x205a5
testb $0x40, %al
je 0x20593
leaq 0x20b0e(%rip), %rdi     # 0x41097
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
movq 0x8(%r14), %rdi
xorl %esi, %esi
callq 0x2033b
leaq 0x37bdb(%rip), %rcx     # 0x58180
testb $0x30, (%rcx)
je 0x2052b
movq 0x18(%r14), %rsi
leaq 0x286b3(%rip), %rdi     # 0x48c68
movq %r15, %rdx
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
cmpq $0x0, 0x20(%r14)
jne 0x2052b
leaq 0x286a3(%rip), %rdi     # 0x48c76
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
jmp 0x2052b
// File: /workspace/github_c_makefile_star2_O1/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 0x2041a
movq 0x18(%r14), %r8
movq 0x20(%r14), %r15
leaq 0x37588(%rip), %rbx     # 0x58180
movq (%rbx), %rax
btl $0x12, %eax
jb 0x20c35
movq %rbp, %rcx
xorl %ebp, %ebp
btl $0x18, %eax
jb 0x20cfc
leaq 0x28068(%rip), %rdx     # 0x48c7f
movq %r12, %rdi
movq %r14, %rsi
movq %r8, %rbx
movl $0x1, %r8d
callq 0x204e6
movq %rbx, %r8
movl %eax, %ebp
jmp 0x20cfc
movq 0x10(%r14), %r13
movq %r8, 0x8(%rsp)
addq %r8, %r13
leal 0xa(%rbp), %edx
leaq 0x23d36(%rip), %rcx     # 0x44981
movl $0x30, %edi
movq %r13, %rsi
callq 0x5605
testq %r12, %r12
movq %r15, 0x10(%rsp)
movq %rbp, (%rsp)
je 0x20cc0
movq (%rbx), %rax
andl $0x30, %eax
je 0x20cc0
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 0x20cc0
movl $0x2000, %ebx           # imm = 0x2000
cmpq %rbx, %r15
movl $0x2000, %ebp           # imm = 0x2000
cmovbq %r15, %rbp
xorl %edi, %edi
callq 0x17530
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x7793
addq %rbp, %r13
subq %rbp, %r15
jne 0x20c97
xorl %edi, %edi
callq 0x16b56
movl %eax, %ebp
decq %r13
leaq 0x23cae(%rip), %rcx     # 0x44981
movl $0x40000, %edi          # imm = 0x40000
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x5605
movq 0x8(%r14), %rdi
movl $0x1, %esi
callq 0x2033b
movq 0x10(%rsp), %r15
movq 0x8(%rsp), %r8
addq %r8, %r15
movl %ebp, %edi
callq 0x16b56
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_O1/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 0x2041a
movq 0x18(%r14), %r15
movq 0x20(%r14), %rbx
leaq 0x3743e(%rip), %rax     # 0x58180
movq (%rax), %rax
btl $0x12, %eax
jb 0x20d79
movq %rbp, %rcx
xorl %ebp, %ebp
btl $0x18, %eax
jb 0x20e36
leaq 0x27f1e(%rip), %rdx     # 0x48c7f
movq %r12, %rdi
movq %r14, %rsi
movl $0x1, %r8d
callq 0x204e6
movl %eax, %ebp
jmp 0x20e36
movq 0x10(%r14), %r13
addq %r15, %r13
leal 0x8(%rbp), %edx
leaq 0x23bf7(%rip), %rcx     # 0x44981
movl $0x40000, %edi          # imm = 0x40000
movq %r13, %rsi
callq 0x5605
testq %r12, %r12
movq %rbx, 0x10(%rsp)
movq %r15, 0x8(%rsp)
movq %rbp, (%rsp)
je 0x20dfa
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 0x20dfa
movl $0x2000, %r15d          # imm = 0x2000
cmpq %r15, %rbx
movl $0x2000, %ebp           # imm = 0x2000
cmovbq %rbx, %rbp
xorl %edi, %edi
callq 0x17530
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x7793
addq %rbp, %r13
subq %rbp, %rbx
jne 0x20dd1
xorl %edi, %edi
callq 0x16b56
movl %eax, %ebp
decq %r13
leaq 0x23b74(%rip), %rcx     # 0x44981
movl $0x40000, %edi          # imm = 0x40000
movq %r13, %rsi
movq (%rsp), %rdx
callq 0x5605
movq 0x8(%r14), %rdi
movl $0x1, %esi
callq 0x2033b
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r15
addq %r15, %rbx
movl %ebp, %edi
callq 0x16b56
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_O1/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 0x36dc3(%rip), %rax     # 0x58180
movzwl 0x2(%rax), %eax
testl $0x104, %eax            # imm = 0x104
je 0x213d9
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %edx
callq 0x2041a
xorl %ebp, %ebp
jmp 0x213f5
leaq 0x2789f(%rip), %rdx     # 0x48c7f
movq %r15, %rdi
movq %r13, %rsi
movl %ebx, %ecx
movl $0x1, %r8d
callq 0x204e6
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 0x22fd9
movq %rax, %r14
movl %ebp, %edi
callq 0x16b56
movl %eax, %ebp
leaq 0x36d59(%rip), %rax     # 0x58180
testb $0x4, 0x2(%rax)
je 0x21453
movq %r14, %rsi
decq %rsi
leaq 0x1fca2(%rip), %rcx     # 0x410dc
movl $0x40000, %edi          # imm = 0x40000
movl %ebx, %edx
callq 0x5605
movq %r12, %rdi
movl $0x1, %esi
callq 0x2033b
movl %ebp, %edi
callq 0x16b56
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/mrw.c
// Function: print_mrw_header
int
print_mrw_header(struct fileheader *fileheader,unsigned long section_id)
{
    struct mrw_header mrwheader;
    int status = -1;
    int chpr = 0;

    if(Print_options & section_id)
    {
        if(fileheader && (fileheader->probe_magic == PROBE_MRWMAGIC))
        {
            mrwheader = fileheader->mrw_header;
            if(mrwheader.mrw_magic == PROBE_MRWMAGIC)
            {
                chpr += printf("MRW magic %#lx, length %u, offset to image data %lu",
                                            mrwheader.mrw_magic,8,mrwheader.mrw_dataoffset + 8);
                chpr = newline(chpr);
                status = 0;
            }
            else 
                chpr += printf(" MRW HEADER MAGIC BAD");
        }
        else
            chpr += printf(" NOT AN MRW HEADER");
    }
    chpr = newline(chpr);
    return(status);
}

// Assembly:
pushq %rbx
leaq 0x330e0(%rip), %rax     # 0x58180
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rsi, (%rax)
je 0x25100
testq %rdi, %rdi
je 0x250ee
cmpq $0x4d524d, 0x8(%rdi)    # imm = 0x4D524D
jne 0x250ee
cmpq $0x4d524d, 0x30(%rdi)   # imm = 0x4D524D
jne 0x2510b
movq 0x38(%rdi), %rcx
addq $0x8, %rcx
leaq 0x2426e(%rip), %rdi     # 0x49340
xorl %ebx, %ebx
movl $0x4d524d, %esi         # imm = 0x4D524D
movl $0x8, %edx
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x16b56
jmp 0x250fc
leaq 0x24295(%rip), %rdi     # 0x4938a
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
jmp 0x25102
xorl %edi, %edi
callq 0x16b56
movl %ebx, %eax
popq %rbx
retq
leaq 0x24262(%rip), %rdi     # 0x49374
jmp 0x250f5
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/lib/veclib.c
// Function: vector
int
vector(buf,wstart,sepchars,singlesep,maxent)
char *buf,**wstart,*sepchars;
int singlesep,maxent;
{
	char *bptr = buf;
	int pos = 0;

	if(!wstart)
		return(0);
	wstart[0] = bptr;
	if(!buf || (*buf == '\0'))
		return(0);
	bptr = buf;

	/* first word													*/
	wstart[0] = bptr;

	/* next_word() replaces the next separator with a null char     */
	/* and returns the start of the next word (which may be null    */
	/* if there are no more words.                                  */
	while(bptr && (bptr = next_word(wstart[pos],sepchars,singlesep)))
	{
		wstart[++pos] = bptr;
		if(pos >= (maxent - 1))
			break;
	}
	wstart[++pos] = CNULL;
	return(pos);
}

// Assembly:
xorl %eax, %eax
testq %rsi, %rsi
je 0x271e2
movq %rdi, (%rsi)
testq %rdi, %rdi
je 0x271e2
cmpb $0x0, (%rdi)
je 0x271e2
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, (%rsi)
decl %r8d
cmpl $0x2, %r8d
movl $0x1, %eax
cmovgel %r8d, %eax
leaq 0x1(%rdx), %r8
xorl %edi, %edi
movq (%rsi,%rdi,8), %r9
testq %r9, %r9
je 0x2716c
movb (%r9), %r10b
testb %r10b, %r10b
je 0x2716c
movb (%rdx), %r11b
xorl %ebx, %ebx
movq %r8, %r14
movl %r11d, %ebp
testb %r11b, %r11b
je 0x27156
cmpb %bpl, %r10b
je 0x27167
movb (%r14), %bpl
incq %r14
testb %bpl, %bpl
jne 0x27146
movb 0x1(%r9), %r10b
incq %r9
testb %r10b, %r10b
sete %bl
jne 0x2713b
jmp 0x2716c
testb $0x1, %bl
je 0x27182
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x271ce
movq %rbx, 0x8(%rsi,%rdi,8)
incq %rdi
cmpq %rax, %rdi
jne 0x27125
jmp 0x271d0
leaq 0x1(%r9), %r10
movb $0x0, (%r9)
testl %ecx, %ecx
je 0x27193
movq %r10, %rbx
jmp 0x2716e
movb (%r10), %r9b
testb %r9b, %r9b
je 0x2716c
movb (%rdx), %r11b
testb %r11b, %r11b
je 0x2718e
movq %r8, %rbx
movl %r11d, %ebp
cmpb %bpl, %r9b
je 0x271bb
movb (%rbx), %bpl
incq %rbx
testb %bpl, %bpl
jne 0x271a9
jmp 0x2718e
movb 0x1(%r10), %r9b
incq %r10
movl $0x0, %ebx
testb %r9b, %r9b
jne 0x271a3
jmp 0x2716e
movl %edi, %eax
movslq %eax, %rcx
incl %eax
movq $0x0, 0x8(%rsi,%rcx,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/lib/veclib.c
// Function: prvector
void
prvector(ioptr,vec,nwords)
FILE * ioptr;
char **vec;
int nwords;
{
	int i = 0;

	fprintf(ioptr,"%d words:\n",nwords);
	if(vec)
	{
		while(*vec && (i < nwords))
			fprintf(ioptr,"\t[%d] \"%s\"\n",i++,*vec++);
	}
	else
		fprintf(ioptr,"no words (nwords = %d\n",nwords);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x2242d(%rip), %rsi     # 0x49628
xorl %eax, %eax
callq 0x3180
testq %r15, %r15
je 0x2724f
movq (%r15), %rcx
testq %rcx, %rcx
sete %al
testl %ebx, %ebx
setle %dl
orb %al, %dl
jne 0x27245
leaq 0x22413(%rip), %r12     # 0x49633
xorl %r13d, %r13d
movq %r14, %rdi
movq %r12, %rsi
movl %r13d, %edx
xorl %eax, %eax
callq 0x3180
movq 0x8(%r15,%r13,8), %rcx
testq %rcx, %rcx
je 0x27245
incq %r13
cmpl %ebx, %r13d
jl 0x27223
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x223e9(%rip), %rsi     # 0x4963f
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3180
nop
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/raf.c
// Function: print_raf_header
int
print_raf_header(FILE *inptr,struct fileheader *fileheader,unsigned long section_id)
{
    int status = -1;
    int chpr = 0;

    if(Print_options & section_id)
    {
        /* ###%%% for now, the first 60 bytes are "header"            */
        if(fileheader && (fileheader->probe_magic == PROBE_RAFMAGIC))
        {
            print_ascii(inptr,28,0);
            chpr += printf(" Model = ");
            print_ascii(inptr,32,28);
            status = 0;
        }
        else
            chpr += printf(" NOT AN RAF HEADER");
    }
    chpr = newline(chpr);
    return(status);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x30f09(%rip), %rax     # 0x58180
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rdx, (%rax)
je 0x272d7
testq %rsi, %rsi
je 0x272c5
cmpq $0x4655, 0x8(%rsi)      # imm = 0x4655
jne 0x272c5
movq %rdi, %r14
xorl %ebx, %ebx
movl $0x1c, %esi
xorl %edx, %edx
callq 0x7793
leaq 0x223ae(%rip), %rdi     # 0x49656
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
movl $0x20, %esi
movl $0x1c, %edx
movq %r14, %rdi
callq 0x7793
jmp 0x272d9
leaq 0x22394(%rip), %rdi     # 0x49660
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
jmp 0x272d9
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x16b56
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/x3f.c
// Function: process_x3f
unsigned long
process_x3f(FILE *inptr,struct fileheader *header,unsigned long fileoffset_base,
                                        struct image_summary *summary_entry,
                                        char *parent_name,int level,int indent)
{
    struct x3f_header *x3fheader;
    unsigned long max_offset = 0UL;
    unsigned short byteorder = 0;
    unsigned long directory_pointer = 0UL;

    if(inptr)
    {
        if(header)
        {
            if(header->x3f_header)
            {
                x3fheader = header->x3f_header;
                /* X3F is always little-endian; nonetheless, pass it  */
                /* as an argument to lower-level functions. Just set  */
                /* it here.                                           */
                byteorder = TIFF_INTEL;
                if(fseek(inptr,-4L,SEEK_END) == 0)
                    directory_pointer = ftell(inptr);
                if(ferror(inptr) == 0)
                {
                    max_offset = process_x3f_dir(inptr,byteorder,x3fheader,
                                                    directory_pointer,summary_entry,
                                                    parent_name,level,indent);
                    if(max_offset > 0L)
                        max_offset += 4;
                }
                else
                    fprintf(stderr,"%s: cannot read directory offset\n",Progname);
            }
            else
                fprintf(stderr,"%s: null x3fheader to process_x3f()\n",Progname);
        }
        else
            fprintf(stderr,"%s: null fileheader to process_x3f()\n",Progname);
    }
    else
        fprintf(stderr,"%s: no open file pointer to read Print Image data\n",
                                                                        Progname);

    return(max_offset);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x28c25
testq %rsi, %rsi
je 0x28c2c
cmpq $0x0, 0x40(%rsi)
je 0x28c33
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movq $-0x4, %rsi
movl $0x2, %edx
callq 0x3210
testl %eax, %eax
je 0x28be0
xorl %r12d, %r12d
jmp 0x28beb
movq %r15, %rdi
callq 0x3190
movq %rax, %r12
movq %r15, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x28c3a
movl 0x40(%rsp), %eax
movl %eax, 0x8(%rsp)
movq %r15, %rdi
movl $0x4949, %esi           # imm = 0x4949
movq %r12, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0x28c4d
movq %rax, %rcx
addq $0x4, %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
jmp 0x28c41
callq 0x35f8
jmp 0x28c3f
callq 0x35d6
jmp 0x28c3f
callq 0x35b4
jmp 0x28c3f
callq 0x3592
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_direntry
struct x3f_direntry *
read_x3f_direntry(FILE *inptr,unsigned short byteorder,struct x3f_direntry *entry,
                                                            unsigned long offset)
{
    if(inptr)
    {
        if(entry == NULL)
            entry = (struct x3f_direntry *)malloc(sizeof(struct x3f_direntry));
        if(entry)
        {
            memset(entry,0,sizeof(struct x3f_direntry));
            entry->data_offset = read_ulong(inptr,byteorder,offset);
            entry->data_length = read_ulong(inptr,byteorder,HERE);
            entry->data_type = read_ulong(inptr,byteorder,HERE);
        }
    }
    else
        entry = (struct x3f_direntry *)0;
    return(entry);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x29017
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testq %rdx, %rdx
jne 0x28fcc
movl $0x20, %edi
callq 0x31e0
movq %rax, %rbx
testq %rbx, %rbx
je 0x29017
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movzwl %bp, %ebp
movq %r14, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x46cc
movq %rax, 0x8(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x10(%rbx)
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %r14, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x18(%rbx)
jmp 0x29019
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/x3f.c
// Function: print_x3f_direntry
void 
print_x3f_direntry(FILE *inptr,struct x3f_direntry *entry,unsigned long offset,
                                        char *parent_name,int entry_num,int indent)
{
    int chpr = 0;

    if(entry)
    {
        print_tag_address(ENTRY,offset,indent + MEDIUMINDENT,"@");
        if((PRINT_TAGINFO))
        {
            if((PRINT_LONGNAMES))
                chpr += printf("%s.",parent_name);
            chpr += printf("%4.4s:%-2d",(char *)&entry->data_type,entry_num);
            if((PRINT_VALUE))
                putindent(X3FTAGWIDTH - 7);
        }
        if((PRINT_VALUE))
        {
            chpr += printf(" = ");
            chpr += printf("@%lu:%lu",entry->data_offset,entry->data_length);
        }
        chpr += newline(chpr);
    }
}

// Assembly:
testq %rsi, %rsi
je 0x29a6d
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %rsi, %rbx
addl $0x4, %r9d
leaq 0x176d8(%rip), %rcx     # 0x410dc
movl $0x4003333, %edi        # imm = 0x4003333
movq %rdx, %rsi
movl %r9d, %edx
callq 0x5605
leaq 0x2e765(%rip), %r12     # 0x58180
movq (%r12), %rax
testl $0x3003, %eax           # imm = 0x3003
je 0x29a6e
xorl %r15d, %r15d
testb $0x40, %al
je 0x29a41
leaq 0x1ba73(%rip), %rdi     # 0x454a7
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
leaq 0x18(%rbx), %rsi
leaq 0x200b2(%rip), %rdi     # 0x49afe
movl %ebp, %edx
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
addl %r15d, %ebp
testb $0x30, (%r12)
je 0x29a70
movl $0xb, %edi
callq 0x5730
jmp 0x29a70
retq
xorl %ebp, %ebp
testb $0x30, (%r12)
je 0x29aa6
leaq 0x20aea(%rip), %rdi     # 0x4a568
xorl %eax, %eax
callq 0x3120
movl %eax, %r14d
addl %ebp, %r14d
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
leaq 0x1b6c8(%rip), %rdi     # 0x45162
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
addl %r14d, %ebp
movl %ebp, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x16b56
// File: /workspace/github_c_makefile_star2_O1/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_imag_header
struct x3f_imag_header *
read_x3f_imag_header(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    static struct x3f_imag_header header;
    struct x3f_imag_header *headerptr= (struct x3f_imag_header *)0;

    if(!feof(inptr) && !ferror(inptr))
    {
        header.section_id = read_ulong(inptr,byteorder,offset);
        header.version_minor = read_ushort(inptr,byteorder,HERE);
        header.version_major = read_ushort(inptr,byteorder,HERE);
        header.image_type = read_ulong(inptr,byteorder,HERE);
        header.image_format = read_ulong(inptr,byteorder,HERE);
        header.image_width = read_ulong(inptr,byteorder,HERE);
        header.image_height = read_ulong(inptr,byteorder,HERE);
        header.image_rowsize = read_ulong(inptr,byteorder,HERE);
            if(!feof(inptr) && !ferror(inptr))
                headerptr = &header;
    }
    return(headerptr);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
callq 0x31a0
testl %eax, %eax
jne 0x29b9b
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
jne 0x29b9b
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x46cc
movq %rax, 0x33d63(%rip)     # 0x5d858
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4574
movw %ax, 0x33d55(%rip)      # 0x5d860
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4574
movw %ax, 0x33d41(%rip)      # 0x5d862
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x33d31(%rip)     # 0x5d868
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x33d23(%rip)     # 0x5d870
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x33d15(%rip)     # 0x5d878
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x33d07(%rip)     # 0x5d880
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %ebp, %esi
callq 0x46cc
movq %rax, 0x33cf9(%rip)     # 0x5d888
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
je 0x29ba2
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x30b0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
leaq 0x33ca1(%rip), %rcx     # 0x5d858
cmoveq %rcx, %rax
jmp 0x29b9d