LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress1X_usingDTable
size_t HUF_decompress1X_usingDTable(void* dst, size_t maxDstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    const HUF_DTable* DTable)
{
    DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
    (void)dtd;
    assert(dtd.tableType == 0);
    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
    (void)dtd;
    assert(dtd.tableType == 1);
    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#else
    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x17c90
movl %eax, -0x2c(%rbp)
movzbl -0x2b(%rbp), %eax
cmpl $0x0, %eax
je 0x18e53
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %r9d, %r9d
callq 0x18970
movq %rax, -0x38(%rbp)
jmp 0x18e73
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %r9d, %r9d
callq 0x17d60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress4X_usingDTable
size_t HUF_decompress4X_usingDTable(void* dst, size_t maxDstSize,
                                    const void* cSrc, size_t cSrcSize,
                                    const HUF_DTable* DTable)
{
    DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
    (void)dtd;
    assert(dtd.tableType == 0);
    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
    (void)dtd;
    assert(dtd.tableType == 1);
    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#else
    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0) :
                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, /* bmi2 */ 0);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x17c90
movl %eax, -0x2c(%rbp)
movzbl -0x2b(%rbp), %eax
cmpl $0x0, %eax
je 0x18ed3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %r9d, %r9d
callq 0x18bc0
movq %rax, -0x38(%rbp)
jmp 0x18ef3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %r9d, %r9d
callq 0x17fb0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x8(%rbp), %rax
jb 0x18f20
movl $0xf, %eax
movl %eax, -0x24(%rbp)
jmp 0x18f33
movq -0x10(%rbp), %rax
shlq $0x4, %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x8(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
shrq $0x8, %rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xe260(%rip), %rax      # 0x271b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
leaq 0xe24b(%rip), %rcx      # 0x271b0
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movl 0x4(%rcx), %ecx
imull -0x18(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
leaq 0xe22c(%rip), %rax      # 0x271b0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
leaq 0xe216(%rip), %rcx      # 0x271b0
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movl 0xc(%rcx), %ecx
imull -0x18(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
shrl $0x3, %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x18ffc
movq $-0x2, -0x8(%rbp)
jmp 0x19096
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x19013
movq $-0x4, -0x8(%rbp)
jmp 0x19096
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x19038
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1120
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19096
cmpq $0x1, -0x28(%rbp)
jne 0x19060
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rdx
movzbl %al, %esi
callq 0x10c0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19096
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x18f00
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
leaq 0x12d54(%rip), %rax     # 0x2bdd0
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x190d0
movq $-0x2, -0x8(%rbp)
jmp 0x19191
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x190e7
movq $-0x4, -0x8(%rbp)
jmp 0x19191
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x1910f
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1120
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19191
cmpq $0x1, -0x30(%rbp)
jne 0x19137
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x10c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19191
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x18f00
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x1916c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x18d50
movq %rax, -0x40(%rbp)
jmp 0x19189
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x18140
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x19228
movq $-0x2, -0x8(%rbp)
jmp 0x192ab
cmpq $0x0, -0x30(%rbp)
jne 0x19239
movq $-0x4, -0x8(%rbp)
jmp 0x192ab
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x18f00
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x1927a
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x18c30
movq %rax, -0x48(%rbp)
jmp 0x192a3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x18020
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x192f8
movq $-0x2, -0x8(%rbp)
jmp 0x193d1
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x1930f
movq $-0x4, -0x8(%rbp)
jmp 0x193d1
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x19337
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1120
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x193d1
cmpq $0x1, -0x30(%rbp)
jne 0x1935f
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movq -0x20(%rbp), %rdx
movzbl %al, %esi
callq 0x10c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x193d1
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x18f00
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x193a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x189e0
movq %rax, -0x48(%rbp)
jmp 0x193c9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x17dd0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress1X_usingDTable_bmi2
size_t HUF_decompress1X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
{
    DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
    (void)dtd;
    assert(dtd.tableType == 0);
    return HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
    (void)dtd;
    assert(dtd.tableType == 1);
    return HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#else
    return dtd.tableType ? HUF_decompress1X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
                           HUF_decompress1X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x17c90
movl %eax, -0x30(%rbp)
movzbl -0x2f(%rbp), %eax
cmpl $0x0, %eax
je 0x19488
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x18970
movq %rax, -0x38(%rbp)
jmp 0x194a9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x17d60
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x10(%rbp), %r8
callq 0x17940
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x17c70
cmpl $0x0, %eax
je 0x19524
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19574
movq -0x48(%rbp), %rax
cmpq -0x30(%rbp), %rax
jb 0x19538
movq $-0x3, -0x8(%rbp)
jmp 0x19574
movq -0x48(%rbp), %rax
addq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %r8
movl 0x18(%rbp), %r9d
callq 0x17d60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress4X_usingDTable_bmi2
size_t HUF_decompress4X_usingDTable_bmi2(void* dst, size_t maxDstSize, const void* cSrc, size_t cSrcSize, const HUF_DTable* DTable, int bmi2)
{
    DTableDesc const dtd = HUF_getDTableDesc(DTable);
#if defined(HUF_FORCE_DECOMPRESS_X1)
    (void)dtd;
    assert(dtd.tableType == 0);
    return HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#elif defined(HUF_FORCE_DECOMPRESS_X2)
    (void)dtd;
    assert(dtd.tableType == 1);
    return HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#else
    return dtd.tableType ? HUF_decompress4X2_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2) :
                           HUF_decompress4X1_usingDTable_internal(dst, maxDstSize, cSrc, cSrcSize, DTable, bmi2);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x28(%rbp), %rdi
callq 0x17c90
movl %eax, -0x30(%rbp)
movzbl -0x2f(%rbp), %eax
cmpl $0x0, %eax
je 0x195d8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x18bc0
movq %rax, -0x38(%rbp)
jmp 0x195f9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x17fb0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1964b
movq $-0x2, -0x8(%rbp)
jmp 0x196df
cmpq $0x0, -0x30(%rbp)
jne 0x1965f
movq $-0x4, -0x8(%rbp)
jmp 0x196df
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x18f00
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x196a7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movl 0x18(%rbp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x18c90
movq %rax, -0x48(%rbp)
jmp 0x196d7
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq 0x10(%rbp), %r10
movl 0x18(%rbp), %eax
movq %r10, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x18080
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/../lib/mem.h
// Function: MEM_readLE16
MEM_STATIC U16 MEM_readLE16(const void* memPtr)
{
    if (MEM_isLittleEndian())
        return MEM_read16(memPtr);
    else {
        const BYTE* p = (const BYTE*)memPtr;
        return (U16)(p[0] + (p[1]<<8));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x1a560
cmpl $0x0, %eax
je 0x1eab5
movq -0x10(%rbp), %rdi
callq 0x1eae0
movw %ax, -0x2(%rbp)
jmp 0x1ead5
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
movq -0x18(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x11f3
leaq -0x28(%rbp), %rdi
callq 0x1060
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1210
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x11e3
movq 0x2e37(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0xe31(%rip), %rsi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x11fa
jmp 0x11e5
movq -0x20(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x118c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/test/../hts_time_funcs.h
// Function: hts_time_gm
static inline time_t hts_time_gm(struct tm *target)
{
    int month_start[2][12] = {
        { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
        { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
    };
    int years_from_epoch, leaps, days;
    int64_t secs;

    if (hts_time_normalise_tm(target) != 0)
        goto overflow;

    if (target->tm_year < 70)
        goto overflow;

    years_from_epoch = target->tm_year - 70;
    leaps = (hts_leaps_to_year_start(target->tm_year + 1900)
        - hts_leaps_to_year_start(1970));
    days = ((365 * (years_from_epoch - leaps) + 366 * leaps)
        + month_start[hts_year_is_leap(target->tm_year + 1900)][target->tm_mon]
        + target->tm_mday - 1);
    secs = ((int64_t) days * 86400LL
        + target->tm_hour * 3600
        + target->tm_min * 60
        + target->tm_sec);
    if (sizeof(time_t) < 8 && secs > INT_MAX)
        goto overflow;

    return (time_t) secs;

 overflow:
    errno = EOVERFLOW;
    return (time_t) -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x70(%rbp), %rdi
leaq 0xe56(%rip), %rsi       # 0x2080
movl $0x60, %edx
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x1840
cmpl $0x0, %eax
je 0x1247
jmp 0x133d
movq -0x10(%rbp), %rax
cmpl $0x46, 0x14(%rax)
jge 0x1256
jmp 0x133d
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x46, %eax
movl %eax, -0x74(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x76c, %eax            # imm = 0x76C
movslq %eax, %rdi
callq 0x1ad0
movq %rax, -0x98(%rbp)
movl $0x7b2, %edi            # imm = 0x7B2
callq 0x1ad0
movq %rax, %rcx
movq -0x98(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x78(%rbp)
movl -0x74(%rbp), %eax
subl -0x78(%rbp), %eax
imull $0x16d, %eax, %eax      # imm = 0x16D
imull $0x16e, -0x78(%rbp), %ecx # imm = 0x16E
addl %ecx, %eax
movl %eax, -0x8c(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x76c, %eax            # imm = 0x76C
movslq %eax, %rdi
callq 0x1b30
movl %eax, %ecx
movl -0x8c(%rbp), %eax
movslq %ecx, %rdx
leaq -0x70(%rbp), %rcx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq -0x10(%rbp), %rdx
movslq 0x10(%rdx), %rdx
addl (%rcx,%rdx,4), %eax
movq -0x10(%rbp), %rcx
addl 0xc(%rcx), %eax
subl $0x1, %eax
movl %eax, -0x7c(%rbp)
movslq -0x7c(%rbp), %rax
imulq $0x15180, %rax, %rax    # imm = 0x15180
movq -0x10(%rbp), %rcx
imull $0xe10, 0x8(%rcx), %ecx # imm = 0xE10
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
imull $0x3c, 0x4(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1350
callq 0x1030
movl $0x4b, (%rax)
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
pushq %rbx
subq $0x88, %rsp
movq 0x10(%rbp), %rax
movl %edi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x50(%rbp)
movl -0x10(%rbp), %eax
subl $0x76c, %eax            # imm = 0x76C
movl %eax, -0x4c(%rbp)
movl $0x0, -0x48(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1210
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq 0x10(%rbp), %rax
je 0x143c
movq 0x2c05(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %r8d
movl -0x1c(%rbp), %r9d
movl -0x20(%rbp), %ebx
movl -0x24(%rbp), %r11d
movq -0x68(%rbp), %r10
movq 0x10(%rbp), %rax
leaq 0xc16(%rip), %rsi       # 0x2030
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movb $0x0, %al
callq 0x1040
movl $0x1, -0xc(%rbp)
jmp 0x1443
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x88, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x1bb7
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jl 0x1c3c
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jl 0x1bcf
movq -0x18(%rbp), %rax
movl (%rax), %eax
cltd
idivl -0x1c(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x1bea
movq -0x18(%rbp), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subl (%rcx), %eax
cltd
idivl -0x1c(%rbp)
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq (%rax), %rax
movslq -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
cmpq $-0x80000000, -0x28(%rbp) # imm = 0x80000000
jl 0x1c16
cmpq $0x7fffffff, -0x28(%rbp) # imm = 0x7FFFFFFF
jle 0x1c1f
movl $0x1, -0x4(%rbp)
jmp 0x1c43
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %edx
imull -0x1c(%rbp), %edx
movq -0x18(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2160
movq %rax, -0x18(%rbp)
callq 0x2270
cltq
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
cmpl $0x0, %eax
jne 0x3004
jmp 0x3023
leaq 0x127f(%rip), %rdi      # 0x428a
leaq 0x1287(%rip), %rsi      # 0x4299
movl $0xe, %edx
leaq 0x1288(%rip), %rcx      # 0x42a6
callq 0x2110
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2140
cmpl $0x0, %eax
jne 0x3047
jmp 0x3066
leaq 0x123c(%rip), %rdi      # 0x428a
leaq 0x1244(%rip), %rsi      # 0x4299
movl $0x11, %edx
leaq 0x1245(%rip), %rcx      # 0x42a6
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x2fe8
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x2720, %rsp           # imm = 0x2720
movl $0x0, -0x4(%rbp)
leaq -0x2720(%rbp), %rdx
leaq 0x2ec0(%rip), %rdi      # 0x4060
movl $0x1388, %esi           # imm = 0x1388
callq 0x1210
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jl 0x11ec
movl -0x8(%rbp), %edx
subl $0x1, %edx
leaq 0x2ea1(%rip), %rdi      # 0x4060
xorl %esi, %esi
callq 0x1300
leaq 0xe37(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movl -0x8(%rbp), %esi
leaq 0x2e82(%rip), %rdi      # 0x4060
callq 0x13d0
movl $0x0, -0x4(%rbp)
jmp 0x1201
leaq 0xe18(%rip), %rdi       # 0x200b
movb $0x0, %al
callq 0x1050
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x2720, %rsp           # imm = 0x2720
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1040
movq %rax, %rcx
movq -0x428(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
leaq -0x420(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x1420
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x12e6
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x128d
movq -0x20(%rbp), %rax
addq $0x2710, %rax           # imm = 0x2710
movq -0x30(%rbp), %rcx
subq %rcx, %rax
movslq -0x24(%rbp), %rcx
cmpq %rcx, %rax
jge 0x1296
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12ec
movl -0x24(%rbp), %eax
subl $0x1, %eax
cltq
movb $0x0, -0x420(%rbp,%rax)
movq -0x30(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0x1030
movq -0x30(%rbp), %rdx
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x28(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x1252
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x131f
jmp 0x13c9
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
callq 0x14e0
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x1396
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1060
cmpl $0x0, %eax
jge 0x1389
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movl -0x14(%rbp), %edx
callq 0x14e0
jmp 0x138b
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x134a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x14e0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
subl $0x1, %edx
callq 0x1300
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x1300
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rdx
subq $0x1, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
jae 0x1476
movq 0x2b8b(%rip), %rax      # 0x3fe0
movq (%rax), %rdi
callq 0x1070
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x21(%rbp)
je 0x1476
cmpl $0xa, -0x14(%rbp)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x147f
jmp 0x149d
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1438
cmpl $0xa, -0x14(%rbp)
jne 0x14bf
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
leaq -0x15(%rbp), %rdi
movl $0x1, %edx
movq %rdx, %rsi
callq 0x1030
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x11d1
leaq 0xe43(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1050
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d8
movzbl -0x15(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x228(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x2180
movq -0x258(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x20e0
jmp 0x23c1
leaq -0x228(%rbp), %rdi
callq 0x21f0
movb %al, -0x259(%rbp)
jmp 0x23d5
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x241a
jmp 0x23e1
movl $0x0, -0x4(%rbp)
movl $0x1, -0x238(%rbp)
jmp 0x2551
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x2070
jmp 0x2569
xorl %eax, %eax
movl %eax, %esi
leaq -0x228(%rbp), %rdi
movl $0x2, %edx
callq 0x21b0
jmp 0x2431
leaq -0x228(%rbp), %rdi
callq 0x2210
movq %rdx, -0x270(%rbp)
movq %rax, -0x268(%rbp)
jmp 0x244d
movq -0x270(%rbp), %rax
movq -0x268(%rbp), %rcx
movq %rcx, -0x250(%rbp)
movq %rax, -0x248(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2f20
movq %rax, -0x278(%rbp)
jmp 0x247e
movq -0x278(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
xorl %esi, %esi
callq 0x2200
jmp 0x24a8
xorl %edx, %edx
movl %edx, %esi
leaq -0x228(%rbp), %rdi
callq 0x21b0
jmp 0x24ba
movq -0x240(%rbp), %rdi
incq %rdi
testq %rdi, %rdi
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x2030
movq %rax, -0x280(%rbp)
jmp 0x24e0
movq -0x280(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x240(%rbp), %rdx
leaq -0x228(%rbp), %rdi
callq 0x21a0
jmp 0x250a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x240(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x20b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
leaq -0x228(%rbp), %rdi
callq 0x2060
jmp 0x2540
movl $0x1, -0x4(%rbp)
movl $0x1, -0x238(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x2070
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x2220
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x228(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x2180
movq -0x258(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x20e0
jmp 0x25c1
leaq -0x228(%rbp), %rdi
callq 0x21f0
movb %al, -0x259(%rbp)
jmp 0x25d5
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x261a
jmp 0x25e1
movl $0x0, -0x4(%rbp)
movl $0x1, -0x238(%rbp)
jmp 0x2749
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x2070
jmp 0x2761
xorl %eax, %eax
movl %eax, %esi
leaq -0x228(%rbp), %rdi
movl $0x2, %edx
callq 0x21b0
jmp 0x2631
leaq -0x228(%rbp), %rdi
callq 0x2210
movq %rdx, -0x270(%rbp)
movq %rax, -0x268(%rbp)
jmp 0x264d
movq -0x270(%rbp), %rax
movq -0x268(%rbp), %rcx
movq %rcx, -0x250(%rbp)
movq %rax, -0x248(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x2f20
movq %rax, -0x278(%rbp)
jmp 0x267e
movq -0x278(%rbp), %rax
movq %rax, -0x240(%rbp)
movq -0x228(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x228(%rbp,%rax), %rdi
xorl %esi, %esi
callq 0x2200
jmp 0x26a8
xorl %edx, %edx
movl %edx, %esi
leaq -0x228(%rbp), %rdi
callq 0x21b0
jmp 0x26ba
movq -0x240(%rbp), %rdi
incq %rdi
testq %rdi, %rdi
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x2030
movq %rax, -0x280(%rbp)
jmp 0x26e0
movq -0x280(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x240(%rbp), %rdx
leaq -0x228(%rbp), %rdi
callq 0x21a0
jmp 0x270a
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x240(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x240(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
leaq -0x228(%rbp), %rdi
callq 0x2060
jmp 0x2738
movl $0x1, -0x4(%rbp)
movl $0x1, -0x238(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x2070
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x230(%rbp), %rdi
callq 0x2220
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
leaq -0x238(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x2180
movq -0x250(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x20e0
jmp 0x27b9
leaq -0x238(%rbp), %rdi
callq 0x21f0
movb %al, -0x251(%rbp)
jmp 0x27cd
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x2812
jmp 0x27d9
movl $0x0, -0x4(%rbp)
movl $0x1, -0x248(%rbp)
jmp 0x298b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x2070
jmp 0x29a3
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
leaq -0x238(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20c0
movq %rax, -0x260(%rbp)
jmp 0x2836
movq -0x260(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2190
movb %al, -0x261(%rbp)
jmp 0x2854
movb -0x261(%rbp), %al
testb $0x1, %al
jne 0x2860
jmp 0x2870
movq -0x20(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x281d
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq 0x475a(%rip), %rdi      # 0x6fd8
callq 0x2230
movq %rax, -0x270(%rbp)
jmp 0x288c
movq -0x270(%rbp), %rdi
movq 0x472e(%rip), %rsi      # 0x6fc8
callq 0x2170
jmp 0x28a1
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x238(%rbp,%rax), %rdi
xorl %esi, %esi
callq 0x2200
jmp 0x28bd
xorl %edx, %edx
movl %edx, %esi
leaq -0x238(%rbp), %rdi
callq 0x21b0
jmp 0x28cf
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x2030
movq %rax, -0x278(%rbp)
jmp 0x28fa
movq -0x278(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq -0x238(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x20c0
movq %rax, -0x280(%rbp)
jmp 0x2921
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2190
movb %al, -0x281(%rbp)
jmp 0x293f
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x294b
jmp 0x296c
movq -0x28(%rbp), %rax
movl %eax, %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movl %edx, (%rax,%rcx,4)
jmp 0x2908
leaq -0x238(%rbp), %rdi
callq 0x2060
jmp 0x297a
movl $0x1, -0x4(%rbp)
movl $0x1, -0x248(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x2070
movl -0x4(%rbp), %eax
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x240(%rbp), %rdi
callq 0x2220
nop