LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_ProgramHeaderEntryGetTypeString
const char * ELF64_ProgramHeaderEntryGetTypeString( ELF64_ProgramHeaderEntryRef entry )
{
    switch( ELF64_ProgramHeaderEntryGetType( entry ) )
    {
        case ELF64_SegmentTypeUnused:                       return "Unused entry";
        case ELF64_SegmentTypeLoadable:                     return "Loadable segment";
        case ELF64_SegmentTypeDynamicLinkingTables:         return "Dynamic linking tables";
        case ELF64_SegmentTypeProgramInterpreterPathName:   return "Program interpreter path name";
        case ELF64_SegmentTypeNoteSections:                 return "Note sections";
        case ELF64_SegmentTypeProgramHeaderTable:           return "Program header table";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4fd0
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x6, %eax
ja 0x50d0
movq -0x18(%rbp), %rax
leaq 0x1d15(%rip), %rcx      # 0x6d90
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x239f(%rip), %rax      # 0x742a
movq %rax, -0x8(%rbp)
jmp 0x50d0
leaq 0x239f(%rip), %rax      # 0x7437
movq %rax, -0x8(%rbp)
jmp 0x50d0
leaq 0x23a3(%rip), %rax      # 0x7448
movq %rax, -0x8(%rbp)
jmp 0x50d0
leaq 0x23ad(%rip), %rax      # 0x745f
movq %rax, -0x8(%rbp)
jmp 0x50d0
leaq 0x23be(%rip), %rax      # 0x747d
movq %rax, -0x8(%rbp)
jmp 0x50d0
leaq 0x23bf(%rip), %rax      # 0x748b
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x50e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x5159
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x5159
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5159
leaq 0x2350(%rip), %rax      # 0x74a0
movq %rax, -0x8(%rbp)
jmp 0x5227
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x517f
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x517f
leaq 0x232e(%rip), %rax      # 0x74a4
movq %rax, -0x8(%rbp)
jmp 0x5227
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x51a5
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x51a5
leaq 0x230c(%rip), %rax      # 0x74a8
movq %rax, -0x8(%rbp)
jmp 0x5227
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x51c8
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x51c8
leaq 0x22ea(%rip), %rax      # 0x74ac
movq %rax, -0x8(%rbp)
jmp 0x5227
movl -0x14(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x51e0
leaq 0x22d6(%rip), %rax      # 0x74b0
movq %rax, -0x8(%rbp)
jmp 0x5227
movl -0x14(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x51f8
leaq 0x22c2(%rip), %rax      # 0x74b4
movq %rax, -0x8(%rbp)
jmp 0x5227
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5210
leaq 0x22ae(%rip), %rax      # 0x74b8
movq %rax, -0x8(%rbp)
jmp 0x5227
jmp 0x5212
jmp 0x5214
jmp 0x5216
jmp 0x5218
jmp 0x521a
jmp 0x521c
leaq 0x2299(%rip), %rax      # 0x74bc
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_SectionHeaderEntryGetTypeString
const char * ELF64_SectionHeaderEntryGetTypeString( ELF64_SectionHeaderEntryRef entry )
{
        switch( ELF64_SectionHeaderEntryGetType( entry ) )
    {
        case        ELF64_SectionTypeUnused:                    return "Unused section";
        case        ELF64_SectionTypeProgBits:                  return "Program information";
        case        ELF64_SectionTypeLinkerSymbolTable:         return "Linker symbol table";
        case        ELF64_SectionTypeStringTable:               return "String table";
        case        ELF64_SectionTypeRelaRelocationEntries:     return "\"Rela\" type relocation entries";
        case        ELF64_SectionTypeSymbolHashTable:           return "Symbol hash table";
        case        ELF64_SectionTypeDynamicLinkingTables:      return "Dynamic linking tables";
        case        ELF64_SectionTypeNoteInformation:           return "Note information";
        case        ELF64_SectionTypeUninitializedSpace:        return "Uninitialized space";
        case        ELF64_SectionTypeRelRelocationEntries:      return "\"Rel\" type relocation entries";
        case        ELF64_SectionTypeDynamicLoaderSymbolTable:  return "Dynamic loader symbol table";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3e60
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xb, %eax
ja 0x53f8
movq -0x18(%rbp), %rax
leaq 0x1a4d(%rip), %rcx      # 0x6dac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2151(%rip), %rax      # 0x74c0
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x2150(%rip), %rax      # 0x74cf
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x2157(%rip), %rax      # 0x74e3
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x215e(%rip), %rax      # 0x74f7
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x215e(%rip), %rax      # 0x7504
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x2170(%rip), %rax      # 0x7523
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x2088(%rip), %rax      # 0x7448
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x2168(%rip), %rax      # 0x7535
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x216c(%rip), %rax      # 0x7546
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x2173(%rip), %rax      # 0x755a
movq %rax, -0x8(%rbp)
jmp 0x53f8
leaq 0x2184(%rip), %rax      # 0x7578
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_SectionHeaderEntryGetAttributesString
const char * ELF64_SectionHeaderEntryGetAttributesString( ELF64_SectionHeaderEntryRef entry )
{
    ELF64_XWord flags;
    
    flags = ELF64_SectionHeaderEntryGetAttributes( entry );
    
    if( flags & ELF64_SectionAttributeWrite && flags & ELF64_SectionAttributeAlloc && flags & ELF64_SectionAttributeExecute )
    {
        return "wax";
    }
    else if( flags & ELF64_SectionAttributeWrite && flags & ELF64_SectionAttributeAlloc )
    {
        return "wa-";
    }
    else if( flags & ELF64_SectionAttributeWrite && flags & ELF64_SegmentAttributeExecute )
    {
        return "w-x";
    }
    else if( flags & ELF64_SectionAttributeAlloc && flags & ELF64_SegmentAttributeExecute )
    {
        return "-ax";
    }
    else if( flags & ELF64_SectionAttributeWrite )
    {
        return "w--";
    }
    else if( flags & ELF64_SectionAttributeAlloc )
    {
        return "-a-";
    }
    else if( flags & ELF64_SectionAttributeExecute )
    {
        return "--x";
    }
    
    return "---";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5410
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5493
movq -0x18(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x5493
movq -0x18(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x5493
leaq 0x210a(%rip), %rax      # 0x7594
movq %rax, -0x8(%rbp)
jmp 0x557c
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x54bf
movq -0x18(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x54bf
leaq 0x20e2(%rip), %rax      # 0x7598
movq %rax, -0x8(%rbp)
jmp 0x557c
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x54eb
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x54eb
leaq 0x20ba(%rip), %rax      # 0x759c
movq %rax, -0x8(%rbp)
jmp 0x557c
movq -0x18(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x5514
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5514
leaq 0x2092(%rip), %rax      # 0x75a0
movq %rax, -0x8(%rbp)
jmp 0x557c
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x552f
leaq 0x207b(%rip), %rax      # 0x75a4
movq %rax, -0x8(%rbp)
jmp 0x557c
movq -0x18(%rbp), %rax
andq $0x2, %rax
cmpq $0x0, %rax
je 0x554a
leaq 0x2064(%rip), %rax      # 0x75a8
movq %rax, -0x8(%rbp)
jmp 0x557c
movq -0x18(%rbp), %rax
andq $0x4, %rax
cmpq $0x0, %rax
je 0x5565
leaq 0x1f59(%rip), %rax      # 0x74b8
movq %rax, -0x8(%rbp)
jmp 0x557c
jmp 0x5567
jmp 0x5569
jmp 0x556b
jmp 0x556d
jmp 0x556f
jmp 0x5571
leaq 0x1f44(%rip), %rax      # 0x74bc
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_SymbolTableEntryGetType
ELF64_SymbolType ELF64_SymbolTableEntryGetType( ELF64_SymbolTableEntryRef sym )
{
    if( sym == NULL )
    {
        return ELF64_SymbolTypeNone;
    }
    
    switch( ELF64_SymbolTableEntryGetInfo( sym ) & 0x0F )
    {
        case 0:     return ELF64_SymbolTypeNone;
        case 1:     return ELF64_SymbolTypeDataObject;
        case 2:     return ELF64_SymbolTypeFunctionEntryPoint;
        case 3:     return ELF64_SymbolTypeSection;
        case 4:     return ELF64_SymbolTypeFile;
        default:    break;
    }
    
    return ELF64_SymbolTypeNone;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x569c
movl $0x0, -0x4(%rbp)
jmp 0x5700
movq -0x10(%rbp), %rdi
callq 0x5650
movzbl %al, %eax
andl $0xf, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x56f7
movq -0x18(%rbp), %rax
leaq 0x171b(%rip), %rcx      # 0x6ddc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x5700
movl $0x1, -0x4(%rbp)
jmp 0x5700
movl $0x2, -0x4(%rbp)
jmp 0x5700
movl $0x3, -0x4(%rbp)
jmp 0x5700
movl $0x4, -0x4(%rbp)
jmp 0x5700
jmp 0x56f9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_SymbolTableEntryGetTypeString
const char * ELF64_SymbolTableEntryGetTypeString( ELF64_SymbolTableEntryRef sym )
{
    switch( ELF64_SymbolTableEntryGetType( sym ) )
    {
        case ELF64_SymbolTypeNone:                  return "No type specified";
        case ELF64_SymbolTypeDataObject:            return "Data object";
        case ELF64_SymbolTypeFunctionEntryPoint:    return "Function entry point";
        case ELF64_SymbolTypeSection:               return "Symbol associated with a section";
        case ELF64_SymbolTypeFile:                  return "Source file associated with the object file";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5680
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x4, %eax
ja 0x5783
movq -0x18(%rbp), %rax
leaq 0x16b5(%rip), %rcx      # 0x6df0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1e61(%rip), %rax      # 0x75ac
movq %rax, -0x8(%rbp)
jmp 0x5783
leaq 0x1e66(%rip), %rax      # 0x75be
movq %rax, -0x8(%rbp)
jmp 0x5783
leaq 0x1e65(%rip), %rax      # 0x75ca
movq %rax, -0x8(%rbp)
jmp 0x5783
leaq 0x1e6d(%rip), %rax      # 0x75df
movq %rax, -0x8(%rbp)
jmp 0x5783
leaq 0x1e81(%rip), %rax      # 0x7600
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_SymbolTableEntryGetBinding
ELF64_SymbolBinding ELF64_SymbolTableEntryGetBinding( ELF64_SymbolTableEntryRef sym )
{
    if( sym == NULL )
    {
        return ELF64_SymbolBindingLocal;
    }
    
    switch( ELF64_SymbolTableEntryGetInfo( sym ) & 0xF0 )
    {
        case 0:     return ELF64_SymbolBindingLocal;
        case 1:     return ELF64_SymbolBindingGlobal;
        case 2:     return ELF64_SymbolBindingWeak;
        default:    break;
    }
    
    return ELF64_SymbolBindingLocal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x57ac
movl $0x0, -0x4(%rbp)
jmp 0x57fc
movq -0x10(%rbp), %rdi
callq 0x5650
movzbl %al, %eax
andl $0xf0, %eax
movl %eax, -0x14(%rbp)
je 0x57d8
jmp 0x57c4
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x57e1
jmp 0x57ce
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x57ea
jmp 0x57f3
movl $0x0, -0x4(%rbp)
jmp 0x57fc
movl $0x1, -0x4(%rbp)
jmp 0x57fc
movl $0x2, -0x4(%rbp)
jmp 0x57fc
jmp 0x57f5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ww9210[P]xnuca_final_ssp/elf.c
// Function: ELF64_SymbolTableEntryGetBindingString
const char * ELF64_SymbolTableEntryGetBindingString( ELF64_SymbolTableEntryRef sym )
{
    switch( ELF64_SymbolTableEntryGetBinding( sym ) )
    {
        case ELF64_SymbolBindingLocal:  return "Local";
        case ELF64_SymbolBindingGlobal: return "Global";
        case ELF64_SymbolBindingWeak:   return "Weak";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5790
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
testl %eax, %eax
je 0x5844
jmp 0x5830
movl -0x14(%rbp), %eax
subl $0x1, %eax
je 0x5851
jmp 0x583a
movl -0x14(%rbp), %eax
subl $0x2, %eax
je 0x585e
jmp 0x5869
leaq 0x1de1(%rip), %rax      # 0x762c
movq %rax, -0x8(%rbp)
jmp 0x5869
leaq 0x1dda(%rip), %rax      # 0x7632
movq %rax, -0x8(%rbp)
jmp 0x5869
leaq 0x1dd4(%rip), %rax      # 0x7639
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x5952
movq -0x10(%rbp), %rax
shlq $0x4, %rax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movzbl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movabsq $0xf0000000, %rax       # imm = 0xF0000000
andq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5942
movq -0x18(%rbp), %rax
shrq $0x18, %rax
xorq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0xfffffff, %rax        # imm = 0xFFFFFFF
movq %rax, -0x10(%rbp)
jmp 0x58f0
movq -0x10(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/bench.c
// Function: BMK_findMaxMem
static size_t BMK_findMaxMem(U64 requiredMem)
{
    size_t step = (64 MB);
    BYTE* testmem=NULL;

    requiredMem = (((requiredMem >> 26) + 1) << 26);
    requiredMem += 2*step;
    if (requiredMem > MAX_MEM) requiredMem = MAX_MEM;

    while (!testmem) {
        requiredMem -= step;
        if (requiredMem <= step) {
            requiredMem = step+64;
            break;
        }
        testmem = (BYTE*) malloc ((size_t)requiredMem);
    }

    free (testmem);
    return (size_t) (requiredMem - step);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x4000000, -0x10(%rbp) # imm = 0x4000000
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
shrq $0x1a, %rax
addq $0x1, %rax
shlq $0x1a, %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
shlq %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $0x240000000, %rax      # imm = 0x240000000
cmpq %rax, -0x8(%rbp)
jbe 0x2b5d
movabsq $0x240000000, %rax      # imm = 0x240000000
movq %rax, -0x8(%rbp)
jmp 0x2b5f
cmpq $0x0, -0x18(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2b6f
jmp 0x2ba5
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
ja 0x2b96
movq -0x10(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
jmp 0x2ba5
movq -0x8(%rbp), %rdi
callq 0x1140
movq %rax, -0x18(%rbp)
jmp 0x2b5f
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
subq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x281a5(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x2199c(%rip), %rsi     # 0x257f9
movb $0x0, %al
callq 0x1100
movq 0x2818d(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x21989(%rip), %rsi     # 0x25802
movb $0x0, %al
callq 0x1100
movq 0x28171(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x2199a(%rip), %rsi     # 0x2582b
movb $0x0, %al
callq 0x1100
movq 0x28159(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x2198f(%rip), %rsi     # 0x25838
movb $0x0, %al
callq 0x1100
movq 0x28141(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x2199e(%rip), %rsi     # 0x2585f
movb $0x0, %al
callq 0x1100
movq 0x28129(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x2199f(%rip), %rsi     # 0x25878
movb $0x0, %al
callq 0x1100
movq 0x28111(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x21996(%rip), %rsi     # 0x25887
movb $0x0, %al
callq 0x1100
movq 0x280f9(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x21998(%rip), %rsi     # 0x258a1
leaq 0x217ed(%rip), %rdx     # 0x256fd
movb $0x0, %al
callq 0x1100
movq 0x280da(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x219a9(%rip), %rsi     # 0x258d1
movb $0x0, %al
callq 0x1100
movq 0x280c2(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x219a7(%rip), %rsi     # 0x258e7
movb $0x0, %al
callq 0x1100
movq 0x280aa(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x219ce(%rip), %rsi     # 0x25926
movb $0x0, %al
callq 0x1100
movq 0x28092(%rip), %rax     # 0x2bff8
movq (%rax), %rdi
leaq 0x219ef(%rip), %rsi     # 0x2595f
movb $0x0, %al
callq 0x1100
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/fileio.c
// Function: FIO_writeLE32
static void FIO_writeLE32(void* memPtr, U32 val32)
{
    BYTE* p = (BYTE*)memPtr;
    p[0] = (BYTE)val32;
    p[1] = (BYTE)(val32>>8);
    p[2] = (BYTE)(val32>>16);
    p[3] = (BYTE)(val32>>24);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0xc(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x3(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10c0
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0xc(%rbp), %eax
addl $0x9e3779b1, %eax       # imm = 0x9E3779B1
addl $0x85ebca77, %eax       # imm = 0x85EBCA77
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
addl $0x85ebca77, %eax       # imm = 0x85EBCA77
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl $0x0, %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
subl $0x9e3779b1, %eax       # imm = 0x9E3779B1
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movl $0x30, %edx
callq 0x1120
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0x10c0
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
addq -0x10(%rbp), %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
addq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
addq $0x0, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x58, %edx
callq 0x1120
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH_swap32
static U32 XXH_swap32 (U32 x)
{
    return  ((x << 24) & 0xff000000 ) |
            ((x <<  8) & 0x00ff0000 ) |
            ((x >>  8) & 0x0000ff00 ) |
            ((x >> 24) & 0x000000ff );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0x18, %eax
andl $0xff000000, %eax       # imm = 0xFF000000
movl -0x4(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x18, %ecx
andl $0xff, %ecx
orl %ecx, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH_swap64
static U64 XXH_swap64 (U64 x)
{
    return  ((x << 56) & 0xff00000000000000ULL) |
            ((x << 40) & 0x00ff000000000000ULL) |
            ((x << 24) & 0x0000ff0000000000ULL) |
            ((x << 8)  & 0x000000ff00000000ULL) |
            ((x >> 8)  & 0x00000000ff000000ULL) |
            ((x >> 24) & 0x0000000000ff0000ULL) |
            ((x >> 40) & 0x000000000000ff00ULL) |
            ((x >> 56) & 0x00000000000000ffULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shlq $0x38, %rax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x28, %rcx
movabsq $0xff000000000000, %rdx # imm = 0xFF000000000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x18, %rcx
movabsq $0xff0000000000, %rdx   # imm = 0xFF0000000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x8, %rcx
movabsq $0xff00000000, %rdx     # imm = 0xFF00000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shrq $0x8, %rcx
movabsq $0xff000000, %rdx       # imm = 0xFF000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shrq $0x18, %rcx
andq $0xff0000, %rcx         # imm = 0xFF0000
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shrq $0x28, %rcx
andq $0xff00, %rcx           # imm = 0xFF00
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shrq $0x38, %rcx
andq $0xff, %rcx
orq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH32_round
static U32 XXH32_round(U32 seed, U32 input)
{
    seed += input * PRIME32_2;
    seed  = XXH_rotl32(seed, 13);
    seed *= PRIME32_1;
    return seed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
imull $0x85ebca77, -0x8(%rbp), %eax # imm = 0x85EBCA77
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0xd, %eax
movl -0x4(%rbp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
imull $0x9e3779b1, -0x4(%rbp), %eax # imm = 0x9E3779B1
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH64_round
static U64 XXH64_round(U64 acc, U64 input)
{
    acc += input * PRIME64_2;
    acc  = XXH_rotl64(acc, 31);
    acc *= PRIME64_1;
    return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
imulq -0x10(%rbp), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shlq $0x1f, %rax
movq -0x8(%rbp), %rcx
shrq $0x21, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/xxhash.c
// Function: XXH64_mergeRound
static U64 XXH64_mergeRound(U64 acc, U64 val)
{
    val  = XXH64_round(0, val);
    acc ^= val;
    acc  = acc * PRIME64_1 + PRIME64_4;
    return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xbb40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq -0x8(%rbp), %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/zlibh.c
// Function: fixedtables
static void fixedtables(struct inflate_state *state)
{
    state->lencode = lenfix;
    state->lenbits = 9;
    state->distcode = distfix;
    state->distbits = 5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq 0x1884d(%rip), %rcx     # 0x265b0
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movl $0x9, 0x68(%rax)
movq -0x8(%rbp), %rax
leaq 0x19033(%rip), %rcx     # 0x26db0
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
movl $0x5, 0x6c(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/zlibh.c
// Function: gen_codes
static void gen_codes(ct_data* tree, unsigned int max_code, unsigned short* bl_count)
{
    unsigned short next_code[ZLIBH_MAX_BITS+1];  /* next code value for each bit length */
    unsigned short code = 0;               /* running code value */
    unsigned int   bits;                   /* bit index */
    unsigned int   n;                      /* code index */

    /* The distribution counts are first used to generate the code values
    * without bit reversal.
    */
    for (bits = 1; bits <= ZLIBH_MAX_BITS; bits++) {
        next_code[bits] = code = (unsigned short)((code + bl_count[bits-1]) << 1);
    }

    for (n = 0;  n <= max_code; n++) {
        int len = tree[n].Len;
        if (len == 0) continue;
        tree[n].Code = (unsigned short)bi_reverse(next_code[len]++, len);   /* Now reverse the bits */
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movw $0x0, -0x42(%rbp)
movl $0x1, -0x48(%rbp)
cmpl $0xf, -0x48(%rbp)
ja 0xe2c8
movzwl -0x42(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x48(%rbp), %edx
subl $0x1, %edx
movl %edx, %edx
movzwl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
shll %eax
movw %ax, %cx
movw %cx, -0x42(%rbp)
movl -0x48(%rbp), %eax
movw %cx, -0x40(%rbp,%rax,2)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xe290
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0xc(%rbp), %eax
ja 0xe327
movq -0x8(%rbp), %rax
movl -0x4c(%rbp), %ecx
movzwl 0x2(%rax,%rcx,4), %eax
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
jne 0xe2ee
jmp 0xe31c
movslq -0x50(%rbp), %rcx
movw -0x40(%rbp,%rcx,2), %ax
movw %ax, %dx
addw $0x1, %dx
movw %dx, -0x40(%rbp,%rcx,2)
movzwl %ax, %edi
movl -0x50(%rbp), %esi
callq 0xe330
movw %ax, %dx
movq -0x8(%rbp), %rax
movl -0x4c(%rbp), %ecx
movw %dx, (%rax,%rcx,4)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xe2cf
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/zlibh.c
// Function: bi_reverse
static unsigned bi_reverse(unsigned code, int len)
{
    unsigned res = 0;
    do {
        res |= code & 1;
        code >>= 1, res <<= 1;
    } while (--len > 0);
    return res >> 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl $0x1, %eax
orl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
movl -0xc(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jg 0xe341
movl -0xc(%rbp), %eax
shrl %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/../lib/error_private.h
// Function: ERR_getErrorString
ERR_STATIC const char* ERR_getErrorString(ERR_enum code)
{
    static const char* notErrorCode = "Unspecified error code";
    switch( code )
    {
    case PREFIX(no_error): return "No error detected";
    case PREFIX(GENERIC):  return "Error (generic)";
    case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
    case PREFIX(srcSize_wrong): return "Src size is incorrect";
    case PREFIX(corruption_detected): return "Corrupted block detected";
    case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported";
    case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large";
    case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small";
    case PREFIX(workSpace_tooSmall): return "workspace buffer is too small";
    case PREFIX(maxCode):
    default: return notErrorCode;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x9, %rax
ja 0xed33
movq -0x18(%rbp), %rax
leaq 0x1817d(%rip), %rcx     # 0x26e30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x181ac(%rip), %rax     # 0x26e6f
movq %rax, -0x8(%rbp)
jmp 0xed3e
leaq 0x181b1(%rip), %rax     # 0x26e81
movq %rax, -0x8(%rbp)
jmp 0xed3e
leaq 0x181b4(%rip), %rax     # 0x26e91
movq %rax, -0x8(%rbp)
jmp 0xed3e
leaq 0x181c7(%rip), %rax     # 0x26eb1
movq %rax, -0x8(%rbp)
jmp 0xed3e
leaq 0x181d0(%rip), %rax     # 0x26ec7
movq %rax, -0x8(%rbp)
jmp 0xed3e
leaq 0x181dc(%rip), %rax     # 0x26ee0
movq %rax, -0x8(%rbp)
jmp 0xed3e
leaq 0x181ff(%rip), %rax     # 0x26f10
movq %rax, -0x8(%rbp)
jmp 0xed3e
leaq 0x1821b(%rip), %rax     # 0x26f39
movq %rax, -0x8(%rbp)
jmp 0xed3e
leaq 0x18234(%rip), %rax     # 0x26f5f
movq %rax, -0x8(%rbp)
jmp 0xed3e
jmp 0xed33
movq 0x1d3fe(%rip), %rax     # 0x2c138
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x10c0
cmpq $0x0, -0x28(%rbp)
jne 0xee82
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xef19
jmp 0xee84
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0xeeaf
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movzbl (%rcx), %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0xee84
jmp 0xeeb1
movq -0x10(%rbp), %rax
movl -0x3c(%rbp), %ecx
cmpl $0x0, (%rax,%rcx,4)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xeec7
jmp 0xeed2
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xeeb1
movl -0x3c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x3c(%rbp), %eax
ja 0xef13
movq -0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
movl (%rax,%rcx,4), %eax
cmpl -0x40(%rbp), %eax
jbe 0xef06
movq -0x10(%rbp), %rax
movl -0x44(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x40(%rbp)
jmp 0xef08
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xeee2
movl -0x40(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
cmpq $0x5dc, -0x28(%rbp)     # imm = 0x5DC
jae 0xef77
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0xee10
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0xefc3
movq -0x30(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0xef8f
movq $-0x1, -0x8(%rbp)
jmp 0xefc3
cmpq $0x1000, -0x38(%rbp)    # imm = 0x1000
jae 0xefa3
movq $-0x8, -0x8(%rbp)
jmp 0xefc3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r9
xorl %r8d, %r8d
callq 0xefd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x30(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0xf458
movq $-0x1, -0x8(%rbp)
jmp 0xf4c8
cmpq $0x1000, -0x38(%rbp)    # imm = 0x1000
jae 0xf46c
movq $-0x8, -0x8(%rbp)
jmp 0xf4c8
movq -0x18(%rbp), %rax
cmpl $0xff, (%rax)
jae 0xf49d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r9
movl $0x1, %r8d
callq 0xefd0
movq %rax, -0x8(%rbp)
jmp 0xf4c8
movq -0x18(%rbp), %rax
movl $0xff, (%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0xef30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse_decompress.c
// Function: FSE_buildDTable_rle
size_t FSE_buildDTable_rle (FSE_DTable* dt, BYTE symbolValue)
{
    void* ptr = dt;
    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
    void* dPtr = dt + 1;
    FSE_decode_t* const cell = (FSE_decode_t*)dPtr;

    DTableH->tableLog = 0;
    DTableH->fastMode = 0;

    cell->newState = 0;
    cell->symbol = symbolValue;
    cell->nbBits = 0;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movw $0x0, (%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0x2(%rax)
movq -0x30(%rbp), %rax
movw $0x0, (%rax)
movb -0x9(%rbp), %cl
movq -0x30(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x30(%rbp), %rax
movb $0x0, 0x3(%rax)
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse_decompress.c
// Function: FSE_buildDTable_raw
size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
{
    void* ptr = dt;
    FSE_DTableHeader* const DTableH = (FSE_DTableHeader*)ptr;
    void* dPtr = dt + 1;
    FSE_decode_t* const dinfo = (FSE_decode_t*)dPtr;
    const unsigned tableSize = 1 << nbBits;
    const unsigned tableMask = tableSize - 1;
    const unsigned maxSV1 = tableMask+1;
    unsigned s;

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

    /* Build Decoding Table */
    DTableH->tableLog = (U16)nbBits;
    DTableH->fastMode = 1;
    for (s=0; s<maxSV1; s++) {
        dinfo[s].newState = 0;
        dinfo[s].symbol = (BYTE)s;
        dinfo[s].nbBits = (BYTE)nbBits;
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
cmpl $0x1, -0x14(%rbp)
jae 0xf9ee
movq $-0x1, -0x8(%rbp)
jmp 0xfa54
movl -0x14(%rbp), %eax
movw %ax, %cx
movq -0x28(%rbp), %rax
movw %cx, (%rax)
movq -0x28(%rbp), %rax
movw $0x1, 0x2(%rax)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x44(%rbp), %eax
jae 0xfa4c
movq -0x38(%rbp), %rax
movl -0x48(%rbp), %ecx
movw $0x0, (%rax,%rcx,4)
movl -0x48(%rbp), %eax
movb %al, %dl
movq -0x38(%rbp), %rax
movl -0x48(%rbp), %ecx
movb %dl, 0x2(%rax,%rcx,4)
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x38(%rbp), %rax
movl -0x48(%rbp), %ecx
movb %dl, 0x3(%rax,%rcx,4)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xfa0c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0xff, -0x258(%rbp)
leaq -0x250(%rbp), %rdi
movq -0x40(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x258(%rbp), %rsi
leaq -0x254(%rbp), %rdx
callq 0xe460
movq %rax, -0x260(%rbp)
movq -0x260(%rbp), %rdi
callq 0x104e0
cmpl $0x0, %eax
je 0x10437
movq -0x260(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x104cb
movl -0x254(%rbp), %eax
cmpl -0x34(%rbp), %eax
jbe 0x1044c
movq $-0x5, -0x8(%rbp)
jmp 0x104cb
movq -0x260(%rbp), %rax
addq -0x48(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x260(%rbp), %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x250(%rbp), %rsi
movl -0x258(%rbp), %edx
movl -0x254(%rbp), %ecx
callq 0xf5a0
movq %rax, -0x268(%rbp)
movq -0x268(%rbp), %rdi
callq 0x104e0
cmpl $0x0, %eax
je 0x104ae
movq -0x268(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x104cb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xfa60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Cyan4973[P]FiniteStateEntropy/programs/../lib/fse.h
// Function: FSE_initDState
MEM_STATIC void FSE_initDState(FSE_DState_t* DStatePtr, BIT_DStream_t* bitD, const FSE_DTable* dt)
{
    const void* ptr = dt;
    const FSE_DTableHeader* const DTableH = (const FSE_DTableHeader*)ptr;
    DStatePtr->state = BIT_readBits(bitD, DTableH->tableLog);
    BIT_reloadDStream(bitD);
    DStatePtr->table = dt + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movzwl (%rax), %esi
callq 0x10b50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x10800
movq -0x18(%rbp), %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpq $0x40, %rax
jbe 0x10825
movl $0x3, -0x4(%rbp)
jmp 0x10919
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x10848
movq -0x10(%rbp), %rdi
callq 0x10c30
movl %eax, -0x4(%rbp)
jmp 0x10919
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x1087f
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpq $0x40, %rax
jae 0x10873
movl $0x1, -0x4(%rbp)
jmp 0x10919
movl $0x2, -0x4(%rbp)
jmp 0x10919
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shrl $0x3, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x108cf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
subq %rcx, %rax
movl %eax, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x14(%rbp), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movl %edx, %edx
movl %edx, %esi
xorl %edx, %edx
subq %rsi, %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %edx
shll $0x3, %edx
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x109f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)