LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_FileGetSectionHeaderEntryWithName
ELF64_SectionHeaderEntryRef ELF64_FileGetSectionHeaderEntryWithName( ELF64_FileRef file, const char * name )
{
    ELF64_Half                  i;
    ELF64_HeaderRef             header;
    ELF64_SectionHeaderEntryRef section;
    const char                * sName;
    
    if( file == NULL )
    {
        return NULL;
    }
    
    header = ELF64_FileGetHeader( file );
    
    if( header == NULL )
    {
        return NULL;
    }
    
    for( i = 0; i < ELF64_HeaderGetSectionHeaderEntryCount( header ); i++ )
    {
        section = ELF64_FileGetSectionHeaderEntry( file, i );
        sName   = ELF64_FileGetNameOfSection( file, section );
        
        if( strcmp( name, sName ) == 0 )
        {
            return section;
        }
    }
    
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
testq %rdi, %rdi
je 0x2f90
movq %rdi, %r15
movzwl 0x3c(%rdi), %r12d
testq %r12, %r12
je 0x2f90
movzwl 0x3a(%r15), %r13d
movq 0x28(%r15), %rbx
addq %r15, %rbx
movzwl 0x3e(%r15), %eax
imulq %r13, %rax
addq 0x18(%rax,%rbx), %r15
xorl %r14d, %r14d
movl (%rbx), %esi
addq %r15, %rsi
movq -0x30(%rbp), %rdi
callq 0x1130
testl %eax, %eax
je 0x2f92
incq %r14
addq %r13, %rbx
cmpq %r14, %r12
jne 0x2f73
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_FileGetSymbolTableEntryWithName
ELF64_SymbolTableEntryRef ELF64_FileGetSymbolTableEntryWithName( ELF64_FileRef file, const char * name )
{
    ELF64_HeaderRef             header;
    ELF64_SectionHeaderEntryRef sHeader;
    ELF64_Half                  i;
    unsigned int                symCount;
    unsigned int                j;
    ELF64_SymbolTableEntryRef   sym;
    const char                * symName;
    
    if( file == NULL )
    {
        return NULL;
    }
    
    header = ELF64_FileGetHeader( file );
    
    if( header == NULL )
    {
        return NULL;
    }
    
    for( i = 0; i < ELF64_HeaderGetSectionHeaderEntryCount( header ); i++ )
    {
        sHeader = ELF64_FileGetSectionHeaderEntry( file, i );
        
        if( ELF64_SectionHeaderEntryGetType( sHeader ) != ELF64_SectionTypeLinkerSymbolTable )
        {
            continue;
        }
        
        symCount = ELF64_SectionHeaderEntryGetSymbolTableEntryCount( sHeader );
            
        for( j = 0; j < symCount; j++ )
        {
            sym     = ELF64_FileGetSymbolTableEntryForSection( file, sHeader, j );
            symName = ELF64_FileGetSymbolTableEntryNameForSection( file, sym, sHeader );
            
            if( strcmp( name, symName ) == 0 )
            {
                return sym;
            }
        }
    }
    
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x50(%rbp)
testq %rdi, %rdi
je 0x3090
movq %rdi, %rbx
movzwl 0x3c(%rdi), %eax
movq %rax, -0x38(%rbp)
testq %rax, %rax
je 0x3090
movzwl 0x3c(%rbx), %eax
movq %rax, -0x40(%rbp)
xorl %ecx, %ecx
cmpq -0x40(%rbp), %rcx
movq %rcx, -0x48(%rbp)
jae 0x2fff
movzwl 0x3a(%rbx), %r15d
movq 0x28(%rbx), %rax
addq %rbx, %rax
imulq %rcx, %r15
addq %rax, %r15
jmp 0x3002
xorl %r15d, %r15d
movq %r15, %rdi
callq 0x2e20
cmpl $0x2, %eax
jne 0x307f
movq %r15, %rdi
callq 0x2e43
movl %eax, -0x2c(%rbp)
testl %eax, %eax
je 0x307f
movl 0x28(%r15), %eax
movzwl 0x3a(%rbx), %ecx
imulq %rax, %rcx
movq 0x28(%rbx), %rax
addq %rbx, %rax
movq 0x18(%rcx,%rax), %r14
addq %rbx, %r14
xorl %r13d, %r13d
movq %rbx, %r12
movq %rbx, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x2dc0
movq %rax, %rbx
movl (%rax), %eax
cmpb $0x0, (%r14,%rax)
leaq 0x1a22(%rip), %rsi      # 0x4a80
je 0x3066
addq %r14, %rax
movq %rax, %rsi
movq -0x50(%rbp), %rdi
callq 0x1130
testl %eax, %eax
je 0x3092
incl %r13d
cmpl %r13d, -0x2c(%rbp)
movq %r12, %rbx
jne 0x303c
movq -0x48(%rbp), %rcx
incq %rcx
cmpq -0x38(%rbp), %rcx
jne 0x2fe0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_FileGetSymbolTableEntryWithAddress
ELF64_SymbolTableEntryRef ELF64_FileGetSymbolTableEntryWithAddress( ELF64_FileRef file, ELF64_Addr address )
{
    ELF64_HeaderRef             header;
    ELF64_SectionHeaderEntryRef sHeader;
    ELF64_Half                  i;
    unsigned int                symCount;
    unsigned int                j;
    ELF64_SymbolTableEntryRef   sym;
    ELF64_Addr                  symAddress;
    
    if( file == NULL )
    {
        return NULL;
    }
    
    header = ELF64_FileGetHeader( file );
    
    if( header == NULL )
    {
        return NULL;
    }
    
    for( i = 0; i < ELF64_HeaderGetSectionHeaderEntryCount( header ); i++ )
    {
        sHeader = ELF64_FileGetSectionHeaderEntry( file, i );
        
        if( ELF64_SectionHeaderEntryGetType( sHeader ) != ELF64_SectionTypeLinkerSymbolTable )
        {
            continue;
        }
        
        symCount = ELF64_SectionHeaderEntryGetSymbolTableEntryCount( sHeader );
            
        for( j = 0; j < symCount; j++ )
        {
            sym         = ELF64_FileGetSymbolTableEntryForSection( file, sHeader, j );
            symAddress  = ELF64_SymbolTableEntryGetSymbolValue( sym );
            
            if( address == symAddress )
            {
                return sym;
            }
        }
    }
    
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x40(%rbp)
testq %rdi, %rdi
je 0x314c
movq %rdi, %r14
movzwl 0x3c(%rdi), %eax
movq %rax, -0x30(%rbp)
testq %rax, %rax
je 0x314c
movzwl 0x3c(%r14), %eax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
cmpq -0x38(%rbp), %rbx
jae 0x30f8
movzwl 0x3a(%r14), %r15d
movq 0x28(%r14), %rax
addq %r14, %rax
imulq %rbx, %r15
addq %rax, %r15
jmp 0x30fb
xorl %r15d, %r15d
movq %r15, %rdi
callq 0x2e20
cmpl $0x2, %eax
jne 0x3143
movq %r15, %rdi
callq 0x2e43
testl %eax, %eax
je 0x3143
movl %eax, %r12d
xorl %r13d, %r13d
movq %r14, %rdi
movq %r15, %rsi
movl %r13d, %edx
callq 0x2dc0
testq %rax, %rax
je 0x3133
movq 0x8(%rax), %rcx
jmp 0x3135
xorl %ecx, %ecx
cmpq -0x40(%rbp), %rcx
je 0x314e
incl %r13d
cmpl %r13d, %r12d
jne 0x311a
incq %rbx
cmpq -0x30(%rbp), %rbx
jne 0x30dd
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_HeaderGetObjectFileClassString
const char * ELF64_HeaderGetObjectFileClassString( ELF64_HeaderRef header )
{
    switch( ELF64_HeaderGetObjectFileClass( header ) )
    {
        case ELF64_ObjectFileClassUnknown:  return "Unknown";
        case ELF64_ObjectFileClass32:       return "32 bits";
        case ELF64_ObjectFileClass64:       return "64 bits";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x31b7
movb 0x4(%rdi), %al
xorl %ecx, %ecx
cmpb $0x2, %al
sete %cl
addl %ecx, %ecx
cmpb $0x1, %al
movl $0x1, %eax
cmovneq %rcx, %rax
jmp 0x31b9
xorl %eax, %eax
leaq 0x2114(%rip), %rcx      # 0x52d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_Hash
unsigned long ELF64_Hash( const char * name )
{
    unsigned long h;
    unsigned long g;
    
    h = 0;
    
    while( *( name ) )
    {
        h = ( h << 4 ) + *( ( const unsigned char * )name++ );
        
        if( ( g = h & 0xF0000000 ) )
        {
            h ^= g >> 24;
        }
        
        h &= 0x0FFFFFFF;
    }
    
    return h;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x36a1
pushq %rbp
movq %rsp, %rbp
incq %rdi
xorl %edx, %edx
shlq $0x4, %rdx
movzbl %cl, %eax
addq %rdx, %rax
movl %eax, %ecx
shrl $0x18, %ecx
andl $-0x10, %ecx
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
xorq %rcx, %rax
movb (%rdi), %cl
incq %rdi
movq %rax, %rdx
testb %cl, %cl
jne 0x3679
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x170a7(%rip), %r15     # 0x18ff8
movq (%r15), %rcx
leaq 0x1081e(%rip), %rdi     # 0x12779
pushq $0x8
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rdi
leaq 0x1080f(%rip), %rsi     # 0x12782
movq %r14, %rdx
xorl %eax, %eax
callq 0x1110
movq (%r15), %rcx
leaq 0x10824(%rip), %rdi     # 0x127ab
pushq $0xc
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1081c(%rip), %rdi     # 0x127b8
pushq $0x26
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1082e(%rip), %rdi     # 0x127df
pushq $0x18
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x10832(%rip), %rdi     # 0x127f8
pushq $0xe
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1082c(%rip), %rdi     # 0x12807
pushq $0x19
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rdi
leaq 0x10831(%rip), %rsi     # 0x12821
leaq 0x106e0(%rip), %rdx     # 0x126d7
xorl %eax, %eax
callq 0x1110
movq (%r15), %rcx
leaq 0x10849(%rip), %rdi     # 0x12851
pushq $0x15
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x1084a(%rip), %rdi     # 0x12867
pushq $0x3e
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x10874(%rip), %rdi     # 0x128a6
pushq $0x38
popq %rsi
movq %rbx, %rdx
callq 0x1190
movq (%r15), %rcx
leaq 0x10898(%rip), %rdi     # 0x128df
pushq $0x1c
popq %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1190
// File: /workspace/github_c_makefile_star2_O1/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 0x5267
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 0x51f6
roll %r10d
roll $0x7, %r9d
addl %r10d, %r9d
roll $0xc, %edx
roll $0x12, %ecx
addl %edx, %ecx
addl %r9d, %ecx
jmp 0x526f
addl $0x165667b1, %edx       # imm = 0x165667B1
movl %edx, %ecx
addl %ecx, %esi
leaq 0x4(%rdi), %rcx
cmpq %rax, %rcx
jbe 0x527f
movq %rdi, %rcx
jmp 0x52b9
imull $0xc2b2ae3d, (%rdi), %ecx # imm = 0xC2B2AE3D
addl %esi, %ecx
roll $0x11, %ecx
imull $0x27d4eb2f, %ecx, %esi # imm = 0x27D4EB2F
leaq 0x4(%rdi), %rcx
addq $0x8, %rdi
cmpq %rax, %rdi
movq %rcx, %rdi
jbe 0x527f
jmp 0x52b9
movzbl (%rcx), %edx
imull $0x165667b1, %edx, %edx # imm = 0x165667B1
addl %esi, %edx
roll $0xb, %edx
imull $0x9e3779b1, %edx, %esi # imm = 0x9E3779B1
incq %rcx
cmpq %rax, %rcx
jb 0x52a2
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_O1/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
leal 0x61c8864f(%rsi), %edx
movq $0x0, (%rdi)
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)
movl $0x0, 0x2c(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
xorl %r8d, %r8d
movq %r8, (%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)
movq %r8, 0x50(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x55ee
leaq (%r14,%rax), %rdi
addq $0x1c, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1130
addl 0x2c(%r14), %ebx
jmp 0x572e
addq %r15, %rbx
testq %rax, %rax
je 0x568a
leaq (%r14,%rax), %rdi
addq $0x1c, %rdi
movl $0x10, %r12d
movl $0x10, %edx
subl %eax, %edx
movq %r15, %rsi
callq 0x1130
imull $0x85ebca77, 0x1c(%r14), %eax # imm = 0x85EBCA77
addl 0xc(%r14), %eax
roll $0xd, %eax
imull $0x9e3779b1, %eax, %eax # imm = 0x9E3779B1
movl %eax, 0xc(%r14)
imull $0x85ebca77, 0x20(%r14), %eax # imm = 0x85EBCA77
addl 0x10(%r14), %eax
roll $0xd, %eax
imull $0x9e3779b1, %eax, %eax # imm = 0x9E3779B1
movl %eax, 0x10(%r14)
imull $0x85ebca77, 0x24(%r14), %eax # imm = 0x85EBCA77
addl 0x14(%r14), %eax
roll $0xd, %eax
imull $0x9e3779b1, %eax, %eax # imm = 0x9E3779B1
movl %eax, 0x14(%r14)
imull $0x85ebca77, 0x28(%r14), %eax # imm = 0x85EBCA77
addl 0x18(%r14), %eax
roll $0xd, %eax
imull $0x9e3779b1, %eax, %eax # imm = 0x9E3779B1
movl %eax, 0x18(%r14)
subl 0x2c(%r14), %r12d
addq %r12, %r15
movl $0x0, 0x2c(%r14)
leaq -0x10(%rbx), %rax
cmpq %rax, %r15
ja 0x5717
movl 0xc(%r14), %edx
movl 0x10(%r14), %edi
movl 0x14(%r14), %esi
movl 0x18(%r14), %ecx
imull $0x85ebca77, (%r15), %r8d # imm = 0x85EBCA77
addl %edx, %r8d
roll $0xd, %r8d
imull $0x85ebca77, 0x4(%r15), %r9d # imm = 0x85EBCA77
addl %edi, %r9d
roll $0xd, %r9d
imull $0x9e3779b1, %r8d, %edx # imm = 0x9E3779B1
imull $0x85ebca77, 0x8(%r15), %r8d # imm = 0x85EBCA77
addl %esi, %r8d
roll $0xd, %r8d
imull $0x85ebca77, 0xc(%r15), %r10d # imm = 0x85EBCA77
imull $0x9e3779b1, %r9d, %edi # imm = 0x9E3779B1
addl %ecx, %r10d
roll $0xd, %r10d
imull $0x9e3779b1, %r8d, %esi # imm = 0x9E3779B1
imull $0x9e3779b1, %r10d, %ecx # imm = 0x9E3779B1
addq $0x10, %r15
cmpq %rax, %r15
jbe 0x56a7
movl %edx, 0xc(%r14)
movl %edi, 0x10(%r14)
movl %esi, 0x14(%r14)
movl %ecx, 0x18(%r14)
cmpq %rbx, %r15
jae 0x5732
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_O1/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), %edx
movq (%rdi), %rax
cmpq $0x10, %rax
jb 0x576f
movl 0xc(%rdi), %ecx
roll %ecx
movl 0x10(%rdi), %r8d
roll $0x7, %r8d
addl %ecx, %r8d
movl 0x14(%rdi), %ecx
roll $0xc, %ecx
movl 0x18(%rdi), %esi
roll $0x12, %esi
addl %ecx, %esi
addl %r8d, %esi
jmp 0x5777
movl $0x165667b1, %esi       # imm = 0x165667B1
addl 0x8(%rdi), %esi
leaq (%rdi,%rdx), %rcx
addq $0x1c, %rcx
addq $0x1c, %rdi
addl %esi, %eax
cmpl $0x4, %edx
jae 0x578f
movq %rdi, %rdx
jmp 0x57c9
imull $0xc2b2ae3d, (%rdi), %edx # imm = 0xC2B2AE3D
addl %eax, %edx
roll $0x11, %edx
imull $0x27d4eb2f, %edx, %eax # imm = 0x27D4EB2F
leaq 0x4(%rdi), %rdx
addq $0x8, %rdi
cmpq %rcx, %rdi
movq %rdx, %rdi
jbe 0x578f
jmp 0x57c9
movzbl (%rdx), %esi
imull $0x165667b1, %esi, %esi # imm = 0x165667B1
addl %eax, %esi
roll $0xb, %esi
imull $0x9e3779b1, %esi, %eax # imm = 0x9E3779B1
incq %rdx
cmpq %rcx, %rdx
jb 0x57b2
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_O1/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 0x5830
leaq (%r14,%rax), %rdi
addq $0x30, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1130
addl 0x50(%r14), %ebx
jmp 0x5983
addq %r15, %rbx
movabsq $-0x3d4d51c2d82b14b1, %r12 # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %r13 # imm = 0x9E3779B185EBCA87
testq %rax, %rax
je 0x58db
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 0x596c
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 0x58fc
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %rdi, 0x20(%r14)
movq %rsi, 0x28(%r14)
cmpq %rbx, %r15
jae 0x5987
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_O1/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 0x5a68
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 0x5a6f
movq 0x8(%rdi), %r8
addq %rdx, %r8
leaq (%rdi,%r10), %r9
addq $0x30, %r9
addq $0x30, %rdi
addq %r11, %r8
cmpl $0x8, %r10d
jae 0x5a8c
movq %r8, %r10
movq %rdi, %r11
jmp 0x5abc
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 0x5a8c
movabsq $0x165667b19e3779f9, %rsi # imm = 0x165667B19E3779F9
leaq 0x4(%r11), %rdi
cmpq %r9, %rdi
jbe 0x5ad4
movq %r11, %rdi
jmp 0x5aec
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 0x5b11
movzbl (%rdi), %r8d
imulq %rdx, %r8
xorq %r10, %r8
rolq $0xb, %r8
imulq %rcx, %r8
incq %rdi
movq %r8, %r10
cmpq %r9, %rdi
jb 0x5af1
jmp 0x5b14
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_O1/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), %r10d
movl (%rsi), %r11d
cmpl %r11d, %r10d
jle 0x703b
movl %ecx, %r9d
jmp 0x70bd
pushq %rbp
pushq %rbx
movslq %eax, %r8
cmpl %r11d, %r10d
jge 0x707b
movl %r10d, %r11d
orl $0x1, %r11d
movslq %r11d, %r9
movslq (%rsi,%r9,4), %r9
movslq %r10d, %rbx
movslq (%rsi,%rbx,4), %rbx
movzwl (%rdi,%rbx,4), %ebp
cmpw %bp, (%rdi,%r9,4)
jae 0x706a
movl %r11d, %r9d
jmp 0x707e
jne 0x707b
movb (%rdx,%r9), %bpl
movl %r10d, %r9d
cmpb (%rdx,%rbx), %bpl
jbe 0x7065
jmp 0x707e
movl %r10d, %r9d
movslq %r9d, %r10
movl (%rsi,%r10,4), %r10d
movslq %r10d, %r11
movzwl (%rdi,%r11,4), %ebx
cmpw %bx, (%rdi,%r8,4)
jb 0x70b8
jne 0x70a0
movb (%rdx,%r8), %bl
cmpb (%rdx,%r11), %bl
jbe 0x70b8
movslq %ecx, %rcx
movl %r10d, (%rsi,%rcx,4)
leal (%r9,%r9), %r10d
movl (%rsi), %r11d
movl %r9d, %ecx
cmpl %r11d, %r10d
jle 0x7040
jmp 0x70bb
movl %ecx, %r9d
popq %rbx
popq %rbp
movslq %r9d, %rcx
movl %eax, (%rsi,%rcx,4)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7686
movq (%rsp), %rcx
jle 0x7658
movzbl (%r15), %eax
incq %r15
incl (%rbx,%rax,4)
cmpq %r14, %r15
jb 0x7649
movl %r13d, %eax
decl %r13d
cmpl $0x0, (%rbx,%rax,4)
je 0x7658
incl %r13d
movl %r13d, (%rcx)
xorl %ebp, %ebp
movq $-0x1, %rax
movl 0x4(%rbx,%rax,4), %ecx
cmpl %ebp, %ecx
cmoval %ecx, %ebp
incq %rax
cmpq %r13, %rax
jb 0x7673
jmp 0x7690
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_O1/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 0x76b7
pushq %rax
callq 0x760e
movl %eax, %eax
addq $0x8, %rsp
retq
movq %r8, %r10
movq $-0x1, %rax
testb $0x3, %r10b
jne 0x76d7
movq $-0x8, %rax
cmpq $0x1000, %r9            # imm = 0x1000
jae 0x76d8
retq
xorl %r8d, %r8d
movq %r10, %r9
jmp 0x76e0
// File: /workspace/github_c_makefile_star2_O1/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 0x7949
movq $-0x8, %rax
cmpq $0x1000, %r9            # imm = 0x1000
jae 0x794a
retq
cmpl $0xfe, (%rsi)
ja 0x7960
movl $0x1, %r8d
movq %r10, %r9
jmp 0x76e0
movl $0xff, (%rsi)
movq %r10, %r8
jmp 0x76a1
// File: /workspace/github_c_makefile_star2_O1/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 0x710d
movq %rax, %rbp
cmpq $-0x9, %rax
ja 0x84c2
movl 0x4(%rsp), %ecx
movq $-0x5, %rax
cmpl %r12d, %ecx
ja 0x84c5
movl (%rsp), %edx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x79ab
cmpq $-0x9, %rax
ja 0x84c5
subq %rbp, %r14
addq %rbp, %r15
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x7b3a
jmp 0x84c5
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_O1/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 0x86ee
movq $-0x1, %rax
cmpl $0x5, %r8d
jae 0x86ef
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 0x8714
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xf, %ecx
cmovbl %esi, %ecx
decb %cl
movl $0x1, %eax
shll %cl, %eax
leal (%rax,%rdi,2), %edi
addl $0x3, %edi
shlq $0x2, %rdi
jmp 0x1150
// File: /workspace/github_c_makefile_star2_O1/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
movl $0xb, %ecx
cmovnel %edi, %ecx
cmpl %ecx, %eax
cmovbl %eax, %ecx
cmpl %ecx, %edx
cmoval %edx, %ecx
cmpl $0x6, %ecx
movl $0x5, %edx
cmovael %ecx, %edx
cmpl $0xc, %edx
movl $0xc, %eax
cmovbl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %eax
shll %cl, %eax
testl %esi, %esi
je 0x8e09
movl %eax, %esi
shrl %esi
movw %cx, (%rdi)
leal -0x1(%rax), %edx
movw %dx, 0x2(%rdi)
movl %eax, %edx
xorl %r8d, %r8d
leal (%rdx,%r8), %r9d
movw %r9w, 0x4(%rdi,%r8,2)
incq %r8
cmpq %r8, %rdx
jne 0x8dd1
shll $0x10, %ecx
subl %eax, %ecx
leaq (%rdi,%rsi,4), %rsi
addq $0x8, %rsi
xorl %eax, %eax
xorl %edi, %edi
movl %ecx, (%rsi,%rdi,8)
leal -0x1(%rdi), %r8d
movl %r8d, -0x4(%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x8df4
retq
movq $-0x1, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9946
jle 0x9916
leaq (%r15,%r12,2), %rax
movzwl (%r15), %ecx
cmpl %ecx, %r13d
jb 0x9951
addq $0x2, %r15
incl (%rbx,%rcx,4)
cmpq %rax, %r15
jb 0x9901
movl %r13d, %eax
decl %r13d
cmpl $0x0, (%rbx,%rax,4)
je 0x9916
incl %r13d
movl %r13d, (%r14)
xorl %eax, %eax
movq $-0x1, %rcx
movl 0x4(%rbx,%rcx,4), %edx
cmpl %eax, %edx
cmoval %edx, %eax
incq %rcx
cmpq %r13, %rcx
jb 0x9931
movl %eax, %eax
jmp 0x9958
movl $0x0, (%r14)
xorl %eax, %eax
jmp 0x9958
movq $-0x7, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa160(%rip), %rcx      # 0x13ff0
andl (%rcx,%r8,4), %r9d
addq %rdx, %r9
movl %r10d, 0x8(%rsi)
movq %r9, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8258, %rsp           # imm = 0x8258
movl $0x11e, 0x8(%rsp)       # imm = 0x11E
movq $-0x3, %r13
cmpq $0x2, %rcx
jb 0xa195
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 0x710d
movq %rax, %r13
xorl %ebp, %ebp
cmpq $-0x8, %rax
cmovbq %rax, %rbp
jae 0xa195
movl 0x8(%rsp), %edx
movl 0xc(%rsp), %ecx
leaq 0x250(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9747
cmpq $-0x8, %rax
cmovaeq %rax, %r13
jae 0xa195
addq %rbp, %r14
subq %rbp, %rbx
leaq 0x250(%rsp), %r8
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x9e9f
movq %rax, %r13
movq %r13, %rax
addq $0x8258, %rsp           # imm = 0x8258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xabc8
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 0xabad
shrq $0x3, %rax
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xac00
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 0xabd5
xorl %eax, %eax
testl %ecx, %ecx
sete %al
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb6ff
callq 0xadc9
jmp 0xb704
callq 0xac1c
cmpq $-0x9, %rax
ja 0xb725
testq %rax, %rax
je 0xb723
addq %rax, %rbx
subq %r15, %rbx
decq %r14
xorl %eax, %eax
cmpq %r14, %rbx
cmovbq %rbx, %rax
jmp 0xb725
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0xb72c
movq %rax, %rcx
cmpq $-0x9, %rax
ja 0xbb73
movq $-0x3, %rcx
subq %rax, %rbx
jbe 0xbb73
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 0xb8c6
movq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb72c
movq %rax, %rcx
cmpq $-0x9, %rax
ja 0xcc7f
movq $-0x3, %rcx
subq %rax, %rbx
jbe 0xcc7f
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 0xbc22
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq