LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mchackorg[P]mcwm/mcwm.c
// Function: deletewin
void deletewin(void)
{
    xcb_get_property_cookie_t cookie;
    xcb_icccm_get_wm_protocols_reply_t protocols;
    bool use_delete = false;
    uint32_t i;

    if (NULL == focuswin)
    {
        return;
    }

    /* Check if WM_DELETE is supported.  */
    cookie = xcb_icccm_get_wm_protocols_unchecked(conn, focuswin->id,
                                                  wm_protocols);
    if (xcb_icccm_get_wm_protocols_reply(conn, cookie, &protocols, NULL) == 1)
    {
        for (i = 0; i < protocols.atoms_len; i++)
        {
            if (protocols.atoms[i] == wm_delete_window)
            {
                 use_delete = true;
            }
        }
    }

    xcb_icccm_get_wm_protocols_reply_wipe(&protocols);

    if (use_delete)
    {
        xcb_client_message_event_t ev = {
          .response_type = XCB_CLIENT_MESSAGE,
          .format = 32,
          .sequence = 0,
          .window = focuswin->id,
          .type = wm_protocols,
          .data.data32 = { wm_delete_window, XCB_CURRENT_TIME }
        };

        xcb_send_event(conn, false, focuswin->id,
                       XCB_EVENT_MASK_NO_EVENT, (char *) &ev);
    }
    else
    {
        xcb_kill_client(conn, focuswin->id);
    }

    xcb_flush(conn);
}

// Assembly:
movq 0x4914(%rip), %rax      # 0xa4c0
testq %rax, %rax
je 0x5c9b
pushq %rbx
subq $0x40, %rsp
movq 0x48cf(%rip), %rdi      # 0xa490
movl (%rax), %esi
movl 0x48e7(%rip), %edx      # 0xa4b0
callq 0x2460
movq 0x48bb(%rip), %rdi      # 0xa490
leaq 0x8(%rsp), %rdx
movl %eax, %esi
xorl %ecx, %ecx
callq 0x2110
cmpb $0x1, %al
jne 0x5c6b
movl 0x8(%rsp), %eax
testq %rax, %rax
je 0x5c6b
movq 0x10(%rsp), %rcx
movl 0x48a5(%rip), %edx      # 0xa4a4
xorl %esi, %esi
xorl %ebx, %ebx
cmpl %edx, (%rcx,%rsi,4)
sete %dil
orb %dil, %bl
incq %rsi
cmpq %rsi, %rax
jne 0x5c03
leaq 0x8(%rsp), %rdi
callq 0x20a0
testb $0x1, %bl
je 0x5c75
leaq 0x20(%rsp), %r8
movl $0x2021, (%r8)          # imm = 0x2021
movq 0x4889(%rip), %rax      # 0xa4c0
movl (%rax), %edx
movl %edx, 0x4(%r8)
movl 0x486d(%rip), %eax      # 0xa4b0
movl %eax, 0x8(%r8)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r8)
movl 0x484f(%rip), %eax      # 0xa4a4
movl %eax, 0xc(%r8)
movq 0x4830(%rip), %rdi      # 0xa490
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x2450
jmp 0x5c8a
leaq 0x8(%rsp), %rdi
callq 0x20a0
movq 0x4814(%rip), %rdi      # 0xa490
movq 0x483d(%rip), %rax      # 0xa4c0
movl (%rax), %esi
callq 0x2530
movq 0x47ff(%rip), %rdi      # 0xa490
callq 0x2150
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mchackorg[P]mcwm/mcwm.c
// Function: prevscreen
void prevscreen(void)
{
    struct item *item;

    if (NULL == focuswin || NULL == focuswin->monitor)
    {
        return;
    }

    item = focuswin->monitor->item->prev;

    if (NULL == item)
    {
        return;
    }

    focuswin->monitor = item->data;

    raisewindow(focuswin->id);
    fitonscreen(focuswin);
    movelim(focuswin);

    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     0, 0);
    xcb_flush(conn);
}

// Assembly:
movq 0x481d(%rip), %rax      # 0xa4c0
testq %rax, %rax
je 0x5d1e
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x5d1e
movq 0x18(%rcx), %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x5d1e
pushq %rax
movq (%rcx), %rcx
movq %rcx, 0x38(%rax)
movl (%rax), %edi
callq 0x4d2d
movq 0x47ec(%rip), %rdi      # 0xa4c0
callq 0x283e
movq 0x47e0(%rip), %rdi      # 0xa4c0
callq 0x5279
movq 0x47a4(%rip), %rdi      # 0xa490
movq 0x47cd(%rip), %rax      # 0xa4c0
movl (%rax), %edx
subq $0x8, %rsp
xorl %eax, %eax
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x2050
addq $0x20, %rsp
movq 0x4778(%rip), %rdi      # 0xa490
popq %rax
jmp 0x2150
retq
// File: /workspace/github_c_makefile_star2_O3/mchackorg[P]mcwm/mcwm.c
// Function: nextscreen
void nextscreen(void)
{
    struct item *item;

    if (NULL == focuswin || NULL == focuswin->monitor)
    {
        return;
    }

    item = focuswin->monitor->item->next;

    if (NULL == item)
    {
        return;
    }

    focuswin->monitor = item->data;

    raisewindow(focuswin->id);
    fitonscreen(focuswin);
    movelim(focuswin);

    xcb_warp_pointer(conn, XCB_NONE, focuswin->id, 0, 0, 0, 0,
                     0, 0);
    xcb_flush(conn);
}

// Assembly:
movq 0x479a(%rip), %rax      # 0xa4c0
testq %rax, %rax
je 0x5da1
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x5da1
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rcx
testq %rcx, %rcx
je 0x5da1
pushq %rax
movq (%rcx), %rcx
movq %rcx, 0x38(%rax)
movl (%rax), %edi
callq 0x4d2d
movq 0x4769(%rip), %rdi      # 0xa4c0
callq 0x283e
movq 0x475d(%rip), %rdi      # 0xa4c0
callq 0x5279
movq 0x4721(%rip), %rdi      # 0xa490
movq 0x474a(%rip), %rax      # 0xa4c0
movl (%rax), %edx
subq $0x8, %rsp
xorl %eax, %eax
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq %rax
callq 0x2050
addq $0x20, %rsp
movq 0x46f5(%rip), %rdi      # 0xa490
popq %rax
jmp 0x2150
retq
// File: /workspace/github_c_makefile_star2_O3/mchackorg[P]mcwm/mcwm.c
// Function: hide
void hide(struct client *client)
{
    long data[] = { XCB_ICCCM_WM_STATE_ICONIC, XCB_NONE };

    /*
     * Unmap window and declare iconic.
     *
     * Unmapping will generate an UnmapNotify event so we can forget
     * about the window later.
     */
    xcb_unmap_window(conn, client->id);
    xcb_change_property(conn, XCB_PROP_MODE_REPLACE, client->id,
                        wm_state, wm_state, 32, 2, data);
    xcb_flush(conn);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movaps 0x13dd(%rip), %xmm0     # 0x7190
movq %rsp, %r14
movaps %xmm0, (%r14)
movq 0x46cf(%rip), %rdi      # 0xa490
movl (%rbx), %esi
callq 0x20d0
movq 0x46c1(%rip), %rdi      # 0xa490
movl (%rbx), %edx
movl 0x46d5(%rip), %ecx      # 0xa4ac
xorl %esi, %esi
movl %ecx, %r8d
movl $0x20, %r9d
pushq %r14
pushq $0x2
callq 0x2520
addq $0x10, %rsp
movq 0x469a(%rip), %rdi      # 0xa490
callq 0x2150
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aegis128/ref/encrypt.c
// Function: aegis128_initialization
void aegis128_initialization(const unsigned char *key, const unsigned char *iv, unsigned char *state)
{
        int i;
        unsigned char constant[32] = {0x0,0x1,0x01,0x02,0x03,0x05,0x08,0x0d,0x15,0x22,0x37,0x59,0x90,0xe9,0x79,0x62,0xdb,0x3d,0x18,0x55,0x6d,0xc2,0x2f,0xf1,0x20,0x11,0x31,0x42,0x73,0xb5,0x28,0xdd};

        unsigned char tmp[16];
        unsigned char keytmp[16];
        unsigned char ivtmp[16];

        memcpy(keytmp, key, 16);
        memcpy(ivtmp, iv, 16);

        memcpy(state, ivtmp, 16);
        memcpy(state+16, constant+16, 16);
        memcpy(state+32, constant+0,  16);

        XOR128(state+48, keytmp,  constant);
        XOR128(state+64, keytmp,  constant + 16);
        XOR128(state,    state,   keytmp);
        XOR128(keytmp,   keytmp,  ivtmp);

        for (i = 0; i < 10; i++)  {
             //state update function
             memcpy(tmp, state+64, 16);
             AESROUND(state+64, state+48, state+64);
             AESROUND(state+48, state+32, state+48);
             AESROUND(state+32, state+16, state+32);
             AESROUND(state+16, state+0,  state+16);
             AESROUND(state+0,  tmp,      state+0);

             //xor msg with state[0]
             XOR128(keytmp, keytmp, ivtmp);
             XOR128(state,  state,  keytmp);
        }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
leaq 0x10(%rdx), %r14
leaq 0x20(%rdx), %r15
leaq 0x30(%rdx), %r12
vmovdqu (%rsi), %xmm2
vmovaps 0xd83(%rip), %ymm0      # 0x2000
vbroadcasti128 (%rdi), %ymm1   # ymm1 = mem[0,1,0,1]
vmovups %ymm0, 0x10(%rdx)
vpxor 0xd91(%rip), %ymm1, %ymm0 # 0x2020
vmovdqu %ymm0, 0x30(%rdx)
leaq 0x40(%rdx), %r13
vmovdqa %xmm2, (%rsp)
vpxor %xmm1, %xmm2, %xmm1
vmovdqu %xmm1, (%rdx)
movl $0xa, %ebp
vmovdqa %xmm1, 0x10(%rsp)
vmovups (%r13), %xmm0
vmovaps %xmm0, 0x20(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movq %r13, %rdx
vzeroupper
callq 0x1040
movq %r12, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1040
movq %r15, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1040
movq %r14, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1040
movq %rbx, %rdi
leaq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x1040
vmovdqa 0x10(%rsp), %xmm1
vpxor (%rsp), %xmm1, %xmm1
vpxor (%rbx), %xmm1, %xmm0
vmovdqu %xmm0, (%rbx)
decl %ebp
jne 0x12aa
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/aegis128/ref/encrypt.c
// Function: aegis128_tag_generation
void aegis128_tag_generation(unsigned long long msglen, unsigned long long adlen, unsigned char maclen, unsigned char *mac, unsigned char *state)
{
       int i;

        unsigned char tmp[16];
        unsigned char msgtmp[16];

        ((unsigned long long*)msgtmp)[0] = adlen << 3;
        ((unsigned long long*)msgtmp)[1] = msglen << 3;

        XOR128(msgtmp, msgtmp, state+48);

        for (i = 0; i < 7; i++) {
             //state update function
             memcpy(tmp, state+64, 16);

             AESROUND(state+64, state+48, state+64);
             AESROUND(state+48, state+32, state+48);
             AESROUND(state+32, state+16, state+32);
             AESROUND(state+16, state+0,  state+16);
             AESROUND(state+0,  tmp,      state+0);

             //xor "msg" with state[0]
             XOR128(state, state, msgtmp);
        }

        XOR128(state+64, state+64, state+48);
        XOR128(state+64, state+64, state+32);
        XOR128(state+64, state+64, state+16);
        XOR128(state+64, state+64, state+0);

        //in this program, the mac length is assumed to be multiple of bytes
        memcpy(mac, state+64, maclen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, 0x8(%rsp)
movl %edx, 0x4(%rsp)
vmovq %rdi, %xmm0
vmovq %rsi, %xmm1
vpunpcklqdq %xmm0, %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[0]
vpsllq $0x3, %xmm0, %xmm0
vpxor 0x30(%r8), %xmm0, %xmm0
vmovdqa %xmm0, 0x10(%rsp)
leaq 0x30(%r8), %r13
leaq 0x40(%r8), %r15
leaq 0x20(%r8), %rbx
leaq 0x10(%r8), %r12
movl $0x7, %ebp
vmovups (%r15), %xmm0
vmovaps %xmm0, 0x20(%rsp)
movq %r15, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1040
movq %r13, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1040
movq %rbx, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1040
movq %r12, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1040
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
movq %r14, %rdx
callq 0x1040
vmovdqa 0x10(%rsp), %xmm0
vpxor (%r14), %xmm0, %xmm0
vmovdqu %xmm0, (%r14)
decl %ebp
jne 0x137b
vmovdqu (%r13), %xmm1
vmovdqu (%rbx), %xmm2
vpternlogq $0x96, (%r15), %xmm1, %xmm2
vpternlogq $0x96, (%r12), %xmm2, %xmm0
vmovdqu %xmm0, (%r15)
movzbl 0x4(%rsp), %edx
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x10a0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Keith-S-Thompson[P]kst-time-utils/timer.c
// Function: usage
static void usage(const char *prog_name, const char *message) {
    if (message != NULL) {
        puts(message);
    }
    printf("Usage: %s [options]\n", prog_name);
    puts("    -a : Absolute time (default is zero-based)");
    puts("    -A : Absolute local time, human-readable");
    puts("    -U : Absolute UTC time, human-readable");
    puts("    -r : Show time interval relative to previous line");
    puts("    -b : Buffered output (default is unbuffered)");
    puts("    -h : Help (show this message and exit)");
    puts("    -z : Zero-based time (redundant, this is the default)");
    puts("    -u : Unbuffered output (redundant, this is the default)");
    puts("    -o file : Print output to specified file");
    exit(EXIT_SUCCESS);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1499
movq %rsi, %rdi
callq 0x1030
leaq 0xbd1(%rip), %rdi       # 0x2071
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1060
leaq 0xbd5(%rip), %rdi       # 0x2086
callq 0x1030
leaq 0xbf8(%rip), %rdi       # 0x20b5
callq 0x1030
leaq 0xc19(%rip), %rdi       # 0x20e2
callq 0x1030
leaq 0xc38(%rip), %rdi       # 0x210d
callq 0x1030
leaq 0xc62(%rip), %rdi       # 0x2143
callq 0x1030
leaq 0xc87(%rip), %rdi       # 0x2174
callq 0x1030
leaq 0xca6(%rip), %rdi       # 0x219f
callq 0x1030
leaq 0xcd4(%rip), %rdi       # 0x21d9
callq 0x1030
leaq 0xd04(%rip), %rdi       # 0x2215
callq 0x1030
xorl %edi, %edi
callq 0x1110
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1070
testl %eax, %eax
je 0x155f
leaq 0xd02(%rip), %rdi       # 0x2245
movl $0x10, %esi
movl $0x1, %edx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1120
cmpb $0x0, 0x2b4f(%rip)      # 0x40b5
jne 0x157b
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x2b44(%rip)     # 0x40b8
movb $0x1, 0x2b3a(%rip)      # 0x40b5
cmpb $0x0, 0x2b2e(%rip)      # 0x40b0
jne 0x158d
cmpb $0x1, 0x2b26(%rip)      # 0x40b1
jne 0x15bf
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x163b
cmpb $0x1, 0x2b0d(%rip)      # 0x40b3
jne 0x15b4
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x2b04(%rip)     # 0x40b8
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r14
movq %r14, %rax
subq 0x2aea(%rip), %rax      # 0x40b8
movq 0x10(%rsp), %r15
movq %r15, %rcx
subq 0x2ae3(%rip), %rcx      # 0x40c0
leaq 0xf4240(%rcx), %rdx
movq %rcx, %rsi
sarq $0x3f, %rsi
addq %rax, %rsi
testq %rcx, %rcx
cmovnsq %rcx, %rdx
movq %rbx, %rdi
callq 0x163b
testb %bpl, %bpl
je 0x159f
leaq 0xc39(%rip), %rdi       # 0x2242
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x1120
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x163b
movl $0x5d, %edi
movq %rbx, %rsi
callq 0x1090
jmp 0x159f
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %rcx
movq %rdi, %rbx
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpb $0x1, 0x2a52(%rip)      # 0x40b1
jne 0x1673
cmpb $0x0, 0x2a4a(%rip)      # 0x40b2
je 0x16a7
movq 0x2977(%rip), %rax      # 0x3fe8
jmp 0x16ae
movq %rsi, %rdx
leaq 0xbeb(%rip), %rax       # 0x2268
cmpb $0x0, 0x2a2c(%rip)      # 0x40b0
leaq 0xbe9(%rip), %rsi       # 0x2274
cmovneq %rax, %rsi
movq %rbx, %rdi
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10c0
movq 0x290a(%rip), %rax      # 0x3fb8
movq %rsp, %r14
movq %r14, %rdi
callq *%rax
movq %rax, %r15
movq 0x8(%r14), %rdx
leaq 0xba2(%rip), %rax       # 0x2266
leaq 0x9ba(%rip), %rcx       # 0x2085
cmpb $0x0, 0x29e0(%rip)      # 0x40b2
cmovneq %rax, %rcx
leaq 0xb79(%rip), %rsi       # 0x2256
leaq 0x80(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0x10(%rsp), %r12
movl $0x64, %esi
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x10d0
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1080
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/readfile.c
// Function: read_ushort
unsigned short
read_ushort(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    unsigned char rbuf[2];
    unsigned long curoffset;
    unsigned short value = 0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
        {
            printred(" SEEK FAILED to read unsigned short at offset ");
            printf("%lu",offset);
        }
        else if(fread(rbuf,1,sizeof(unsigned short),inptr) == sizeof(unsigned short))
            value = to_ushort(rbuf,byteorder);
        else
        {
            printred(" FAILED to read unsigned short value at offset ");
            if(offset == HERE)
                offset = curoffset;
            chpr += printf("%lu",offset);
        }
        if(ferror(inptr))
        {
            chpr += printf(" (");
            setcharsprinted(chpr);
            chpr = 0;
            printred(strerror(errno));
            chpr += printf(")");
            chpr = newline(chpr);
        }
        else if(feof(inptr))
        {
            printred(" (EOF)");
            chpr = newline(chpr);
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4630
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
callq 0x31b0
movq %r14, %rdi
callq 0x3190
movq %rax, %r12
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
je 0x45f7
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x4668
leaq 0xe(%rsp), %rdi
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rcx
callq 0x30d0
cmpq $0x2, %rax
jne 0x4639
movzwl 0xe(%rsp), %eax
movzwl %r15w, %ecx
movl %eax, %ebx
rolw $0x8, %bx
cmpl $0x4d4d, %ecx           # imm = 0x4D4D
cmovnel %eax, %ebx
xorl %ebp, %ebp
jmp 0x4687
xorl %ebx, %ebx
xorl %ebp, %ebp
jmp 0x46f1
leaq 0x3cb98(%rip), %rdi     # 0x411d8
callq 0x5c26
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
cmovneq %rbx, %r12
leaq 0x442dd(%rip), %rdi     # 0x48935
xorl %ebx, %ebx
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
jmp 0x4687
leaq 0x3cb3a(%rip), %rdi     # 0x411a9
callq 0x5c26
leaq 0x442ba(%rip), %rdi     # 0x48935
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3120
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x46d0
leaq 0x3cb6e(%rip), %rdi     # 0x41208
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x17a82
callq 0x3070
movl (%rax), %edi
callq 0x32c0
movq %rax, %rdi
callq 0x5c26
leaq 0x444f0(%rip), %rdi     # 0x48bb5
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
jmp 0x46e8
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
je 0x46f1
leaq 0x3cb28(%rip), %rdi     # 0x4120b
callq 0x5c26
movl %ebp, %edi
callq 0x1707a
movl %eax, %ebp
movl %ebp, %edi
callq 0x17a82
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/readfile.c
// Function: read_ulong
unsigned long
read_ulong(FILE *inptr,unsigned short byteorder,unsigned long offset)
{
    unsigned char rbuf[4];
    unsigned long curoffset;
    unsigned long value = 0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
        {
            printred(" SEEK FAILED to read unsigned 32bit integer at offset ");
            printf("%lu",offset);
        }
        else if(fread(rbuf,1,4,inptr) == 4)
            value = to_ulong(rbuf,byteorder);
        else
        {
            printred(" FAILED to read unsigned 32bit integer at offset ");
            if(offset == HERE)
                offset = curoffset;
            chpr += printf("%lu",offset);
        }
        if(ferror(inptr))
        {
            chpr += printf(" (");
            setcharsprinted(chpr);
            chpr = 0;
            printred(strerror(errno));
            chpr += printf(")");
            chpr = newline(chpr);
        }
        else if(feof(inptr))
        {
            printred(" (EOF)");
            chpr = newline(chpr);
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4785
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x31b0
movq %r14, %rdi
callq 0x3190
movq %rax, %r12
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
je 0x474f
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x47bf
leaq 0xc(%rsp), %rdi
movl $0x1, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x30d0
cmpq $0x4, %rax
jne 0x478f
movl 0xc(%rsp), %eax
movzwl %bp, %ecx
cmpl $0x4d4d, %ecx           # imm = 0x4D4D
movl %eax, %ebx
bswapl %ebx
cmovnel %eax, %ebx
xorl %r15d, %r15d
jmp 0x47de
xorl %ebx, %ebx
xorl %r15d, %r15d
jmp 0x484d
leaq 0x3caaf(%rip), %rdi     # 0x41245
callq 0x5c26
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rbx
cmovneq %rbx, %r12
leaq 0x44187(%rip), %rdi     # 0x48935
xorl %ebx, %ebx
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
jmp 0x47de
leaq 0x3ca7a(%rip), %rdi     # 0x41240
callq 0x5c26
leaq 0x44163(%rip), %rdi     # 0x48935
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3120
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x482a
leaq 0x3ca17(%rip), %rdi     # 0x41208
xorl %eax, %eax
callq 0x3120
addl %eax, %r15d
movl %r15d, %edi
callq 0x17a82
callq 0x3070
movl (%rax), %edi
callq 0x32c0
movq %rax, %rdi
callq 0x5c26
leaq 0x44397(%rip), %rdi     # 0x48bb5
xorl %eax, %eax
callq 0x3120
movl %eax, %r15d
jmp 0x4842
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
je 0x484d
leaq 0x3c9ce(%rip), %rdi     # 0x4120b
callq 0x5c26
movl %r15d, %edi
callq 0x1707a
movl %eax, %r15d
movl %r15d, %edi
callq 0x17a82
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/readfile.c
// Function: read_ubyte
unsigned short
read_ubyte(FILE *inptr,unsigned long offset)
{
    unsigned char rbuf[1];
    unsigned long curoffset;
    unsigned short value = 0;
    int chpr = 0;

    if(inptr)
    {
        clearerr(inptr);
        curoffset = ftell(inptr);
        if((offset != HERE) && (fseek(inptr,offset,SEEK_SET) == -1))
        {
            printred(" SEEK FAILED to read unsigned byte at offset ");
            chpr += printf("%lu",offset);
        }
        else if(fread(rbuf,1,1,inptr) == 1)
            value = rbuf[0] & 0xff;
        else
        {
            if(offset == HERE)
                offset = curoffset;
            printred(" FAILED to read unsigned byte at offset ");
            chpr += printf("%lu",offset);
        }
        if(ferror(inptr))
        {
            chpr += printf(" (");
            setcharsprinted(chpr);
            chpr = 0;
            printred(strerror(errno));
            chpr += printf(")");
            chpr = newline(chpr);
        }
        else if(feof(inptr))
        {
            printred(" (EOF)");
            chpr = newline(chpr);
        }
    }
    setcharsprinted(chpr);
    return(value);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4db1
movq %rsi, %r15
movq %rdi, %r14
callq 0x31b0
movq %r14, %rdi
callq 0x3190
movq %rax, %r12
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r15
je 0x4d8b
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x4de0
leaq 0xf(%rsp), %rdi
movl $0x1, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x30d0
cmpq $0x1, %rax
jne 0x4dba
movzbl 0xf(%rsp), %ebx
xorl %ebp, %ebp
jmp 0x4e01
xorl %ebx, %ebx
xorl %ebp, %ebp
jmp 0x4e6b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r15
cmovneq %r15, %r12
leaq 0x3c44a(%rip), %rdi     # 0x41217
callq 0x5c26
leaq 0x43b5c(%rip), %rdi     # 0x48935
xorl %ebx, %ebx
movq %r12, %rsi
jmp 0x4df8
leaq 0x3c42b(%rip), %rdi     # 0x41212
callq 0x5c26
leaq 0x43b42(%rip), %rdi     # 0x48935
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
movq %r14, %rdi
callq 0x30b0
testl %eax, %eax
je 0x4e4a
leaq 0x3c3f4(%rip), %rdi     # 0x41208
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movl %ebp, %edi
callq 0x17a82
callq 0x3070
movl (%rax), %edi
callq 0x32c0
movq %rax, %rdi
callq 0x5c26
leaq 0x43d76(%rip), %rdi     # 0x48bb5
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
jmp 0x4e62
movq %r14, %rdi
callq 0x31a0
testl %eax, %eax
je 0x4e6b
leaq 0x3c3ae(%rip), %rdi     # 0x4120b
callq 0x5c26
movl %ebp, %edi
callq 0x1707a
movl %eax, %ebp
movl %ebp, %edi
callq 0x17a82
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x4f1c
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
callq 0x31b0
movq %r12, %rdi
callq 0x3190
movq %rax, %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x4edb
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x4f48
leaq 0x8(%rsp), %r13
movl $0x1, %esi
movl $0x8, %edx
movq %r13, %rdi
movq %r12, %rcx
callq 0x30d0
cmpq $0x8, %rax
jne 0x4f21
movzwl %bp, %eax
cmpl $0x4d4d, %eax           # imm = 0x4D4D
jne 0x4f16
movq 0x8(%rsp), %rax
bswapq %rax
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq (%r13), %r12
jmp 0x4f5e
xorl %r12d, %r12d
jmp 0x4f5e
leaq 0x3c381(%rip), %rdi     # 0x412a9
callq 0x5c26
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
cmovneq %r14, %r15
leaq 0x4090e(%rip), %rdi     # 0x4584e
xorl %r12d, %r12d
movq %r15, %rsi
jmp 0x4f55
leaq 0x3c328(%rip), %rdi     # 0x41277
xorl %r12d, %r12d
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
movl %ebx, %edi
callq 0x17a82
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %ebx, %ebx
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
testq %rdi, %rdi
je 0x5063
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r12
callq 0x31b0
movq %r12, %rdi
callq 0x3190
movq %rax, %r15
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
je 0x4ff0
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
je 0x5050
leaq 0x8(%rsp), %r13
movl $0x1, %esi
movl $0x8, %edx
movq %r13, %rdi
movq %r12, %rcx
callq 0x30d0
cmpq $0x8, %rax
jne 0x5038
movzwl %bp, %eax
cmpl $0x4d4d, %eax           # imm = 0x4D4D
jne 0x502b
movq 0x8(%rsp), %rax
bswapq %rax
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movsd (%r13), %xmm0
movsd %xmm0, (%rsp)
jmp 0x5063
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r14
cmovneq %r14, %r15
leaq 0x3c290(%rip), %rdi     # 0x412db
movq %r15, %rsi
jmp 0x505a
leaq 0x3c220(%rip), %rdi     # 0x41277
movq %r14, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
movl %ebx, %edi
callq 0x17a82
movsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/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 %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x514c
movq %rdi, %rbx
callq 0x31b0
movq %rbx, %rdi
callq 0x3190
movq %rax, %r15
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3210
testl %eax, %eax
jne 0x514f
movq %rbx, %rdi
callq 0x3190
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3210
testl %eax, %eax
je 0x514f
movq %rbx, %rdi
callq 0x31b0
jmp 0x514f
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/print.c
// Function: print_tiff_header
int
print_tiff_header(unsigned short magic,unsigned short byteorder,unsigned long section_id)
{
    char *name = CNULL;
    int status = -1;
    int chpr = 0;

    if(Print_options & section_id)
    {
        switch(magic)
        {
            case TIFF_MAGIC: name = "TIFF"; break;
            case ORF1_MAGIC: name = "ORF1"; break;
            case ORF2_MAGIC: name = "ORF2"; break;
            case RW2_MAGIC:  name = "RW2"; break;
            default: break;
        }

        if(name)
        {
            chpr += printf("%s",name);
            switch(byteorder)
            {
                case TIFF_INTEL:
                case TIFF_MOTOROLA:
                    print_byteorder(byteorder,1);
                    print_magic((unsigned long)magic,2);
                    status = 0;
                    break;
                default:
                    chpr += printf("INVALID %s BYTEORDER ",name);
                    print_byteorder(byteorder,1);
                    print_magic((unsigned long)magic,2);
                    break;
            }
        }
        else
        {
            chpr += printf("INVALID TIFF IDENTIFIER, byteorder ");
            print_byteorder(byteorder,1);
            print_magic((unsigned long)magic,2);
        }
    }
    else
        status = 0;

    setcharsprinted(chpr);
    return(status);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x52ed1(%rip), %rax     # 0x58180
testq %rdx, (%rax)
je 0x52d5
movzwl %di, %ebx
movzwl %si, %ebp
cmpl $0x4f51, %ebx           # imm = 0x4F51
jg 0x52e0
cmpl $0x2a, %ebx
je 0x530c
cmpl $0x55, %ebx
jne 0x52f9
leaq 0x40705(%rip), %r12     # 0x459d8
jmp 0x531c
xorl %r15d, %r15d
xorl %r14d, %r14d
jmp 0x5376
cmpl $0x5352, %ebx           # imm = 0x5352
je 0x5315
cmpl $0x4f52, %ebx           # imm = 0x4F52
jne 0x52f9
leaq 0x3bddb(%rip), %r12     # 0x410d2
jmp 0x531c
leaq 0x3c268(%rip), %rdi     # 0x41568
xorl %eax, %eax
callq 0x3120
movl %eax, %r14d
jmp 0x5357
leaq 0x40010(%rip), %r12     # 0x45323
jmp 0x531c
leaq 0x3bdbb(%rip), %r12     # 0x410d7
leaq 0x3bd74(%rip), %rdi     # 0x41097
xorl %r15d, %r15d
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %r14d
cmpl $0x4949, %ebp           # imm = 0x4949
je 0x535d
cmpl $0x4d4d, %ebp           # imm = 0x4D4D
je 0x535d
leaq 0x3c208(%rip), %rdi     # 0x41552
movq %r12, %rsi
xorl %eax, %eax
callq 0x3120
addl %eax, %r14d
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movl %ebp, %edi
movl $0x1, %esi
callq 0x538a
movq %rbx, %rdi
movl $0x2, %esi
callq 0x5454
movl %r14d, %edi
callq 0x17a82
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movw %di, 0xe(%rsp)
cmpl $0x2, %esi
je 0x53e5
cmpl $0x1, %esi
jne 0x541c
leaq 0x3be61(%rip), %rdi     # 0x41209
xorl %eax, %eax
callq 0x3120
movl %eax, %ebx
leaq 0xe(%rsp), %r14
movq %r14, %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x957f
movzwl (%r14), %esi
cmpl $0x4d4d, %esi           # imm = 0x4D4D
je 0x53dc
cmpl $0x4949, %esi           # imm = 0x4949
jne 0x5434
leaq 0x3c668(%rip), %rdi     # 0x41a4b
jmp 0x543b
leaq 0x3fbe9(%rip), %rbx     # 0x44fd5
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
leaq 0xe(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x957f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
addl %ebp, %edi
jmp 0x5446
leaq 0xe(%rsp), %rdi
movl $0x2, %esi
movl $0x1, %edx
callq 0x957f
xorl %edi, %edi
jmp 0x5446
leaq 0x3c618(%rip), %rdi     # 0x41a53
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
addl %ebx, %edi
callq 0x17a82
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/print.c
// Function: print_tag_address
void
print_tag_address(unsigned long section_id,unsigned long address,int indent,char *prefix)
{
    int chpr = 0;

    if(Print_options & section_id)
    {
        print_filename();
        if(PRINT_INDENT_BEFORE_ADDRESS)
            putindent(indent);
        if(!prefix)
            prefix = "@";
        if(address == HERE)
        {
            /* special case; bland address field                      */
            if(PRINT_BOTH_ADDRESS)
                chpr += printf("%*s:  ",(ADDRWIDTH * 2) + 3,prefix);
            else if(PRINT_HEX_ADDRESS)
                chpr += printf("%*s:  ",ADDRWIDTH + 1,prefix);
            else if(PRINT_DEC_ADDRESS)
                chpr += printf("%*s:  ",ADDRWIDTH,prefix);
        }
        else
        {
            if(PRINT_BOTH_ADDRESS)
                chpr += printf("%s%#0*lx=%-*lu:  ",prefix,ADDRWIDTH+1,address,ADDRWIDTH,address);
            else if(PRINT_HEX_ADDRESS)
                chpr += printf("%s%#0*lx:  ",prefix,ADDRWIDTH+1,address);
            else if(PRINT_DEC_ADDRESS)
                chpr += printf("%s%-*lu:  ",prefix,ADDRWIDTH,address);
        }
        if(PRINT_INDENT_AFTER_ADDRESS)
            putindent(indent);
        setcharsprinted(chpr);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x52b86(%rip), %r12     # 0x58180
testq %rdi, (%r12)
je 0x5658
movq %rcx, %r15
movl %edx, %ebx
movq %rsi, %r14
xorl %eax, %eax
callq 0x17ff9
testb $0x20, 0x3(%r12)
je 0x561e
movl %ebx, %edi
callq 0x5716
testq %r15, %r15
leaq 0x3bab4(%rip), %rdx     # 0x410dc
cmovneq %r15, %rdx
movq (%r12), %rax
movl %eax, %ecx
andl $0x30000, %ecx          # imm = 0x30000
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
cmpq %rsi, %r14
jne 0x5661
cmpl $0x30000, %ecx          # imm = 0x30000
jne 0x568d
leaq 0x3bf4b(%rip), %rdi     # 0x4159c
movl $0x13, %esi
jmp 0x56c3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x30000, %ecx          # imm = 0x30000
jne 0x56a7
leaq 0x3bf33(%rip), %rdi     # 0x415a3
movq %rdx, %rsi
movl $0x9, %edx
movq %r14, %rcx
movl $0x8, %r8d
movq %r14, %r9
xorl %eax, %eax
callq 0x3120
jmp 0x56f6
btl $0x10, %eax
jb 0x56b7
btl $0x11, %eax
jae 0x56b3
leaq 0x3befc(%rip), %rdi     # 0x4159c
movl $0x8, %esi
jmp 0x56c3
btl $0x10, %eax
jb 0x56cc
btl $0x11, %eax
jb 0x56dd
xorl %ebp, %ebp
jmp 0x56f8
leaq 0x3bede(%rip), %rdi     # 0x4159c
movl $0x9, %esi
xorl %eax, %eax
callq 0x3120
jmp 0x56f6
leaq 0x3bee2(%rip), %rdi     # 0x415b5
movq %rdx, %rsi
movl $0x9, %edx
jmp 0x56ec
leaq 0x3bedd(%rip), %rdi     # 0x415c1
movq %rdx, %rsi
movl $0x8, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3120
movl %eax, %ebp
testb $0x10, 0x3(%r12)
je 0x5707
movl %ebx, %edi
callq 0x5716
movl %ebp, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rbx
pushq %rax
cmpl $0x50, %edi
movl $0x50, %ebx
cmovll %edi, %ebx
testl %edi, %edi
jle 0x573c
leal 0x1(%rbx), %ebp
movl $0x20, %edi
callq 0x3060
decl %ebp
cmpl $0x1, %ebp
jg 0x572b
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/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:
movq %rdi, %rax
xorl %edi, %edi
testq %rax, %rax
je 0x17a82
pushq %rax
leaq 0x5191f(%rip), %rcx     # 0x58180
movq (%rcx), %rcx
testl $0x4003333, %ecx        # imm = 0x4003333
je 0x68e9
btl $0xc, %ecx
setae %sil
testb $0x3, %cl
setne %r8b
testb %r8b, %sil
jne 0x6897
movzwl (%rax), %eax
movzwl %ax, %edi
cmpl $0x3, %edx
je 0x68c0
cmpl $0x4, %edx
jne 0x68c7
callq 0xc500
jmp 0x68cc
testb $0x1, %cl
jne 0x68ad
testb $0x2, %cl
je 0x68e9
movzwl (%rax), %esi
leaq 0x3ad70(%rip), %rdi     # 0x4161b
jmp 0x68b7
movzwl (%rax), %esi
leaq 0x3ad5c(%rip), %rdi     # 0x41613
xorl %eax, %eax
callq 0x3120
jmp 0x68e7
callq 0xc44e
jmp 0x68cc
callq 0xaad8
leaq 0x4225e(%rip), %rdi     # 0x48b31
movl $0x1b, %esi
movl $0x1b, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
addq $0x8, %rsp
jmp 0x17a82
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movl $0x0, 0x4(%rsp)
movl $0x1, %ebp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rdx
je 0x73a7
movq %rdx, %r15
movq %rbx, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x3210
cmpl $-0x1, %eax
jne 0x73a7
leaq 0x3a4c0(%rip), %rdi     # 0x41852
movq %r15, %rsi
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
callq 0x1707a
movl %eax, %ebp
incl %ebp
shrq %r14
movl $0x27, %edi
callq 0x3060
xorl %r15d, %r15d
testl %r14d, %r14d
jle 0x7447
movzwl %r12w, %r12d
movq %rbx, %rdi
callq 0x31a0
testl %eax, %eax
jne 0x7447
cmpl $0x0, 0x4(%rsp)
je 0x73f2
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq %rbx, %rdi
movl %r12d, %esi
callq 0x45af
movzwl %ax, %r13d
movl %r13d, 0x4(%rsp)
jmp 0x7405
xorl %r13d, %r13d
leaq 0x3a44d(%rip), %rdi     # 0x41849
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
leaq 0x50d74(%rip), %rax     # 0x58180
testb $0x40, 0x1(%rax)
jne 0x741c
movl %r13d, %edi
callq 0x3060
jmp 0x743a
movq 0x50ba5(%rip), %rax     # 0x57fc8
movq (%rax), %rcx
movl $0x2, %esi
movl $0x1, %edx
leaq 0x4(%rsp), %rdi
callq 0x32a0
incl %r15d
incl %ebp
cmpl %r15d, %r14d
jne 0x73c4
movl %r14d, %r15d
movl $0x27, %edi
callq 0x3060
movq %rbx, %rdi
callq 0x30b0
testl %eax, %eax
je 0x7465
movq %rbx, %rdi
callq 0x31b0
incl %ebp
movl %ebp, %edi
callq 0x17a82
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/print.c
// Function: show_string
int
show_string(char *string,int maxchars,int noquotes)
{
    int lastch;
    int chpr = 0;
    int indent = 0;
    int printed = 0;
    char *ch;

    if(string)
    {
        indent = charsprinted();
        lastch = 'A';
        if(!noquotes)
        {
            (void)putchar('\'');
            chpr++;
        }
        ch = string;
        while(printed < maxchars)
        {
            if(*ch == '\0')
            {
                printf("\\0");
                break;
            }
            else if(isprint(*ch))
            {
                if(isdigit(*ch) && (lastch == '\0'))
                    chpr += printf("00");
                (void)putchar(*ch);
                chpr++;
            }
            else if(*ch == '\n')
            {
                chpr = newline(chpr);
                putindent(indent);
            }
            else if(*ch == '\011')
            {
                putchar(*ch);
                ++ch;
            }
            else
                chpr += printf("\\%03o",(unsigned int)(*ch & 0xff));
            lastch = *ch;
            ++printed;
            ++ch;
        }
        if(!noquotes)
        {
            (void)putchar('\'');
            chpr++;
        }
    }
    setcharsprinted(chpr);
    return(printed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x967d
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x17fea
movl %eax, 0x4(%rsp)
movl $0x0, %ebp
testl %r14d, %r14d
jne 0x95c2
movl $0x27, %edi
callq 0x3060
movl $0x1, %ebp
testl %r15d, %r15d
jle 0x9695
movl %r14d, (%rsp)
movl $0x41, %r13d
xorl %ebx, %ebx
movsbq (%r12), %r14
testq %r14, %r14
je 0x9683
callq 0x32d0
movq (%rax), %rax
movzwl (%rax,%r14,2), %eax
btl $0xe, %eax
jb 0x961a
movzbl %r14b, %esi
cmpl $0x9, %esi
je 0x9646
cmpl $0xa, %esi
jne 0x9655
movl %ebp, %edi
callq 0x1707a
movl %eax, %ebp
movl 0x4(%rsp), %edi
callq 0x5716
jmp 0x9665
btl $0xb, %eax
jae 0x9639
testl %r13d, %r13d
jne 0x9639
leaq 0x3f3cb(%rip), %rdi     # 0x489f7
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movb (%r12), %r14b
movsbl %r14b, %edi
callq 0x3060
incl %ebp
jmp 0x9665
movl $0x9, %edi
callq 0x3060
incq %r12
jmp 0x9665
leaq 0x381f0(%rip), %rdi     # 0x4184c
xorl %eax, %eax
callq 0x3120
addl %eax, %ebp
movsbl (%r12), %r13d
incl %ebx
incq %r12
cmpl %ebx, %r15d
jne 0x95d7
movl %r15d, %ebx
jmp 0x9691
xorl %ebp, %ebp
xorl %ebx, %ebx
jmp 0x96a6
leaq 0x381bf(%rip), %rdi     # 0x41849
xorl %eax, %eax
callq 0x3120
movl (%rsp), %r14d
testl %r14d, %r14d
jne 0x96a6
movl $0x27, %edi
callq 0x3060
incl %ebp
movl %ebp, %edi
callq 0x17a82
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/hfiguiere[P]exifprobe/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 %rax
xorl %edi, %edi
callq 0x1336d
leaq 0x4ea3d(%rip), %rcx     # 0x58180
testb $0x8, 0x2(%rcx)
je 0x9780
decl %eax
cmpl $0x7, %eax
ja 0x9780
movl $0x8b, %ecx
btl %eax, %ecx
jae 0x9780
movl %eax, %eax
leaq 0x37d51(%rip), %rcx     # 0x414b4
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
leaq 0x37926(%rip), %rdi     # 0x41097
xorl %eax, %eax
callq 0x3120
movl %eax, %edi
popq %rax
jmp 0x17a82
popq %rax
retq