LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
leaq 0x415c4(%rip), %rdi     # 0x6a306
callq 0x3030
movq %rax, -0x808(%rbp)
cmpq $0x0, -0x808(%rbp)
je 0x28e1b
movq -0x808(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x28e1b
movq -0x808(%rbp), %rdi
callq 0x30f0
movq %rax, %rdi
addq $0x3, %rdi
movl $0x1, %esi
callq 0x3160
movq %rax, -0x818(%rbp)
movq -0x818(%rbp), %rdi
leaq 0x41219(%rip), %rsi     # 0x69fba
callq 0x3090
movq -0x818(%rbp), %rdi
movq -0x808(%rbp), %rsi
callq 0x3260
movq 0x4e210(%rip), %rax     # 0x76fd0
movl $0x0, (%rax)
movq -0x818(%rbp), %rdi
leaq -0x800(%rbp), %rsi
leaq 0x4153d(%rip), %rdx     # 0x6a318
xorl %ecx, %ecx
movl $0x100, %r8d            # imm = 0x100
movb $0x0, %al
callq 0x38220
movl %eax, -0x80c(%rbp)
movl -0x80c(%rbp), %edi
leaq -0x800(%rbp), %rsi
callq 0x28390
movq 0x4e1c7(%rip), %rax     # 0x76fd0
movl $0x1, (%rax)
movq -0x818(%rbp), %rdi
callq 0x3040
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
leaq 0x4f34d(%rip), %rax     # 0x78468
movq (%rax), %rsi
movq 0x4f2c3(%rip), %rdx     # 0x783e8
leaq 0x41ac1(%rip), %rdi     # 0x6abed
movb $0x0, %al
callq 0x3110
movl $0xa, %edi
callq 0x3050
leaq 0x4f2b4(%rip), %rax     # 0x783f8
cmpq $0x0, (%rax)
je 0x29162
leaq 0x4f2a7(%rip), %rax     # 0x783f8
movq (%rax), %rsi
leaq 0x41aac(%rip), %rdi     # 0x6ac07
movb $0x0, %al
callq 0x3110
movq 0x4f277(%rip), %rsi     # 0x783e0
leaq 0x41aa6(%rip), %rdi     # 0x6ac16
movb $0x0, %al
callq 0x3110
leaq 0x41a9d(%rip), %rdi     # 0x6ac1b
movb $0x0, %al
callq 0x3110
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x29bb8
cmpq $0x0, -0x10(%rbp)
jne 0x29b3b
movl $0x18, %edi
callq 0x31d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29bb6
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x3130
movq -0x8(%rbp), %rdi
movw -0x12(%rbp), %ax
movq -0x20(%rbp), %rdx
movzwl %ax, %esi
callq 0x4480
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x8(%rbp), %rdi
movw -0x12(%rbp), %ax
movq -0x20(%rbp), %rdx
addq $0x2, %rdx
movzwl %ax, %esi
callq 0x4610
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movw -0x12(%rbp), %ax
movq -0x20(%rbp), %rdx
addq $0x6, %rdx
movzwl %ax, %esi
callq 0x4610
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x29bb8
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x4000, -0x20(%rbp)    # imm = 0x4000
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2e24a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x200, %rsi            # imm = 0x200
xorl %edx, %edx
callq 0x3200
cmpl $-0x1, %eax
je 0x2e24a
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2e1e3
movq -0x18(%rbp), %rax
movl %eax, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3140
movl %eax, %ecx
movl %ecx, -0x28(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x2d(%rbp)
je 0x2e216
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl -0x20(%rbp), %eax
setl %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x2e21f
jmp 0x2e248
cmpl $0xff, -0x2c(%rbp)
jne 0x2e240
movl $0x1, -0x1c(%rbp)
cmpl $0x0, -0x28(%rbp)
je 0x2e23e
movl $0x0, -0x1c(%rbp)
jmp 0x2e248
jmp 0x2e240
movl -0x28(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x2e1ea
jmp 0x2e24a
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x4e202(%rip), %rdi     # 0x7c6b8
xorl %esi, %esi
movl $0x38, %edx
callq 0x3130
cmpq $0x0, -0x8(%rbp)
je 0x2e603
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movzwl %ax, %esi
callq 0x4480
movw %ax, 0x4e1d0(%rip)      # 0x7c6b8
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x4e1bf(%rip)     # 0x7c6c0
movq -0x8(%rbp), %rdi
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x47a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2e571
movq -0x28(%rbp), %rsi
leaq 0x4e18e(%rip), %rdi     # 0x7c6b8
addq $0x10, %rdi
movl $0x4, %edx
callq 0x3070
movq -0x8(%rbp), %rdi
movl $0x4, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x47a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2e56f
movq -0x28(%rbp), %rsi
leaq 0x4e157(%rip), %rdi     # 0x7c6b8
addq $0x15, %rdi
movl $0x4, %edx
callq 0x3070
jmp 0x2e571
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x4e14e(%rip)     # 0x7c6d8
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x4e13d(%rip)     # 0x7c6e0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x4e12c(%rip)     # 0x7c6e8
movzwl 0x4e0f5(%rip), %eax     # 0x7c6b8
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x2e601
leaq 0x4e0e6(%rip), %rdi     # 0x7c6b8
addq $0x10, %rdi
leaq 0x3cbb6(%rip), %rsi     # 0x6b193
movl $0x4, %edx
callq 0x3080
cmpl $0x0, %eax
jne 0x2e601
cmpq $0x0, 0x4e0cc(%rip)     # 0x7c6c0
jbe 0x2e601
leaq 0x4e0bb(%rip), %rax     # 0x7c6b8
movq %rax, -0x20(%rbp)
jmp 0x2e603
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2e717
movq -0x10(%rbp), %rax
movq %rax, 0x4e0ca(%rip)     # 0x7c708
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x4d4d, %esi           # imm = 0x4D4D
callq 0x4610
movq %rax, 0x4e099(%rip)     # 0x7c6f0
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
jne 0x2e70d
movq -0x8(%rbp), %rdi
callq 0x30a0
cmpl $0x0, %eax
jne 0x2e70d
movq -0x8(%rbp), %rdi
movl $0x4d4d, %esi           # imm = 0x4D4D
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4610
movq %rax, 0x4e063(%rip)     # 0x7c6f8
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
jne 0x2e703
movq -0x8(%rbp), %rdi
callq 0x30a0
cmpl $0x0, %eax
jne 0x2e703
cmpq $0x1, 0x4e037(%rip)     # 0x7c6f0
jne 0x2e6dd
leaq 0x49da6(%rip), %rax     # 0x78468
movq (%rax), %rsi
leaq 0x3cd00(%rip), %rdi     # 0x6b3cc
movb $0x0, %al
callq 0x3110
movq $0x0, -0x18(%rbp)
jmp 0x2e6f6
movq 0x4e00c(%rip), %rax     # 0x7c6f0
movq %rax, 0x4e025(%rip)     # 0x7c710
movq $0x8, 0x4e00a(%rip) # 0x7c700
leaq 0x4dff3(%rip), %rax     # 0x7c6f0
movq %rax, -0x18(%rbp)
jmp 0x2e70b
movq $0x0, -0x18(%rbp)
jmp 0x2e715
movq $0x0, -0x18(%rbp)
jmp 0x2e717
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x30(%rbp)
leaq 0x48a2b(%rip), %rax     # 0x77180
movq (%rax), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x2e810
cmpq $0x0, -0x8(%rbp)
je 0x2e7fa
movq -0x8(%rbp), %rax
cmpq $0xd0a870a, 0x8(%rax)   # imm = 0xD0A870A
jne 0x2e7fa
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x20(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0xd0a870a, -0x18(%rbp) # imm = 0xD0A870A
jne 0x2e7e4
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x2e830
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x3cc32(%rip), %rdi     # 0x6b3f5
movb $0x0, %al
callq 0x3110
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %edi
callq 0x1ef50
movl %eax, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0x2e7f8
leaq 0x3cc29(%rip), %rdi     # 0x6b414
movb $0x0, %al
callq 0x3110
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x2e80e
leaq 0x3cc13(%rip), %rdi     # 0x6b414
movb $0x0, %al
callq 0x3110
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x2e810
movl -0x30(%rbp), %edi
callq 0x1ef50
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x8(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x18(%rbp)
leaq 0x48927(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1040000, %rax        # imm = 0x1040000
cmpq $0x0, %rax
je 0x2e87b
movl $0x5b, %edi
callq 0x3050
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2e894
movl $0x2f, %edi
callq 0x3050
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x2e949
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
andl $-0x80, %eax
cmpl $0x0, %eax
jne 0x2e8eb
callq 0x32c0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x2e8eb
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x3050
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2e92d
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2e917
movq -0x18(%rbp), %rax
movsbl (%rax), %esi
andl $0xff, %esi
leaq 0x3cb4d(%rip), %rdi     # 0x6b455
movb $0x0, %al
callq 0x3110
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2e92b
leaq 0x35eeb(%rip), %rdi     # 0x64809
movb $0x0, %al
callq 0x3110
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x2e92d
jmp 0x2e92f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x2e89b
leaq 0x48830(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1040000, %rax        # imm = 0x1040000
cmpq $0x0, %rax
je 0x2e972
movl $0x5d, %edi
callq 0x3050
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2ea98
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2e9d6
movq -0x8(%rbp), %rdi
callq 0x5530
movq %rax, %rcx
movq -0x10(%rbp), %rax
subq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2e9e2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
leaq 0x48797(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x2ea96
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x14(%rbp), %edx
movl $0x40000, %edi          # imm = 0x40000
leaq 0x356c9(%rip), %rcx     # 0x640dc
callq 0x5ed0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x2e830
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x3c9f0(%rip), %rdi     # 0x6b426
movb $0x0, %al
callq 0x3110
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rsi
leaq 0x3c26b(%rip), %rdi     # 0x6acb9
movb $0x0, %al
callq 0x3110
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2ea7a
leaq 0x3c9c1(%rip), %rdi     # 0x6b42e
movb $0x0, %al
callq 0x3110
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x3c9aa(%rip), %rdi     # 0x6b433
movb $0x0, %al
callq 0x3110
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x2ea98
movl -0x24(%rbp), %edi
callq 0x1ef50
movl %eax, -0x24(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2ebed
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2eb07
movq -0x8(%rbp), %rdi
callq 0x5530
movq -0x10(%rbp), %rcx
subq 0x18(%rcx), %rax
movq %rax, -0x28(%rbp)
jmp 0x2eb13
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
leaq 0x48666(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1040000, %rax        # imm = 0x1040000
cmpq $0x0, %rax
jne 0x2ebeb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl -0x1c(%rbp), %edx
movl $0x4003333, %edi        # imm = 0x4003333
leaq 0x35598(%rip), %rcx     # 0x640dc
callq 0x5ed0
leaq 0x48630(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x3003, %rax           # imm = 0x3003
cmpq $0x0, %rax
je 0x2eb94
leaq 0x4861a(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x2eb85
movq -0x18(%rbp), %rsi
leaq 0x35519(%rip), %rdi     # 0x64097
movb $0x0, %al
callq 0x3110
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x2e830
leaq 0x485e5(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x30, %rax
cmpq $0x0, %rax
je 0x2ebe9
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x28(%rbp), %rdx
leaq 0x3c889(%rip), %rdi     # 0x6b444
movb $0x0, %al
callq 0x3110
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2ebe7
leaq 0x3c878(%rip), %rdi     # 0x6b452
movb $0x0, %al
callq 0x3110
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x2ebe9
jmp 0x2ebeb
jmp 0x2ebed
cmpl $0x0, -0x20(%rbp)
je 0x2ebfe
movl -0x2c(%rbp), %edi
callq 0x1ef50
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x44(%rbp)
leaq 0x472cb(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1040000, %rax        # imm = 0x1040000
cmpq $0x0, %rax
jne 0x2fee6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %ecx
leaq 0x3b585(%rip), %rdx     # 0x6b45b
movl $0x1, %r8d
callq 0x2eab0
movl %eax, -0x44(%rbp)
jmp 0x2fef6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x2e980
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
addq 0x10(%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %r8d
addl $0x8, %r8d
callq 0x32820
movq %rax, -0x30(%rbp)
movl -0x44(%rbp), %edi
callq 0x1ef50
movl %eax, -0x44(%rbp)
leaq 0x47223(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x40000, %rax          # imm = 0x40000
cmpq $0x0, %rax
je 0x2ff96
movq -0x30(%rbp), %rsi
subq $0x1, %rsi
movl -0x1c(%rbp), %edx
movl $0x40000, %edi          # imm = 0x40000
leaq 0x34159(%rip), %rcx     # 0x640dc
callq 0x5ed0
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x2e830
movl -0x44(%rbp), %edi
callq 0x1ef50
movl %eax, -0x44(%rbp)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x28(%rbp)
leaq 0x41c5b(%rip), %rax     # 0x77180
movq (%rax), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x355ce
cmpq $0x0, -0x8(%rbp)
je 0x355b8
movq -0x8(%rbp), %rax
cmpq $0x4d524d, 0x8(%rax)    # imm = 0x4D524D
jne 0x355b8
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x4d524d, -0x20(%rbp)  # imm = 0x4D524D
jne 0x355a2
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
addq $0x8, %rcx
leaq 0x365e4(%rip), %rdi     # 0x6bb60
movl $0x8, %edx
movb $0x0, %al
callq 0x3110
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x1ef50
movl %eax, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
jmp 0x355b6
leaq 0x365eb(%rip), %rdi     # 0x6bb94
movb $0x0, %al
callq 0x3110
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x355cc
leaq 0x365eb(%rip), %rdi     # 0x6bbaa
movb $0x0, %al
callq 0x3110
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x355ce
movl -0x28(%rbp), %edi
callq 0x1ef50
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3825d
movl $0x0, -0x4(%rbp)
jmp 0x3831c
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x3827b
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x38287
movl $0x0, -0x4(%rbp)
jmp 0x3831c
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
cmpq $0x0, -0x30(%rbp)
movb %al, -0x35(%rbp)
je 0x382cc
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x383e0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x382d5
jmp 0x382fe
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x34(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
movl -0x28(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jl 0x382fc
jmp 0x382fe
jmp 0x3829a
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x34(%rbp)
movslq %ecx, %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x33ae6(%rip), %rsi     # 0x6be3e
movb $0x0, %al
callq 0x3170
cmpq $0x0, -0x10(%rbp)
je 0x383bf
jmp 0x38368
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, (%rcx)
movb %al, -0x19(%rbp)
je 0x38383
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x3838c
jmp 0x383bd
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %edx
movl %edx, %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x10(%rbp)
movq (%rax), %rcx
leaq 0x33a95(%rip), %rsi     # 0x6be49
movb $0x0, %al
callq 0x3170
jmp 0x38368
jmp 0x383d4
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x33a88(%rip), %rsi     # 0x6be55
movb $0x0, %al
callq 0x3170
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/lib/veclib.c
// Function: is_sep
int
is_sep(c,sepchars)
char c,*sepchars;
{
	char *tmp = sepchars;

	if(c)
	{
		while(*tmp)
		{
			if(*tmp == c)
				return(1);
			else
				++tmp;
		}
	}
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpb $0x0, -0x5(%rbp)
je 0x3851f
jmp 0x384ee
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3851d
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movsbl -0x5(%rbp), %ecx
cmpl %ecx, %eax
jne 0x3850f
movl $0x1, -0x4(%rbp)
jmp 0x38526
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x384ee
jmp 0x3851f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xffffffff, -0x1c(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x20(%rbp)
leaq 0x3ec27(%rip), %rax     # 0x77180
movq (%rax), %rax
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
je 0x385d3
cmpq $0x0, -0x10(%rbp)
je 0x385bd
movq -0x10(%rbp), %rax
cmpq $0x4655, 0x8(%rax)      # imm = 0x4655
jne 0x385bd
movq -0x8(%rbp), %rdi
movl $0x1c, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x8e70
leaq 0x338d8(%rip), %rdi     # 0x6be6c
movb $0x0, %al
callq 0x3110
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
movl $0x1c, %edx
callq 0x8e70
movl $0x0, -0x1c(%rbp)
jmp 0x385d1
leaq 0x338b2(%rip), %rdi     # 0x6be76
movb $0x0, %al
callq 0x3110
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x385d3
movl -0x20(%rbp), %edi
callq 0x1ef50
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3b0ed
cmpq $0x0, -0x18(%rbp)
jne 0x3b07b
movl $0x20, %edi
callq 0x31d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3b0eb
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3130
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x20(%rbp), %rdx
movzwl %ax, %esi
callq 0x4610
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x3b0f5
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3bff8
movq -0x18(%rbp), %rsi
movl -0x28(%rbp), %edx
addl $0x4, %edx
movl $0x4003333, %edi        # imm = 0x4003333
leaq 0x281c4(%rip), %rcx     # 0x640dc
callq 0x5ed0
leaq 0x3b25c(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x3003, %rax           # imm = 0x3003
cmpq $0x0, %rax
je 0x3bf9e
leaq 0x3b246(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x40, %rax
cmpq $0x0, %rax
je 0x3bf5f
movq -0x20(%rbp), %rsi
leaq 0x2bc27(%rip), %rdi     # 0x67b79
movb $0x0, %al
callq 0x3110
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
movl -0x24(%rbp), %edx
leaq 0x30465(%rip), %rdi     # 0x6c3d6
movb $0x0, %al
callq 0x3110
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
leaq 0x3b1fb(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x30, %rax
cmpq $0x0, %rax
je 0x3bf9c
movl $0xb, %edi
callq 0x60e0
jmp 0x3bf9e
leaq 0x3b1db(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x30, %rax
cmpq $0x0, %rax
je 0x3bfea
leaq 0x30d5f(%rip), %rdi     # 0x6cd18
movb $0x0, %al
callq 0x3110
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x2b857(%rip), %rdi     # 0x67834
movb $0x0, %al
callq 0x3110
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
callq 0x1ef50
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
jne 0x3c136
movq -0x8(%rbp), %rdi
callq 0x30a0
cmpl $0x0, %eax
jne 0x3c136
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movzwl %ax, %esi
callq 0x4610
movq %rax, 0x4083a(%rip)     # 0x7c898
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4480
movw %ax, 0x40829(%rip)      # 0x7c8a0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4480
movw %ax, 0x40812(%rip)      # 0x7c8a2
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x407ff(%rip)     # 0x7c8a8
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x407ee(%rip)     # 0x7c8b0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x407dd(%rip)     # 0x7c8b8
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x407cc(%rip)     # 0x7c8c0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x407bb(%rip)     # 0x7c8c8
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
jne 0x3c134
movq -0x8(%rbp), %rdi
callq 0x30a0
cmpl $0x0, %eax
jne 0x3c134
leaq 0x40768(%rip), %rax     # 0x7c898
movq %rax, -0x20(%rbp)
jmp 0x3c136
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_prop_header
struct x3f_prop_header *
read_x3f_prop_header(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    static struct x3f_prop_header header;
    struct x3f_prop_header *headerptr = (struct x3f_prop_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.num_entries = read_ulong(inptr,byteorder,HERE);
        header.char_format = read_ulong(inptr,byteorder,HERE);
        header.reserved = read_ulong(inptr,byteorder,HERE);
        header.entry_length = read_ulong(inptr,byteorder,HERE);
        if(!feof(inptr) && !ferror(inptr))
            headerptr = &header;
    }
    return(headerptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
jne 0x3ca1d
movq -0x8(%rbp), %rdi
callq 0x30a0
cmpl $0x0, %eax
jne 0x3ca1d
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movzwl %ax, %esi
callq 0x4610
movq %rax, 0x3ffaa(%rip)     # 0x7c908
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4480
movw %ax, 0x3ff99(%rip)      # 0x7c910
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4480
movw %ax, 0x3ff82(%rip)      # 0x7c912
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x3ff6f(%rip)     # 0x7c918
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x3ff5e(%rip)     # 0x7c920
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x3ff4d(%rip)     # 0x7c928
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x3ff3c(%rip)     # 0x7c930
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
jne 0x3ca1b
movq -0x8(%rbp), %rdi
callq 0x30a0
cmpl $0x0, %eax
jne 0x3ca1b
leaq 0x3fef1(%rip), %rax     # 0x7c908
movq %rax, -0x20(%rbp)
jmp 0x3ca1d
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/x3f.c
// Function: read_x3f_camf_header
struct x3f_camf_header *
read_x3f_camf_header(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    static struct x3f_camf_header header;
    struct x3f_camf_header *headerptr = (struct x3f_camf_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.item1 = read_ulong(inptr,byteorder,HERE);
        header.item2 = read_ulong(inptr,byteorder,HERE);
        header.item3 = read_ulong(inptr,byteorder,HERE);
        header.item4 = read_ulong(inptr,byteorder,HERE);
        header.item5 = read_ulong(inptr,byteorder,HERE);
        if(!feof(inptr) && !ferror(inptr))
            headerptr = &header;
    }
    return(headerptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
jne 0x3d8d6
movq -0x8(%rbp), %rdi
callq 0x30a0
cmpl $0x0, %eax
jne 0x3d8d6
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movzwl %ax, %esi
callq 0x4610
movq %rax, 0x3f0d2(%rip)     # 0x7c8d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4480
movw %ax, 0x3f0c1(%rip)      # 0x7c8d8
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4480
movw %ax, 0x3f0aa(%rip)      # 0x7c8da
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x3f097(%rip)     # 0x7c8e0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x3f086(%rip)     # 0x7c8e8
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x3f075(%rip)     # 0x7c8f0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x3f064(%rip)     # 0x7c8f8
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
movq %rax, 0x3f053(%rip)     # 0x7c900
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
jne 0x3d8d4
movq -0x8(%rbp), %rdi
callq 0x30a0
cmpl $0x0, %eax
jne 0x3d8d4
leaq 0x3f000(%rip), %rax     # 0x7c8d0
movq %rax, -0x20(%rbp)
jmp 0x3d8d6
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_nikon.c
// Function: nikon_model_number
int
nikon_model_number(char *model,char *software)
{
    struct camera_id *model_id;
    int number = NO_MODEL;

    for(model_id = &nikon_model_id[0]; model_id && model_id->name; ++model_id)
    {
        if(strncasecmp(model,model_id->name,model_id->namelen) == 0)
        {
            number = model_id->id;
            setnoteversion(model_id->noteversion);
            setnotetagset(model_id->notetagset);    /* info only      */
            break;
        }
    }
    return(number);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x39772(%rip), %rax     # 0x77b60
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1d(%rbp)
je 0x3e40c
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x3e415
jmp 0x3e466
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rax
movslq 0x8(%rax), %rdx
callq 0x31e0
cmpl $0x0, %eax
jne 0x3e456
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %edi
callq 0x28080
movq -0x18(%rbp), %rax
movl 0x14(%rax), %edi
callq 0x28100
jmp 0x3e466
jmp 0x3e458
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x18(%rbp)
jmp 0x3e3f2
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/maker_nikon.c
// Function: set_nikon_noteversion
int
set_nikon_noteversion()
{
    struct maker_scheme *scheme;
    int noteversion = 0;
    int tagset = 0;

    scheme = retrieve_makerscheme();
    if(scheme->note_version <= 0)
    {
        noteversion = -1;
        tagset = -1;
        switch(scheme->scheme_type)
        {
            case HAS_ID_SCHEME:
                tagset = 1;
                noteversion = 1;
                break;
            case PLAIN_IFD_SCHEME:
            case HAS_ID_PLUS_TIFFHDR_SCHEME:
                tagset = 2;
                noteversion = 2;
                break;
            case UNKNOWN_SCHEME:
                break;
            default: 
                break;
        }
        setnotetagset(tagset);
        setnoteversion(noteversion);
    }
    else
        noteversion = scheme->note_version;
    return(noteversion);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movb $0x0, %al
callq 0x28130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jg 0x3e504
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x3e4f0
movq -0x18(%rbp), %rax
leaq 0x2e1fb(%rip), %rcx     # 0x6c6c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
jmp 0x3e4f2
movl $0x2, -0x10(%rbp)
movl $0x2, -0xc(%rbp)
jmp 0x3e4f2
jmp 0x3e4f2
jmp 0x3e4f2
movl -0x10(%rbp), %edi
callq 0x28100
movl -0xc(%rbp), %edi
callq 0x28080
jmp 0x3e50e
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)