LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/process.c
// Function: lock_number
int
lock_number(struct image_summary *summary_entry)
{
    int number = 0;
    struct image_summary *prev_entry,*last_entry;

    if(summary_entry)
    {
        if(summary_entry->entry_lock)
            number = summary_entry->entry_lock;  /* don't change it */
        else if((last_entry = last_summary_entry(summary_entry)))
        {
            /* Find the highest existing lock number; go to the end   */
            /* and scan back to the head                              */
            if(last_entry->entry_lock > 0)
                number = last_entry->entry_lock + 1;
            prev_entry = last_entry->prev_entry;
            while(prev_entry)
            {
                if(prev_entry->entry_lock >= number)
                    number = prev_entry->entry_lock + 1;
                prev_entry = prev_entry->prev_entry;
            }
            if(number <= 0)
                number = 1;
        }
        else
            number = 1;
    }
    if(Debug & SCAN_DEBUG)
    {
        (void)newline(1);
        printred("DEBUG: LOCK SUMMARY");
        printf(" %#x ==> %d",(unsigned int)summary_entry,number);
        (void)newline(1);
        (void)newline(1);
    }
    return(number);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x15870
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x157f4
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x1586e
movq -0x8(%rbp), %rdi
callq 0x15780
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x15865
movq -0x20(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x1581e
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15856
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0x15849
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15829
cmpl $0x0, -0xc(%rbp)
jg 0x15863
movl $0x1, -0xc(%rbp)
jmp 0x1586c
movl $0x1, -0xc(%rbp)
jmp 0x1586e
jmp 0x15870
leaq 0x66e39(%rip), %rax     # 0x7c6b0
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x158c2
movl $0x1, %edi
callq 0x1ef50
leaq 0x51922(%rip), %rdi     # 0x671b4
callq 0x6860
movq -0x8(%rbp), %rax
movl %eax, %esi
movl -0xc(%rbp), %edx
leaq 0x51921(%rip), %rdi     # 0x671c8
movb $0x0, %al
callq 0x3110
movl $0x1, %edi
callq 0x1ef50
movl $0x1, %edi
callq 0x1ef50
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/process.c
// Function: destroy_summary
struct image_summary *
destroy_summary(struct image_summary *summary_entry)
{
    struct image_summary *prev_entry = NULL;

    /* start at the end and work back to the head                     */
    if(Debug & SCAN_DEBUG)
        printred("DEBUG: DESTROY SUMMARY ");
    if(summary_entry)
    {
        while(summary_entry->next_entry)
            summary_entry = summary_entry->next_entry;
        while(summary_entry)
        {
            prev_entry = summary_entry->prev_entry;
            free(summary_entry);
            summary_entry = prev_entry;
        }
    }
    return(prev_entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
leaq 0x621c5(%rip), %rax     # 0x7c6b0
movl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1a501
leaq 0x4ccd8(%rip), %rdi     # 0x671d4
callq 0x6860
cmpq $0x0, -0x8(%rbp)
je 0x1a54c
jmp 0x1a50a
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1a523
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a50a
jmp 0x1a525
cmpq $0x0, -0x8(%rbp)
je 0x1a54a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3040
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1a525
jmp 0x1a54c
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/process.c
// Function: skip_past_newline
int
skip_past_newline(FILE *inptr,unsigned long max_offset)
{
    int ch;
    while(((unsigned long)ftell(inptr) < max_offset) && ((ch = fgetc(inptr)) != '\n') && ch != EOF)
        continue;
    return(fgetc(inptr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3180
movq %rax, %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x15(%rbp)
jae 0x1d9e9
movq -0x8(%rbp), %rdi
callq 0x3140
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x15(%rbp)
je 0x1d9e9
cmpl $-0x1, -0x14(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1d9f2
jmp 0x1d9f4
jmp 0x1d9b0
movq -0x8(%rbp), %rdi
callq 0x3140
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/process.c
// Function: putword
int
putword(FILE *inptr,int firstch,unsigned long max_offset,int indent)
{
    int eol = 0;
    int chpr = 0;
    int ch = firstch;

    if(firstch)
        print_tag_address(APP_ENTRY,ftell(inptr),indent + SMALLINDENT,"@");
    if(firstch)
    {
        if(firstch != '[')
            extraindent(SMALLINDENT);
        putchar(firstch);
        ++chpr;
    }
    else
        ++eol;
    while(((unsigned long)ftell(inptr) < max_offset) && !eol)
    {
        ch = fgetc(inptr);
        switch(ch)
        {
        case '\r':
            break;
        case 0:
            ++eol;
            break;
        case '\n':
            ++eol;
            ch = fgetc(inptr);
            break;
        case EOF:
            ++eol;
            break;
        default:
            if(isprint(ch))
                putchar(ch);
            ++chpr;
            break;
        }
    }
    setcharsprinted(chpr);
    return(ch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1da63
movq -0x8(%rbp), %rdi
callq 0x3180
movq %rax, %rsi
movl -0x1c(%rbp), %edx
addl $0x2, %edx
movl $0x100000, %edi         # imm = 0x100000
leaq 0x4667e(%rip), %rcx     # 0x640dc
callq 0x5ed0
cmpl $0x0, -0xc(%rbp)
je 0x1da8c
cmpl $0x5b, -0xc(%rbp)
je 0x1da79
movl $0x2, %edi
callq 0xb970
movl -0xc(%rbp), %edi
callq 0x3050
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1da95
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1da97
movq -0x8(%rbp), %rdi
callq 0x3180
movq %rax, %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x29(%rbp)
jae 0x1daba
cmpl $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x1dac6
jmp 0x1db55
movq -0x8(%rbp), %rdi
callq 0x3140
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
incl %eax
movl %eax, %ecx
movq %rcx, -0x38(%rbp)
subl $0xe, %eax
ja 0x1db25
movq -0x38(%rbp), %rax
leaq 0x48dc7(%rip), %rcx     # 0x668b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x1db50
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1db50
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3140
movl %eax, -0x28(%rbp)
jmp 0x1db50
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1db50
callq 0x32c0
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4000, %eax           # imm = 0x4000
cmpl $0x0, %eax
je 0x1db47
movl -0x28(%rbp), %edi
callq 0x3050
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1da97
movl -0x24(%rbp), %edi
callq 0x1ff00
movl -0x28(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/process.c
// Function: skip_to_bracket
int
skip_to_bracket(FILE *inptr,unsigned long max_offset)
{
    int ch = EOF;

    while(((unsigned long)ftell(inptr) < max_offset) && ((ch = fgetc(inptr)) != '[') && ch != EOF)
        continue;
    if(ftell(inptr) >= max_offset)
        ch = 0;
    return(ch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
callq 0x3180
movq %rax, %rcx
xorl %eax, %eax
cmpq -0x10(%rbp), %rcx
movb %al, -0x15(%rbp)
jae 0x1dbc0
movq -0x8(%rbp), %rdi
callq 0x3140
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x5b, %ecx
movb %al, -0x15(%rbp)
je 0x1dbc0
cmpl $-0x1, -0x14(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x1dbc9
jmp 0x1dbcb
jmp 0x1db87
movq -0x8(%rbp), %rdi
callq 0x3180
cmpq -0x10(%rbp), %rax
jb 0x1dbe1
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: value_type_name
char *
value_type_name(unsigned short value_type)
{
    char *name;

    switch(value_type)
    {
        case BYTE: name = "BYTE"; break;
        case ASCII: name = "ASCII"; break;
        case SBYTE: name = "SBYTE"; break;
        case UNDEFINED: name = "UNDEFINED"; break;
        case SHORT: name = "SHORT"; break;
        case SSHORT: name = "SSHORT"; break;
        case LONG: name = "LONG"; break;
        case SLONG: name = "SLONG"; break;
        case FLOAT: name = "FLOAT"; break;
        case RATIONAL: name = "RATIONAL"; break;
        case SRATIONAL: name = "SRATIONAL"; break;
        case DOUBLE: name = "DOUBLE"; break;
        default: name = "INVALID"; break;
    }
    return(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xb, %eax
ja 0x1dd39
movq -0x18(%rbp), %rax
leaq 0x49f65(%rip), %rcx     # 0x67bf0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x49ff2(%rip), %rax     # 0x67c8d
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x46bd9(%rip), %rax     # 0x64884
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49fd1(%rip), %rax     # 0x67c8c
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x47009(%rip), %rax     # 0x64cd4
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49fbb(%rip), %rax     # 0x67c93
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49fad(%rip), %rax     # 0x67c92
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49fa8(%rip), %rax     # 0x67c9a
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49f9a(%rip), %rax     # 0x67c99
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49f93(%rip), %rax     # 0x67c9f
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49f8d(%rip), %rax     # 0x67ca6
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49f7f(%rip), %rax     # 0x67ca5
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49f7c(%rip), %rax     # 0x67caf
movq %rax, -0x10(%rbp)
jmp 0x1dd44
leaq 0x49f76(%rip), %rax     # 0x67cb6
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: strdup_value
char *
strdup_value(struct ifd_entry *entry, FILE *inptr,
                                        unsigned long fileoffset_base)
{
    char *val = NULL;
    if (is_offset(entry))
    {
        char *buf = (char *)read_bytes(inptr,
                                       entry->count,
                                       fileoffset_base +
                                       entry->value);
        if (buf) {
            val = strndup(buf, entry->count);
        }
        return val;
    }
    else
    {
        char *buf = (char *)&(entry->value);
        val = (char*)calloc(entry->count + 1, sizeof(char));
        for (int i = 0; i < entry->count; i++) {
          val[i] = buf[i];
        }
        return val;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x158d0
cmpl $0x0, %eax
je 0x1ddc1
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
addq 0x10(%rax), %rdx
callq 0x47a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1ddb7
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3150
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1de25
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x3160
movq %rax, -0x28(%rbp)
movl $0x0, -0x3c(%rbp)
movslq -0x3c(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1de1d
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1ddee
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_summary
void
print_summary(struct image_summary *summary_entry)
{
    int number_of_images = 0;
    int images_found = 0;
    int chpr = 0;
    char *plural;

    /* Pre-process the summary list; marks primary, reduced-res image */
    /* types and attempts to avoid kruft from imcomplete summary      */
    /* entries.                                                       */
    number_of_images = scan_summary(summary_entry);

    for( ; summary_entry; summary_entry = summary_entry->next_entry)
    {
        PUSHCOLOR(SUMMARY_COLOR);
        images_found += print_image_summary_entry(summary_entry,"@");
        POPCOLOR();
    }

    chpr = newline(chpr);
    plural = NULLSTRING;
    print_filename();
    if(LIST_MODE)
        chpr += printf("NumberOfImages = %d",number_of_images);
    else
        chpr += printf("Number of images = %d",number_of_images);
    if(number_of_images - images_found)
    {
        chpr = newline(chpr);
        print_filename();
        if(LIST_MODE)
            chpr += printf("ImagesNotFound = %d",number_of_images - images_found);
        else
            chpr += printf("Images not found = %d",number_of_images - images_found);
    }
    chpr = newline(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1df70
movl %eax, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1de88
movq -0x8(%rbp), %rdi
leaq 0x4626d(%rip), %rsi     # 0x640dc
callq 0x1ebc0
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x1de5d
movl -0x14(%rbp), %edi
callq 0x1ef50
movl %eax, -0x14(%rbp)
leaq 0x4c480(%rip), %rax     # 0x6a31a
movq %rax, -0x20(%rbp)
callq 0x20a30
leaq 0x592d6(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1040000, %rax        # imm = 0x1040000
cmpq $0x0, %rax
jne 0x1ded2
movl -0xc(%rbp), %esi
leaq 0x49dfb(%rip), %rdi     # 0x67cbe
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1dee9
movl -0xc(%rbp), %esi
leaq 0x49df6(%rip), %rdi     # 0x67cd2
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
subl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x1df52
movl -0x14(%rbp), %edi
callq 0x1ef50
movl %eax, -0x14(%rbp)
callq 0x20a30
leaq 0x59275(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1040000, %rax        # imm = 0x1040000
cmpq $0x0, %rax
jne 0x1df36
movl -0xc(%rbp), %esi
subl -0x10(%rbp), %esi
leaq 0x49dc1(%rip), %rdi     # 0x67ce8
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1df50
movl -0xc(%rbp), %esi
subl -0x10(%rbp), %esi
leaq 0x49db9(%rip), %rdi     # 0x67cfc
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1df52
movl -0x14(%rbp), %edi
callq 0x1ef50
movl %eax, -0x14(%rbp)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: newline
int
newline(int charsprinted)
{
    if((charsprinted != 0) || (Charsprinted != 0))
        putchar('\n');
    Charsprinted = 0;
    return(Charsprinted);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x1ef6a
cmpl $0x0, 0x5d620(%rip)     # 0x7c588
je 0x1ef74
movl $0xa, %edi
callq 0x3050
movl $0x0, 0x5d60a(%rip)     # 0x7c588
movl 0x5d604(%rip), %eax     # 0x7c588
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_imagecompression
void
print_imagecompression(struct image_summary *entry)
{
    if(entry)
    {
        switch(entry->imageformat)
        {
        case IMGFMT_MRW:    /* gets it from a TIFF IFD                */
        case IMGFMT_TIFF:
            print_tiff_compression(entry);
            break;
        case IMGFMT_JPEG:
            print_jpeg_compression(entry);
            break;
        case IMGFMT_JPEG2000:
            print_jp2c_compression(entry);
            break;
        case IMGFMT_CRW:
            print_crw_compression(entry);
            break;
        case IMGFMT_RAF:
            print_raf_compression(entry);
            break;
        case IMGFMT_X3F:
            print_x3f_compression(entry);
            break;
        default:
            break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1f486
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq %rax, -0x10(%rbp)
subq $0x1a, %rax
je 0x1f461
jmp 0x1f3ee
movq -0x10(%rbp), %rax
subq $0x2a, %rax
je 0x1f440
jmp 0x1f3fa
movq -0x10(%rbp), %rax
subq $0x4655, %rax           # imm = 0x4655
je 0x1f46c
jmp 0x1f408
movq -0x10(%rbp), %rax
subq $0xffd8, %rax           # imm = 0xFFD8
je 0x1f44b
jmp 0x1f416
movq -0x10(%rbp), %rax
subq $0x4d524d, %rax         # imm = 0x4D524D
je 0x1f440
jmp 0x1f424
movq -0x10(%rbp), %rax
subq $0xd0a870a, %rax        # imm = 0xD0A870A
je 0x1f456
jmp 0x1f432
movq -0x10(%rbp), %rax
subq $0x62564f46, %rax       # imm = 0x62564F46
je 0x1f477
jmp 0x1f482
movq -0x8(%rbp), %rdi
callq 0x1ff20
jmp 0x1f484
movq -0x8(%rbp), %rdi
callq 0x20310
jmp 0x1f484
movq -0x8(%rbp), %rdi
callq 0x20460
jmp 0x1f484
movq -0x8(%rbp), %rdi
callq 0x20550
jmp 0x1f484
movq -0x8(%rbp), %rdi
callq 0x205e0
jmp 0x1f484
movq -0x8(%rbp), %rdi
callq 0x20670
jmp 0x1f484
jmp 0x1f484
jmp 0x1f486
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_imagesubtype
void
print_imagesubtype(struct image_summary *entry)
{
    char *type_of_image = UNKNOWN_STRING;
    int chpr = 0;

    switch(entry->subfiletype)
    {
    case THUMBNAIL_TYPE:
        type_of_image = THUMBNAIL_STRING;
        break;
    case PRIMARY_TYPE:
        type_of_image = PRIMARY_STRING;
        break;
    case PAGE_TYPE:
        type_of_image = PAGE_STRING;
        break;
    case MASK_TYPE:
        type_of_image = MASK_STRING;
        break;
    case REDUCED_RES_TYPE:
        type_of_image = REDUCED_RES_STRING; /* if not marked THUMBNAIL */
        break;
    default:
        type_of_image = UNSPECIFIED_STRING;
        break;
    }
    if(*type_of_image)
        chpr += printf(" %s",type_of_image);
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x4ae77(%rip), %rax     # 0x6a31a
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0xc4(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0x1f51a
movq -0x20(%rbp), %rax
leaq 0x48750(%rip), %rcx     # 0x67c20
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4833e(%rip), %rax     # 0x6781e
movq %rax, -0x10(%rbp)
jmp 0x1f525
leaq 0x48fec(%rip), %rax     # 0x684d9
movq %rax, -0x10(%rbp)
jmp 0x1f525
leaq 0x48fe7(%rip), %rax     # 0x684e1
movq %rax, -0x10(%rbp)
jmp 0x1f525
leaq 0x48fe5(%rip), %rax     # 0x684ec
movq %rax, -0x10(%rbp)
jmp 0x1f525
leaq 0x48fe3(%rip), %rax     # 0x684f7
movq %rax, -0x10(%rbp)
jmp 0x1f525
leaq 0x4adf9(%rip), %rax     # 0x6a31a
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1f546
movq -0x10(%rbp), %rsi
leaq 0x44b5d(%rip), %rdi     # 0x64096
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_imagesize
void
print_imagesize(struct image_summary *entry)
{
    int chpr = 0;
    char *maybeshort = NULLSTRING;

    if(entry)
    {
        if(entry->imagesubformat & IMGSUBFMT_JPEG_EARLY_EOI)
            maybeshort = "<= ";
        chpr += printf(" image [%ldx%ld",entry->pixel_width,entry->pixel_height);
        if(entry->subfiletype == PRIMARY_TYPE)
        {
            if((entry->primary_width > entry->pixel_width) ||
                       (entry->primary_height > entry->pixel_height)) 
            {
                chpr += printf("<=%ldx%ld",entry->primary_width,entry->primary_height);
            }
        }
        chpr += printf("] length %s%lu",maybeshort,entry->length);
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
leaq 0x4ada0(%rip), %rax     # 0x6a31a
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1f649
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
andq $0x20000000, %rax       # imm = 0x20000000
cmpq $0x0, %rax
je 0x1f5ab
leaq 0x48f63(%rip), %rax     # 0x6850a
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdx
leaq 0x48f4c(%rip), %rdi     # 0x6850e
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, 0xc4(%rax)
jne 0x1f626
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x70(%rcx), %rax
ja 0x1f600
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x78(%rcx), %rax
jbe 0x1f624
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdx
leaq 0x48f07(%rip), %rdi     # 0x6851e
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x1f626
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdx
leaq 0x48eec(%rip), %rdi     # 0x68528
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: find_camera_name
char *
find_camera_name(int make)
{
    struct camera_name *maker_id;
    char *camera_name = UNKNOWN_CAMERA_STRING;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
leaq 0x48148(%rip), %rax     # 0x67fe6
movq %rax, -0x18(%rbp)
leaq 0x582f7(%rip), %rax     # 0x781a0
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x1fec7
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x1fed0
jmp 0x1fef9
movl -0x4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x1fee9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1fef9
jmp 0x1feeb
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x10(%rbp)
jmp 0x1fead
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_tiff_compression
void
print_tiff_compression(struct image_summary *entry)
{
    char *compression;
    int chpr = 0;

    compression = tiff_compression_string(entry->compression);
    chpr += printf(" %s",compression);
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq 0xc8(%rax), %rdi
callq 0x1ff70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x44144(%rip), %rdi     # 0x64096
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_jp2c_compression
void
print_jp2c_compression(struct image_summary *entry)
{
    char *transform;
    char *quantization;
    int chpr = 0;

    transform = quantization = NULLSTRING;
    if(entry)
    {
        if((entry->compression & 0xff) == 1)
            transform = "5/3 reversible";
        else
            transform = "9/7 irreversible";
        switch((entry->compression & 0xff00) >> 8)
        {
            case 0:
                quantization = "no quantization";
                break;
            case 1:
                quantization = "implicit quantization";
                break;
            case 2:
                quantization = "explicit quantization";
                break;
            default:
                quantization = "unknown quantization";
                break;
        }
    }
    chpr += printf(" (%s compression with %s)",transform,quantization);
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x49ea0(%rip), %rax     # 0x6a31a
movq %rax, -0x18(%rbp)
leaq 0x49e95(%rip), %rax     # 0x6a31a
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2051f
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %eax
andl $0xff, %eax
cmpl $0x1, %eax
jne 0x204b5
leaq 0x4b4b2(%rip), %rax     # 0x6b961
movq %rax, -0x10(%rbp)
jmp 0x204c0
leaq 0x4b4b7(%rip), %rax     # 0x6b973
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xc8(%rax), %eax
shrl $0x8, %eax
movl %eax, -0x20(%rbp)
testl %eax, %eax
je 0x204eb
jmp 0x204d7
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x204f8
jmp 0x204e1
movl -0x20(%rbp), %eax
subl $0x2, %eax
je 0x20505
jmp 0x20512
leaq 0x47f0f(%rip), %rax     # 0x68401
movq %rax, -0x18(%rbp)
jmp 0x2051d
leaq 0x47f12(%rip), %rax     # 0x68411
movq %rax, -0x18(%rbp)
jmp 0x2051d
leaq 0x47f1b(%rip), %rax     # 0x68427
movq %rax, -0x18(%rbp)
jmp 0x2051d
leaq 0x47f24(%rip), %rax     # 0x6843d
movq %rax, -0x18(%rbp)
jmp 0x2051f
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x47f24(%rip), %rdi     # 0x68452
movb $0x0, %al
callq 0x3110
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_crw_compression
void
print_crw_compression(struct image_summary *entry)
{
    char *compression;
    int chpr = 0;

    compression = NULLSTRING;
    if(entry)
    {
        switch(entry->compression)
        {
            case 0: compression = "uncompressed"; break;
            case 1: compression = "compressed"; break;
            default: break;
        }
    }
    chpr += printf(" %s",compression);
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x49db0(%rip), %rax     # 0x6a31a
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x205b0
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x20592
jmp 0x20588
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x2059f
jmp 0x205ac
leaq 0x47aae(%rip), %rax     # 0x68047
movq %rax, -0x10(%rbp)
jmp 0x205ae
leaq 0x47c98(%rip), %rax     # 0x6823e
movq %rax, -0x10(%rbp)
jmp 0x205ae
jmp 0x205ae
jmp 0x205b0
movq -0x10(%rbp), %rsi
leaq 0x43adb(%rip), %rdi     # 0x64096
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_raf_compression
void
print_raf_compression(struct image_summary *entry)
{
    char *compression;
    int chpr = 0;

    compression = NULLSTRING;
    if(entry)
    {
        switch(entry->compression)
        {
            case 0: compression = "uncompressed"; break;
            case 1: compression = "uncompressed (with secondary)"; break;
            default: break;
        }
    }
    chpr += printf(" %s",compression);
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x49d20(%rip), %rax     # 0x6a31a
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20640
movq -0x8(%rbp), %rax
movl 0xc8(%rax), %eax
movl %eax, -0x18(%rbp)
testl %eax, %eax
je 0x20622
jmp 0x20618
movl -0x18(%rbp), %eax
subl $0x1, %eax
je 0x2062f
jmp 0x2063c
leaq 0x47a1e(%rip), %rax     # 0x68047
movq %rax, -0x10(%rbp)
jmp 0x2063e
leaq 0x47e36(%rip), %rax     # 0x6846c
movq %rax, -0x10(%rbp)
jmp 0x2063e
jmp 0x2063e
jmp 0x20640
movq -0x10(%rbp), %rsi
leaq 0x43a4b(%rip), %rdi     # 0x64096
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_x3f_compression
void
print_x3f_compression(struct image_summary *entry)
{
    char *compression;
    int chpr = 0;

    compression = NULLSTRING;
    if(entry)
    {
        switch(entry->imagesubformat)
        {
            case IMGSUBFMT_HUFF_COMPRESSED_RGB: compression = "Huffman compressed"; break;
            case IMGSUBFMT_JPEG_COMPRESSED_RGB: compression = "Jpeg compressed"; break;
            case IMGSUBFMT_X3F_COMPRESSED: compression = "compressed"; break;
            case IMGSUBFMT_RGB: compression = "uncompressed"; break;
            default: break;
        }
    }
    chpr += printf(" %s",compression);
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x49c90(%rip), %rax     # 0x6a31a
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x20710
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x20(%rbp)
subq $0x10002, %rax          # imm = 0x10002
je 0x206ff
jmp 0x206ae
movq -0x20(%rbp), %rax
subq $0x20001, %rax          # imm = 0x20001
je 0x206d8
jmp 0x206bc
movq -0x20(%rbp), %rax
subq $0x20002, %rax          # imm = 0x20002
je 0x206e5
jmp 0x206ca
movq -0x20(%rbp), %rax
subq $0x20004, %rax          # imm = 0x20004
je 0x206f2
jmp 0x2070c
leaq 0x47dab(%rip), %rax     # 0x6848a
movq %rax, -0x10(%rbp)
jmp 0x2070e
leaq 0x47db1(%rip), %rax     # 0x6849d
movq %rax, -0x10(%rbp)
jmp 0x2070e
leaq 0x47b45(%rip), %rax     # 0x6823e
movq %rax, -0x10(%rbp)
jmp 0x2070e
leaq 0x47941(%rip), %rax     # 0x68047
movq %rax, -0x10(%rbp)
jmp 0x2070e
jmp 0x2070e
jmp 0x20710
movq -0x10(%rbp), %rsi
leaq 0x4397b(%rip), %rdi     # 0x64096
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: sum_strip_bytecounts
unsigned long
sum_strip_bytecounts(FILE *inptr,unsigned short byteorder,unsigned long offset,
    unsigned long count,unsigned short value_type)
{
    int i;
    unsigned long sum = 0L;

    if(count)
    {
        /* Some use SHORT, some use LONG. If anyone uses some other   */
        /* type, just ignore 'em.                                     */
        if(value_type == SHORT)
        {
            sum = read_ushort(inptr,byteorder,offset);
            for(i = 1; i < count; ++i)
                sum += read_ushort(inptr,byteorder,HERE);
        }
        else if(value_type == LONG)
        {
            sum = read_ulong(inptr,byteorder,offset);
            for(i = 1; i < count; ++i)
                sum += read_ulong(inptr,byteorder,HERE);
        }
    }
    return(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movw %si, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movw %ax, -0x22(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2082f
movzwl -0x22(%rbp), %eax
cmpl $0x3, %eax
jne 0x207d2
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movzwl %ax, %esi
callq 0x4480
movzwl %ax, %eax
movq %rax, -0x30(%rbp)
movl $0x1, -0x28(%rbp)
movslq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x207d0
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4480
movzwl %ax, %eax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2079e
jmp 0x2082d
movzwl -0x22(%rbp), %eax
cmpl $0x4, %eax
jne 0x2082b
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movzwl %ax, %esi
callq 0x4610
movq %rax, -0x30(%rbp)
movl $0x1, -0x28(%rbp)
movslq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x20829
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0xa(%rbp), %esi
callq 0x4610
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x207fa
jmp 0x2082b
jmp 0x2082d
jmp 0x2082f
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: toggle
unsigned long
toggle(unsigned long options,unsigned long bits)
{
    if(options & bits)
        options &= ~bits;
    else
        options |= bits;
    return(options);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
andq -0x10(%rbp), %rax
cmpq $0x0, %rax
je 0x208bc
movq -0x10(%rbp), %rax
xorq $-0x1, %rax
andq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x208c8
movq -0x10(%rbp), %rax
orq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: clear_memory
void
clear_memory()
{
    if(Make_name)
        free(Make_name);
    if(Model_name)
        free(Model_name);
    if(Software_name)
        free(Software_name);
    Make_name = Model_name = Software_name = (char *)0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x57b55(%rip), %rax     # 0x78430
cmpq $0x0, (%rax)
je 0x208f0
leaq 0x57b48(%rip), %rax     # 0x78430
movq (%rax), %rdi
callq 0x3040
leaq 0x57b41(%rip), %rax     # 0x78438
cmpq $0x0, (%rax)
je 0x2090c
leaq 0x57b34(%rip), %rax     # 0x78438
movq (%rax), %rdi
callq 0x3040
leaq 0x57b2d(%rip), %rax     # 0x78440
cmpq $0x0, (%rax)
je 0x20928
leaq 0x57b20(%rip), %rax     # 0x78440
movq (%rax), %rdi
callq 0x3040
leaq 0x57b11(%rip), %rax     # 0x78440
movq $0x0, (%rax)
leaq 0x57afb(%rip), %rax     # 0x78438
movq $0x0, (%rax)
leaq 0x57ae5(%rip), %rax     # 0x78430
movq $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: splice
char *
splice(char *string1,char *sep,char *string2)
{
    char splicebuf[1024];
    char *result = NULL;

    if(string1 == NULL)
        sep = string1 = NULLSTRING;
    if(string2 == NULL)
        string2 = NULLSTRING;
    snprintf(splicebuf,1024,"%s%s%s",string1,sep,string2);
    result = strdup(splicebuf);
    return(result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x428(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2099f
leaq 0x4998a(%rip), %rax     # 0x6a31a
movq %rax, -0x8(%rbp)
leaq 0x4997f(%rip), %rax     # 0x6a31a
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x209b1
leaq 0x4996d(%rip), %rax     # 0x6a31a
movq %rax, -0x18(%rbp)
leaq -0x420(%rbp), %rdi
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %r8
movq -0x18(%rbp), %r9
movl $0x400, %esi            # imm = 0x400
leaq 0x47baa(%rip), %rdx     # 0x6857a
movb $0x0, %al
callq 0x3120
leaq -0x420(%rbp), %rdi
callq 0x32a0
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/misc.c
// Function: print_filename
void
print_filename()
{
    int chpr = 0;

    if(((PRINT_FILENAMES)) && (Current_filename))
    {
        PUSHCOLOR(BLACK);
        chpr = printf("%s: ",Current_filename);
        POPCOLOR();
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x5673a(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x800, %rax            # imm = 0x800
cmpq $0x0, %rax
je 0x20a77
cmpq $0x0, 0x5bb33(%rip)     # 0x7c590
je 0x20a77
movq 0x5bb2a(%rip), %rsi     # 0x7c590
leaq 0x47b14(%rip), %rdi     # 0x68581
movb $0x0, %al
callq 0x3110
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x1ff00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/interpret.c
// Function: print_compression
void
print_compression(unsigned long compvalue)
{
    char *compstr;
    int chpr = 0;

    if((compstr = tiff_compression_string(compvalue)))
    {
        print_startvalue();
        chpr += printf("%s",compstr);
        print_endvalue();
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1ff70
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x20f3c
movb $0x0, %al
callq 0xb9a0
movq -0x10(%rbp), %rsi
leaq 0x4316f(%rip), %rdi     # 0x64097
movb $0x0, %al
callq 0x3110
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movb $0x0, %al
callq 0xb9d0
movl -0x14(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/interpret.c
// Function: print_orientation
void
print_orientation(unsigned long value)
{
    int chpr = 0;

    print_startvalue();
    switch(value)
    {
        case 1: chpr += printf("0,0 is top left"); break;
        case 2: chpr += printf("0,0 is top right"); break;
        case 3: chpr += printf("0,0 is bottom right"); break;
        case 4: chpr += printf("0,0 is bottom left"); break;
        case 5: chpr += printf("0,0 is left top"); break;
        case 6: chpr += printf("0,0 is right top"); break;
        case 7: chpr += printf("0,0 is right bottom"); break;
        case 8: chpr += printf("0,0 is left bottom"); break;
        default: chpr += printf("undefined"); break;
    }
    print_endvalue();
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
xorl %eax, %eax
callq 0xb9a0
movq -0x8(%rbp), %rax
decq %rax
movq %rax, -0x18(%rbp)
subq $0x7, %rax
ja 0x2133c
movq -0x18(%rbp), %rax
leaq 0x4730e(%rip), %rcx     # 0x68588
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4750a(%rip), %rdi     # 0x68794
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21350
leaq 0x47501(%rip), %rdi     # 0x687a4
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21350
leaq 0x474f9(%rip), %rdi     # 0x687b5
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21350
leaq 0x474f4(%rip), %rdi     # 0x687c9
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21350
leaq 0x474f1(%rip), %rdi     # 0x687dc
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21350
leaq 0x474eb(%rip), %rdi     # 0x687ec
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21350
leaq 0x474e6(%rip), %rdi     # 0x687fd
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21350
leaq 0x474e4(%rip), %rdi     # 0x68811
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21350
leaq 0x4a2c8(%rip), %rdi     # 0x6b60b
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movb $0x0, %al
callq 0xb9d0
movl -0xc(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/interpret.c
// Function: print_resunit
void
print_resunit(unsigned long unit)
{
    int chpr = 0;

    print_startvalue();
    switch(unit)
    {
        case 1: chpr += printf("no units"); break;
        case 2: chpr += printf("pixels per inch"); break;
        case 3: chpr += printf("pixels per cm"); break;
        default: chpr += printf("undefined"); break;
    }
    print_endvalue();
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
xorl %eax, %eax
callq 0xb9a0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
subq $0x1, %rax
je 0x213b2
jmp 0x2139a
movq -0x18(%rbp), %rax
subq $0x2, %rax
je 0x213c8
jmp 0x213a6
movq -0x18(%rbp), %rax
subq $0x3, %rax
je 0x213de
jmp 0x213f4
leaq 0x4746b(%rip), %rdi     # 0x68824
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21408
leaq 0x4745e(%rip), %rdi     # 0x6882d
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21408
leaq 0x47458(%rip), %rdi     # 0x6883d
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x21408
leaq 0x4a210(%rip), %rdi     # 0x6b60b
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movb $0x0, %al
callq 0xb9d0
movl -0xc(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/interpret.c
// Function: print_epfpresunit
void
print_epfpresunit(unsigned long unit)
{
    int chpr = 0;

    print_startvalue();
    switch(unit)
    {
        case 1: chpr += printf("no units"); break;
        case 2: chpr += printf("per meter"); break;
        case 3: chpr += printf("per cm"); break;
        case 4: chpr += printf("per mm"); break;
        case 5: chpr += printf("per um"); break;
        default: chpr += printf("undefined"); break;
    }
    print_endvalue();
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
xorl %eax, %eax
callq 0xb9a0
movq -0x8(%rbp), %rax
decq %rax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x214d1
movq -0x18(%rbp), %rax
leaq 0x4714e(%rip), %rcx     # 0x685a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x473ba(%rip), %rdi     # 0x68824
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x214e5
leaq 0x473cb(%rip), %rdi     # 0x6884b
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x214e5
leaq 0x473ae(%rip), %rdi     # 0x68844
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x214e5
leaq 0x4e3cb(%rip), %rdi     # 0x6f877
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x214e5
leaq 0x47393(%rip), %rdi     # 0x68855
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x214e5
leaq 0x4a133(%rip), %rdi     # 0x6b60b
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movb $0x0, %al
callq 0xb9d0
movl -0xc(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/interpret.c
// Function: print_colorspace
void
print_colorspace(unsigned long space)
{
    int chpr = 0;

    print_startvalue();
    if(space == 1)
        chpr += printf("sRGB");
    else if(space == 0xffff)
        chpr += printf("uncalibrated");
    else
        chpr += printf("reserved");
    print_endvalue();
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movb $0x0, %al
callq 0xb9a0
cmpq $0x1, -0x8(%rbp)
jne 0x21537
leaq 0x4a0ce(%rip), %rdi     # 0x6b5f6
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x2156d
cmpq $0xffff, -0x8(%rbp)     # imm = 0xFFFF
jne 0x21557
leaq 0x47314(%rip), %rdi     # 0x6885c
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x2156b
leaq 0x4730b(%rip), %rdi     # 0x68869
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x2156d
movb $0x0, %al
callq 0xb9d0
movl -0xc(%rbp), %edi
callq 0x1ff00
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/interpret.c
// Function: print_meteringmode
void
print_meteringmode(unsigned long mode)
{
    int chpr = 0;

    print_startvalue();
    switch(mode)
    {
        case 0: chpr += printf("unknown"); break;
        case 1: chpr += printf("Average"); break;
        case 2: chpr += printf("Center Weighted Average"); break;
        case 3: chpr += printf("Spot"); break;
        case 4: chpr += printf("Multi Spot"); break;
        case 5: chpr += printf("Pattern"); break;
        case 6: chpr += printf("Partial"); break;
        default: if(mode < 255) chpr += printf("reserved");
            else chpr += printf("other"); break;
    }
    print_endvalue();
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
xorl %eax, %eax
callq 0xb9a0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
subq $0x6, %rax
ja 0x21673
movq -0x18(%rbp), %rax
leaq 0x46ff5(%rip), %rcx     # 0x685bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x46a07(%rip), %rdi     # 0x67fde
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x216a9
leaq 0x47292(%rip), %rdi     # 0x68882
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x216a9
leaq 0x47269(%rip), %rdi     # 0x68872
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x216a9
leaq 0x4726e(%rip), %rdi     # 0x68890
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x216a9
leaq 0x47252(%rip), %rdi     # 0x6888a
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x216a9
leaq 0x43e9a(%rip), %rdi     # 0x654e8
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x216a9
leaq 0x47231(%rip), %rdi     # 0x68895
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x216a9
cmpq $0xff, -0x8(%rbp)
jae 0x21693
leaq 0x471e5(%rip), %rdi     # 0x68869
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x216a7
leaq 0x47203(%rip), %rdi     # 0x6889d
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x216a9
movb $0x0, %al
callq 0xb9d0
movl -0xc(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/interpret.c
// Function: print_epcfapattern
void
print_epcfapattern(unsigned long value,unsigned long count)
{
    unsigned char *p;
    int i;
    int chpr = 0;

    p = (unsigned char *)&value;
    print_startvalue();
    for(i = 0; i < count; ++i)
    {
        if(i)
        {
            putchar(',');
            ++chpr;
        }
        putcolorchar((unsigned short)*p++ & 0xff);
    }
    print_endvalue();
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x20(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, %al
callq 0xb9a0
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2173d
cmpl $0x0, -0x1c(%rbp)
je 0x21710
movl $0x2c, %edi
callq 0x3050
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movzbl (%rax), %eax
movzwl %ax, %eax
andl $0xff, %eax
movzwl %ax, %edi
callq 0xb8d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x216ed
movb $0x0, %al
callq 0xb9d0
movl -0x20(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)