LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Keith-S-Thompson[P]kst-time-utils/timer.c
// Function: show_time
static void show_time(FILE *stream, bool real_time_too) {
    struct timeval tv;
    int result = gettimeofday(&tv, NULL);
    if (result == 0) {
        if (! t0_initialized) {
            t0 = tv;
            t0_initialized = true;
        }
        if (absolute || absolute_readable) {
            show_timeval(stream, tv);
        }
        else {
            show_timeval(stream, diff(tv, t0));
            if (real_time_too) {
                fprintf(stream, " [");
                show_timeval(stream, tv);
                fprintf(stream, "]");
            }
        }
        if (relative) {
            t0 = tv;
        }
    }
    else {
        fprintf(stream, "---------.------");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1070
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x17b3
testb $0x1, 0x29d8(%rip)      # 0x40ad
jne 0x16f4
movq -0x20(%rbp), %rax
movq %rax, 0x29ce(%rip)      # 0x40b0
movq -0x18(%rbp), %rax
movq %rax, 0x29cb(%rip)      # 0x40b8
movb $0x1, 0x29b9(%rip)      # 0x40ad
testb $0x1, 0x29ad(%rip)      # 0x40a8
jne 0x1706
testb $0x1, 0x29a5(%rip)      # 0x40a9
je 0x1719
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x17d0
jmp 0x1792
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x2980(%rip), %rdx      # 0x40b0
movq 0x2981(%rip), %rcx      # 0x40b8
callq 0x18c0
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x17d0
testb $0x1, -0x9(%rbp)
je 0x1790
movq -0x8(%rbp), %rdi
leaq 0xaf7(%rip), %rsi       # 0x225d
movb $0x0, %al
callq 0x10c0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x17d0
movq -0x8(%rbp), %rdi
leaq 0xad7(%rip), %rsi       # 0x2260
movb $0x0, %al
callq 0x10c0
jmp 0x1792
testb $0x1, 0x2912(%rip)      # 0x40ab
je 0x17b1
movq -0x20(%rbp), %rax
movq %rax, 0x290a(%rip)      # 0x40b0
movq -0x18(%rbp), %rax
movq %rax, 0x2907(%rip)      # 0x40b8
jmp 0x17c5
movq -0x8(%rbp), %rdi
leaq 0xaa4(%rip), %rsi       # 0x2262
movb $0x0, %al
callq 0x10c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Keith-S-Thompson[P]kst-time-utils/timer.c
// Function: show_timeval
static void show_timeval(FILE *stream, struct timeval tv) {
    if (absolute_readable) {
        // YYYY-MM-DD-HH:MM:SS-mmmmmm
        struct tm *ltime = (utc ? gmtime : localtime)(&tv.tv_sec);
        char format[100];
        sprintf(format, "%%F-%%T.%06ld%s", tv.tv_usec, utc ? "Z" : "");
        char buf[100];
        strftime(buf, sizeof buf, format, ltime);
        fputs(buf, stream);
    }
    else {
        fprintf(stream, absolute ? "%10ld.%06ld" : "%8ld.%06ld",
                        (long)tv.tv_sec,
                        (long)tv.tv_usec);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
testb $0x1, 0x28bb(%rip)      # 0x40a9
je 0x187d
movb 0x28b0(%rip), %dl       # 0x40aa
movq 0x27b7(%rip), %rax      # 0x3fb8
movq 0x27e0(%rip), %rcx      # 0x3fe8
testb $0x1, %dl
cmovneq %rcx, %rax
leaq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
leaq -0x90(%rbp), %rdi
movq -0x8(%rbp), %rdx
movb 0x287f(%rip), %sil      # 0x40aa
leaq 0x86e(%rip), %rcx       # 0x20a0
leaq 0xa4a(%rip), %rax       # 0x2283
testb $0x1, %sil
cmovneq %rax, %rcx
leaq 0xa2b(%rip), %rsi       # 0x2273
movb $0x0, %al
callq 0x1100
leaq -0x100(%rbp), %rdi
leaq -0x90(%rbp), %rdx
movq -0x20(%rbp), %rcx
movl $0x64, %esi
callq 0x10d0
leaq -0x100(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1080
jmp 0x18ab
movq -0x18(%rbp), %rdi
movb 0x2821(%rip), %cl       # 0x40a8
leaq 0xa03(%rip), %rsi       # 0x2291
leaq 0x9f0(%rip), %rax       # 0x2285
testb $0x1, %cl
cmovneq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movb $0x0, %al
callq 0x10c0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Keith-S-Thompson[P]kst-time-utils/timer.c
// Function: diff
static struct timeval diff(struct timeval left, struct timeval right) {
    struct timeval result;

    result.tv_sec = left.tv_sec - right.tv_sec;
    result.tv_usec = left.tv_usec - right.tv_usec;
    if (result.tv_usec < 0) {
        result.tv_sec --;
        result.tv_usec += 1000000;
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
subq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x190d
movq -0x10(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0xf4240, %rax          # imm = 0xF4240
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_04/unlink.c
// Function: main
int main(int argc, char *argv[])
{
	int ret;

	if (argc < 2) {
		fprintf(stderr, "usage: %s <file>\n",
			argv[0]);
		return -1;
	}

	printf("unlinking %s\n", argv[1]);
	ret = unlink(argv[1]);
	if (ret < 0) {
		perror("link");
		return -1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x11b4
movq 0x2e65(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
leaq 0xe60(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11fc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xe53(%rip), %rdi       # 0x2016
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x11f5
leaq 0xe3d(%rip), %rdi       # 0x2024
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11fc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: to_ulong
unsigned long
to_ulong(unsigned char *buf,unsigned short byteorder)
{
    u_int32_t value = 0;

    if(buf)
    {
        value = *(u_int32_t *)buf;
#ifdef NATIVE_BYTEORDER_BIGENDIAN
        if(byteorder == TIFF_INTEL)
#else
        if(byteorder == TIFF_MOTOROLA)
#endif
            value = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
    }
    return((unsigned long)value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x49f4
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x4d4d, %eax           # imm = 0x4D4D
jne 0x49f2
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
shll $0x18, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x49f4
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: to_ushort
unsigned short
to_ushort(unsigned char *buf,unsigned short byteorder)
{
    unsigned short value = 0;

    if(buf)
    {
        value = *(unsigned short *)buf;
#ifdef NATIVE_BYTEORDER_BIGENDIAN
        if(byteorder == TIFF_INTEL)
            value = (buf[1] << 8) | buf[0];
#else
        if(byteorder == TIFF_MOTOROLA)
            value = (buf[0] << 8) | buf[1];
#endif
    }
    return(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movw $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4f0c
movq -0x8(%rbp), %rax
movw (%rax), %ax
movw %ax, -0xc(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x4d4d, %eax           # imm = 0x4D4D
jne 0x4f0a
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x8(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movw %ax, -0xc(%rbp)
jmp 0x4f0c
movw -0xc(%rbp), %ax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: read_float
float
read_float(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    float value = 0.0;
    unsigned long ulval;

    ulval = read_ulong(inptr,byteorder,offset);
    value = to_float(ulval);
    return(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movzwl %ax, %esi
callq 0x4610
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5100
movss %xmm0, -0x1c(%rbp)
movss -0x1c(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: to_float
float
to_float(unsigned long uval)
{
    float value = 0.0;
    unsigned long *uval_ptr = &uval;

    value = *(float *)uval_ptr;
    return(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rbp)
leaq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: read_ulong64
unsigned long long
read_ulong64(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    unsigned char rbuf[sizeof(double)];
    unsigned long curoffset;
    unsigned long long value = 0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
            chpr += printf(" seek failed to offset %lu to read unsigned long\n",
                    offset);
        else if(fread(rbuf,1,sizeof(long long),inptr) == sizeof(long long))
            value = to_ulong64(rbuf,byteorder);
        else
        {
            printred(" FAILED to read unsigned 64bit integer at offset ");
            if(offset == HERE)
                offset = curoffset;
            chpr += printf("%lu\n",offset);
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x521b
movq -0x8(%rbp), %rdi
callq 0x31a0
movq -0x8(%rbp), %rdi
callq 0x3180
movq %rax, -0x28(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
je 0x51b0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3200
cmpl $-0x1, %eax
jne 0x51b0
movq -0x18(%rbp), %rsi
leaq 0x5f0b7(%rip), %rdi     # 0x64258
movb $0x0, %al
callq 0x3110
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x5219
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x8, %edx
callq 0x30c0
cmpq $0x8, %rax
jne 0x51e0
leaq -0x20(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x5230
movq %rax, -0x30(%rbp)
jmp 0x5217
leaq 0x5f0a3(%rip), %rdi     # 0x6428a
callq 0x6860
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jne 0x51ff
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x62c7a(%rip), %rdi     # 0x67e84
movb $0x0, %al
callq 0x3110
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x5219
jmp 0x521b
movl -0x34(%rbp), %edi
callq 0x1ff00
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: to_ulong64
unsigned long long
to_ulong64(unsigned char *buf,unsigned short byteorder)
{
    unsigned long long value = 0;
    unsigned char swap[sizeof(long long)];
    unsigned char *p;
    int i,size;

    if(buf)
    {
        p = buf;
#ifdef NATIVE_BYTEORDER_BIGENDIAN
        if(byteorder == TIFF_INTEL)
#else
        if(byteorder == TIFF_MOTOROLA)
#endif
        {
            size = sizeof(long long);
            for(i = 0; i < size; ++i)
                swap[i] = buf[size - 1 - i];
            p = swap;
        }
        value = *(long long *)p;
    }
    return(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x52b0
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x4d4d, %eax           # imm = 0x4D4D
jne 0x52a5
movl $0x8, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x529d
movq -0x8(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
subl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movslq -0x2c(%rbp), %rax
movb %cl, -0x20(%rbp,%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x526f
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: read_double
double
read_double(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    unsigned char rbuf[sizeof(double)];
    unsigned long curoffset;
    double value = 0.0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
            chpr += printf(" seek failed to offset %lu to read unsigned long\n",
                    offset);
        else if(fread(rbuf,1,sizeof(double),inptr) == sizeof(double))
            value = to_double(rbuf,byteorder);
        else
        {
            if(offset == HERE)
                offset = curoffset;
            PUSHCOLOR(RED);
            chpr += printf(" failed to read double value at offset %lu\n",offset);
            POPCOLOR();
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x53a0
movq -0x8(%rbp), %rdi
callq 0x31a0
movq -0x8(%rbp), %rdi
callq 0x3180
movq %rax, -0x28(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
je 0x5340
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3200
cmpl $-0x1, %eax
jne 0x5340
movq -0x18(%rbp), %rsi
leaq 0x5ef27(%rip), %rdi     # 0x64258
movb $0x0, %al
callq 0x3110
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x539e
leaq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rcx
movl $0x1, %esi
movl $0x8, %edx
callq 0x30c0
cmpq $0x8, %rax
jne 0x5371
leaq -0x20(%rbp), %rdi
movzwl -0xa(%rbp), %esi
callq 0x53c0
movsd %xmm0, -0x30(%rbp)
jmp 0x539c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
jne 0x5384
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x5ef2d(%rip), %rdi     # 0x642bc
movb $0x0, %al
callq 0x3110
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x539e
jmp 0x53a0
movl -0x34(%rbp), %edi
callq 0x1ff00
movsd -0x30(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: to_double
double
to_double(unsigned char *buf,unsigned short byteorder)
{
    double value = 0.0;
    unsigned char swap[sizeof(double)];
    unsigned char *p;
    int i,size;

    if(buf)
    {
        p = buf;
#ifdef NATIVE_BYTEORDER_BIGENDIAN
        if(byteorder == TIFF_INTEL)
#else
        if(byteorder == TIFF_MOTOROLA)
#endif
        {
            size = sizeof(double);
            for(i = 0; i < size; ++i)
                swap[i] = buf[size - 1 - i];
            p = swap;
        }
        value = *(double *)p;
    }
    return(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5442
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movzwl -0xa(%rbp), %eax
cmpl $0x4d4d, %eax           # imm = 0x4D4D
jne 0x5435
movl $0x8, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x30(%rbp), %eax
jge 0x542d
movq -0x8(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
subl -0x2c(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %cl
movslq -0x2c(%rbp), %rax
movb %cl, -0x20(%rbp,%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x53ff
leaq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: read_appstring
char *
read_appstring(FILE *inptr,unsigned short apptype,unsigned long offset)
{
    unsigned long length;
    char *appstring = NULLSTRING;


    if(inptr)
    {
        switch(apptype)
        {
            case JPEG_APP0:
                length = 32;    /* should be 5; allow for garbage     */
                break;
            case JPEG_APP1:
            case JPEG_APP2:
                length = 32;    /* should be 5; allow for garbage     */
                break;
            default:
                length = 32; 
                break;
        }
        if(length)
            appstring = read_string(inptr,offset,length);
    }
    return(appstring);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x64eac(%rip), %rax     # 0x6a31a
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54d2
movzwl -0xa(%rbp), %eax
movl %eax, -0x2c(%rbp)
subl $0xffe0, %eax           # imm = 0xFFE0
je 0x5498
jmp 0x5489
movl -0x2c(%rbp), %eax
addl $0xffff001f, %eax       # imm = 0xFFFF001F
subl $0x2, %eax
jb 0x54a2
jmp 0x54ac
movq $0x20, -0x20(%rbp)
jmp 0x54b4
movq $0x20, -0x20(%rbp)
jmp 0x54b4
movq $0x20, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x54d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4a00
movq %rax, -0x28(%rbp)
jmp 0x54d2
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: ateof
int
ateof(FILE *inptr)
{
    int atend = 0;
    if(feof(inptr))
        atend++;
    else if(fgetc(inptr) == -1)
        atend++;
    return(atend);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
je 0x550c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5525
movq -0x8(%rbp), %rdi
callq 0x3140
cmpl $-0x1, %eax
jne 0x5523
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5525
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/readfile.c
// Function: get_filesize
unsigned long
get_filesize(FILE *inptr)
{
    unsigned long size = 0L;
    long current_offset;

    if(inptr)
    {
        clearerr(inptr);
        /* move back here after getting the size                      */
        current_offset = ftell(inptr);
        if(fseek(inptr,0L,SEEK_END) == 0)
        {
            size = ftell(inptr);
            if(fseek(inptr,current_offset,SEEK_SET) != 0)
                clearerr(inptr);    /* silently                       */
        }
        else
            size = 0L;
    }
    return(size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x55ae
movq -0x8(%rbp), %rdi
callq 0x31a0
movq -0x8(%rbp), %rdi
callq 0x3180
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3200
cmpl $0x0, %eax
jne 0x55a4
movq -0x8(%rbp), %rdi
callq 0x3180
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3200
cmpl $0x0, %eax
je 0x55a2
movq -0x8(%rbp), %rdi
callq 0x31a0
jmp 0x55ac
movq $0x0, -0x10(%rbp)
jmp 0x55ae
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: print_byteorder
void
print_byteorder(unsigned short byteorder,int verbose)
{
    int chpr = 0;

    if(verbose == 1)
        chpr += printf("(");
    else if(verbose == 2)
        chpr += printf("\'");
    (void)show_string((char *)&byteorder,2,1);

    /* Check for a legitimate TIFF byteorder                          */
    if(verbose == 1)
    {
        switch(byteorder)
        {
            case TIFF_INTEL:
            case TIFF_MOTOROLA:
                chpr += printf("=%#06x)",byteorder);
                break;
            default:
                chpr +=printf("=%#06x=unknown)",byteorder);
                break;
        }
    }
    else if(verbose == 2)
        chpr += printf("\'");
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x5a15
leaq 0x5e7e4(%rip), %rdi     # 0x641ea
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x5a31
cmpl $0x2, -0x8(%rbp)
jne 0x5a2f
leaq 0x61c41(%rip), %rdi     # 0x67663
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x5a31
leaq -0x2(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0xb600
cmpl $0x1, -0x8(%rbp)
jne 0x5a9a
movzwl -0x2(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x4949, %eax           # imm = 0x4949
je 0x5a66
jmp 0x5a5a
movl -0x10(%rbp), %eax
subl $0x4d4d, %eax           # imm = 0x4D4D
jne 0x5a80
jmp 0x5a66
movzwl -0x2(%rbp), %esi
leaq 0x5efa5(%rip), %rdi     # 0x64a16
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x5a98
movzwl -0x2(%rbp), %esi
leaq 0x5ef93(%rip), %rdi     # 0x64a1e
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x5ab6
cmpl $0x2, -0x8(%rbp)
jne 0x5ab4
leaq 0x61bbc(%rip), %rdi     # 0x67663
movb $0x0, %al
callq 0x3110
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x5ab6
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/print.c
// Function: print_magic
void
print_magic(unsigned long magic,int size)
{
    int chpr = 0;

    chpr += printf(" magic=%#06lx=",magic);
    show_string((char *)&magic,size,0);
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rsi
leaq 0x5ef3d(%rip), %rdi     # 0x64a2e
movb $0x0, %al
callq 0x3110
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %esi
leaq -0x8(%rbp), %rdi
xorl %edx, %edx
callq 0xb600
movl -0x10(%rbp), %edi
callq 0x1ff00
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: putindent
void
putindent(int spaces)
{
    int spaces_left;

    if(spaces > MAXINDENT)
        spaces = MAXINDENT;
    spaces_left = spaces;
    while(spaces_left-- > 0)
        (void)putchar(' ');
    setcharsprinted(spaces);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x50, -0x4(%rbp)
jle 0x60f8
movl $0x50, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
jle 0x611a
movl $0x20, %edi
callq 0x3050
jmp 0x60fe
movl -0x4(%rbp), %edi
callq 0x1ff00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: is_a_long_offset
int
is_a_long_offset(struct ifd_entry *entry_ptr)
{
    int is_an_offset = 0;

    if(entry_ptr)
    {
        switch(entry_ptr->tag)
        {
            case EXIFTAG_ExifIFDPointer:
            case EXIFTAG_GPSInfoIFDPointer:
            case EXIFTAG_Interoperability:
            case TIFFTAG_JPEGInterchangeFormat:
                ++is_an_offset;
                break;
            default:
                break;
        }
    }
    return(is_an_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x71bc
movq -0x8(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x10(%rbp)
subl $0x201, %eax            # imm = 0x201
je 0x71ad
jmp 0x7189
movl -0x10(%rbp), %eax
subl $0x8769, %eax           # imm = 0x8769
je 0x71ad
jmp 0x7195
movl -0x10(%rbp), %eax
subl $0x8825, %eax           # imm = 0x8825
je 0x71ad
jmp 0x71a1
movl -0x10(%rbp), %eax
subl $0xa005, %eax           # imm = 0xA005
jne 0x71b8
jmp 0x71ad
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x71ba
jmp 0x71ba
jmp 0x71bc
movl -0xc(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: print_tagid
void
print_tagid(struct ifd_entry *entry_ptr,int indent,int ifdtype)
{
    char *nameoftag;
    int chpr = 0;

    if(entry_ptr && (PRINT_ENTRY))
    {
        if(PRINT_TAGNAME || !(PRINT_TAGNO))
        {
            switch(ifdtype)
            {
                case GPS_IFD:
                    nameoftag = gps_tagname(entry_ptr->tag);
                    break;
                case INTEROP_IFD:
                    nameoftag = interop_tagname(entry_ptr->tag);
                    break;
                case EXIF_IFD:
                case TIFF_IFD:
                case TIFF_SUBIFD:
                default:
                    nameoftag = tagname(entry_ptr->tag);
                    break;
            }
            chpr += printf("%-*.*s",TAGWIDTH,TAGWIDTH,nameoftag);
        }
        else if(PRINT_HEX_TAGNO)
            chpr += printf("<%#06x>",entry_ptr->tag & 0xffff);
        else if(PRINT_DEC_TAGNO)
            chpr += printf("<%5u>",entry_ptr->tag & 0xffff);
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7c32
leaq 0x6f675(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x4003333, %rax        # imm = 0x4003333
cmpq $0x0, %rax
je 0x7c32
leaq 0x6f65b(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1000, %rax           # imm = 0x1000
cmpq $0x0, %rax
jne 0x7b48
leaq 0x6f645(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x7bc0
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $0x3, %eax
jb 0x7b8d
jmp 0x7b55
movl -0x20(%rbp), %eax
subl $0x3, %eax
je 0x7b7b
jmp 0x7b5f
movl -0x20(%rbp), %eax
subl $0x4, %eax
jne 0x7b8f
jmp 0x7b69
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0x107e0
movq %rax, -0x18(%rbp)
jmp 0x7b9f
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0x106e0
movq %rax, -0x18(%rbp)
jmp 0x7b9f
jmp 0x7b8f
movq -0x8(%rbp), %rax
movzwl (%rax), %edi
callq 0xd580
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
leaq 0x634f2(%rip), %rdi     # 0x6b09c
movl $0x1b, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x3110
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c30
leaq 0x6f5b9(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x7bf7
movq -0x8(%rbp), %rax
movzwl (%rax), %esi
andl $0xffff, %esi           # imm = 0xFFFF
leaq 0x5c9eb(%rip), %rdi     # 0x645d3
movb $0x0, %al
callq 0x3110
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c2e
leaq 0x6f582(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x7c2c
movq -0x8(%rbp), %rax
movzwl (%rax), %esi
andl $0xffff, %esi           # imm = 0xFFFF
leaq 0x5c9bc(%rip), %rdi     # 0x645db
movb $0x0, %al
callq 0x3110
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x7c2e
jmp 0x7c30
jmp 0x7c32
movl -0x1c(%rbp), %edi
callq 0x1ff00
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: print_unicode
int
print_unicode(FILE *inptr,unsigned long count,unsigned long offset,unsigned short byteorder)
{
    int remaining;
    int nread;
    int ch = 0;
    int chpr = 0;

    nread = 0;
    if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
    {
        chpr += printf(" seek failed to offset %lu to print unicode",offset);
        chpr = newline(chpr);
    }

    remaining = count / 2;
    putchar('\''); ++chpr;
    while((remaining > 0) && !feof(inptr))
    {
        if(ch == 0)
            chpr += printf("\\0");
        else
            ch = read_ushort(inptr,byteorder,HERE);
        ++nread;
        ++chpr;
        --remaining;
        /* Write both bytes iff requested by user                     */
        if((PRINT_UNICODE))
            (void)fwrite((char *)&ch,2,1,stdout);
        else
            putchar(ch);
    }
    putchar('\''); ++chpr;
    if(ferror(inptr))
        clearerr(inptr);

    setcharsprinted(chpr);
    return(nread);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %cx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movw %ax, -0x1a(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x24(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0x18(%rbp)
je 0x8982
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3200
cmpl $-0x1, %eax
jne 0x8982
movq -0x18(%rbp), %rsi
leaq 0x5bea8(%rip), %rdi     # 0x64812
movb $0x0, %al
callq 0x3110
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
callq 0x1ef50
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
shrq %rax
movl %eax, -0x20(%rbp)
movl $0x27, %edi
callq 0x3050
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x20(%rbp)
movb %al, -0x2d(%rbp)
jle 0x89be
movq -0x8(%rbp), %rdi
callq 0x3190
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x89ca
jmp 0x8a5b
cmpl $0x0, -0x28(%rbp)
jne 0x89e6
leaq 0x5be32(%rip), %rdi     # 0x64809
movb $0x0, %al
callq 0x3110
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x89fe
movq -0x8(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movzwl -0x1a(%rbp), %esi
callq 0x4480
movzwl %ax, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
leaq 0x6e760(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x4000, %rax           # imm = 0x4000
cmpq $0x0, %rax
je 0x8a4e
movq 0x6e592(%rip), %rax     # 0x76fc8
movq (%rax), %rcx
leaq -0x28(%rbp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x3290
jmp 0x8a56
movl -0x28(%rbp), %edi
callq 0x3050
jmp 0x899f
movl $0x27, %edi
callq 0x3050
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
cmpl $0x0, %eax
je 0x8a85
movq -0x8(%rbp), %rdi
callq 0x31a0
movl -0x2c(%rbp), %edi
callq 0x1ff00
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: pushcolor
void
pushcolor(int color)
{
    if(USE_COLOR)
    {
        if(colorstack_index < 0)
        {
            colorstack_index = 0;
            colorstack[0] = END_COLOR;
        }
        else if(colorstack_index >= (COLORSTACKSIZE - 1))
            colorstack_index = 0;

        printf("\033[%dm",color);
        colorstack[++colorstack_index] = color;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x6b9ae(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x0, %rax
cmpq $0x0, %rax
je 0xb843
cmpl $0x0, 0x6b9a2(%rip)     # 0x77188
jge 0xb7fe
movl $0x0, 0x6b996(%rip)     # 0x77188
movl $0x0, 0x70cd4(%rip)     # 0x7c4d0
jmp 0xb813
cmpl $0xf, 0x6b983(%rip)     # 0x77188
jl 0xb811
movl $0x0, 0x6b977(%rip)     # 0x77188
jmp 0xb813
movl -0x4(%rbp), %esi
leaq 0x590c0(%rip), %rdi     # 0x648dd
movb $0x0, %al
callq 0x3110
movl -0x4(%rbp), %edx
movl 0x6b95b(%rip), %eax     # 0x77188
addl $0x1, %eax
movl %eax, 0x6b952(%rip)     # 0x77188
movslq %eax, %rcx
leaq 0x70c90(%rip), %rax     # 0x7c4d0
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: popcolor
void
popcolor()
{
    if(USE_COLOR)
    {
        if(colorstack_index > 0)
            colorstack[colorstack_index--] = END_COLOR;
        printf("\033[0m");
        if(colorstack_index >= 0)
            printf("\033[%dm",colorstack[colorstack_index]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x6b925(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x0, %rax
cmpq $0x0, %rax
je 0xb8cb
cmpl $0x0, 0x6b919(%rip)     # 0x77188
jle 0xb893
movl 0x6b911(%rip), %eax     # 0x77188
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, 0x6b906(%rip)     # 0x77188
movslq %eax, %rcx
leaq 0x70c44(%rip), %rax     # 0x7c4d0
movl $0x0, (%rax,%rcx,4)
leaq 0x59049(%rip), %rdi     # 0x648e3
movb $0x0, %al
callq 0x3110
cmpl $0x0, 0x6b8e0(%rip)     # 0x77188
jl 0xb8c9
movslq 0x6b8d7(%rip), %rcx     # 0x77188
leaq 0x70c18(%rip), %rax     # 0x7c4d0
movl (%rax,%rcx,4), %esi
leaq 0x5901b(%rip), %rdi     # 0x648dd
movb $0x0, %al
callq 0x3110
jmp 0xb8cb
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: putcolorchar
void
putcolorchar(unsigned short color)
{
    switch(color & 0xff)
    {
        case 0: putchar('R'); break;
        case 1: putchar('G'); break;
        case 2: putchar('B'); break;
        case 3: putchar('C'); break;
        case 4: putchar('M'); break;
        case 5: putchar('Y'); break;
        case 6: putchar('W'); break;
        default: putchar('?'); break;
    }
    setcharsprinted(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x6, %eax
ja 0xb956
movq -0x10(%rbp), %rax
leaq 0x58b37(%rip), %rcx     # 0x64430
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x52, %edi
callq 0x3050
jmp 0xb960
movl $0x47, %edi
callq 0x3050
jmp 0xb960
movl $0x42, %edi
callq 0x3050
jmp 0xb960
movl $0x43, %edi
callq 0x3050
jmp 0xb960
movl $0x4d, %edi
callq 0x3050
jmp 0xb960
movl $0x59, %edi
callq 0x3050
jmp 0xb960
movl $0x57, %edi
callq 0x3050
jmp 0xb960
movl $0x3f, %edi
callq 0x3050
movl $0x1, %edi
callq 0x1ff00
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: print_jpeg_status
void
print_jpeg_status()
{
    int status = 0;

    /* get and clear the status                                       */
    status = jpeg_status(status);

    if((PRINT_SEGMENT))
    {
        if(status == JPEG_NO_SOI)
            printred(" ### (JPEG_SOI NOT FOUND)");
        if(status == JPEG_HAD_ERROR)
            printred(" ### (INVALID JPEG MARKER)");
        else if(status == JPEG_NO_EOI)
            printred(" ### (JPEG_EOI NOT FOUND)");
        else if(status == JPEG_EARLY_EOI)
            printred(" (JPEG_EOI FOUND EARLY)");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x19930
movl %eax, -0x4(%rbp)
leaq 0x6b75f(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x80000, %rax          # imm = 0x80000
cmpq $0x0, %rax
je 0xba82
cmpl $0x4, -0x4(%rbp)
jne 0xba42
leaq 0x59000(%rip), %rdi     # 0x64a3d
callq 0x6860
cmpl $0x8, -0x4(%rbp)
jne 0xba56
leaq 0x59008(%rip), %rdi     # 0x64a57
callq 0x6860
jmp 0xba80
cmpl $0x2, -0x4(%rbp)
jne 0xba6a
leaq 0x5900f(%rip), %rdi     # 0x64a72
callq 0x6860
jmp 0xba7e
cmpl $0x1, -0x4(%rbp)
jne 0xba7c
leaq 0x59015(%rip), %rdi     # 0x64a8c
callq 0x6860
jmp 0xba7e
jmp 0xba80
jmp 0xba82
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: dumpsection
void
dumpsection(FILE *inptr,unsigned long offset,unsigned long length,int indent)
{
    unsigned long dumplength;

    if(inptr)
    {
        if(Max_imgdump > 0L)
            dumplength = Max_imgdump;
        else
            dumplength = DEF_DUMPLENGTH;
        if(dumplength > length)
            dumplength = length;
        if(dumplength)
        {
            hexdump(inptr,offset,length,dumplength,16,indent,0);
            (void)newline(1);
        }
    }
}

// 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)
cmpq $0x0, -0x8(%rbp)
je 0xbcf0
leaq 0x6c79b(%rip), %rax     # 0x78420
cmpq $0x0, (%rax)
jbe 0xbc9b
leaq 0x6c78e(%rip), %rax     # 0x78420
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xbca3
movq $0x40, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0xbcb5
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xbcee
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %r9d
movl $0x10, %r8d
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0x8aa0
movl $0x1, %edi
callq 0x1ef50
jmp 0xbcf0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: private_value_is_offset
int
private_value_is_offset(int make,unsigned short subifd_ident,unsigned short tag)
{
    int is_offset = 0;

    switch(make)
    {
        case MAKER_OLYMPUS:
            is_offset = olympus_private_value_is_offset(subifd_ident,tag);
            break;
        default:
            break;
    }
    return(is_offset);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %dx, %ax
movw %si, %cx
movl %edi, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %eax
subl $0xd, %eax
jne 0xcacf
jmp 0xcaba
movw -0x6(%rbp), %ax
movzwl %ax, %edi
movzwl -0x8(%rbp), %esi
callq 0x465f0
movl %eax, -0xc(%rbp)
jmp 0xcad1
jmp 0xcad1
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: interpret_pe_value
void
interpret_pe_value(struct ifd_entry *entry_ptr,unsigned short subifd_ident,
                                                    int make,char *prefix)
{
    if(entry_ptr)
    {
        switch(make)
        {
            case MAKER_OLYMPUS:
                olympus_interpret_pe_value(entry_ptr,subifd_ident,prefix);
                break;
            default:
                break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcf35
movl -0x10(%rbp), %eax
subl $0xd, %eax
jne 0xcf31
jmp 0xcf1b
movq -0x8(%rbp), %rdi
movw -0xa(%rbp), %ax
movq -0x18(%rbp), %rdx
movzwl %ax, %esi
callq 0x447b0
jmp 0xcf33
jmp 0xcf33
jmp 0xcf35
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: private_tagname
char *
private_tagname(int make,unsigned short tag,unsigned short subifd_ident)
{
    static char unknown_buf[16];
    char *tagname = CNULL;

    switch(make)
    {
        case MAKER_OLYMPUS:
            tagname = olympus_private_tagname(tag,subifd_ident);
            break;
        default:
            break;
    }
    if(tagname == CNULL)
    {
        unknown_buf[0] = '\0';
        if(snprintf(unknown_buf,11,"TAG_%#06x",(int)tag) > 11)
        {
            printf(" bad tag %#x not converted\n",tag);
            why(stdout);
            tagname = "<BADTAG>";
        }
        else
            tagname = unknown_buf;
    }
    return(tagname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %dx, %ax
movw %si, %cx
movl %edi, -0x4(%rbp)
movw %cx, -0x6(%rbp)
movw %ax, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
subl $0xd, %eax
jne 0xcf81
jmp 0xcf6b
movw -0x6(%rbp), %ax
movzwl %ax, %edi
movzwl -0x8(%rbp), %esi
callq 0x43cf0
movq %rax, -0x10(%rbp)
jmp 0xcf83
jmp 0xcf83
cmpq $0x0, -0x10(%rbp)
jne 0xcfef
movb $0x0, 0x6f57f(%rip)     # 0x7c510
movzwl -0x6(%rbp), %ecx
leaq 0x6f574(%rip), %rdi     # 0x7c510
movl $0xb, %esi
leaq 0x57cac(%rip), %rdx     # 0x64c54
movb $0x0, %al
callq 0x3120
cmpl $0xb, %eax
jle 0xcfe2
movzwl -0x6(%rbp), %esi
leaq 0x57c9f(%rip), %rdi     # 0x64c5e
movb $0x0, %al
callq 0x3110
movq 0x69ffb(%rip), %rax     # 0x76fc8
movq (%rax), %rdi
callq 0x20840
leaq 0x57c9e(%rip), %rax     # 0x64c7a
movq %rax, -0x10(%rbp)
jmp 0xcfed
leaq 0x6f527(%rip), %rax     # 0x7c510
movq %rax, -0x10(%rbp)
jmp 0xcfef
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/print.c
// Function: print_private_tagid
void
print_private_tagid(struct ifd_entry *entry_ptr,unsigned short subifd_ident,
                                                        int make,int indent)
{
    char *nameoftag;
    int chpr = 0;

    if(entry_ptr && (PRINT_ENTRY))
    {
        extraindent(indent);
        if(PRINT_TAGNAME || !(PRINT_TAGNO))
        {
            nameoftag = private_tagname(make,entry_ptr->tag,subifd_ident);
            chpr += printf("%-*.*s",TAGWIDTH,TAGWIDTH,nameoftag);
        }
        else if(PRINT_HEX_TAGNO)
            chpr += printf("<%#06x>",entry_ptr->tag & 0xffff);
        else if(PRINT_DEC_TAGNO)
            chpr += printf("<%5u>",entry_ptr->tag & 0xffff);
        /* ###%%% should be done just befor value is printed, not     */
        /* here                                                       */
        if(PRINT_VALUE)
            chpr += printf(" = ");
    }
    setcharsprinted(chpr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xd14c
leaq 0x6a14e(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x4003333, %rax        # imm = 0x4003333
cmpq $0x0, %rax
je 0xd14c
movl -0x14(%rbp), %edi
callq 0xb970
leaq 0x6a12c(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1000, %rax           # imm = 0x1000
cmpq $0x0, %rax
jne 0xd077
leaq 0x6a116(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0xd0b2
movl -0x10(%rbp), %edi
movq -0x8(%rbp), %rax
movw (%rax), %ax
movzwl %ax, %esi
movzwl -0xa(%rbp), %edx
callq 0xcf40
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
leaq 0x5e000(%rip), %rdi     # 0x6b09c
movl $0x1b, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x3110
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xd122
leaq 0x6a0c7(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xd0e9
movq -0x8(%rbp), %rax
movzwl (%rax), %esi
andl $0xffff, %esi           # imm = 0xFFFF
leaq 0x574f9(%rip), %rdi     # 0x645d3
movb $0x0, %al
callq 0x3110
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xd120
leaq 0x6a090(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0xd11e
movq -0x8(%rbp), %rax
movzwl (%rax), %esi
andl $0xffff, %esi           # imm = 0xFFFF
leaq 0x574ca(%rip), %rdi     # 0x645db
movb $0x0, %al
callq 0x3110
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xd120
jmp 0xd122
leaq 0x6a057(%rip), %rax     # 0x77180
movq (%rax), %rax
andq $0x30, %rax
cmpq $0x0, %rax
je 0xd14a
leaq 0x5fbdb(%rip), %rdi     # 0x6cd18
movb $0x0, %al
callq 0x3110
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xd14c
movl -0x24(%rbp), %edi
callq 0x1ff00
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/tagnames.c
// Function: interop_tagname
char *
interop_tagname(unsigned short tag)
{
    static char unknown_buf[16];
    char *tagname;

    switch(tag)
    {
        case 0x0001: tagname = "InteroperabilityIndex"; break;   /* EXIF */
        case 0x0002: tagname = "InteroperabilityVersion"; break; /* EXIF */
        case 0x1000: tagname = "RelatedImageFileFormat"; break;  /* EXIF */
        case 0x1001: tagname = "RelatedImageWidth"; break;       /* EXIF */
        case 0x1002: tagname = "RelatedImageLength"; break;      /* EXIF */
        default:
            if(snprintf(unknown_buf,11,"IOP_%#06x",(int)tag) > 11)
            {
                printf(" bad tag %#x not converted\n",tag);
                why(stdout);
                tagname = "<BADTAG>";
            }
            else
                tagname = unknown_buf;
            break;
    }
    return(tagname);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0x1072b
jmp 0x106fd
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x1073b
jmp 0x10707
movl -0x14(%rbp), %eax
subl $0x1000, %eax           # imm = 0x1000
je 0x1074b
jmp 0x10713
movl -0x14(%rbp), %eax
subl $0x1001, %eax           # imm = 0x1001
je 0x10758
jmp 0x1071f
movl -0x14(%rbp), %eax
subl $0x1002, %eax           # imm = 0x1002
je 0x10765
jmp 0x10772
leaq 0x55caa(%rip), %rax     # 0x663dc
movq %rax, -0x10(%rbp)
jmp 0x107d0
leaq 0x55cb0(%rip), %rax     # 0x663f2
movq %rax, -0x10(%rbp)
jmp 0x107d0
leaq 0x55cb8(%rip), %rax     # 0x6640a
movq %rax, -0x10(%rbp)
jmp 0x107d0
leaq 0x55cc2(%rip), %rax     # 0x66421
movq %rax, -0x10(%rbp)
jmp 0x107d0
leaq 0x55cc7(%rip), %rax     # 0x66433
movq %rax, -0x10(%rbp)
jmp 0x107d0
movzwl -0x2(%rbp), %ecx
leaq 0x6bdb3(%rip), %rdi     # 0x7c530
movl $0xb, %esi
leaq 0x55cbd(%rip), %rdx     # 0x66446
movb $0x0, %al
callq 0x3120
cmpl $0xb, %eax
jle 0x107c3
movzwl -0x2(%rbp), %esi
leaq 0x544be(%rip), %rdi     # 0x64c5e
movb $0x0, %al
callq 0x3110
movq 0x6681a(%rip), %rax     # 0x76fc8
movq (%rax), %rdi
callq 0x20840
leaq 0x544bd(%rip), %rax     # 0x64c7a
movq %rax, -0x10(%rbp)
jmp 0x107ce
leaq 0x6bd66(%rip), %rax     # 0x7c530
movq %rax, -0x10(%rbp)
jmp 0x107d0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/hfiguiere[P]exifprobe/process.c
// Function: last_summary_entry
struct image_summary *
last_summary_entry(struct image_summary *summary_entry)
{
    if(summary_entry)
    {
        while(summary_entry->next_entry)
            summary_entry = summary_entry->next_entry;
    }
    return(summary_entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x157ac
jmp 0x15791
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x157aa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x15791
jmp 0x157ac
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)