LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress1X2_DCtx_wksp
size_t HUF_decompress1X2_DCtx_wksp(HUF_DTable* DCtx, void* dst, size_t dstSize,
                                   const void* cSrc, size_t cSrcSize,
                                   void* workSpace, size_t wkspSize)
{
    const BYTE* ip = (const BYTE*) cSrc;

    size_t const hSize = HUF_readDTableX2_wksp(DCtx, cSrc, cSrcSize,
                                               workSpace, wkspSize);
    if (HUF_isError(hSize)) return hSize;
    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
    ip += hSize; cSrcSize -= hSize;

    return HUF_decompress1X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, DCtx, /* bmi2 */ 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq 0x30(%rsp), %r8
movq %rcx, %rsi
movq %rbx, %rdx
movq %r9, %rcx
callq 0xb251
cmpq $-0x9, %rax
ja 0xb91d
subq %rax, %rbx
jbe 0xb91a
addq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
xorl %r9d, %r9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb688
pushq $-0x3
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress4X2_DCtx_wksp_bmi2
static size_t HUF_decompress4X2_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize,
                                   const void* cSrc, size_t cSrcSize,
                                   void* workSpace, size_t wkspSize, int bmi2)
{
    const BYTE* ip = (const BYTE*) cSrc;

    size_t hSize = HUF_readDTableX2_wksp(dctx, cSrc, cSrcSize,
                                         workSpace, wkspSize);
    if (HUF_isError(hSize)) return hSize;
    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
    ip += hSize; cSrcSize -= hSize;

    return HUF_decompress4X2_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movl 0x48(%rsp), %ebp
movq 0x40(%rsp), %r8
movq %rcx, %rsi
movq %rbx, %rdx
movq %r9, %rcx
callq 0xb251
cmpq $-0x9, %rax
ja 0xc8da
subq %rax, %rbx
jbe 0xc8d7
addq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb9bb
pushq $-0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_selectDecoder
U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
{
    assert(dstSize > 0);
    assert(dstSize <= 128*1024);
#if defined(HUF_FORCE_DECOMPRESS_X1)
    (void)dstSize;
    (void)cSrcSize;
    return 0;
#elif defined(HUF_FORCE_DECOMPRESS_X2)
    (void)dstSize;
    (void)cSrcSize;
    return 1;
#else
    /* decoder timing evaluation */
    {   U32 const Q = (cSrcSize >= dstSize) ? 15 : (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 */
        U32 const D256 = (U32)(dstSize >> 8);
        U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
        U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
        DTime1 += DTime1 >> 3;  /* advantage to algorithm using less memory, to reduce cache eviction */
        return DTime1 < DTime0;
    }
#endif
}

// Assembly:
cmpq %rdi, %rsi
jae 0xc9a8
shlq $0x4, %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movl %eax, %eax
jmp 0xc9ab
pushq $0xf
popq %rax
shrq $0x8, %rdi
imulq $0x18, %rax, %rax
leaq 0x4776(%rip), %rcx      # 0x11130
movl 0x4(%rax,%rcx), %edx
imull %edi, %edx
addl (%rax,%rcx), %edx
imull 0xc(%rax,%rcx), %edi
addl 0x8(%rax,%rcx), %edi
movl %edi, %ecx
shrl $0x3, %ecx
addl %edi, %ecx
xorl %eax, %eax
cmpl %edx, %ecx
setb %al
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress
size_t HUF_decompress (void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{
#if !defined(HUF_FORCE_DECOMPRESS_X1) && !defined(HUF_FORCE_DECOMPRESS_X2)
    static const decompressionAlgo decompress[2] = { HUF_decompress4X1, HUF_decompress4X2 };
#endif

    /* validation checks */
    if (dstSize == 0) return ERROR(dstSize_tooSmall);
    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */

    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
#if defined(HUF_FORCE_DECOMPRESS_X1)
        (void)algoNb;
        assert(algoNb == 0);
        return HUF_decompress4X1(dst, dstSize, cSrc, cSrcSize);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
        (void)algoNb;
        assert(algoNb == 1);
        return HUF_decompress4X2(dst, dstSize, cSrc, cSrcSize);
#else
        return decompress[algoNb](dst, dstSize, cSrc, cSrcSize);
#endif
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc9f8
movq %rcx, %r15
movq %rsi, %rbx
cmpq %rsi, %rcx
jbe 0xca0a
pushq $-0x4
jmp 0xc9fa
pushq $-0x2
popq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r14
movq %rdi, %r12
jne 0xca22
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1130
jmp 0xc9fb
cmpq $0x1, %r15
jne 0xca39
movzbl (%r14), %esi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x10c0
jmp 0xc9fb
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc993
movl %eax, %eax
leaq 0x9383(%rip), %r8       # 0x15dd0
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *(%r8,%rax,8)
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress4X_DCtx
size_t HUF_decompress4X_DCtx (HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize)
{
    /* validation checks */
    if (dstSize == 0) return ERROR(dstSize_tooSmall);
    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */

    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
#if defined(HUF_FORCE_DECOMPRESS_X1)
        (void)algoNb;
        assert(algoNb == 0);
        return HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
        (void)algoNb;
        assert(algoNb == 1);
        return HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize);
#else
        return algoNb ? HUF_decompress4X2_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) :
                        HUF_decompress4X1_DCtx(dctx, dst, dstSize, cSrc, cSrcSize) ;
#endif
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0xca85
movq %r8, %r15
movq %rdx, %rbx
cmpq %rdx, %r8
jbe 0xca95
pushq $-0x4
jmp 0xca87
pushq $-0x2
popq %rbx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rcx, %r14
movq %rsi, %r12
jne 0xcaad
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1130
jmp 0xca88
cmpq $0x1, %r15
jne 0xcac4
movzbl (%r14), %esi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x10c0
jmp 0xca88
movq %rdi, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc993
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
testl %eax, %eax
je 0xcaf3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc8e9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb1d5
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress4X_hufOnly_wksp
size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
                                     size_t dstSize, const void* cSrc,
                                     size_t cSrcSize, void* workSpace,
                                     size_t wkspSize)
{
    /* validation checks */
    if (dstSize == 0) return ERROR(dstSize_tooSmall);
    if (cSrcSize == 0) return ERROR(corruption_detected);

    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
#if defined(HUF_FORCE_DECOMPRESS_X1)
        (void)algoNb;
        assert(algoNb == 0);
        return HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
        (void)algoNb;
        assert(algoNb == 1);
        return HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
#else
        return algoNb ? HUF_decompress4X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
                            cSrcSize, workSpace, wkspSize):
                        HUF_decompress4X1_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize);
#endif
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0xcb8a
movq %r8, %r14
testq %r8, %r8
je 0xcb8e
movq %r9, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rdx, %rdi
movq %r14, %rsi
callq 0xc993
testl %eax, %eax
je 0xcba0
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc863
pushq $-0x2
jmp 0xcb90
pushq $-0x4
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
callq 0xb14f
jmp 0xcb91
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress1X_DCtx_wksp
size_t HUF_decompress1X_DCtx_wksp(HUF_DTable* dctx, void* dst, size_t dstSize,
                                  const void* cSrc, size_t cSrcSize,
                                  void* workSpace, size_t wkspSize)
{
    /* validation checks */
    if (dstSize == 0) return ERROR(dstSize_tooSmall);
    if (cSrcSize > dstSize) return ERROR(corruption_detected);   /* invalid */
    if (cSrcSize == dstSize) { memcpy(dst, cSrc, dstSize); return dstSize; }   /* not compressed */
    if (cSrcSize == 1) { memset(dst, *(const BYTE*)cSrc, dstSize); return dstSize; }   /* RLE */

    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
#if defined(HUF_FORCE_DECOMPRESS_X1)
        (void)algoNb;
        assert(algoNb == 0);
        return HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
                                cSrcSize, workSpace, wkspSize);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
        (void)algoNb;
        assert(algoNb == 1);
        return HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
                                cSrcSize, workSpace, wkspSize);
#else
        return algoNb ? HUF_decompress1X2_DCtx_wksp(dctx, dst, dstSize, cSrc,
                                cSrcSize, workSpace, wkspSize):
                        HUF_decompress1X1_DCtx_wksp(dctx, dst, dstSize, cSrc,
                                cSrcSize, workSpace, wkspSize);
#endif
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0xcbe4
movq %r8, %r12
movq %rdx, %rbx
cmpq %rdx, %r8
jbe 0xcbf9
pushq $-0x4
jmp 0xcbe6
pushq $-0x2
popq %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r15
movq %rsi, %r13
jne 0xcc11
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1130
jmp 0xcbe7
cmpq $0x1, %r12
jne 0xcc28
movzbl (%r15), %esi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x10c0
jmp 0xcbe7
movq %r9, %r14
movq %rdi, %rbp
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc993
testl %eax, %eax
je 0xcc6c
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r14, %r9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb8c1
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
movq %r14, %r9
callq 0xa5d1
jmp 0xcbea
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress1X1_DCtx_wksp_bmi2
size_t HUF_decompress1X1_DCtx_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
{
    const BYTE* ip = (const BYTE*) cSrc;

    size_t const hSize = HUF_readDTableX1_wksp(dctx, cSrc, cSrcSize, workSpace, wkspSize);
    if (HUF_isError(hSize)) return hSize;
    if (hSize >= cSrcSize) return ERROR(srcSize_wrong);
    ip += hSize; cSrcSize -= hSize;

    return HUF_decompress1X1_usingDTable_internal(dst, dstSize, ip, cSrcSize, dctx, bmi2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movl 0x48(%rsp), %ebp
movq 0x40(%rsp), %r8
movq %rcx, %rsi
movq %rbx, %rdx
movq %r9, %rcx
callq 0xa2f0
cmpq $-0x9, %rax
ja 0xcd29
subq %rax, %rbx
jbe 0xcd26
addq %rax, %r14
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
movl %ebp, %r9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa461
pushq $-0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress4X_hufOnly_wksp_bmi2
size_t HUF_decompress4X_hufOnly_wksp_bmi2(HUF_DTable* dctx, void* dst, size_t dstSize, const void* cSrc, size_t cSrcSize, void* workSpace, size_t wkspSize, int bmi2)
{
    /* validation checks */
    if (dstSize == 0) return ERROR(dstSize_tooSmall);
    if (cSrcSize == 0) return ERROR(corruption_detected);

    {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
#if defined(HUF_FORCE_DECOMPRESS_X1)
        (void)algoNb;
        assert(algoNb == 0);
        return HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
        (void)algoNb;
        assert(algoNb == 1);
        return HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
#else
        return algoNb ? HUF_decompress4X2_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2) :
                        HUF_decompress4X1_DCtx_wksp_bmi2(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize, bmi2);
#endif
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0xcdb9
movq %r8, %r14
testq %r8, %r8
je 0xcdbd
movq %r9, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl 0x58(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rdx, %rdi
movq %r14, %rsi
callq 0xc993
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
testl %eax, %eax
je 0xcdcf
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc873
pushq $-0x2
jmp 0xcdbf
pushq $-0x4
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq 0x8(%rsp)
pushq 0x18(%rsp)
callq 0xb15f
addq $0x28, %rsp
jmp 0xcdc4
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/bitstream.h
// Function: BIT_reloadDStreamFast
MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
{
    if (UNLIKELY(bitD->ptr < bitD->limitPtr))
        return BIT_DStream_overflow;
    assert(bitD->bitsConsumed <= sizeof(bitD->bitContainer)*8);
    bitD->ptr -= bitD->bitsConsumed >> 3;
    bitD->bitsConsumed &= 7;
    bitD->bitContainer = MEM_readLEST(bitD->ptr);
    return BIT_DStream_unfinished;
}

// Assembly:
movq 0x10(%rdi), %rax
cmpq 0x20(%rdi), %rax
jb 0xd0a3
movl 0x8(%rdi), %ecx
movl %ecx, %edx
shrl $0x3, %edx
subq %rdx, %rax
movq %rax, 0x10(%rdi)
andl $0x7, %ecx
movl %ecx, 0x8(%rdi)
movq (%rax), %rax
movq %rax, (%rdi)
xorl %eax, %eax
retq
pushq $0x3
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_time_funcs.c
// Function: test_normalised
int test_normalised(time_t start, time_t end, time_t incr) {
    time_t i, j;
    struct tm *utc;

    for (i = start; i < end; i += incr) {
        utc = gmtime(&i);
        j = hts_time_gm(utc);
        if (i != j) {
            fprintf(stderr,
                    "hts_time_gm() failed, got %"PRId64" expected %"PRId64"\n",
                    (int64_t) j, (int64_t) i);
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rax
leaq 0x8(%rsp), %r15
movq %rax, 0x8(%rsp)
cmpq %r14, %rax
jge 0x119c
movq %r15, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x11c8
movq 0x8(%rsp), %rcx
cmpq %rax, %rcx
jne 0x11a8
addq %rbx, %rax
jmp 0x1173
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x2e49(%rip), %rdx      # 0x3ff8
movq (%rdx), %rdi
leaq 0xe4b(%rip), %rsi       # 0x2004
movq %rax, %rdx
xorl %eax, %eax
callq 0x1040
pushq $0x1
popq %rax
jmp 0x119e
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/test_time_funcs.c
// Function: test_specific
int test_specific(int year, int mon, int mday, int hour, int min, int sec,
                  time_t expected) {
    struct tm utc = { sec, min, hour, mday, mon - 1, year - 1900, 0, 0, 0 };
    time_t res = hts_time_gm(&utc);
    if (res != expected) {
        fprintf(stderr,
                "hts_time_gm() failed for %4d/%02d/%02d %02d:%02d:%02d :"
                " got %"PRId64" expected %"PRId64"\n",
                year, mon, mday, hour, min, sec,
                (int64_t) res, (int64_t) expected);
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %r14d
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movl %edi, %r13d
leaq 0x10(%rsp), %rdi
movl %r9d, (%rdi)
movq %r8, 0x8(%rsp)
movl %r8d, 0x4(%rdi)
movl %ecx, 0x8(%rdi)
movl %edx, 0xc(%rdi)
leal -0x1(%r12), %eax
movl %eax, 0x10(%rdi)
leal -0x76c(%r13), %eax
movl %eax, 0x14(%rdi)
andq $0x0, 0x18(%rdi)
andl $0x0, 0x20(%rdi)
movq 0x80(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
callq 0x11c8
movq %rax, %r10
xorl %eax, %eax
cmpq %rbx, %r10
jne 0x148d
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2b64(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0xb92(%rip), %rsi       # 0x2030
movl %r13d, %edx
movl %r12d, %ecx
movl %r15d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
pushq %rbx
pushq %r10
pushq %r14
pushq 0x20(%rsp)
callq 0x1040
addq $0x20, %rsp
pushq $0x1
popq %rax
jmp 0x147e
// File: /workspace/github_c_makefile_star2_O2/samtools[P]htslib/test/../hts_time_funcs.h
// Function: hts_time_normalise
static inline int hts_time_normalise(int *tens, int *units, int base) {
    if (*units < 0 || *units >= base) {
        int delta = *units >= 0 ? *units / base : (-1 - (-1 - *units) / base);
        int64_t tmp = (int64_t) (*tens) + delta;
        if (tmp < INT_MIN || tmp > INT_MAX) return 1;
        *tens = tmp;
        *units -= delta * base;
    }
    return 0;
}

// Assembly:
movl %edx, %r8d
movl (%rsi), %eax
testl %eax, %eax
setns %dl
cmpl %r8d, %eax
setl %r9b
xorl %ecx, %ecx
testb %r9b, %dl
jne 0x1878
testl %eax, %eax
js 0x1851
xorl %edx, %edx
divl %r8d
jmp 0x185a
notl %eax
xorl %edx, %edx
divl %r8d
notl %eax
movslq (%rdi), %r9
movslq %eax, %rdx
addq %r9, %rdx
movslq %edx, %r9
cmpq %rdx, %r9
je 0x1870
pushq $0x1
popq %rcx
jmp 0x1878
movl %edx, (%rdi)
imull %r8d, %eax
subl %eax, (%rsi)
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/antonblanchard[P]will-it-scale/tests/brk1.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	void *addr = sbrk(0);
	unsigned long page_size = getpagesize();

	while (1) {
		addr += page_size;
		assert(brk(addr) == 0);

		addr -= page_size;
		assert(brk(addr) == 0);

		(*iterations) += 2;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2170
movq %rax, %r14
callq 0x2280
movslq %eax, %r15
addq %r14, %r15
movq %r15, %rdi
callq 0x2150
testl %eax, %eax
jne 0x2b7b
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
jne 0x2b94
addq $0x2, (%rbx)
jmp 0x2b5d
leaq 0x708(%rip), %rdi       # 0x328a
leaq 0x710(%rip), %rsi       # 0x3299
leaq 0x716(%rip), %rcx       # 0x32a6
pushq $0xe
jmp 0x2bab
leaq 0x6ef(%rip), %rdi       # 0x328a
leaq 0x6f7(%rip), %rsi       # 0x3299
leaq 0x6fd(%rip), %rcx       # 0x32a6
pushq $0x11
popq %rdx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_07/readlines.c
// Function: main
int main()
{
  int nr_of_lines;             // # of input lines read
  char stored_lines[MAXSTORE]; // # of chars to be stored for all lines

  if ((nr_of_lines = readlines(line_ptr, MAXLINES, stored_lines)) >= 0)
  {
    quick_sort(line_ptr, 0, nr_of_lines - 1);
    printf("-----\n");
    writelines(line_ptr, nr_of_lines);
    return 0;
  }
  else
  {
    printf("Error: input too big to sort.\n");
    return 1;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x2710, %rsp           # imm = 0x2710
leaq 0x2ed2(%rip), %rdi      # 0x4060
movq %rsp, %rdx
movl $0x1388, %esi           # imm = 0x1388
callq 0x11ed
testl %eax, %eax
js 0x11d0
movl %eax, %ebx
movl %eax, %edx
decl %edx
leaq 0x2eb4(%rip), %r14      # 0x4060
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x1293
leaq 0xe63(%rip), %rdi       # 0x2022
callq 0x1040
movq %r14, %rdi
movl %ebx, %esi
callq 0x1356
jmp 0x11df
leaq 0xe2d(%rip), %rdi       # 0x2004
callq 0x1040
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x2710, %rsp           # imm = 0x2710
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_07/readlines.c
// Function: readlines
int readlines(char *line_ptr[], int max_nr_of_lines, char *stored_lines)
{
  int len;
  int nr_of_lines;

  char *p = stored_lines + strlen(stored_lines); // Init p with the first empty position from stored_lines
  char line[MAXLEN];

  nr_of_lines = 0;
  while ((len = get_line(line, MAXLEN)) > 0)
  {
    // Checking if the current # of lines exceeds the max # of lines that can be stored
    // Also checking if the max # of chars from the stored_lines buffer is not exceeded
    if (nr_of_lines >= max_nr_of_lines || stored_lines + MAXSTORE - p < len)
    {
      return -1;
    }
    else
    {
      line[len - 1] = '\0'; // Delete newline
      strcpy(p, line);
      line_ptr[nr_of_lines++] = p;
      p += len; // Move p to the next empty position
    }
  }

  return nr_of_lines;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, 0x8(%rsp)
movq %rdx, %rdi
callq 0x1050
movq %rax, %r12
addq %rbx, %r12
addq $0x2710, %rbx           # imm = 0x2710
xorl %ebp, %ebp
testl %r14d, %r14d
cmovlel %ebp, %r14d
leaq 0x10(%rsp), %r13
movl $0x3e8, %esi            # imm = 0x3E8
movq %r13, %rdi
callq 0x137b
testl %eax, %eax
jle 0x127f
cmpq %rbp, %r14
je 0x127a
movq %rbx, %rcx
subq %r12, %rcx
movl %eax, %r15d
andl $0x7fffffff, %r15d      # imm = 0x7FFFFFFF
cmpq %r15, %rcx
jl 0x127a
decl %eax
movb $0x0, 0x10(%rsp,%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x1030
movq 0x8(%rsp), %rax
movq %r12, (%rax,%rbp,8)
incq %rbp
addq %r15, %r12
jmp 0x122c
pushq $-0x1
popq %rax
jmp 0x1281
movl %ebp, %eax
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_07/readlines.c
// Function: quick_sort
void quick_sort(char *v[], int left, int right)
{
  int i;
  int last;

  // Do nothing if the array contains less than 2 elements
  if (left >= right)
  {
    return;
  }

  swap(v, left, (left + right) / 2);
  last = left;

  for (i = left + 1; i <= right; ++i)
  {
    if (strcmp(v[i], v[left]) < 0)
    {
      swap(v, ++last, i);
    }
  }

  swap(v, left, last);
  quick_sort(v, left, last - 1);
  quick_sort(v, last + 1, right);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movslq %edx, %rax
movq %rax, 0x10(%rsp)
movq %rdx, (%rsp)
cmpl %edx, %esi
jge 0x1347
leal (%rsi,%rdx), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
movslq %esi, %rbx
movq (%r14,%rbx,8), %rcx
cltq
movq (%r14,%rax,8), %rdx
movq %rdx, (%r14,%rbx,8)
movq %rcx, (%r14,%rax,8)
movq %rbx, %rbp
movq %rsi, 0x8(%rsp)
movl %esi, %r13d
movslq %r13d, %r15
cmpq 0x10(%rsp), %rbp
jge 0x1317
movq 0x8(%r14,%rbp,8), %r12
incq %rbp
movq (%r14,%rbx,8), %rsi
movq %r12, %rdi
callq 0x1060
testl %eax, %eax
jns 0x12e1
leal 0x1(%r15), %r13d
movq 0x8(%r14,%r15,8), %rax
movq %r12, 0x8(%r14,%r15,8)
movq %rax, (%r14,%rbp,8)
jmp 0x12e1
movq (%r14,%rbx,8), %rax
movq (%r14,%r15,8), %rcx
movq %rcx, (%r14,%rbx,8)
movq %rax, (%r14,%r15,8)
leal -0x1(%r15), %edx
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x1293
incl %r15d
movl %r15d, %esi
movq (%rsp), %rdx
jmp 0x12b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_5/exercise_5_07/readlines.c
// Function: get_line
size_t get_line(char line[], size_t max_line_len)
{
  int c;
  size_t i;

  for (i = 0; i < max_line_len - 1 && (c = getc(stdin)) != EOF && c != '\n'; ++i)
  {
    line[i] = c;
  }

  if (c == '\n')
  {
    line[i] = c;
    ++i;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
decq %r15
xorl %r14d, %r14d
movq 0x2c4a(%rip), %r12      # 0x3fe0
cmpq %r14, %r15
je 0x13b7
movq (%r12), %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0x13ba
cmpl $0xa, %eax
je 0x13ba
movb %al, (%rbx,%r14)
incq %r14
jmp 0x1396
movq %r15, %r14
cmpl $0xa, %eax
jne 0x13c7
movb $0xa, (%rbx,%r14)
incq %r14
movb $0x0, (%rbx,%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/extracters/sdsdump/sdsdump.c
// Function: getfc
int getfc (FILE *ifile)
{
int k;
unsigned char by;

k = fread (&by, sizeof (char), 1, ifile);
if (k == 0) {
	printf ("End of physical tape\n");
	return -1;  }
return by;
}

// Assembly:
pushq %rax
movq %rdi, %rcx
leaq 0x7(%rsp), %rdi
pushq $0x1
popq %rdx
movq %rdx, %rsi
callq 0x1050
testl %eax, %eax
je 0x11bb
movzbl 0x7(%rsp), %eax
jmp 0x11ca
leaq 0xf65(%rip), %rdi       # 0x2127
callq 0x1040
pushq $-0x1
popq %rax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/ijleesw[P]data-compression/src/checker/readfile.hpp
// Function: readchar2buf(char const*, char*&, long*)
int readchar2buf(const char* _path_, char*& buf, long* length)
{
	ifstream inFile;
	inFile.open(_path_);
	if (!inFile.is_open()) return 0;

	inFile.seekg(0, ios::end);
	long size = inFile.tellg();
	inFile.clear();
	inFile.seekg(0, ios::beg);

	buf = new char[size+1];
	inFile.read(buf, size);
	buf[size] = '\0';
	*length = strlen(buf);

	inFile.close();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x228(%rbp), %r12
movq %r12, %rdi
callq 0x21a0
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x20f0
leaq -0x1b0(%rbp), %rdi
callq 0x2070
xorl %r15d, %r15d
testb %al, %al
je 0x2438
leaq -0x228(%rbp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x21c0
movq %r12, %rdi
callq 0x2200
movq %rax, %r15
movq -0x228(%rbp), %rax
addq -0x18(%rax), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x21f0
leaq -0x228(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21c0
leaq 0x1(%r15), %rax
cmpq $-0x1, %r15
pushq $-0x1
popq %rdi
cmovgeq %rax, %rdi
callq 0x2030
movq %rax, (%r14)
leaq -0x228(%rbp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x21b0
movq (%r14), %rax
movb $0x0, (%rax,%r15)
movq (%r14), %rdi
callq 0x20c0
movq %rax, (%rbx)
leaq -0x228(%rbp), %rdi
callq 0x2060
pushq $0x1
popq %r15
leaq -0x228(%rbp), %rdi
callq 0x2080
movl %r15d, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x245b
jmp 0x245b
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O2/ijleesw[P]data-compression/src/checker/readfile.hpp
// Function: readbyte2buf(char const*, unsigned char*&, long*)
int readbyte2buf(const char* _path_, unsigned char*& buf, long* length)
{
	ifstream inFile;
	inFile.open(_path_);
	if (!inFile.is_open()) return 0;

	inFile.seekg(0, ios::end);
	long size = inFile.tellg();
	inFile.clear();
	inFile.seekg(0, ios::beg);

	buf = new unsigned char[size+1];
	inFile.read((char*)buf, size);
	buf[size] = '\0';
	*length = size;

	inFile.close();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x228(%rbp), %r12
movq %r12, %rdi
callq 0x21a0
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x20f0
leaq -0x1b0(%rbp), %rdi
callq 0x2070
xorl %r15d, %r15d
testb %al, %al
je 0x2546
leaq -0x228(%rbp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x21c0
movq %r12, %rdi
callq 0x2200
movq %rax, %r15
movq -0x228(%rbp), %rax
addq -0x18(%rax), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x21f0
leaq -0x228(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21c0
leaq 0x1(%r15), %rax
cmpq $-0x1, %r15
pushq $-0x1
popq %rdi
cmovgeq %rax, %rdi
callq 0x2030
movq %rax, (%r14)
leaq -0x228(%rbp), %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x21b0
movq (%r14), %rax
movb $0x0, (%rax,%r15)
movq %r15, (%rbx)
leaq -0x228(%rbp), %rdi
callq 0x2060
pushq $0x1
popq %r15
leaq -0x228(%rbp), %rdi
callq 0x2080
movl %r15d, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2569
jmp 0x2569
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O2/ijleesw[P]data-compression/src/checker/readfile.hpp
// Function: readint2buf(char const*, int*&, long*)
int readint2buf(const char* _path_, int*& buf, long* length)
{
	long tmp;
	long cnt = 0;
	ifstream inFile;

	inFile.open(_path_);
	if (!inFile.is_open()) return 0;

	*length = 0;
	while (inFile >> tmp) (*length)++;
	cout << *length << endl;
	inFile.clear();
	inFile.seekg(0, ios::beg);

	buf = new int[*length];
	while (inFile >> tmp) buf[cnt++] = tmp;

	inFile.close();
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x230(%rbp), %r12
movq %r12, %rdi
callq 0x21a0
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x20f0
leaq -0x1b8(%rbp), %rdi
callq 0x2070
xorl %r15d, %r15d
testb %al, %al
je 0x26a1
xorl %esi, %esi
leaq -0x230(%rbp), %r15
leaq -0x28(%rbp), %r12
movq %rsi, (%r14)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2180
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movq (%r14), %rsi
jne 0x2600
incq %rsi
jmp 0x25dc
movq 0x29d1(%rip), %rdi      # 0x4fd8
callq 0x2150
movq %rax, %rdi
callq 0x20e0
movq -0x230(%rbp), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x21f0
leaq -0x230(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21c0
movq (%r14), %rax
movq %rax, %rcx
shrq $0x3e, %rcx
shlq $0x2, %rax
xorl %edi, %edi
negq %rcx
sbbq %rdi, %rdi
orq %rax, %rdi
callq 0x2030
movq %rax, (%rbx)
xorl %r12d, %r12d
leaq -0x230(%rbp), %r14
leaq -0x28(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2691
movl -0x28(%rbp), %eax
movq (%rbx), %rcx
movl %eax, (%rcx,%r12)
addq $0x4, %r12
jmp 0x2668
leaq -0x230(%rbp), %rdi
callq 0x2060
pushq $0x1
popq %r15
leaq -0x230(%rbp), %rdi
callq 0x2080
movl %r15d, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26c4
jmp 0x26c4
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O2/ijleesw[P]data-compression/src/checker/main.cpp
// Function: symbol_counter(unsigned char*, int)
int symbol_counter(uchar* buf, int length)
{
	set<uchar> s;
	int cnt = 0;
	while (cnt < length) s.insert(buf[cnt++]);
/*
	cout << endl;
	for (auto &iter: s) cout << (int)iter << " ";
	cout << endl;
*/
	return s.size();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq -0x40(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rdi, %rbx
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
xorl %r15d, %r15d
testl %esi, %esi
cmovgl %esi, %r15d
leaq -0x48(%rbp), %r14
subq $0x1, %r15
jb 0x296e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2a4e
incq %rbx
jmp 0x2958
leaq -0x48(%rbp), %rdi
movl 0x28(%rdi), %ebx
callq 0x29f8
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x29f8
movq %rbx, %rdi
callq 0x2210
// File: /workspace/github_c_makefile_star2_O2/ijleesw[P]data-compression/src/checker/main.cpp
// Function: ceil_log2(int)
int ceil_log2(int n)
{
	assert (n >= 1);
	int last = -1, secondlast = -1, count = 0;
	int log2_n, tmp = n;

	while (tmp) {
	if (tmp & 1) {
		secondlast = last;
		last = count;
	}
	tmp >>= 1;
	++count;
	}
	if (secondlast == -1)
		log2_n = last;
	else
		log2_n = last+1;

	return log2_n;
}

// Assembly:
testl %edi, %edi
jle 0x29c9
xorl %ecx, %ecx
pushq $-0x1
popq %rax
movl %eax, %edx
testl %edi, %edi
je 0x29be
testb $0x1, %dil
movl %ecx, %esi
cmovel %eax, %esi
cmovnel %eax, %edx
shrl %edi
incl %ecx
movl %esi, %eax
jmp 0x29a6
xorl %ecx, %ecx
cmpl $-0x1, %edx
setne %cl
addl %ecx, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x726(%rip), %rdi       # 0x30fa
leaq 0x726(%rip), %rsi       # 0x3101
leaq 0x734(%rip), %rcx       # 0x3116
pushq $0x6c
popq %rdx
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/silverneko[P]miku/./src/tddump.cpp
// Function: main
int main(int argc, char *argv[])
{
  if(argc < 2) return 0;
  int pid = cast(argv[1]).to<int>();
  submission sub;

  sub.problem_id = pid;

  ostringstream sout;
  sout << "./testdata/";
  sout << setfill('0') << setw(4) << sub.problem_id;
  string testdata_dir(sout.str());
  if(access(testdata_dir.c_str(), F_OK)){
    system(("mkdir " + testdata_dir + " 2>/dev/null").c_str());
  }

  downloadTestdata(sub);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1278, %rsp           # imm = 0x1278
cmpl $0x2, %edi
jl 0x25ab
movq 0x8(%rsi), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2636
leaq 0x1e0(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x21c0
leaq 0x1e0(%rsp), %rdi
callq 0x2672
movl %eax, %ebx
leaq 0x1e0(%rsp), %rdi
callq 0x20d0
leaq 0x68(%rsp), %rdi
callq 0x20d0
leaq 0x1e0(%rsp), %r14
movq %r14, %rdi
callq 0x26c8
movl %ebx, (%r14)
leaq 0x68(%rsp), %rdi
callq 0x21b0
leaq 0x1b26(%rip), %rsi      # 0x4004
leaq 0x68(%rsp), %rdi
callq 0x2160
leaq 0x68(%rsp), %rdi
pushq $0x30
popq %rsi
callq 0x2230
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x4, 0x10(%rax,%rcx)
movl 0x1e0(%rsp), %esi
movq %rax, %rdi
callq 0x2290
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2250
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x2270
testl %eax, %eax
je 0x257d
leaq 0x1ad6(%rip), %rsi      # 0x4010
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2910
leaq 0x1ac7(%rip), %rdx      # 0x4017
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x28f1
movq 0x48(%rsp), %rdi
callq 0x2130
leaq 0x48(%rsp), %rdi
callq 0x20d0
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x1e0(%rsp), %rdi
callq 0x2d0b
leaq 0x8(%rsp), %rdi
callq 0x20d0
leaq 0x68(%rsp), %rdi
callq 0x2060
leaq 0x1e0(%rsp), %rdi
callq 0x2986
xorl %eax, %eax
addq $0x1278, %rsp           # imm = 0x1278
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20d0
jmp 0x25ca
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
jmp 0x25db
jmp 0x25d8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20d0
jmp 0x2617
jmp 0x2614
movq %rax, %rbx
jmp 0x2621
movq %rax, %rbx
leaq 0x1e0(%rsp), %rdi
callq 0x20d0
jmp 0x2603
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x20d0
jmp 0x262e
movq %rax, %rbx
jmp 0x262e
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x2060
leaq 0x1e0(%rsp), %rdi
callq 0x2986
movq %rbx, %rdi
callq 0x22a0
// File: /workspace/github_c_makefile_star2_O2/millimat[P]Soft-Heap/approx-sort.c
// Function: metric_mispositions
double metric_mispositions(int *output, int n) {
  int mispos = 0;
  for(int i = 0; i < n; i++) {
    if(output[i] != i)
      mispos++;
  }

  return mispos/(double)n;
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
xorl %edx, %edx
cmpq %rax, %rcx
je 0x11f5
movl (%rdi,%rax,4), %r8d
xorl %r9d, %r9d
cmpq %r8, %rax
setne %r9b
addl %r9d, %edx
incq %rax
jmp 0x11da
cvtsi2sd %edx, %xmm0
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/millimat[P]Soft-Heap/approx-sort.c
// Function: metric_distance
long metric_distance(int *output, int n) {
  long dist = 0;
  for(int i = 0; i < n; i++) {
    dist += (output[i] > i ? output[i] - i : i - output[i]);
  }

  return dist;
}

// Assembly:
xorl %ecx, %ecx
testl %esi, %esi
cmovlel %ecx, %esi
negq %rsi
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x122d
movl (%rdi), %edx
addl %ecx, %edx
movl %edx, %r8d
negl %r8d
cmovsl %edx, %r8d
addq %r8, %rax
decq %rcx
addq $0x4, %rdi
jmp 0x120e
retq
// File: /workspace/github_c_makefile_star2_O2/millimat[P]Soft-Heap/approx-sort.c
// Function: metric_kendall
double metric_kendall(int *output, int n) {
  long count = 0;
  for(int i = 0; i < n; i++) {
    for(int j = i+1; j < n; j++) {
      if(output[i] > output[j])
        count++;
    }
  }

  return 2*count / (n*(n-1.0));
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
pushq $0x1
popq %rdx
xorl %r8d, %r8d
cmpq %rcx, %rax
je 0x126c
movq %rdx, %r9
cmpl %esi, %r9d
jge 0x1264
movl (%rdi,%rax,4), %r10d
xorl %r11d, %r11d
cmpl (%rdi,%r9,4), %r10d
setg %r11b
addq %r11, %r8
incq %r9
jmp 0x1248
incq %rax
incq %rdx
jmp 0x1240
addq %r8, %r8
cvtsi2sd %r8, %xmm0
cvtsi2sd %esi, %xmm1
movsd 0xd88(%rip), %xmm2      # 0x2008
addsd %xmm1, %xmm2
mulsd %xmm1, %xmm2
divsd %xmm2, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/millimat[P]Soft-Heap/approx-sort.c
// Function: metric_mispositions_threshold
double metric_mispositions_threshold(int *output, int n, int threshold) {
  int mispos = 0;
  for(int i = 0; i < n; i++) {
    if(output[i] > i + threshold || output[i] < i - threshold)
      mispos++;
  }

  return mispos/(double)n;
}

// Assembly:
pushq %rbx
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
movslq %edx, %rdx
movq %rdx, %r8
negq %r8
xorl %r9d, %r9d
cmpq %rax, %rcx
je 0x12d4
leaq (%rdx,%rax), %r10
movslq (%rdi,%rax,4), %r11
cmpq %r11, %r10
setl %r10b
leaq (%r8,%rax), %rbx
cmpq %r11, %rbx
setg %r11b
orb %r10b, %r11b
movzbl %r11b, %r10d
addl %r10d, %r9d
incq %rax
jmp 0x12a6
cvtsi2sd %r9d, %xmm0
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/millimat[P]Soft-Heap/approx-sort.c
// Function: all_metrics_per_epsilon
void all_metrics_per_epsilon(int *elts, int n) {
  int output[n];

  for(int k = 1; k < n; k *= 2) {
    double epsilon = ((double)k)/n;
    int r = ceil(-log(epsilon)/log(2)) + 5;

    softheap *P = makeheap_empty(epsilon);

    for(int i = 0; i < n; i++)
      insert(P, elts[i]);

    for(int i = 0; i < n; i++)
      output[i] = extract_min(P);

    destroy_heap(P);

    printf("r=%d \t\t %f \t\t %ld \t\t %f \n", r, metric_mispositions(output,n),metric_distance(output,n),metric_mispositions_threshold(output,n,n/100));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r12d
movq %rdi, %r14
movl %esi, %eax
movq %rsp, %r15
leaq 0xf(,%rax,4), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
cvtsi2sd %esi, %xmm0
movsd %xmm0, -0x50(%rbp)
pushq $0x64
popq %rcx
movl %esi, %eax
cltd
idivl %ecx
movl %eax, -0x3c(%rbp)
xorl %ebx, %ebx
testl %esi, %esi
cmovgl %esi, %ebx
pushq $0x1
popq %rax
movl %esi, -0x40(%rbp)
cmpl %r12d, %eax
jge 0x1411
movl %eax, -0x44(%rbp)
cvtsi2sd %eax, %xmm0
divsd -0x50(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x1060
divsd 0xcb7(%rip), %xmm0      # 0x2010
callq 0x10b0
addsd 0xcb2(%rip), %xmm0      # 0x2018
movsd %xmm0, -0x38(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x14f4
movq %rax, %r13
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x1391
movl (%r14,%r12,4), %esi
movq %r13, %rdi
callq 0x1666
incq %r12
jmp 0x137b
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0x13aa
movq %r13, %rdi
callq 0x189e
movl %eax, (%r15,%r12,4)
incq %r12
jmp 0x1394
cvttsd2si -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movq %r13, %rdi
callq 0x15dd
movq %r15, %rdi
movl -0x40(%rbp), %r12d
movl %r12d, %esi
callq 0x11cc
movsd %xmm0, -0x30(%rbp)
movq %r15, %rdi
movl %r12d, %esi
callq 0x1202
movq %rax, %r13
movq %r15, %rdi
movl %r12d, %esi
movl -0x3c(%rbp), %edx
callq 0x128d
movapd %xmm0, %xmm1
leaq 0xc33(%rip), %rdi       # 0x2028
movl -0x38(%rbp), %esi
movsd -0x30(%rbp), %xmm0
movq %r13, %rdx
movb $0x2, %al
callq 0x1040
movl -0x44(%rbp), %eax
addl %eax, %eax
jmp 0x1332
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/millimat[P]Soft-Heap/approx-sort.c
// Function: random_permutation
void random_permutation(int *elts, int n) {
  for(int i = 0; i < n; i++) {
    int j = randint(i+1);
    elts[i] = elts[j];
    elts[j] = i;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %ebx
cmpq %r12, %rbx
je 0x1481
leaq 0x1(%r12), %r15
movl %r15d, %edi
callq 0x1420
cltq
movl (%r14,%rax,4), %ecx
movl %ecx, (%r14,%r12,4)
leal -0x1(%r15), %ecx
movl %ecx, (%r14,%rax,4)
movq %r15, %r12
jmp 0x1458
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/millimat[P]Soft-Heap/approx-sort.c
// Function: main
int main(int argc, char *argv[]) {
  int n = 1000000;

  int elts[n];

  srand(time(NULL));
  random_permutation(elts, n);

  all_metrics_per_epsilon(elts, n);

  return 0;
}

// Assembly:
pushq %rbx
subq $0x3d0900, %rsp         # imm = 0x3D0900
xorl %edi, %edi
callq 0x1080
movl %eax, %edi
callq 0x1070
movq %rsp, %rbx
movq %rbx, %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x1442
movq %rbx, %rdi
movl $0xf4240, %esi          # imm = 0xF4240
callq 0x12e3
xorl %eax, %eax
addq $0x3d0900, %rsp         # imm = 0x3D0900
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/vusec[P]fpvi-scsb/fp_reverse_engineering/test_operands/test_operands.c
// Function: print_double
void print_double(char *name, double n)
{
    int64_t  bias = 1023;
    uint64_t hex_n = *((uint64_t *)&n);
    uint64_t unbiased_exp = (hex_n>>52)&0x7FF;
    int64_t  biased_exp   = unbiased_exp == 0 ? -1022 : (int64_t)unbiased_exp - bias;
    uint64_t mantissa = hex_n&0x000FFFFFFFFFFFFFUL;
    
    printf("%9s = 0x%016lx    %16e    ", name, hex_n, n);
    printf("(%8s    biased_exp=%5ld    unbiased_exp=%5ld    mantissa=0x%013lx)\n",
            unbiased_exp == 0 ? "DENORMAL" : "  NORMAL",
            unbiased_exp, biased_exp, mantissa);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rsi
movq %xmm0, %rdx
movq %rdx, %rbx
shrq $0x34, %rbx
andl $0x7ff, %ebx            # imm = 0x7FF
leaq -0x3ff(%rbx), %r15
movabsq $0xfffffffffffff, %r14  # imm = 0xFFFFFFFFFFFFF
andq %rdx, %r14
leaq 0xdda(%rip), %rdi       # 0x2017
movb $0x1, %al
callq 0x1040
testq %rbx, %rbx
movq $-0x3fe, %rcx           # imm = 0xFC02
cmovneq %r15, %rcx
leaq 0xe1d(%rip), %rax       # 0x2076
leaq 0xe1f(%rip), %rsi       # 0x207f
cmoveq %rax, %rsi
leaq 0xdc7(%rip), %rdi       # 0x2032
movq %rbx, %rdx
movq %r14, %r8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/tudurom[P]windowchef/wm.c
// Function: cleanup
static void
cleanup(void)
{
	xcb_set_input_focus(conn, XCB_NONE, XCB_INPUT_FOCUS_POINTER_ROOT,
			XCB_CURRENT_TIME);
	ungrab_buttons();
	if (ewmh != NULL)
		xcb_ewmh_connection_wipe(ewmh);
	if (win_list != NULL)
		list_delete_all_items(&win_list, true);
	if (focus_list != NULL)
	    list_delete_all_items(&focus_list, true);
	if (conn != NULL)
		xcb_disconnect(conn);
}

// Assembly:
pushq %rbx
movq 0x830f(%rip), %rdi      # 0xc3b8
pushq $0x1
popq %rdx
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x3150
callq 0x411e
movq 0x82ff(%rip), %rbx      # 0xc3c0
testq %rbx, %rbx
je 0x40d8
movq 0x8(%rbx), %rdi
callq 0x32c0
movq 0x18(%rbx), %rdi
callq 0x32c0
cmpq $0x0, 0x82e8(%rip)      # 0xc3c8
je 0x40f1
leaq 0x82df(%rip), %rdi      # 0xc3c8
pushq $0x1
popq %rsi
callq 0x7fe3
cmpq $0x0, 0x82d7(%rip)      # 0xc3d0
je 0x410a
leaq 0x82ce(%rip), %rdi      # 0xc3d0
pushq $0x1
popq %rsi
callq 0x7fe3
movq 0x82a7(%rip), %rdi      # 0xc3b8
testq %rdi, %rdi
je 0x411c
popq %rbx
jmp 0x3620
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tudurom[P]windowchef/wm.c
// Function: ungrab_buttons
static void
ungrab_buttons(void)
{
	struct list_item *item;
	struct client *client;

	for (item = win_list; item != NULL; item = item->next) {
		client = item->data;
		xcb_ungrab_button(conn, XCB_BUTTON_INDEX_ANY, client->window, XCB_MOD_MASK_ANY);
	}
}

// Assembly:
pushq %rbx
leaq 0x82a2(%rip), %rbx      # 0xc3c8
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x414c
movq (%rbx), %rax
movq 0x8280(%rip), %rdi      # 0xc3b8
movl (%rax), %edx
xorl %esi, %esi
movl $0x8000, %ecx           # imm = 0x8000
callq 0x34f0
addq $0x10, %rbx
jmp 0x4126
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/tudurom[P]windowchef/wm.c
// Function: event_destroy_notify
static void
event_destroy_notify(xcb_generic_event_t *ev)
{
	struct client *client;
	xcb_destroy_notify_event_t *e = (xcb_destroy_notify_event_t *)ev;

	client = find_client(&e->window);
	if (conf.last_window_focusing && focused_win != NULL && focused_win == client) {
	    focused_win = NULL;
		set_focused_last_best();
	}

	if (client != NULL) {
		free_window(client);
	}


	update_client_list();
	update_group_list();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
addq $0x8, %rdi
callq 0x49ea
movq %rax, %rbx
cmpb $0x1, 0x84a8(%rip)      # 0xc7c4
jne 0x433c
movq 0x84bb(%rip), %rax      # 0xc7e0
testq %rax, %rax
je 0x433c
cmpq %rbx, %rax
jne 0x433c
andq $0x0, 0x84a9(%rip)      # 0xc7e0
callq 0x590a
testq %rbx, %rbx
je 0x436f
movq 0x30(%rbx), %r14
movq 0x38(%rbx), %r15
movq %rbx, %rdi
callq 0x32c0
leaq 0x8070(%rip), %rdi      # 0xc3c8
movq %r14, %rsi
callq 0x7f9c
leaq 0x8069(%rip), %rdi      # 0xc3d0
movq %r15, %rsi
callq 0x7f9c
callq 0x5738
popq %rbx
popq %r14
popq %r15
jmp 0x5804
// File: /workspace/github_c_makefile_star2_O2/tudurom[P]windowchef/wm.c
// Function: event_enter_notify
static void
event_enter_notify(xcb_generic_event_t *ev)
{
	xcb_enter_notify_event_t *e = (xcb_enter_notify_event_t *)ev;
	struct client *client;

	if (conf.sloppy_focus == false)
		return;

	if (focused_win != NULL && e->event == focused_win->window)
		return;

	client = find_client(&e->event);

	if (client != NULL)
		set_focused_no_raise(client);
}

// Assembly:
cmpb $0x0, 0x843b(%rip)      # 0xc7c0
je 0x43b6
movq 0x8452(%rip), %rax      # 0xc7e0
testq %rax, %rax
je 0x439a
movl 0xc(%rdi), %ecx
cmpl (%rax), %ecx
je 0x43b6
pushq %rax
addq $0xc, %rdi
callq 0x49ea
testq %rax, %rax
leaq 0x8(%rsp), %rsp
je 0x43b6
movq %rax, %rdi
jmp 0x4e56
retq