LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_ProgramHeaderEntryGetAttributesString
const char * ELF64_ProgramHeaderEntryGetAttributesString( ELF64_ProgramHeaderEntryRef entry )
{
    ELF64_Word flags;
    
    flags = ELF64_ProgramHeaderEntryGetAttributes( entry );
    
    if( flags & ELF64_SegmentAttributeRead && flags & ELF64_SegmentAttributeWrite && flags & ELF64_SegmentAttributeExecute )
    {
        return "rwx";
    }
    else if( flags & ELF64_SegmentAttributeRead && flags & ELF64_SegmentAttributeWrite )
    {
        return "rw-";
    }
    else if( flags & ELF64_SegmentAttributeRead && flags & ELF64_SegmentAttributeExecute )
    {
        return "r-x";
    }
    else if( flags & ELF64_SegmentAttributeWrite && flags & ELF64_SegmentAttributeExecute )
    {
        return "-wx";
    }
    else if( flags & ELF64_SegmentAttributeRead )
    {
        return "r--";
    }
    else if( flags & ELF64_SegmentAttributeWrite )
    {
        return "-w-";
    }
    else if( flags & ELF64_SegmentAttributeExecute )
    {
        return "--x";
    }
    
    return "---";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x30a9
movl 0x4(%rdi), %ecx
jmp 0x30ab
xorl %ecx, %ecx
movl %ecx, %edx
andl $0x6, %edx
movl %ecx, %esi
notl %esi
testb $0x7, %sil
leaq 0x205d(%rip), %rdi      # 0x511c
leaq 0x205a(%rip), %rax      # 0x5120
cmoveq %rdi, %rax
cmpl $0x6, %edx
je 0x311d
testb $0x5, %sil
jne 0x30de
leaq 0x2048(%rip), %rax      # 0x5124
jmp 0x311d
testb $0x4, %cl
leaq 0x2048(%rip), %rax      # 0x5130
leaq 0x203d(%rip), %rdi      # 0x512c
cmoveq %rax, %rdi
testb $0x3, %sil
leaq 0x202a(%rip), %rsi      # 0x5128
cmovneq %rdi, %rsi
testb $0x1, %cl
leaq 0x202c(%rip), %rcx      # 0x5138
leaq 0x2021(%rip), %rax      # 0x5134
cmoveq %rcx, %rax
testl %edx, %edx
cmovneq %rsi, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/bench.c
// Function: BMK_GetFileSize
static U64 BMK_GetFileSize(const char* infilename)
{
    int r;
#if defined(_MSC_VER)
    struct _stat64 statbuf;
    r = _stat64(infilename, &statbuf);
#else
    struct stat statbuf;
    r = stat(infilename, &statbuf);
#endif
    if (r || !S_ISREG(statbuf.st_mode)) return 0;   /* No good... */
    return (U64)statbuf.st_size;
}

// Assembly:
subq $0x98, %rsp
leaq 0x8(%rsp), %rsi
callq 0x10a0
testl %eax, %eax
jne 0x2416
movl $0xf000, %eax           # imm = 0xF000
andl 0x20(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x2416
movq 0x38(%rsp), %rax
jmp 0x2418
xorl %eax, %eax
addq $0x98, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/commandline.c
// Function: usage
static int usage(const char* programName)
{
    DISPLAY("Usage :\n");
    DISPLAY("%s [arg] inputFilename [outputFilename]\n", programName);
    DISPLAY("Arguments :\n");
    DISPLAY("(default): fse core loop timing tests\n");
    DISPLAY(" -e : use FSE (default)\n");
    DISPLAY(" -h : use HUF\n");
    DISPLAY(" -z : use zlib's huffman\n");
    DISPLAY(" -d : decompression (default for %s extension)\n", FSE_EXTENSION);
    DISPLAY(" -b : benchmark mode\n");
    DISPLAY(" -i#: iteration loops [1-9](default : 4), benchmark mode only\n");
    DISPLAY(" -B#: block size (default : 32768), benchmark mode only\n");
    DISPLAY(" -H : display help and exit\n");
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x12dbd(%rip), %r15     # 0x15ff8
movq (%r15), %rcx
leaq 0xc534(%rip), %rdi      # 0xf779
pushq $0x8
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rdi
leaq 0xc525(%rip), %rsi      # 0xf782
movq %r14, %rdx
xorl %eax, %eax
callq 0x1110
movq (%r15), %rcx
leaq 0xc53a(%rip), %rdi      # 0xf7ab
pushq $0xc
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0xc532(%rip), %rdi      # 0xf7b8
pushq $0x26
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0xc544(%rip), %rdi      # 0xf7df
pushq $0x18
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0xc548(%rip), %rdi      # 0xf7f8
pushq $0xe
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0xc542(%rip), %rdi      # 0xf807
pushq $0x19
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rdi
leaq 0xc547(%rip), %rsi      # 0xf821
leaq 0xc3f6(%rip), %rdx      # 0xf6d7
xorl %eax, %eax
callq 0x1110
movq (%r15), %rcx
leaq 0xc55f(%rip), %rdi      # 0xf851
pushq $0x15
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0xc560(%rip), %rdi      # 0xf867
pushq $0x3e
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0xc58a(%rip), %rdi      # 0xf8a6
pushq $0x38
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0xc5ae(%rip), %rdi      # 0xf8df
pushq $0x1c
popq %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH32
XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH32_CREATESTATE_STATIC(state);
    XXH32_reset(state, seed);
    XXH32_update(state, input, len);
    return XXH32_digest(state);
#else
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
            else
                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
    }   }

    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
    else
        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
#endif
}

// Assembly:
pushq %rbp
pushq %rbx
leaq (%rdi,%rsi), %rax
cmpq $0x10, %rsi
jb 0x4a01
leaq -0x10(%rax), %r8
leal 0x24234428(%rdx), %r10d
leal -0x7a143589(%rdx), %r9d
leal 0x61c8864f(%rdx), %ecx
imull $0x85ebca77, (%rdi), %r11d # imm = 0x85EBCA77
addl %r10d, %r11d
roll $0xd, %r11d
imull $0x85ebca77, 0x4(%rdi), %ebx # imm = 0x85EBCA77
addl %r9d, %ebx
roll $0xd, %ebx
imull $0x9e3779b1, %r11d, %r10d # imm = 0x9E3779B1
imull $0x85ebca77, 0x8(%rdi), %r11d # imm = 0x85EBCA77
addl %edx, %r11d
roll $0xd, %r11d
imull $0x85ebca77, 0xc(%rdi), %ebp # imm = 0x85EBCA77
imull $0x9e3779b1, %ebx, %r9d # imm = 0x9E3779B1
addl %ecx, %ebp
roll $0xd, %ebp
imull $0x9e3779b1, %r11d, %edx # imm = 0x9E3779B1
imull $0x9e3779b1, %ebp, %ecx # imm = 0x9E3779B1
addq $0x10, %rdi
cmpq %r8, %rdi
jbe 0x4990
roll %r10d
roll $0x7, %r9d
addl %r10d, %r9d
roll $0xc, %edx
roll $0x12, %ecx
addl %edx, %ecx
addl %r9d, %ecx
jmp 0x4a09
addl $0x165667b1, %edx       # imm = 0x165667B1
movl %edx, %ecx
addl %ecx, %esi
leaq 0x4(%rdi), %rcx
cmpq %rax, %rcx
ja 0x4a41
imull $0xc2b2ae3d, (%rdi), %edx # imm = 0xC2B2AE3D
addl %esi, %edx
roll $0x11, %edx
imull $0x27d4eb2f, %edx, %esi # imm = 0x27D4EB2F
movq %rcx, %rdi
jmp 0x4a0b
movzbl (%rdi), %ecx
imull $0x165667b1, %ecx, %ecx # imm = 0x165667B1
addl %esi, %ecx
roll $0xb, %ecx
imull $0x9e3779b1, %ecx, %esi # imm = 0x9E3779B1
incq %rdi
cmpq %rax, %rdi
jb 0x4a2a
movl %esi, %eax
shrl $0xf, %eax
xorl %esi, %eax
imull $0x85ebca77, %eax, %eax # imm = 0x85EBCA77
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0xc2b2ae3d, %ecx, %ecx # imm = 0xC2B2AE3D
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH32_reset
XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
{
    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state));
    state.seed = seed;
    state.v1 = seed + PRIME32_1 + PRIME32_2;
    state.v2 = seed + PRIME32_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME32_1;
    memcpy(statePtr, &state, sizeof(state));
    return XXH_OK;
}

// Assembly:
leal 0x24234428(%rsi), %eax
leal -0x7a143589(%rsi), %ecx
andq $0x0, (%rdi)
leal 0x61c8864f(%rsi), %edx
movl %esi, 0x8(%rdi)
movl %eax, 0xc(%rdi)
movl %ecx, 0x10(%rdi)
movl %esi, 0x14(%rdi)
movl %edx, 0x18(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rdi)
andl $0x0, 0x2c(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH64_reset
XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
{
    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state));
    state.seed = seed;
    state.v1 = seed + PRIME64_1 + PRIME64_2;
    state.v2 = seed + PRIME64_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME64_1;
    memcpy(statePtr, &state, sizeof(state));
    return XXH_OK;
}

// Assembly:
movabsq $0x60ea27eeadc0b5d6, %rax # imm = 0x60EA27EEADC0B5D6
addq %rsi, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq %rsi, %rcx
movabsq $0x61c8864e7a143579, %rdx # imm = 0x61C8864E7A143579
addq %rsi, %rdx
andq $0x0, (%rdi)
movq %rsi, 0x8(%rdi)
movq %rax, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rsi, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH32_update
XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_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 XXH32_update_endian(state_in, input, len, XXH_littleEndian);
    else
        return XXH32_update_endian(state_in, input, len, XXH_bigEndian);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
addq %rdx, (%rdi)
movq %rsi, %r15
movl 0x2c(%rdi), %eax
leaq (%rax,%rdx), %rcx
cmpq $0xf, %rcx
ja 0x4d4c
leaq (%r14,%rax), %rdi
addq $0x1c, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1130
addl 0x2c(%r14), %ebx
jmp 0x4e81
addq %r15, %rbx
testq %rax, %rax
je 0x4deb
leaq (%r14,%rax), %rdi
addq $0x1c, %rdi
pushq $0x10
popq %r12
movl %r12d, %edx
subl %eax, %edx
movq %r15, %rsi
callq 0x1130
movdqu 0xc(%r14), %xmm0
movdqu 0x1c(%r14), %xmm1
movdqa 0xb06b(%rip), %xmm2     # 0xfdf0
pshufd $0xf5, %xmm1, %xmm3     # xmm3 = xmm1[1,1,3,3]
pmuludq %xmm2, %xmm1
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
pmuludq %xmm2, %xmm3
pshufd $0xe8, %xmm3, %xmm2     # xmm2 = xmm3[0,2,2,3]
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
paddd %xmm0, %xmm1
movdqa %xmm1, %xmm0
psrld $0x13, %xmm0
pslld $0xd, %xmm1
por %xmm0, %xmm1
movdqa 0xb042(%rip), %xmm0     # 0xfe00
pshufd $0xf5, %xmm1, %xmm2     # xmm2 = xmm1[1,1,3,3]
pmuludq %xmm0, %xmm1
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
pmuludq %xmm0, %xmm2
pshufd $0xe8, %xmm2, %xmm0     # xmm0 = xmm2[0,2,2,3]
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
movdqu %xmm1, 0xc(%r14)
subl 0x2c(%r14), %r12d
addq %r12, %r15
andl $0x0, 0x2c(%r14)
leaq -0x10(%rbx), %rax
cmpq %rax, %r15
ja 0x4e6a
movdqu 0xc(%r14), %xmm2
movdqa 0xafee(%rip), %xmm0     # 0xfdf0
movdqa 0xaff6(%rip), %xmm1     # 0xfe00
movdqu (%r15), %xmm3
pshufd $0xf5, %xmm3, %xmm4     # xmm4 = xmm3[1,1,3,3]
pmuludq %xmm0, %xmm3
pshufd $0xe8, %xmm3, %xmm3     # xmm3 = xmm3[0,2,2,3]
pmuludq %xmm0, %xmm4
pshufd $0xe8, %xmm4, %xmm4     # xmm4 = xmm4[0,2,2,3]
punpckldq %xmm4, %xmm3    # xmm3 = xmm3[0],xmm4[0],xmm3[1],xmm4[1]
paddd %xmm2, %xmm3
movdqa %xmm3, %xmm2
psrld $0x13, %xmm2
pslld $0xd, %xmm3
por %xmm2, %xmm3
pshufd $0xf5, %xmm3, %xmm4     # xmm4 = xmm3[1,1,3,3]
pmuludq %xmm1, %xmm3
pshufd $0xe8, %xmm3, %xmm2     # xmm2 = xmm3[0,2,2,3]
pmuludq %xmm1, %xmm4
pshufd $0xe8, %xmm4, %xmm3     # xmm3 = xmm4[0,2,2,3]
punpckldq %xmm3, %xmm2    # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
addq $0x10, %r15
cmpq %rax, %r15
jbe 0x4e0a
movdqu %xmm2, 0xc(%r14)
cmpq %rbx, %r15
jae 0x4e85
leaq 0x1c(%r14), %rdi
subq %r15, %rbx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1130
movl %ebx, 0x2c(%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH32_digest
FORCE_INLINE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
{
    const BYTE * p = (const BYTE*)state->mem32;
    const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize;
    U32 h32;

    if (state->total_len >= 16) {
        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
    } else {
        h32 = state->seed + PRIME32_5;
    }

    h32 += (U32) state->total_len;

    while (p+4<=bEnd) {
        h32 += XXH_readLE32(p, endian) * PRIME32_3;
        h32  = XXH_rotl32(h32, 17) * PRIME32_4;
        p+=4;
    }

    while (p<bEnd) {
        h32 += (*p) * PRIME32_5;
        h32  = XXH_rotl32(h32, 11) * PRIME32_1;
        p++;
    }

    h32 ^= h32 >> 15;
    h32 *= PRIME32_2;
    h32 ^= h32 >> 13;
    h32 *= PRIME32_3;
    h32 ^= h32 >> 16;

    return h32;
}

// Assembly:
movl 0x2c(%rdi), %ecx
movq (%rdi), %rax
cmpq $0x10, %rax
jb 0x4ef6
movdqu 0xc(%rdi), %xmm0
movdqa 0xaf64(%rip), %xmm1     # 0xfe10
pshufd $0xf5, %xmm0, %xmm2     # xmm2 = xmm0[1,1,3,3]
pmuludq %xmm1, %xmm0
pshufd $0xed, %xmm0, %xmm3     # xmm3 = xmm0[1,3,2,3]
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pmuludq %xmm2, %xmm1
pshufd $0xed, %xmm1, %xmm2     # xmm2 = xmm1[1,3,2,3]
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
por %xmm3, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %edx
jmp 0x4efe
movl $0x165667b1, %edx       # imm = 0x165667B1
addl 0x8(%rdi), %edx
addq %rdi, %rcx
addq $0x1c, %rcx
addq $0x1c, %rdi
addl %edx, %eax
leaq 0x4(%rdi), %rdx
cmpq %rcx, %rdx
ja 0x4f41
imull $0xc2b2ae3d, (%rdi), %esi # imm = 0xC2B2AE3D
addl %eax, %esi
roll $0x11, %esi
imull $0x27d4eb2f, %esi, %eax # imm = 0x27D4EB2F
movq %rdx, %rdi
jmp 0x4f0b
movzbl (%rdi), %edx
imull $0x165667b1, %edx, %edx # imm = 0x165667B1
addl %eax, %edx
roll $0xb, %edx
imull $0x9e3779b1, %edx, %eax # imm = 0x9E3779B1
incq %rdi
cmpq %rcx, %rdi
jb 0x4f2a
movl %eax, %ecx
shrl $0xf, %ecx
xorl %eax, %ecx
imull $0x85ebca77, %ecx, %eax # imm = 0x85EBCA77
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0xc2b2ae3d, %ecx, %ecx # imm = 0xC2B2AE3D
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x4fa8
leaq (%r14,%rax), %rdi
addq $0x30, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1130
addl 0x50(%r14), %ebx
jmp 0x50f3
addq %r15, %rbx
movabsq $-0x3d4d51c2d82b14b1, %r12 # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %r13 # imm = 0x9E3779B185EBCA87
testq %rax, %rax
je 0x504b
leaq (%r14,%rax), %rdi
addq $0x30, %rdi
pushq $0x20
popq %rbp
movl %ebp, %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
andl $0x0, 0x50(%r14)
leaq 0x20(%r15), %rax
cmpq %rbx, %rax
ja 0x50dc
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 0x506c
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %rdi, 0x20(%r14)
movq %rsi, 0x28(%r14)
cmpq %rbx, %r15
jae 0x50f7
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_O2/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, %r8 # imm = 0x85EBCA77C2B2AE63
movabsq $0x27d4eb2f165667c5, %rdx # imm = 0x27D4EB2F165667C5
movl 0x50(%rdi), %r10d
movq (%rdi), %r9
cmpq $0x20, %r9
jb 0x51d8
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %rbx
movq 0x20(%rdi), %r11
movq 0x28(%rdi), %rsi
movq %r14, %r15
rolq %r15
movq %rbx, %r12
rolq $0x7, %r12
addq %r15, %r12
movq %r11, %r15
rolq $0xc, %r15
movq %rsi, %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 %r8, %r14
imulq %rax, %rbx
rolq $0x1f, %rbx
imulq %rcx, %rbx
xorq %r14, %rbx
imulq %rcx, %rbx
imulq %rax, %r11
rolq $0x1f, %r11
addq %r8, %rbx
imulq %rcx, %r11
xorq %rbx, %r11
imulq %rcx, %r11
addq %r8, %r11
imulq %rax, %rsi
rolq $0x1f, %rsi
imulq %rcx, %rsi
xorq %r11, %rsi
imulq %rcx, %rsi
addq %r8, %rsi
jmp 0x51df
movq 0x8(%rdi), %rsi
addq %rdx, %rsi
addq %rdi, %r10
addq $0x30, %r10
addq $0x30, %rdi
addq %r9, %rsi
leaq 0x8(%rdi), %r9
cmpq %r10, %r9
ja 0x521b
movq (%rdi), %rdi
imulq %rax, %rdi
rolq $0x1f, %rdi
imulq %rcx, %rdi
xorq %rsi, %rdi
rolq $0x1b, %rdi
imulq %rcx, %rdi
addq %r8, %rdi
movq %rdi, %rsi
movq %r9, %rdi
jmp 0x51ed
movabsq $0x165667b19e3779f9, %r8 # imm = 0x165667B19E3779F9
leaq 0x4(%rdi), %r9
cmpq %r10, %r9
jbe 0x5233
movq %rdi, %r9
jmp 0x524a
movl (%rdi), %edi
imulq %rcx, %rdi
xorq %rsi, %rdi
rolq $0x17, %rdi
imulq %rax, %rdi
addq %r8, %rdi
movq %rdi, %rsi
cmpq %r10, %r9
jae 0x5267
movzbl (%r9), %edi
imulq %rdx, %rdi
xorq %rsi, %rdi
rolq $0xb, %rdi
imulq %rcx, %rdi
incq %r9
jmp 0x5247
movq %rsi, %rcx
shrq $0x21, %rcx
xorq %rsi, %rcx
imulq %rax, %rcx
movq %rcx, %rdx
shrq $0x1d, %rdx
xorq %rcx, %rdx
imulq %r8, %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_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %eax
movl (%rsi,%rax,4), %eax
movslq %eax, %r8
movslq %ecx, %r9
addl %ecx, %ecx
cmpl (%rsi), %ecx
jg 0x67e7
jge 0x67b1
movl %ecx, %r11d
orl $0x1, %r11d
movslq %r11d, %rbx
movslq (%rsi,%rbx,4), %r14
movslq %ecx, %r10
movslq (%rsi,%r10,4), %r15
movzwl (%rdi,%r15,4), %ebp
cmpw %bp, (%rdi,%r14,4)
jae 0x67d9
movq %rbx, %r10
movl %r11d, %ecx
jmp 0x67b4
movslq %ecx, %r10
movl (%rsi,%r10,4), %r10d
movslq %r10d, %r11
movzwl (%rdi,%r11,4), %ebx
cmpw %bx, (%rdi,%r8,4)
jb 0x67e7
jne 0x67d3
movb (%rdx,%r8), %bl
cmpb (%rdx,%r11), %bl
jbe 0x67e7
movl %r10d, (%rsi,%r9,4)
jmp 0x677d
jne 0x67b4
movb (%rdx,%r14), %bpl
cmpb (%rdx,%r15), %bpl
jbe 0x67a9
jmp 0x67b4
movl %eax, (%rsi,%r9,4)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %r13d
leal 0x1(%r13), %edx
shlq $0x2, %rdx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x10c0
testq %r15, %r15
je 0x6ca3
addq %r12, %r15
cmpq %r15, %r12
jae 0x6c7b
movzbl (%r12), %eax
incq %r12
incl (%rbx,%rax,4)
jmp 0x6c69
movl %r13d, %eax
decl %r13d
cmpl $0x0, (%rbx,%rax,4)
je 0x6c7b
incl %r13d
movl %r13d, (%r14)
xorl %ecx, %ecx
xorl %ebp, %ebp
cmpq %rax, %rcx
ja 0x6ca7
movl (%rbx,%rcx,4), %edx
cmpl %ebp, %edx
cmoval %edx, %ebp
incq %rcx
jmp 0x6c91
andl $0x0, (%r14)
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_O2/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 0x6cce
pushq %rax
callq 0x6c36
movl %eax, %eax
addq $0x8, %rsp
retq
movq %r8, %rax
testb $0x3, %al
je 0x6cd9
pushq $-0x1
jmp 0x6ce4
cmpq $0x1000, %r9            # imm = 0x1000
jae 0x6ce6
pushq $-0x8
popq %rax
retq
xorl %r8d, %r8d
movq %rax, %r9
jmp 0x6cee
// File: /workspace/github_c_makefile_star2_O2/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, %rax
testb $0x3, %al
je 0x6f0b
pushq $-0x1
jmp 0x6f16
cmpq $0x1000, %r9            # imm = 0x1000
jae 0x6f18
pushq $-0x8
popq %rax
retq
cmpl $0xfe, (%rsi)
ja 0x6f2c
pushq $0x1
popq %r8
movq %rax, %r9
jmp 0x6cee
movl $0xff, (%rsi)
movq %rax, %r8
jmp 0x6cb8
// File: /workspace/github_c_makefile_star2_O2/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 0x683d
movq %rax, %rbp
cmpq $-0x9, %rax
ja 0x7459
movl 0x4(%rsp), %ecx
cmpl %r12d, %ecx
jbe 0x7424
pushq $-0x5
popq %rbp
jmp 0x7459
movl (%rsp), %edx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x6f73
cmpq $-0x9, %rax
ja 0x7456
subq %rbp, %r14
addq %rbp, %r15
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x70ff
movq %rax, %rbp
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_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/bitstream.h
// Function: BIT_reloadDStream
MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
{
    if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* overflow detected, like end of stream */
        return BIT_DStream_overflow;

    if (bitD->ptr >= bitD->limitPtr) {
        return BIT_reloadDStreamFast(bitD);
    }
    if (bitD->ptr == bitD->start) {
        if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
        return BIT_DStream_completed;
    }
    /* start < ptr < limitPtr */
    {   U32 nbBytes = bitD->bitsConsumed >> 3;
        BIT_DStream_status result = BIT_DStream_unfinished;
        if (bitD->ptr - nbBytes < bitD->start) {
            nbBytes = (U32)(bitD->ptr - bitD->start);  /* ptr > start */
            result = BIT_DStream_endOfBuffer;
        }
        bitD->ptr -= nbBytes;
        bitD->bitsConsumed -= nbBytes*8;
        bitD->bitContainer = MEM_readLEST(bitD->ptr);   /* reminder : srcSize > sizeof(bitD->bitContainer), otherwise bitD->ptr == bitD->start */
        return result;
    }
}

// Assembly:
movl 0x8(%rdi), %ecx
cmpq $0x40, %rcx
jbe 0x75c7
pushq $0x3
popq %rax
retq
movq 0x10(%rdi), %rdx
cmpq 0x20(%rdi), %rdx
jae 0x7611
movq 0x18(%rdi), %rsi
cmpq %rsi, %rdx
je 0x762c
movl %ecx, %r8d
shrl $0x3, %r8d
movq %rdx, %r9
subq %r8, %r9
movl %edx, %r10d
subl %esi, %r10d
xorl %eax, %eax
cmpq %rsi, %r9
cmovael %r8d, %r10d
setb %al
subq %r10, %rdx
movq %rdx, 0x10(%rdi)
shll $0x3, %r10d
subl %r10d, %ecx
movl %ecx, 0x8(%rdi)
movq (%rdx), %rcx
movq %rcx, (%rdi)
retq
movl %ecx, %eax
shrl $0x3, %eax
subq %rax, %rdx
movq %rdx, 0x10(%rdi)
andl $0x7, %ecx
movl %ecx, 0x8(%rdi)
movq (%rdx), %rax
movq %rax, (%rdi)
xorl %eax, %eax
retq
xorl %eax, %eax
cmpl $0x40, %ecx
sete %al
incl %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse.h
// Function: FSE_decodeSymbolFast
MEM_STATIC BYTE FSE_decodeSymbolFast(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
{
    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
    U32 const nbBits = DInfo.nbBits;
    BYTE const symbol = DInfo.symbol;
    size_t const lowBits = BIT_readBitsFast(bitD, nbBits);

    DStatePtr->state = DInfo.newState + lowBits;
    return symbol;
}

// Assembly:
movq (%rdi), %r8
movq 0x8(%rdi), %r9
movzwl (%r9,%r8,4), %r10d
movb 0x2(%r9,%r8,4), %al
movq (%rsi), %r11
movl 0x8(%rsi), %edx
movl %edx, %ecx
shlq %cl, %r11
movzbl 0x3(%r9,%r8,4), %ecx
addl %ecx, %edx
negb %cl
shrq %cl, %r11
addq %r10, %r11
movl %edx, 0x8(%rsi)
movq %r11, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse.h
// Function: FSE_decodeSymbol
MEM_STATIC BYTE FSE_decodeSymbol(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD)
{
    FSE_decode_t const DInfo = ((const FSE_decode_t*)(DStatePtr->table))[DStatePtr->state];
    U32 const nbBits = DInfo.nbBits;
    BYTE const symbol = DInfo.symbol;
    size_t const lowBits = BIT_readBits(bitD, nbBits);

    DStatePtr->state = DInfo.newState + lowBits;
    return symbol;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movzwl (%rdx,%rcx,4), %r14d
movb 0x2(%rdx,%rcx,4), %bpl
movzbl 0x3(%rdx,%rcx,4), %esi
movq %rax, %rdi
callq 0x769f
addq %r14, %rax
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/bitstream.h
// Function: BIT_readBits
MEM_STATIC size_t BIT_getMiddleBits(size_t bitContainer, U32 const start, U32 const nbBits)
{
    U32 const regMask = sizeof(bitContainer)*8 - 1;
    /* if start > regMask, bitstream is corrupted, and result is undefined */
    assert(nbBits < BIT_MASK_SIZE);
    return (bitContainer >> (start & regMask)) & BIT_mask[nbBits];
}

// Assembly:
movl %esi, %edx
addl 0x8(%rdi), %esi
movq (%rdi), %rax
movl %esi, %ecx
negb %cl
shrq %cl, %rax
leaq 0x986b(%rip), %rcx      # 0x10f20
andl (%rcx,%rdx,4), %eax
movl %esi, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl $0xc, %r8d
jbe 0x7894
pushq $-0x5
jmp 0x789c
cmpl $0x5, %r8d
jae 0x789e
pushq $-0x1
popq %rax
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 0x78c3
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse_compress.c
// Function: FSE_createCTable
FSE_CTable* FSE_createCTable (unsigned maxSymbolValue, unsigned tableLog)
{
    size_t size;
    if (tableLog > FSE_TABLELOG_ABSOLUTE_MAX) tableLog = FSE_TABLELOG_ABSOLUTE_MAX;
    size = FSE_CTABLE_SIZE_U32 (tableLog, maxSymbolValue) * sizeof(U32);
    return (FSE_CTable*)malloc(size);
}

// Assembly:
cmpl $0xf, %esi
pushq $0xf
popq %rcx
cmovbl %esi, %ecx
decb %cl
pushq $0x1
popq %rax
shll %cl, %eax
leal (%rax,%rdi,2), %edi
addl $0x3, %edi
shlq $0x2, %rdi
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse_compress.c
// Function: FSE_optimalTableLog_internal
unsigned FSE_optimalTableLog_internal(unsigned maxTableLog, size_t srcSize, unsigned maxSymbolValue, unsigned minus)
{
    U32 maxBitsSrc = BIT_highbit32((U32)(srcSize - 1)) - minus;
    U32 tableLog = maxTableLog;
    U32 minBits = FSE_minTableLog(srcSize, maxSymbolValue);
    assert(srcSize > 1); /* Not supported, RLE should be used instead */
    if (tableLog==0) tableLog = FSE_DEFAULT_TABLELOG;
    if (maxBitsSrc < tableLog) tableLog = maxBitsSrc;   /* Accuracy can be reduced */
    if (minBits > tableLog) tableLog = minBits;   /* Need a minimum to safely represent all symbol values */
    if (tableLog < FSE_MIN_TABLELOG) tableLog = FSE_MIN_TABLELOG;
    if (tableLog > FSE_MAX_TABLELOG) tableLog = FSE_MAX_TABLELOG;
    return tableLog;
}

// Assembly:
leal -0x1(%rsi), %eax
bsrl %eax, %eax
subl %ecx, %eax
bsrl %esi, %ecx
xorl $-0x20, %ecx
addl $0x21, %ecx
bsrl %edx, %edx
xorl $-0x20, %edx
addl $0x22, %edx
cmpl %edx, %ecx
cmovbl %ecx, %edx
testl %edi, %edi
pushq $0xb
popq %rcx
cmovnel %edi, %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
cmpl %ecx, %edx
cmoval %edx, %ecx
cmpl $0x6, %ecx
pushq $0x5
popq %rdx
cmovael %ecx, %edx
cmpl $0xc, %edx
pushq $0xc
popq %rax
cmovbl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse_compress.c
// Function: FSE_buildCTable_raw
size_t FSE_buildCTable_raw (FSE_CTable* ct, unsigned nbBits)
{
    const unsigned tableSize = 1 << nbBits;
    const unsigned tableMask = tableSize - 1;
    const unsigned maxSymbolValue = tableMask;
    void* const ptr = ct;
    U16* const tableU16 = ( (U16*) ptr) + 2;
    void* const FSCT = ((U32*)ptr) + 1 /* header */ + (tableSize>>1);   /* assumption : tableLog >= 1 */
    FSE_symbolCompressionTransform* const symbolTT = (FSE_symbolCompressionTransform*) (FSCT);
    unsigned s;

    /* Sanity checks */
    if (nbBits < 1) return ERROR(GENERIC);             /* min size */

    /* header */
    tableU16[-2] = (U16) nbBits;
    tableU16[-1] = (U16) maxSymbolValue;

    /* Build table */
    for (s=0; s<tableSize; s++)
        tableU16[s] = (U16)(tableSize + s);

    /* Build Symbol Transformation Table */
    {   const U32 deltaNbBits = (nbBits << 16) - (1 << nbBits);
        for (s=0; s<=maxSymbolValue; s++) {
            symbolTT[s].deltaNbBits = deltaNbBits;
            symbolTT[s].deltaFindState = s-1;
    }   }

    return 0;
}

// Assembly:
movl %esi, %ecx
pushq $0x1
popq %rax
shll %cl, %eax
testl %esi, %esi
je 0x7ed0
movl %eax, %esi
shrl %esi
movw %cx, (%rdi)
leal -0x1(%rax), %edx
movw %dx, 0x2(%rdi)
movl %eax, %edx
xorl %r8d, %r8d
cmpq %r8, %rdx
je 0x7ea9
leal (%rdx,%r8), %r9d
movw %r9w, 0x4(%rdi,%r8,2)
incq %r8
jmp 0x7e95
shll $0x10, %ecx
subl %eax, %ecx
leaq (%rdi,%rsi,4), %rsi
addq $0x8, %rsi
xorl %eax, %eax
xorl %edi, %edi
cmpq %rdi, %rdx
je 0x7ed3
movl %ecx, (%rsi,%rdi,8)
leal -0x1(%rdi), %r8d
movl %r8d, -0x4(%rsi,%rdi,8)
incq %rdi
jmp 0x7eba
pushq $-0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse.h
// Function: FSE_encodeSymbol
MEM_STATIC void FSE_encodeSymbol(BIT_CStream_t* bitC, FSE_CState_t* statePtr, unsigned symbol)
{
    FSE_symbolCompressionTransform const symbolTT = ((const FSE_symbolCompressionTransform*)(statePtr->symbolTT))[symbol];
    const U16* const stateTable = (const U16*)(statePtr->stateTable);
    U32 const nbBitsOut  = (U32)((statePtr->value + symbolTT.deltaNbBits) >> 16);
    BIT_addBits(bitC, statePtr->value, nbBitsOut);
    statePtr->value = stateTable[ (statePtr->value >> nbBitsOut) + symbolTT.deltaFindState];
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rsi), %rax
movl %edx, %ecx
movslq (%rax,%rcx,8), %r15
movl 0x4(%rax,%rcx,8), %r14d
movq (%rsi), %rsi
movq 0x8(%rbx), %r12
addq %rsi, %r14
shrq $0x10, %r14
movl %r14d, %edx
callq 0x8499
movq (%rbx), %rax
movl %r14d, %ecx
sarq %cl, %rax
leaq (%r12,%rax,2), %rax
movzwl (%rax,%r15,2), %eax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/bitstream.h
// Function: BIT_flushBits
MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
{
    size_t const nbBytes = bitC->bitPos >> 3;
    assert(bitC->bitPos < sizeof(bitC->bitContainer) * 8);
    assert(bitC->ptr <= bitC->endPtr);
    MEM_writeLEST(bitC->ptr, bitC->bitContainer);
    bitC->ptr += nbBytes;
    if (bitC->ptr > bitC->endPtr) bitC->ptr = bitC->endPtr;
    bitC->bitPos &= 7;
    bitC->bitContainer >>= nbBytes*8;
}

// Assembly:
movl 0x8(%rdi), %ecx
movl %ecx, %eax
shrl $0x3, %eax
movq 0x18(%rdi), %rdx
movq (%rdi), %rsi
movq %rsi, (%rdx)
addq %rdx, %rax
movq 0x20(%rdi), %rdx
cmpq %rdx, %rax
cmovaq %rdx, %rax
movq %rax, 0x18(%rdi)
movl %ecx, %eax
andl $0x7, %eax
movl %eax, 0x8(%rdi)
andb $-0x8, %cl
shrq %cl, %rsi
movq %rsi, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8883
leaq (%r15,%r12,2), %rcx
pushq $-0x7
popq %rax
cmpq %rcx, %r15
jae 0x885b
movzwl (%r15), %edx
cmpl %edx, %r13d
jb 0x888d
addq $0x2, %r15
incl (%rbx,%rdx,4)
jmp 0x8844
movl %r13d, %eax
decl %r13d
cmpl $0x0, (%rbx,%rax,4)
je 0x885b
incl %r13d
movl %r13d, (%r14)
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rax, %rcx
ja 0x888b
movl (%rbx,%rcx,4), %esi
cmpl %edx, %esi
cmoval %esi, %edx
incq %rcx
jmp 0x8871
andl $0x0, (%r14)
xorl %eax, %eax
jmp 0x888d
movl %edx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movzwl (%rdx,%rcx,4), %r14d
movzwl 0x2(%rdx,%rcx,4), %ebp
movl %ebp, %esi
andl $0xf, %esi
shrl $0x4, %ebp
movq %rax, %rdi
callq 0x8ce2
addq %r14, %rax
movq %rax, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpq $0x2, %rcx
jae 0x8f70
pushq $-0x3
popq %r13
jmp 0x8fe1
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 0x683d
movq %rax, %r13
cmpq $-0x9, %rax
ja 0x8fe1
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
leaq 0x250(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8692
cmpq $-0x9, %rax
ja 0x8fde
addq %r13, %r14
subq %r13, %rbx
leaq 0x250(%rsp), %r8
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x8cff
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_O2/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:
movslq %edx, %rcx
xorl %edx, %edx
xorl %eax, %eax
cmpq %rcx, %rdx
jg 0x9926
movzbl 0x2(%rdi,%rdx,4), %r8d
imull (%rsi,%rdx,4), %r8d
addq %r8, %rax
incq %rdx
jmp 0x990e
shrq $0x3, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movslq %edx, %rax
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rax, %rcx
jg 0x9957
cmpl $0x0, (%rsi,%rcx,4)
setne %r8b
cmpb $0x0, 0x2(%rdi,%rcx,4)
sete %r9b
andb %r8b, %r9b
movzbl %r9b, %r8d
orl %r8d, %edx
incq %rcx
jmp 0x9932
xorl %eax, %eax
testl %edx, %edx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/bitstream.h
// Function: BIT_closeCStream
MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
{
    BIT_addBitsFast(bitC, 1, 1);   /* endMark */
    BIT_flushBits(bitC);
    if (bitC->ptr >= bitC->endPtr) return 0; /* overflow detected */
    return (bitC->ptr - bitC->startPtr) + (bitC->bitPos > 0);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
pushq $0x1
popq %rax
shlq %cl, %rax
orq %rax, (%rdi)
incl %ecx
movl %ecx, 0x8(%rdi)
callq 0xa221
movq 0x18(%rbx), %rax
cmpq 0x20(%rbx), %rax
jae 0xa289
subq 0x10(%rbx), %rax
cmpl $0x1, 0x8(%rbx)
sbbq $-0x1, %rax
jmp 0xa28b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa2c2
callq 0x9b1b
jmp 0xa2c7
callq 0x9975
cmpq $-0x9, %rax
ja 0xa2e8
testq %rax, %rax
je 0xa2e6
addq %rax, %rbx
subq %r15, %rbx
decq %r14
xorl %eax, %eax
cmpq %r14, %rbx
cmovbq %rbx, %rax
jmp 0xa2e8
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0xa2f0
cmpq $-0x9, %rax
ja 0xa62d
subq %rax, %rbx
jbe 0xa62a
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 0xa461
pushq $-0x3
popq %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/Cyan4973[P]FiniteStateEntropy/programs/../lib/huf_decompress.c
// Function: HUF_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 0xa2f0
cmpq $-0x9, %rax
ja 0xb1c6
subq %rax, %rbx
jbe 0xb1c3
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 0xa6c3
pushq $-0x3
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq