LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH64_update
XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void* input, size_t len)
{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_update_endian(state_in, input, len, XXH_littleEndian);
    else
        return XXH64_update_endian(state_in, input, len, XXH_bigEndian);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
addq %rdx, (%rdi)
movq %rsi, %r15
movl 0x50(%rdi), %eax
leaq (%rax,%rdx), %rcx
cmpq $0x1f, %rcx
ja 0x5b2c
leaq (%r14,%rax), %rdi
addq $0x30, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1130
addl 0x50(%r14), %ebx
jmp 0x5c7f
addq %r15, %rbx
movabsq $-0x3d4d51c2d82b14b1, %r12 # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %r13 # imm = 0x9E3779B185EBCA87
testq %rax, %rax
je 0x5bd7
leaq (%r14,%rax), %rdi
addq $0x30, %rdi
movl $0x20, %ebp
movl $0x20, %edx
subl %eax, %edx
movq %r15, %rsi
callq 0x1130
movq 0x30(%r14), %rax
imulq %r12, %rax
addq 0x10(%r14), %rax
rolq $0x1f, %rax
imulq %r13, %rax
movq %rax, 0x10(%r14)
movq 0x38(%r14), %rax
imulq %r12, %rax
addq 0x18(%r14), %rax
rolq $0x1f, %rax
imulq %r13, %rax
movq %rax, 0x18(%r14)
movq 0x40(%r14), %rax
imulq %r12, %rax
addq 0x20(%r14), %rax
rolq $0x1f, %rax
imulq %r13, %rax
movq %rax, 0x20(%r14)
movq 0x48(%r14), %rax
imulq %r12, %rax
addq 0x28(%r14), %rax
rolq $0x1f, %rax
imulq %r13, %rax
movq %rax, 0x28(%r14)
subl 0x50(%r14), %ebp
addq %rbp, %r15
movl $0x0, 0x50(%r14)
leaq 0x20(%r15), %rax
cmpq %rbx, %rax
ja 0x5c68
leaq -0x20(%rbx), %rax
movq 0x10(%r14), %rcx
movq 0x18(%r14), %rdx
movq 0x20(%r14), %rdi
movq 0x28(%r14), %rsi
movq (%r15), %r8
imulq %r12, %r8
addq %rcx, %r8
rolq $0x1f, %r8
movq %r8, %rcx
imulq %r13, %rcx
movq 0x8(%r15), %r8
imulq %r12, %r8
addq %rdx, %r8
rolq $0x1f, %r8
movq %r8, %rdx
movq 0x10(%r15), %r8
imulq %r12, %r8
addq %rdi, %r8
rolq $0x1f, %r8
imulq %r13, %rdx
movq %r8, %rdi
imulq %r13, %rdi
movq 0x18(%r15), %r8
imulq %r12, %r8
addq %rsi, %r8
rolq $0x1f, %r8
movq %r8, %rsi
imulq %r13, %rsi
addq $0x20, %r15
cmpq %rax, %r15
jbe 0x5bf8
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %rdi, 0x20(%r14)
movq %rsi, 0x28(%r14)
cmpq %rbx, %r15
jae 0x5c83
leaq 0x30(%r14), %rdi
subq %r15, %rbx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1130
movl %ebx, 0x50(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH64_digest
XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_digest_endian(state_in, XXH_littleEndian);
    else
        return XXH64_digest_endian(state_in, XXH_bigEndian);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
movabsq $-0x7a1435883d4d519d, %rsi # imm = 0x85EBCA77C2B2AE63
movabsq $0x27d4eb2f165667c5, %rdx # imm = 0x27D4EB2F165667C5
movl 0x50(%rdi), %r10d
movq (%rdi), %r11
cmpq $0x20, %r11
jb 0x5d64
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %r9
movq 0x28(%rdi), %r8
movq %r14, %r15
rolq %r15
movq %rbx, %r12
rolq $0x7, %r12
addq %r15, %r12
movq %r9, %r15
rolq $0xc, %r15
movq %r8, %r13
rolq $0x12, %r13
addq %r15, %r13
addq %r12, %r13
imulq %rax, %r14
rolq $0x1f, %r14
imulq %rcx, %r14
xorq %r13, %r14
imulq %rcx, %r14
addq %rsi, %r14
imulq %rax, %rbx
rolq $0x1f, %rbx
imulq %rcx, %rbx
xorq %r14, %rbx
imulq %rcx, %rbx
imulq %rax, %r9
rolq $0x1f, %r9
addq %rsi, %rbx
imulq %rcx, %r9
xorq %rbx, %r9
imulq %rcx, %r9
addq %rsi, %r9
imulq %rax, %r8
rolq $0x1f, %r8
imulq %rcx, %r8
xorq %r9, %r8
imulq %rcx, %r8
addq %rsi, %r8
jmp 0x5d6b
movq 0x8(%rdi), %r8
addq %rdx, %r8
leaq (%rdi,%r10), %r9
addq $0x30, %r9
addq $0x30, %rdi
addq %r11, %r8
cmpl $0x8, %r10d
jae 0x5d88
movq %r8, %r10
movq %rdi, %r11
jmp 0x5db8
movq (%rdi), %r10
imulq %rax, %r10
rolq $0x1f, %r10
imulq %rcx, %r10
xorq %r8, %r10
rolq $0x1b, %r10
imulq %rcx, %r10
addq %rsi, %r10
leaq 0x8(%rdi), %r11
addq $0x10, %rdi
movq %r10, %r8
cmpq %r9, %rdi
movq %r11, %rdi
jbe 0x5d88
movabsq $0x165667b19e3779f9, %rsi # imm = 0x165667B19E3779F9
leaq 0x4(%r11), %rdi
cmpq %r9, %rdi
jbe 0x5dd0
movq %r11, %rdi
jmp 0x5de8
movl (%r11), %r8d
imulq %rcx, %r8
xorq %r10, %r8
rolq $0x17, %r8
imulq %rax, %r8
addq %rsi, %r8
movq %r8, %r10
cmpq %r9, %rdi
jae 0x5e0d
movzbl (%rdi), %r8d
imulq %rdx, %r8
xorq %r10, %r8
rolq $0xb, %r8
imulq %rcx, %r8
incq %rdi
movq %r8, %r10
cmpq %r9, %rdi
jb 0x5ded
jmp 0x5e10
movq %r10, %r8
movq %r8, %rcx
shrq $0x21, %rcx
xorq %r8, %rcx
imulq %rax, %rcx
movq %rcx, %rdx
shrq $0x1d, %rdx
xorq %rcx, %rdx
imulq %rsi, %rdx
movq %rdx, %rax
shrq $0x20, %rax
xorq %rdx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/zlibh.c
// Function: pqdownheap
static void pqdownheap(ct_data *tree, int *huf_heap, unsigned char *depth, int k)
{
    int v = huf_heap[k];
    int j = k << 1;  /* left son of k */
    while (j <= huf_heap[0]) {
        /* Set j to the smallest of the two sons: */
        if (j < huf_heap[0] &&
            smaller(tree, huf_heap[j+1], huf_heap[j], depth)) {
                j++;
        }
        /* Exit if v is smaller than both sons */
        if (smaller(tree, v, huf_heap[j], depth)) break;

        /* Exchange v with the smallest son */
        huf_heap[k] = huf_heap[j];  k = j;

        /* And continue down the tree, setting j to the left son of k */
        j <<= 1;
    }
    huf_heap[k] = v;
}

// Assembly:
movl %ecx, %eax
movl (%rsi,%rax,4), %eax
leal (%rcx,%rcx), %r9d
movl (%rsi), %r11d
cmpl %r11d, %r9d
jle 0x7677
movl %ecx, %r10d
jmp 0x7704
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq %eax, %r8
cmpl %r11d, %r9d
jge 0x76ad
movl %r9d, %ebx
orl $0x1, %ebx
movslq %ebx, %r14
movslq (%rsi,%r14,4), %r10
movslq %r9d, %r11
movslq (%rsi,%r11,4), %r15
movzwl (%rdi,%r15,4), %ebp
cmpw %bp, (%rdi,%r10,4)
jae 0x76ea
movq %r14, %r11
movl %ebx, %r10d
jmp 0x76b3
movslq %r9d, %r11
movl %r9d, %r10d
movl (%rsi,%r11,4), %r9d
movslq %r9d, %r11
movzwl (%rdi,%r11,4), %ebx
cmpw %bx, (%rdi,%r8,4)
jb 0x76fb
jne 0x76d2
movb (%rdx,%r8), %bl
cmpb (%rdx,%r11), %bl
jbe 0x76fb
movslq %ecx, %rcx
movl %r9d, (%rsi,%rcx,4)
leal (%r10,%r10), %r9d
movl (%rsi), %r11d
movl %r10d, %ecx
cmpl %r11d, %r9d
jle 0x7680
jmp 0x76fe
jne 0x76b0
movb (%rdx,%r10), %bpl
movl %r9d, %r10d
cmpb (%rdx,%r15), %bpl
jbe 0x76a5
jmp 0x76b3
movl %ecx, %r10d
popq %rbx
popq %r14
popq %r15
popq %rbp
movslq %r10d, %rcx
movl %eax, (%rsi,%rcx,4)
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/hist.c
// Function: HIST_count_simple
unsigned HIST_count_simple(unsigned* count, unsigned* maxSymbolValuePtr,
                           const void* src, size_t srcSize)
{
    const BYTE* ip = (const BYTE*)src;
    const BYTE* const end = ip + srcSize;
    unsigned maxSymbolValue = *maxSymbolValuePtr;
    unsigned largestCount=0;

    memset(count, 0, (maxSymbolValue+1) * sizeof(*count));
    if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; }

    while (ip<end) {
        assert(*ip <= maxSymbolValue);
        count[*ip++]++;
    }

    while (!count[maxSymbolValue]) maxSymbolValue--;
    *maxSymbolValuePtr = maxSymbolValue;

    {   U32 s;
        for (s=0; s<=maxSymbolValue; s++)
            if (count[s] > largestCount) largestCount = count[s];
    }

    return largestCount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, %rbx
leaq (%rdx,%rcx), %r14
movq %rsi, (%rsp)
movl (%rsi), %r13d
leal 0x1(%r13), %edx
shlq $0x2, %rdx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x10c0
testq %r12, %r12
je 0x7c6a
movq (%rsp), %rcx
jle 0x7c3c
movzbl (%r15), %eax
incq %r15
incl (%rbx,%rax,4)
cmpq %r14, %r15
jb 0x7c2d
movl %r13d, %eax
decl %r13d
cmpl $0x0, (%rbx,%rax,4)
je 0x7c3c
incl %r13d
movl %r13d, (%rcx)
xorl %ebp, %ebp
movq $-0x1, %rcx
movl 0x4(%rbx,%rcx,4), %edx
cmpl %ebp, %edx
cmoval %edx, %ebp
incq %rcx
cmpq %rax, %rcx
jb 0x7c57
jmp 0x7c74
movq (%rsp), %rax
movl $0x0, (%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/hist.c
// Function: HIST_countFast_wksp
size_t HIST_countFast_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
                          const void* source, size_t sourceSize,
                          void* workSpace, size_t workSpaceSize)
{
    if (sourceSize < 1500) /* heuristic threshold */
        return HIST_count_simple(count, maxSymbolValuePtr, source, sourceSize);
    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
    return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, trustInput, (U32*)workSpace);
}

// Assembly:
cmpq $0x5db, %rcx            # imm = 0x5DB
ja 0x7c9b
pushq %rax
callq 0x7bf2
movl %eax, %eax
addq $0x8, %rsp
retq
movq %r8, %r10
movq $-0x1, %rax
testb $0x3, %r10b
jne 0x7cbb
movq $-0x8, %rax
cmpq $0x1000, %r9            # imm = 0x1000
jae 0x7cbc
retq
xorl %r8d, %r8d
movq %r10, %r9
jmp 0x7cc4
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/hist.c
// Function: HIST_count_wksp
size_t HIST_count_wksp(unsigned* count, unsigned* maxSymbolValuePtr,
                       const void* source, size_t sourceSize,
                       void* workSpace, size_t workSpaceSize)
{
    if ((size_t)workSpace & 3) return ERROR(GENERIC);  /* must be aligned on 4-bytes boundaries */
    if (workSpaceSize < HIST_WKSP_SIZE) return ERROR(workSpace_tooSmall);
    if (*maxSymbolValuePtr < 255)
        return HIST_count_parallel_wksp(count, maxSymbolValuePtr, source, sourceSize, checkMaxSymbolValue, (U32*)workSpace);
    *maxSymbolValuePtr = 255;
    return HIST_countFast_wksp(count, maxSymbolValuePtr, source, sourceSize, workSpace, workSpaceSize);
}

// Assembly:
movq %r8, %r10
movq $-0x1, %rax
testb $0x3, %r10b
jne 0x7fa4
movq $-0x8, %rax
cmpq $0x1000, %r9            # imm = 0x1000
jae 0x7fa5
retq
cmpl $0xfe, (%rsi)
ja 0x7fbb
movl $0x1, %r8d
movq %r10, %r9
jmp 0x7cc4
movl $0xff, (%rsi)
movq %r10, %r8
jmp 0x7c85
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse_decompress.c
// Function: FSE_decompress_wksp
size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog)
{
    const BYTE* const istart = (const BYTE*)cSrc;
    const BYTE* ip = istart;
    short counting[FSE_MAX_SYMBOL_VALUE+1];
    unsigned tableLog;
    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;

    /* normal FSE decoding mode */
    size_t const NCountLength = FSE_readNCount (counting, &maxSymbolValue, &tableLog, istart, cSrcSize);
    if (FSE_isError(NCountLength)) return NCountLength;
    if (tableLog > maxLog) return ERROR(tableLog_tooLarge);
    assert(NCountLength <= cSrcSize);
    ip += NCountLength;
    cSrcSize -= NCountLength;

    CHECK_F( FSE_buildDTable (workSpace, counting, maxSymbolValue, tableLog) );

    return FSE_decompress_usingDTable (dst, dstCapacity, ip, cSrcSize, workSpace);   /* always return, even if it is an error code */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movl %r9d, %r12d
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, 0x8(%rsp)
movq %rdi, %r13
movq %rsp, %rsi
movl $0xff, (%rsi)
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x7755
movq %rax, %rbp
cmpq $-0x9, %rax
ja 0x8ac3
movl 0x4(%rsp), %ecx
movq $-0x5, %rax
cmpl %r12d, %ecx
ja 0x8ac6
movl (%rsp), %edx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x8007
cmpq $-0x9, %rax
ja 0x8ac6
subq %rbp, %r14
addq %rbp, %r15
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x818a
jmp 0x8ac6
movq %rbp, %rax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse_compress.c
// Function: FSE_writeNCount
size_t FSE_writeNCount (void* buffer, size_t bufferSize,
                  const short* normalizedCounter, unsigned maxSymbolValue, unsigned tableLog)
{
    if (tableLog > FSE_MAX_TABLELOG) return ERROR(tableLog_tooLarge);   /* Unsupported */
    if (tableLog < FSE_MIN_TABLELOG) return ERROR(GENERIC);   /* Unsupported */

    if (bufferSize < FSE_NCountWriteBound(maxSymbolValue, tableLog))
        return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 0);

    return FSE_writeNCount_generic(buffer, bufferSize, normalizedCounter, maxSymbolValue, tableLog, 1 /* write in buffer is safe */);
}

// Assembly:
movq $-0x5, %rax
cmpl $0xc, %r8d
ja 0x8ced
movq $-0x1, %rax
cmpl $0x5, %r8d
jae 0x8cee
retq
leal 0x1(%rcx), %eax
imull %r8d, %eax
shrl $0x3, %eax
addl $0x3, %eax
testl %ecx, %ecx
movl $0x200, %r10d           # imm = 0x200
cmovnel %eax, %r10d
xorl %r9d, %r9d
cmpq %rsi, %r10
setbe %r9b
jmp 0x8d13
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/fseU16.c
// Function: FSE_countU16
size_t FSE_countU16(unsigned* count, unsigned* maxSymbolValuePtr,
                    const U16* src, size_t srcSize)
{
    const U16* ip16 = (const U16*)src;
    const U16* const end = src + srcSize;
    unsigned maxSymbolValue = *maxSymbolValuePtr;

    memset(count, 0, (maxSymbolValue+1)*sizeof(*count));
    if (srcSize==0) { *maxSymbolValuePtr = 0; return 0; }

    while (ip16<end) {
        if (*ip16 > maxSymbolValue)
            return ERROR(maxSymbolValue_tooSmall);
        count[*ip16++]++;
    }

    while (!count[maxSymbolValue]) maxSymbolValue--;
    *maxSymbolValuePtr = maxSymbolValue;

    {   U32 s, max=0;
        for (s=0; s<=maxSymbolValue; s++)
            if (count[s] > max) max = count[s];
        return (size_t)max;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %r13d
leal 0x1(%r13), %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x10c0
testq %r12, %r12
je 0xa14d
jle 0xa11d
leaq (%r15,%r12,2), %rax
movzwl (%r15), %ecx
cmpl %ecx, %r13d
jb 0xa158
addq $0x2, %r15
incl (%rbx,%rcx,4)
cmpq %rax, %r15
jb 0xa108
movl %r13d, %eax
decl %r13d
cmpl $0x0, (%rbx,%rax,4)
je 0xa11d
incl %r13d
movl %r13d, (%r14)
xorl %ecx, %ecx
movq $-0x1, %rdx
movl 0x4(%rbx,%rdx,4), %esi
cmpl %ecx, %esi
cmoval %esi, %ecx
incq %rdx
cmpq %rax, %rdx
jb 0xa138
movl %ecx, %eax
jmp 0xa15f
movl $0x0, (%r14)
xorl %eax, %eax
jmp 0xa15f
movq $-0x7, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/fseU16.c
// Function: FSE_decodeSymbolU16
U16 FSE_decodeSymbolU16(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
{
    const FSE_decode_tU16 DInfo = ((const FSE_decode_tU16*)(DStatePtr->table))[DStatePtr->state];
    U16 symbol;
    size_t lowBits;
    const U32 nbBits = DInfo.nbBits;

    symbol = (U16)(DInfo.symbol);
    lowBits = BIT_readBits(bitD, nbBits);
    DStatePtr->state = DInfo.newState + lowBits;

    return symbol;
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movzwl (%rcx,%rax,4), %edx
movzwl 0x2(%rcx,%rax,4), %eax
movl %eax, %r8d
andl $0xf, %r8d
movq (%rsi), %r9
movl 0x8(%rsi), %r10d
addl %r8d, %r10d
movl %r10d, %ecx
negb %cl
shrq %cl, %r9
shrl $0x4, %eax
leaq 0xaaad(%rip), %rcx      # 0x15110
andl (%rcx,%r8,4), %r9d
addq %rdx, %r9
movl %r10d, 0x8(%rsi)
movq %r9, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/fseU16.c
// Function: FSE_decompressU16
size_t FSE_decompressU16(U16* dst, size_t maxDstSize,
                  const void* cSrc, size_t cSrcSize)
{
    const BYTE* const istart = (const BYTE*) cSrc;
    const BYTE* ip = istart;
    short NCount[FSE_MAX_SYMBOL_VALUE+1];
    DTable_max_t dt;
    unsigned maxSymbolValue = FSE_MAX_SYMBOL_VALUE;
    unsigned tableLog;

    /* Sanity check */
    if (cSrcSize<2) return ERROR(srcSize_wrong);   /* specific corner cases (uncompressed & rle) */

    /* normal FSE decoding mode */
    {   size_t const NSize = FSE_readNCount (NCount, &maxSymbolValue, &tableLog, istart, cSrcSize);
        if (FSE_isError(NSize)) return NSize;
        ip += NSize;
        cSrcSize -= NSize;
    }
    {   size_t const errorCode = FSE_buildDTableU16 (dt, NCount, maxSymbolValue, tableLog);
        if (FSE_isError(errorCode)) return errorCode;
    }
    return FSE_decompressU16_usingDTable (dst, maxDstSize, ip, cSrcSize, dt);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8260, %rsp           # imm = 0x8260
movl $0x11e, 0x8(%rsp)       # imm = 0x11E
movq $-0x3, %r13
cmpq $0x2, %rcx
jb 0xa96c
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
leaq 0xc(%rsp), %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x7755
movq %rax, %r13
cmpq $-0x9, %rax
ja 0xa96c
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
leaq 0x250(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9f5a
cmpq $-0x9, %rax
ja 0xa969
addq %r13, %r14
subq %r13, %rbx
leaq 0x250(%rsp), %r8
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xa672
movq %rax, %r13
movq %r13, %rax
addq $0x8260, %rsp           # imm = 0x8260
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_compress.c
// Function: HUF_estimateCompressedSize
size_t HUF_estimateCompressedSize(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue)
{
    size_t nbBits = 0;
    int s;
    for (s = 0; s <= (int)maxSymbolValue; ++s) {
        nbBits += CTable[s].nbBits * count[s];
    }
    return nbBits >> 3;
}

// Assembly:
testl %edx, %edx
js 0xbafd
incl %edx
xorl %ecx, %ecx
xorl %eax, %eax
movzbl 0x2(%rdi,%rcx,4), %r8d
imull (%rsi,%rcx,4), %r8d
addq %r8, %rax
incq %rcx
cmpq %rcx, %rdx
jne 0xbae2
shrq $0x3, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_compress.c
// Function: HUF_validateCTable
int HUF_validateCTable(const HUF_CElt* CTable, const unsigned* count, unsigned maxSymbolValue) {
  int bad = 0;
  int s;
  for (s = 0; s <= (int)maxSymbolValue; ++s) {
    bad |= (count[s] != 0) & (CTable[s].nbBits == 0);
  }
  return !bad;
}

// Assembly:
testl %edx, %edx
js 0xbb35
incl %edx
xorl %eax, %eax
xorl %ecx, %ecx
cmpl $0x0, (%rsi,%rax,4)
setne %r8b
cmpb $0x0, 0x2(%rdi,%rax,4)
sete %r9b
andb %r8b, %r9b
movzbl %r9b, %r8d
orl %r8d, %ecx
incq %rax
cmpq %rax, %rdx
jne 0xbb0a
xorl %eax, %eax
testl %ecx, %ecx
sete %al
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_compress.c
// Function: HUF_compressCTable_internal
static size_t HUF_compressCTable_internal(
                BYTE* const ostart, BYTE* op, BYTE* const oend,
                const void* src, size_t srcSize,
                HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int bmi2)
{
    size_t const cSize = (nbStreams==HUF_singleStream) ?
                         HUF_compress1X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, bmi2) :
                         HUF_compress4X_usingCTable_internal(op, (size_t)(oend - op), src, srcSize, CTable, bmi2);
    if (HUF_isError(cSize)) { return cSize; }
    if (cSize==0) { return 0; }   /* incompressible */
    op += cSize;
    /* check compressibility */
    assert(op >= ostart);
    if ((size_t)(op-ostart) >= srcSize-1) { return 0; }
    return (size_t)(op-ostart);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %r9d, %eax
movq %r8, %r14
movq %rsi, %rbx
movq %rdi, %r15
movl 0x28(%rsp), %r9d
movq 0x20(%rsp), %r8
subq %rsi, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r14, %rcx
testl %eax, %eax
je 0xc539
callq 0xbcfd
jmp 0xc53e
callq 0xbb51
cmpq $-0x9, %rax
ja 0xc55f
testq %rax, %rax
je 0xc55d
addq %rax, %rbx
subq %r15, %rbx
decq %r14
xorl %eax, %eax
cmpq %r14, %rbx
cmovbq %rbx, %rax
jmp 0xc55f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress1X1_DCtx_wksp
size_t HUF_decompress1X1_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_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 */ 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 0xc568
movq %rax, %rcx
cmpq $-0x9, %rax
ja 0xc994
movq $-0x3, %rcx
subq %rax, %rbx
jbe 0xc994
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 0xc6f4
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_decompress4X1_DCtx_wksp_bmi2
static size_t HUF_decompress4X1_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_decompress4X1_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 0xc568
movq %rax, %rcx
cmpq $-0x9, %rax
ja 0xd9d3
movq $-0x3, %rcx
subq %rax, %rbx
jbe 0xd9d3
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 0xca43
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xda6d
movq %rax, %rcx
cmpq $-0x9, %rax
ja 0xe4b3
movq $-0x3, %rcx
subq %rax, %rbx
jbe 0xe4b3
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 0xe0f1
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xda6d
movq %rax, %rcx
cmpq $-0x9, %rax
ja 0xfb56
movq $-0x3, %rcx
subq %rax, %rbx
jbe 0xfb56
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 0xe56a
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfc9e
movq %rcx, %r15
movq %rsi, %rbx
movq $-0x4, %rax
cmpq %rsi, %rcx
ja 0xfcbf
movq %rdx, %r14
movq %rdi, %r12
jne 0xfca7
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1130
jmp 0xfcbc
movq $-0x2, %rax
jmp 0xfcbf
cmpq $0x1, %r15
jne 0xfccb
movzbl (%r14), %esi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x10c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfc1e
movl %eax, %eax
leaq 0xa0f1(%rip), %r8       # 0x19dd0
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_O3/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:
testq %rdx, %rdx
je 0xfd39
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %r8, %r15
movq %rdx, %rbx
movq $-0x4, %rax
cmpq %rdx, %r8
ja 0xfd9d
movq %rcx, %r14
movq %rsi, %r12
jne 0xfd41
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1130
jmp 0xfd56
movq $-0x2, %rax
retq
cmpq $0x1, %r15
jne 0xfd5b
movzbl (%r14), %esi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x10c0
movq %rbx, %rax
jmp 0xfd9d
movq %rdi, %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfc1e
movq %rsp, %r9
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r15, %r8
testl %eax, %eax
je 0xfd8d
pushq $0x0
pushq $0x800                  # imm = 0x800
callq 0xfae8
jmp 0xfd99
pushq $0x0
pushq $0x800                  # imm = 0x800
callq 0xd965
addq $0x10, %rsp
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
testq %rdx, %rdx
je 0xfe24
movq %r8, %r14
testq %r8, %r8
je 0xfe2d
movq %r9, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq %rdx, %rdi
movq %r14, %rsi
callq 0xfc1e
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
testl %eax, %eax
je 0xfe3a
pushq $0x0
pushq 0x48(%rsp)
callq 0xfae8
jmp 0xfe45
movq $-0x2, %rax
jmp 0xfe34
movq $-0x4, %rax
addq $0x8, %rsp
jmp 0xfe49
pushq $0x0
pushq 0x48(%rsp)
callq 0xd965
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xfe91
movq %r8, %r12
movq %rdx, %rbx
movq $-0x4, %rax
cmpq %rdx, %r8
ja 0xfeb2
movq %rcx, %r15
movq %rsi, %r13
jne 0xfe9a
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1130
jmp 0xfeaf
movq $-0x2, %rax
jmp 0xfeb2
cmpq $0x1, %r12
jne 0xfec1
movzbl (%r15), %esi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x10c0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r9, %r14
movq %rdi, %rbp
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfc1e
testl %eax, %eax
je 0xff05
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 0xe450
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 0xc931
jmp 0xfeb2
// File: /workspace/github_c_makefile_star2_O3/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 0xc568
movq %rax, %rcx
cmpq $-0x9, %rax
ja 0xffc6
movq $-0x3, %rcx
subq %rax, %rbx
jbe 0xffc6
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 0xc6f4
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10059
movq %r8, %r14
testq %r8, %r8
je 0x10062
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 0xfc1e
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
testl %eax, %eax
je 0x10078
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfae8
movq $-0x2, %rax
jmp 0x10069
movq $-0x4, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq 0x8(%rsp)
pushq 0x18(%rsp)
callq 0xd965
addq $0x28, %rsp
jmp 0x1006d
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
xorl %ebx, %ebx
cmpq %rsi, %rdi
jge 0x119d
movq %rdx, %r14
movq %rsi, %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0x1050
movq %rax, %rdi
callq 0x11cd
movq (%rsp), %rcx
cmpq %rax, %rcx
jne 0x11ab
addq %r14, %rax
movq %rax, (%rsp)
cmpq %r15, %rax
jl 0x1178
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x2e46(%rip), %rdx      # 0x3ff8
movq (%rdx), %rdi
leaq 0xe48(%rip), %rsi       # 0x2004
movq %rax, %rdx
xorl %eax, %eax
callq 0x1040
movl $0x1, %ebx
jmp 0x119d
// File: /workspace/github_c_makefile_star2_O3/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 $0x38, %rsp
movl %r9d, %r14d
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movl %edi, %r13d
movq %rsp, %rdi
movl %r9d, (%rdi)
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)
movq $0x0, 0x18(%rdi)
movl $0x0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
callq 0x11cd
movq 0x70(%rsp), %r11
movq %rax, %r10
xorl %eax, %eax
cmpq %r11, %r10
jne 0x16da
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2917(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x945(%rip), %rsi       # 0x2030
movl %r13d, %edx
movl %r12d, %ecx
movl %r15d, %r8d
movl %ebp, %r9d
xorl %eax, %eax
pushq %r11
pushq %r10
pushq %r14
pushq %rbx
callq 0x1040
addq $0x20, %rsp
movl $0x1, %eax
jmp 0x16cb
// File: /workspace/github_c_makefile_star2_O3/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 0x2cbf
movq %r14, %rdi
callq 0x2150
testl %eax, %eax
jne 0x2cde
addq $0x2, (%rbx)
jmp 0x2ca1
leaq 0x604(%rip), %rdi       # 0x32ca
leaq 0x60c(%rip), %rsi       # 0x32d9
leaq 0x612(%rip), %rcx       # 0x32e6
movl $0xe, %edx
callq 0x2120
leaq 0x5e5(%rip), %rdi       # 0x32ca
leaq 0x5ed(%rip), %rsi       # 0x32d9
leaq 0x5f3(%rip), %rcx       # 0x32e6
movl $0x11, %edx
callq 0x2120
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl %edx, %esi
jge 0x1378
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
movslq %edx, %rbp
movq %rdx, (%rsp)
leal (%r14,%rdx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %r14d, %rbx
movq (%r15,%rbx,8), %rax
movslq %ecx, %rcx
movq (%r15,%rcx,8), %rdx
movq %rdx, (%r15,%rbx,8)
movq %rax, (%r15,%rcx,8)
movq %rbx, %r12
movq 0x8(%r15,%r12,8), %r13
movq (%r15,%rbx,8), %rsi
movq %r13, %rdi
callq 0x1060
testl %eax, %eax
jns 0x1331
movslq %r14d, %rax
incl %r14d
movq 0x8(%r15,%rax,8), %rcx
movq %r13, 0x8(%r15,%rax,8)
movq %rcx, 0x8(%r15,%r12,8)
incq %r12
cmpq %rbp, %r12
jl 0x1307
movq (%r15,%rbx,8), %rax
movslq %r14d, %r14
movq (%r15,%r14,8), %rcx
movq %rcx, (%r15,%rbx,8)
movq %rax, (%r15,%r14,8)
leal -0x1(%r14), %edx
movq %r15, %rdi
movl %ebx, %esi
callq 0x12c1
incl %r14d
movq (%rsp), %rdx
cmpl %edx, %r14d
jl 0x12e1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %r14d, %r14d
decq %r15
je 0x13e7
movq 0x2c20(%rip), %r12      # 0x3fe0
movq (%r12), %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0x13e2
cmpl $0xa, %eax
je 0x13e2
movb %al, (%rbx,%r14)
incq %r14
cmpq %r14, %r15
jne 0x13c0
movq %r15, %r14
cmpl $0xa, %eax
jne 0x13ef
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_O3/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
movl $0x0, (%rax)
xorl %r14d, %r14d
movq %r14, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %r14, 0x20(%rax)
testl %esi, %esi
jle 0x2a42
movq %rdi, %rbx
movl %esi, %r15d
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b30
incq %rbx
decq %r15
jne 0x2a2b
movl -0x20(%rbp), %r14d
leaq -0x48(%rbp), %rdi
callq 0x2ad8
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2ad8
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_c_makefile_star2_O3/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 0x2aa6
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
xorl %edx, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %edi, %esi
movl %eax, %r8d
testb $0x1, %dil
movl %edx, %eax
cmovel %r8d, %eax
cmovnel %r8d, %ecx
shrl %esi
incl %edx
cmpl $0x1, %edi
movl %esi, %edi
ja 0x2a7f
xorl %edx, %edx
cmpl $-0x1, %ecx
setne %dl
addl %edx, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x649(%rip), %rdi       # 0x30fa
leaq 0x649(%rip), %rsi       # 0x3101
leaq 0x657(%rip), %rcx       # 0x3116
movl $0x6c, %edx
callq 0x20e0