LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/YiweiMao[P]tessDX/src/tessellator.cpp
// Function: CHWTessellator::TessellateIsoLineDomain(float, float)
void CHWTessellator::TessellateIsoLineDomain( float TessFactor_V_LineDensity, float TessFactor_U_LineDetail )
{
    PROCESSED_TESS_FACTORS_ISOLINE processedTessFactors;
    IsoLineProcessTessFactors(TessFactor_V_LineDensity,TessFactor_U_LineDetail,processedTessFactors);
    if( processedTessFactors.bPatchCulled )
    {
        m_NumPoints = 0;
        m_NumIndices = 0;
        return;
    }
    IsoLineGeneratePoints(processedTessFactors);
    IsoLineGenerateConnectivity(processedTessFactors); // can be done in parallel to IsoLineGeneratePoints
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %r14
movq %r14, %rsi
callq 0x40425c
cmpb $0x1, 0x30(%r14)
jne 0x404238
movq $0x0, 0x28(%rbx)
jmp 0x404253
leaq 0xc(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4043e8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x404536
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/YiweiMao[P]tessDX/src/tessellator.cpp
// Function: CHWTessellator::IsoLineGeneratePoints(CHWTessellator::PROCESSED_TESS_FACTORS_ISOLINE const&)
void CHWTessellator::IsoLineGeneratePoints( const PROCESSED_TESS_FACTORS_ISOLINE& processedTessFactors )
{
    int line, pointOffset;
    for(line = 0, pointOffset = 0; line < processedTessFactors.numLines; line++)
    {
        for(int point = 0; point < processedTessFactors.numPointsPerLine; point++)
        {
            FXP fxpU,fxpV;
            SetTessellationParity(processedTessFactors.lineDensityParity);
            PlacePointIn1D(processedTessFactors.lineDensityTessFactorCtx,line,fxpV);

            SetTessellationParity(processedTessFactors.lineDetailParity);
            PlacePointIn1D(processedTessFactors.lineDetailTessFactorCtx,point,fxpU);

            DefinePoint(fxpU,fxpV,pointOffset++);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl 0x38(%rsi), %eax
movl %eax, 0x8(%rsp)
testl %eax, %eax
jle 0x404527
movq %rdi, %r10
movl 0x34(%rsi), %r11d
movl (%rsi), %ebp
movl 0x4(%rsi), %eax
leaq 0x8(%rsi), %rbx
addq $0x1c, %rsi
movq 0x18(%rdi), %rdi
addq $0x4, %rdi
movq %rdi, 0x18(%rsp)
xorl %edi, %edi
leaq 0x10(%rsp), %r15
xorl %r14d, %r14d
movl %eax, 0xc(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %r13
testl %r11d, %r11d
jle 0x404519
movq %rdi, 0x20(%rsp)
movslq %edi, %rax
movq 0x18(%rsp), %rdi
leaq (%rdi,%rax,8), %rax
movq %rax, 0x40(%rsp)
xorl %r12d, %r12d
movl %ebp, 0x4(%r13)
movq %r13, %rdi
movq %rbx, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0x4031d6
movl 0xc(%rsp), %eax
movl %eax, 0x4(%r13)
movq %r13, %rdi
movq 0x28(%rsp), %rsi
movl %r12d, %edx
leaq 0x14(%rsp), %rcx
callq 0x4031d6
movss 0xc1b98(%rip), %xmm2    # 0x4c603c
movl $0xffff, %edi           # imm = 0xFFFF
movl 0x14(%rsp), %eax
movl 0x10(%rsp), %esi
movl %eax, %r9d
shrl $0x10, %r9d
xorps %xmm0, %xmm0
cvtsi2ss %r9d, %xmm0
andl %edi, %eax
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq 0x40(%rsp), %r9
movss %xmm1, -0x4(%r9,%r12,8)
movl %esi, %eax
shrl $0x10, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
andl %edi, %esi
xorps %xmm1, %xmm1
cvtsi2ss %esi, %xmm1
movq 0x38(%rsp), %r11
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movss %xmm1, (%r9,%r12,8)
incq %r12
cmpl %r12d, %r11d
jne 0x40446a
movq 0x20(%rsp), %rdi
addl %r12d, %edi
incl %r14d
cmpl 0x8(%rsp), %r14d
jne 0x404448
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/YiweiMao[P]tessDX/src/tessellator.cpp
// Function: CHWTessellator::IsoLineGenerateConnectivity(CHWTessellator::PROCESSED_TESS_FACTORS_ISOLINE const&)
void CHWTessellator::IsoLineGenerateConnectivity( const PROCESSED_TESS_FACTORS_ISOLINE& processedTessFactors )
{
    int line, pointOffset, indexOffset;
    if( m_outputPrimitive == D3D11_TESSELLATOR_OUTPUT_POINT )
    {
        for(line = 0, pointOffset = 0, indexOffset = 0; line < processedTessFactors.numLines; line++)
        {
            for(int point = 0; point < processedTessFactors.numPointsPerLine; point++)
            {
                DefineIndex(pointOffset++,indexOffset++);
            }
        }
    }
    else // line
    {
        for(line = 0, pointOffset = 0, indexOffset = 0; line < processedTessFactors.numLines; line++)
        {
            for(int point = 0; point < processedTessFactors.numPointsPerLine; point++)
            {
                if( point > 0 )
                {
                    DefineIndex(pointOffset-1,indexOffset++);
                    DefineIndex(pointOffset,indexOffset++);
                }
                pointOffset++;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbp
cmpl $0x0, 0x10(%rdi)
movl 0x38(%rsi), %eax
je 0x4045f9
testl %eax, %eax
jle 0x40465c
movl $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
movq %rbp, 0x20(%rsp)
movq 0x20(%rsp), %r15
cmpl $0x0, 0x34(%r14)
jle 0x4045ef
movl %eax, 0x18(%rsp)
movq 0x20(%rbp), %rbx
xorl %r12d, %r12d
testl %r12d, %r12d
je 0x4045d0
movq 0x8(%rsp), %rax
leal (%rax,%r12), %ebp
leal (%rax,%r12), %esi
decl %esi
movq %r15, %rdi
callq 0x4046a0
movq %r14, %r13
movslq 0x10(%rsp), %r14
movl %eax, (%rbx,%r14,4)
leal 0x2(%r14), %eax
movl %eax, 0x10(%rsp)
movq %r15, %rdi
movl %ebp, %esi
callq 0x4046a0
movl %eax, 0x4(%rbx,%r14,4)
movq %r13, %r14
incl %r12d
cmpl 0x34(%r14), %r12d
jl 0x40458e
movq 0x8(%rsp), %rax
addl %r12d, %eax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rbp
movl 0x18(%rsp), %eax
incl %eax
cmpl 0x38(%r14), %eax
jl 0x40457c
jmp 0x40465c
testl %eax, %eax
jle 0x40465c
movq 0x20(%rbp), %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
xorl %edx, %edx
xorl %r13d, %r13d
cmpl $0x0, 0x34(%r14)
jle 0x404653
movq %rax, 0x10(%rsp)
cltq
movq 0x18(%rsp), %rcx
leaq (%rcx,%rax,4), %r15
movl %edx, 0x8(%rsp)
movl %edx, %r12d
xorl %ebx, %ebx
leal (%r12,%rbx), %esi
movq %rbp, %rdi
callq 0x4046a0
movl %eax, (%r15,%rbx,4)
incq %rbx
cmpl 0x34(%r14), %ebx
jl 0x40462d
movq 0x10(%rsp), %rax
addl %ebx, %eax
movl 0x8(%rsp), %edx
addl %ebx, %edx
incl %r13d
cmpl 0x38(%r14), %r13d
jl 0x40460d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/YiweiMao[P]tessDX/src/tessellator.cpp
// Function: GetMSB(int)
int GetMSB(int val)
{
    int check;
    if( val <= 0x0000ffff ) { check = ( val <= 0x000000ff ) ? 0x00000080 : 0x00008000; }
    else                    { check = ( val <= 0x00ffffff ) ? 0x00800000 : 0x80000000; }
    for( int i = 0; i < 8; i++, check >>= 1 ) { if( val & check ) return check; }
    return 0;
}

// Assembly:
cmpl $0x100, %edi            # imm = 0x100
movl $0x80, %eax
movl $0x8000, %ecx           # imm = 0x8000
cmovll %eax, %ecx
cmpl $0x1000000, %edi        # imm = 0x1000000
movl $0x800000, %edx         # imm = 0x800000
movl $0x80000000, %eax       # imm = 0x80000000
cmovll %edx, %eax
cmpl $0x10000, %edi          # imm = 0x10000
cmovll %ecx, %eax
testl %edi, %eax
je 0x404764
retq
xorl %edx, %edx
movl %edx, %ecx
sarl %eax
cmpl $0x6, %edx
ja 0x404778
leal 0x1(%rcx), %edx
movl %eax, %esi
andl %edi, %esi
je 0x404766
xorl %edx, %edx
cmpl $0x7, %ecx
cmovael %edx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/YiweiMao[P]tessDX/src/tessellator.cpp
// Function: CHLSLTessellator::Init(D3D11_TESSELLATOR_PARTITIONING, D3D11_TESSELLATOR_REDUCTION, D3D11_TESSELLATOR_QUAD_REDUCTION_AXIS, D3D11_TESSELLATOR_OUTPUT_PRIMITIVE)
void CHLSLTessellator::Init(  
    D3D11_TESSELLATOR_PARTITIONING       partitioning,
    D3D11_TESSELLATOR_REDUCTION          insideTessFactorReduction,
    D3D11_TESSELLATOR_QUAD_REDUCTION_AXIS quadInsideTessFactorReductionAxis,
    D3D11_TESSELLATOR_OUTPUT_PRIMITIVE   outputPrimitive)
{
    CHWTessellator::Init(partitioning,outputPrimitive);
    m_LastComputedTessFactors[0] = m_LastComputedTessFactors[1] = m_LastComputedTessFactors[2] = 
    m_LastComputedTessFactors[3] = m_LastComputedTessFactors[4] = m_LastComputedTessFactors[5] = 0;
    m_partitioning = partitioning;
    m_originalPartitioning = partitioning;
    switch( partitioning )
    {
    case D3D11_TESSELLATOR_PARTITIONING_INTEGER:
    default:
        break;
    case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_ODD:
        m_parity = TESSELLATOR_PARITY_ODD;
        break;
    case D3D11_TESSELLATOR_PARTITIONING_FRACTIONAL_EVEN:
        m_parity = TESSELLATOR_PARITY_EVEN;
        break;
    }
    m_originalParity = m_parity;
    m_outputPrimitive = outputPrimitive;
    m_insideTessFactorReduction = insideTessFactorReduction;
    m_quadInsideTessFactorReductionAxis = quadInsideTessFactorReductionAxis;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %ebx
movl %edx, %r14d
movl %esi, %r12d
movq %rdi, %r15
movl %r8d, %edx
callq 0x402006
xorps %xmm0, %xmm0
movups %xmm0, 0x7c(%r15)
movq $0x0, 0x8c(%r15)
movl %r12d, 0x6c(%r15)
movl %r12d, 0x68(%r15)
cmpl $0x2, %r12d
je 0x4047e7
cmpl $0x3, %r12d
jne 0x4047f0
xorl %eax, %eax
jmp 0x4047ec
movl $0x1, %eax
movl %eax, 0x64(%r15)
movl 0x64(%r15), %eax
movl %eax, 0x60(%r15)
movl %ebp, 0x70(%r15)
movl %r14d, 0x74(%r15)
movl %ebx, 0x78(%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/YiweiMao[P]tessDX/src/tessellator.cpp
// Function: CHLSLTessellator::RoundUpTessFactor(float&)
void CHLSLTessellator::RoundUpTessFactor(float& TessFactor)
{
    // Assume TessFactor is in [1.0f..+INF]
    if( Pow2Partitioning() )
    {
        int bits = *(int*)&TessFactor;
        if( bits & mantissaMask )
        {
            *(int*)&TessFactor = (bits & exponentMask) + exponentLSB;
        }
    }
    else if( IntegerPartitioning() )
    {
        TessFactor = ceil(TessFactor);
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl 0x6c(%rdi), %eax
testl %eax, %eax
je 0x40517d
cmpl $0x1, %eax
jne 0x40518a
movl (%rbx), %eax
testl $0x7fffff, %eax         # imm = 0x7FFFFF
je 0x40518a
andl $0x7f800000, %eax       # imm = 0x7F800000
addl $0x800000, %eax         # imm = 0x800000
movl %eax, (%rbx)
jmp 0x40518a
movss (%rbx), %xmm0
callq 0x4010c8
movss %xmm0, (%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/YiweiMao[P]tessDX/src/tessellator.cpp
// Function: CHLSLTessellator::ClampFloatTessFactorScale(float&)
void CHLSLTessellator::ClampFloatTessFactorScale(float& input)
{
    // If input is < 0.0f or NaN, clamp to 0.0f.  > 1 clamps to 1.
    // In other words, clamp input to [0.0f...1.0f]
    int bits = *(int*)&input;
    if( ( ( ( bits & exponentMask ) == exponentMask ) && ( bits & mantissaMask ) ) ||// nan?
        (input < 0.0f) )
    {
        input = 0;
    }
    else if( input > 1 )
    {
        input = 1;
    }
}

// Assembly:
movl (%rsi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx       # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax         # imm = 0x7FFFFF
setne %al
xorps %xmm0, %xmm0
testb %al, %cl
jne 0x405210
movss (%rsi), %xmm1
ucomiss %xmm1, %xmm0
ja 0x405210
movss 0xc0e39(%rip), %xmm0    # 0x4c6044
ucomiss %xmm0, %xmm1
jbe 0x405214
movss %xmm0, (%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]minijson/./minijson.h
// Function: minijson::value::str[abi:cxx11](char const*) const
std::string str(const char* p) const {
    std::stringstream ss;
    ss << '"';
    while (*p) {
      if (*p == '\n') ss << "\\n";
      if (*p == '\r') ss << "\\r";
      if (*p == '\t') ss << "\\t";
      else if (strchr("\"", *p)) ss << "\\" << *p;
      else ss << *p;
      p++;
    }
    ss << '"';
    return ss.str();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r15
movq %rdi, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x20(%rsp), %r14
leaq 0x7(%rsp), %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x21c0
leaq 0x2264(%rip), %r12      # 0x5172
leaq 0x2260(%rip), %r13      # 0x5175
leaq 0x225f(%rip), %rbp      # 0x517b
leaq 0x7(%rsp), %rbx
movzbl (%r15), %eax
cmpl $0xa, %eax
je 0x2f33
testl %eax, %eax
jne 0x2f43
jmp 0x2fc6
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x21c0
cmpb $0xd, (%r15)
jne 0x2f59
movl $0x2, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x21c0
movzbl (%r15), %eax
testl %eax, %eax
je 0x2f81
cmpl $0x22, %eax
je 0x2f81
cmpl $0x9, %eax
jne 0x2faa
movl $0x2, %edx
movq %r14, %rdi
leaq 0x21fe(%rip), %rsi      # 0x5178
callq 0x21c0
jmp 0x2fbe
movl $0x1, %edx
movq %r14, %rdi
movq %rbp, %rsi
callq 0x21c0
movb (%r15), %al
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21c0
jmp 0x2fbe
movb %al, 0x7(%rsp)
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21c0
incq %r15
jmp 0x2f21
leaq 0x7(%rsp), %rsi
movb $0x22, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x21c0
leaq 0x28(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x21f0
movq 0x4fc7(%rip), %rsi      # 0x7fb8
leaq 0x10(%rsp), %rdi
callq 0x2120
leaq 0x90(%rsp), %rdi
callq 0x2070
movq 0x8(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3021
movq %rax, %rbx
movq 0x4f8d(%rip), %rsi      # 0x7fb8
leaq 0x10(%rsp), %rdi
callq 0x2120
leaq 0x90(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]minijson/./minijson.h
// Function: minijson::value::value(minijson::value const&)
value(const value& v) : t(v.t), u() {
    if (t == array_type) {
      u.a = new array();
      *u.a = *v.u.a;
    } else if (t == object_type) {
      u.o = new object();
      *u.o = *v.u.o;
    } else if (t == string_type) {
      u.s = new string();
      *u.s = *v.u.s;
    } else
      u.d = v.u.d;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
movl %eax, (%rdi)
movq $0x0, 0x8(%rdi)
cmpl $0x4, %eax
je 0x3215
cmpl $0x6, %eax
je 0x31d2
cmpl $0x5, %eax
jne 0x3249
movl $0x18, %edi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x325c
movl $0x30, %edi
callq 0x2180
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, (%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x35f2
movl $0x20, %edi
callq 0x2180
leaq 0x10(%rax), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq 0x8(%rbx), %rsi
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20c0
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]minijson/./minijson.h
// Function: minijson::value::operator=(minijson::value const&)
const value& operator=(const value& v) {
    t = v.t;
    if (t == array_type) {
      u.a = new array(*v.u.a);
    } else if (t == object_type) {
      u.o = new object(*v.u.o);
    } else if (t == string_type) {
      u.s = new string(*v.u.s);
    } else u.d = v.u.d;
    return *this;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
movl %eax, (%rdi)
cmpl $0x4, %eax
je 0x346c
cmpl $0x6, %eax
je 0x3451
cmpl $0x5, %eax
jne 0x349c
movl $0x18, %edi
callq 0x2180
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x304a
jmp 0x3496
movl $0x30, %edi
callq 0x2180
movq %rax, %r15
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x3956
jmp 0x3496
movl $0x20, %edi
callq 0x2180
movq %rax, %r15
movq 0x8(%r14), %rax
leaq 0x10(%r15), %rcx
movq %rcx, (%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x34dc
movq %r15, 0x8(%rbx)
jmp 0x34a7
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x18, %esi
jmp 0x34cc
movq %rax, %rbx
movl $0x20, %esi
jmp 0x34cc
movq %rax, %rbx
movl $0x30, %esi
movq %r15, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]minijson/./minijson.h
// Function: minijson::error minijson::parse_any<char const*>(char const*&, minijson::value&)
inline error
parse_any(Iter& i, value& v) {
  _MINIJSON_SKIP(i);
  if (*i == '\x7b') return parse_object(i, v);
  if (*i == '[') return parse_array(i, v);
  if (*i == 't' || *i == 'f') return parse_boolean(i, v);
  if (*i == 'n') return parse_null(i, v);
  if ('0' <= *i && *i <= '9') return parse_number(i, v);
  if (*i == '"') return parse_string(i, v);
  return invalid_token_error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r12
movb (%r12), %r13b
testb %r13b, %r13b
je 0x3bf5
leaq 0x1527(%rip), %r15      # 0x50f1
movsbl %r13b, %esi
movl $0x5, %edx
movq %r15, %rdi
callq 0x21b0
testq %rax, %rax
je 0x3c3e
leaq 0x1(%r12), %rax
movq %rax, (%rbx)
movb 0x1(%r12), %r13b
movq %rax, %r12
testb %r13b, %r13b
jne 0x3bca
leal -0x30(%r13), %eax
cmpb $0x9, %al
ja 0x3c16
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4186
movl $0x2, %ebp
cmpb $0x22, %r13b
jne 0x3d55
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x42e1
movzbl %r13b, %eax
cmpl $0x6d, %eax
jle 0x3c6f
cmpl $0x6e, %eax
je 0x3c7e
cmpl $0x74, %eax
je 0x3cb3
cmpl $0x7b, %eax
jne 0x3bf5
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d66
cmpl $0x5b, %eax
je 0x3cd4
cmpl $0x66, %eax
je 0x3cf3
jmp 0x3bf5
cmpb $0x75, 0x1(%r12)
jne 0x3d2b
cmpb $0x6c, 0x2(%r12)
jne 0x3d2b
cmpb $0x6c, 0x3(%r12)
jne 0x3d2b
leaq 0x4(%r12), %rax
movq %rax, (%rbx)
movl $0x1, (%r14)
jmp 0x3d2b
cmpb $0x72, 0x1(%r12)
jne 0x3ced
cmpb $0x75, 0x2(%r12)
jne 0x3ced
cmpb $0x65, 0x3(%r12)
jne 0x3ced
movb $0x1, %al
movl $0x4, %ecx
jmp 0x3d1a
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3fcf
cmpb $0x66, %r13b
jne 0x3d2b
cmpb $0x61, 0x1(%r12)
jne 0x3d2b
cmpb $0x6c, 0x2(%r12)
jne 0x3d2b
cmpb $0x73, 0x3(%r12)
jne 0x3d2b
cmpb $0x65, 0x4(%r12)
jne 0x3d2b
movl $0x5, %ecx
xorl %eax, %eax
addq %r12, %rcx
movq %rcx, (%rbx)
movl $0x2, (%r14)
movb %al, 0x8(%r14)
movq (%rbx), %rax
movsbl (%rax), %esi
xorl %ebp, %ebp
testl %esi, %esi
je 0x3d55
leaq 0x1483(%rip), %rdi      # 0x51c1
movl $0x8, %edx
callq 0x21b0
testq %rax, %rax
jne 0x3d55
movq %r12, (%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]minijson/./minijson.h
// Function: minijson::error minijson::parse_array<char const*>(char const*&, minijson::value&)
inline error
parse_array(Iter& i, value& v) {
  array a;
  i++;
  _MINIJSON_SKIP(i);
  if (*i != ']') {
    while (*i) {
      value va;
      error e = parse_any(i, va);
      if (e != no_error) return e;
      a.push_back(va);
      _MINIJSON_SKIP(i);
      if (*i == ']') break;
      if (*i != ',') return invalid_token_error;
      i++;
      _MINIJSON_SKIP(i);
#ifdef __MINIJSON_LIBERAL
      if (*i == '\x7d') break;
#endif
    }
  }
  v = value(a);
  i++;
  return no_error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, 0x40(%rsp)
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq (%rdi), %r14
incq %r14
leaq 0x10ee(%rip), %r15      # 0x50f1
movq %r14, (%rbx)
movsbl (%r14), %ebp
testl %ebp, %ebp
je 0x402f
movl $0x5, %edx
movq %r15, %rdi
movl %ebp, %esi
callq 0x21b0
incq %r14
testq %rax, %rax
jne 0x4003
cmpb $0x5d, %bpl
je 0x4118
leaq 0x10(%rsp), %r15
leaq 0x10b6(%rip), %r13      # 0x50f1
movq (%rbx), %rax
cmpb $0x0, (%rax)
je 0x4118
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ba6
movl $0x1, %r14d
testl %eax, %eax
je 0x4074
movl %eax, %ebp
jmp 0x4101
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x4916
movl %ebp, 0xc(%rsp)
movq (%rbx), %r12
movb (%r12), %bpl
testb %bpl, %bpl
je 0x40f0
incq %r12
movsbl %bpl, %esi
movl $0x5, %edx
movq %r13, %rdi
callq 0x21b0
testq %rax, %rax
je 0x40bb
movq %r12, (%rbx)
movb (%r12), %bpl
incq %r12
testb %bpl, %bpl
jne 0x4094
jmp 0x40f0
cmpb $0x5d, %bpl
je 0x40f7
movzbl %bpl, %eax
cmpl $0x2c, %eax
jne 0x40f0
movq %r12, (%rbx)
movsbl (%r12), %esi
xorl %r14d, %r14d
testl %esi, %esi
je 0x40fd
movl $0x5, %edx
movq %r13, %rdi
callq 0x21b0
incq %r12
testq %rax, %rax
jne 0x40ca
jmp 0x40fd
movl $0x2, %ebp
jmp 0x4101
movl $0x5, %r14d
movl 0xc(%rsp), %ebp
movq %r15, %rdi
callq 0x298e
testl %r14d, %r14d
je 0x403b
cmpl $0x5, %r14d
jne 0x4145
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4942
leaq 0x10(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x3418
leaq 0x10(%rsp), %rdi
callq 0x298e
incq (%rbx)
xorl %ebp, %ebp
leaq 0x20(%rsp), %rdi
callq 0x2dfa
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4167
movq %rax, %rbx
jmp 0x4174
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x298e
leaq 0x20(%rsp), %rdi
callq 0x2dfa
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]minijson/./minijson.h
// Function: minijson::error minijson::parse_number<char const*>(char const*&, minijson::value&)
inline error
parse_number(Iter& i, value& v) {
  Iter p = i;

#define _IS_NUM(x)  ('0' <= x && x <= '9')
#define _IS_ALNUM(x)  (('0' <= x && x <= '9') || ('a' <= x && x <= 'f') || ('A' <= x && x <= 'F'))
  if (*i == '0' && *(i + 1) == 'x' && _IS_ALNUM(*(i+2))) {
    i += 3;
    while (_IS_ALNUM(*i)) i++;
    v = (number) strtod(p, nullptr);
  } else {
    while (_IS_NUM(*i)) i++;
    if (*i == '.') {
      i++;
      if (!_IS_NUM(*i)) {
        i = p;
        return invalid_token_error;
      }
      while (_IS_NUM(*i)) i++;
    }
    if (*i == 'e') {
      i++;
      if (!_IS_NUM(*i)) {
        i = p;
        return invalid_token_error;
      }
      while (_IS_NUM(*i)) i++;
    }
    v = (number) strtod(p, nullptr);
  }
  if (*i && nullptr == strchr(":,\x7d]\r\n ", *i)) {
    i = p;
    return invalid_token_error;
  }
  return no_error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r14
cmpb $0x30, (%r14)
jne 0x41fb
cmpb $0x78, 0x1(%r14)
jne 0x41fb
movb 0x2(%r14), %cl
leal -0x30(%rcx), %edx
movabsq $0x3f0000003f, %rax     # imm = 0x3F0000003F
cmpb $0xa, %dl
jb 0x41cb
movzbl %cl, %ecx
addl $-0x41, %ecx
cmpl $0x25, %ecx
ja 0x41fb
btq %rcx, %rax
jae 0x41fb
leaq 0x3(%r14), %rcx
movq %rcx, (%rbx)
movb (%rcx), %dl
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x41f6
movzbl %dl, %edx
addl $-0x41, %edx
cmpl $0x25, %edx
ja 0x428f
btq %rdx, %rax
jae 0x428f
incq %rcx
jmp 0x41cf
movq (%rbx), %rax
movb (%rax), %cl
leal -0x30(%rcx), %edx
cmpb $0x9, %dl
ja 0x421e
incq %rax
movq %rax, (%rbx)
movb (%rax), %cl
leal -0x30(%rcx), %edx
incq %rax
cmpb $0xa, %dl
jb 0x420b
decq %rax
cmpb $0x2e, %cl
jne 0x4257
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb 0x1(%rax), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x42c9
movq (%rbx), %rax
movb (%rax), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x4257
incq %rax
movq %rax, (%rbx)
movb (%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x4247
movq (%rbx), %rax
cmpb $0x65, (%rax)
jne 0x428f
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movb 0x1(%rax), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x42c9
movq (%rbx), %rax
movb (%rax), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0x428f
incq %rax
movq %rax, (%rbx)
movb (%rax), %cl
addb $-0x30, %cl
incq %rax
cmpb $0xa, %cl
jb 0x427f
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
callq 0x2130
movl $0x3, (%r15)
movsd %xmm0, 0x8(%r15)
movq (%rbx), %rax
movsbl (%rax), %esi
testl %esi, %esi
je 0x42d2
leaq 0xf07(%rip), %rdi       # 0x51c1
movl $0x8, %edx
callq 0x21b0
testq %rax, %rax
jne 0x42d2
movq %r14, (%rbx)
movl $0x2, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mattn[P]minijson/./minijson.h
// Function: minijson::error minijson::parse_string<char const*>(char const*&, minijson::value&)
inline error
parse_string(Iter& i, value& v) {
  if (*i != '"') return invalid_token_error;

  char t = *i++;
  Iter p = i;
  std::stringstream ss;
  
  while (*i && *i != t) {
    if (*i == '\\' && *(i+1)) {
      i++;
      if (*i == 'n') ss << "\n";
      else if (*i == 'r') ss << "\r";
      else if (*i == 't') ss << "\t";
      else ss << *i;
    } else {
      ss << *i;
    }
    i++;
  }
  if (!*i) return invalid_token_error;
  v = std::string(p, i-p);
  i++;
  if (*i && nullptr == strchr(":,\x7d]\r\n ", *i)) {
    i = p;
    return invalid_token_error;
  }
  return no_error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq (%rdi), %rax
movl $0x2, %ebp
cmpb $0x22, (%rax)
jne 0x4470
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq %rcx, (%rdi)
movb (%rax), %bpl
leaq 0x30(%rsp), %rdi
callq 0x2100
movq (%rbx), %rdx
movb (%rdx), %al
testb %al, %al
sete %cl
cmpb %bpl, %al
sete %sil
orb %cl, %sil
jne 0x43d8
leaq 0x40(%rsp), %r12
leaq 0xe81(%rip), %r14       # 0x51c9
leaq 0x8(%rsp), %r13
cmpb $0x5c, %al
jne 0x437b
cmpb $0x0, 0x1(%rdx)
je 0x437b
incq %rdx
movq %rdx, (%rbx)
movzbl (%rdx), %eax
cmpl $0x74, %eax
je 0x4391
movq %r14, %rsi
cmpl $0x72, %eax
je 0x4398
cmpl $0x6e, %eax
jne 0x43a7
leaq 0xd71(%rip), %rsi       # 0x50ea
jmp 0x4398
movb %al, 0x8(%rsp)
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x21c0
jmp 0x43bb
leaq 0xd5c(%rip), %rsi       # 0x50f4
movl $0x1, %edx
movq %r12, %rdi
callq 0x21c0
jmp 0x43bb
movb %al, 0x8(%rsp)
movl $0x1, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x21c0
movq (%rbx), %rax
leaq 0x1(%rax), %rdx
movq %rdx, (%rbx)
movb 0x1(%rax), %al
testb %al, %al
sete %cl
je 0x43d8
cmpb %bpl, %al
jne 0x434d
movl $0x2, %ebp
testb %cl, %cl
jne 0x4452
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8(%rsp), %rdi
movq 0x28(%rsp), %r12
movq %r12, %rsi
callq 0x3b16
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x4bba
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4420
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
movq (%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%rbx)
movsbl 0x1(%rax), %esi
xorl %ebp, %ebp
testl %esi, %esi
je 0x4452
leaq 0xd86(%rip), %rdi       # 0x51c1
movl $0x8, %edx
callq 0x21b0
testq %rax, %rax
jne 0x4452
movq %r12, (%rbx)
movl $0x2, %ebp
movq 0x3b5f(%rip), %rsi      # 0x7fb8
leaq 0x30(%rsp), %rdi
callq 0x2120
leaq 0xb0(%rsp), %rdi
callq 0x2070
movl %ebp, %eax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x44a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2190
jmp 0x44a5
jmp 0x44a2
movq %rax, %rbx
movq 0x3b0c(%rip), %rsi      # 0x7fb8
leaq 0x30(%rsp), %rdi
callq 0x2120
leaq 0xb0(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/tdv[P]boss/boss/examples/simple_object/main.cpp
// Function: main
int main()
{
  try
  {
    Boss::RefObjPtr<MyNs::ISimpleObject> Inst = Boss::Base<MyNs::SimpleObject>::Create();
    Inst->HelloWorld();
  }
  catch (std::exception const &e)
  {
    std::cerr << "Error: " << e.what() << std::endl;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rdi
callq 0x1613a
movq 0x8(%rsp), %rax
leaq 0x8(%rax), %r15
testq %rax, %rax
cmoveq %rax, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x161ca
movq %rdx, %r14
movq %rax, %rbx
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
jmp 0x160d5
jmp 0x160b4
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x1612d
movq %rbx, %rdi
callq 0x16740
movq %rax, %rbx
leaq 0xdf1f3(%rip), %rdi     # 0xf52e0
leaq 0xa3f10(%rip), %rsi     # 0xba004
movl $0x7, %edx
callq 0x801e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0xdf1d2(%rip), %rdi     # 0xf52e0
movq %rax, %rsi
callq 0x80710
movq %rax, %rdi
callq 0x7fff0
callq 0x167b0
jmp 0x160a8
movq %rax, %rbx
callq 0x167b0
movq %rbx, %rdi
callq 0xb70c0
jmp 0x160b4
// File: /workspace/github_cpp_makefile_star2_O1/haught[P]cws_plugin/cws_plugin.cpp
// Function: split[abi:cxx11](char const*, char const*)
std::vector<std::string> split(const char *s, const char *delim)
{
	std::vector<std::string> result;
	if (s && strlen(s))
	{
		int len = strlen(s);
		char *src = new char[len + 1];
		strcpy(src, s);
		src[len] = '\0';
		char *tokenptr = strtok(src, delim);
		while (tokenptr != NULL)
		{
			std::string tk = tokenptr;
			result.emplace_back(tk);
			tokenptr = strtok(NULL, delim);
		}
		delete[] src;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rsi, %rsi
je 0x263f
movq %rdx, %r14
movq %rsi, %r12
movq %rsi, %rdi
callq 0x2110
testq %rax, %rax
je 0x263f
movq %rax, %r13
shlq $0x20, %r13
movabsq $0x100000000, %rdi      # imm = 0x100000000
addq %r13, %rdi
sarq $0x20, %rdi
callq 0x2030
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0x21d0
sarq $0x20, %r13
movb $0x0, (%r15,%r13)
movq %r15, -0x30(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2300
testq %rax, %rax
je 0x2636
movq %rax, %r13
leaq -0x40(%rbp), %r15
leaq -0x50(%rbp), %r12
movq %r15, -0x50(%rbp)
movq %r13, %rdi
callq 0x2110
leaq (%rax,%r13), %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x7388
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7064
xorl %edi, %edi
movq %r14, %rsi
callq 0x2300
movq %rax, %r13
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x2631
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
testq %r13, %r13
jne 0x25e9
movq -0x30(%rbp), %rdi
callq 0x2260
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2653
movq %rax, %r14
jmp 0x2670
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x2670
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2210
movq %rbx, %rdi
callq 0x70b4
movq %r14, %rdi
callq 0x2380
// File: /workspace/github_cpp_makefile_star2_O1/ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::remove(node<int>*, int)
node< itemType >* AVLTree< itemType >::remove( node< itemType > *root , itemType target ) {
	if ( root == nullptr ) return nullptr;

	if ( root->getData() == target ) { // target found
		if ( root->isLeaf() ) { // no children
			delete root;
			root = nullptr;
			return root;
		}
		else {
			itemType returnValue;
			node< itemType > *temp = this->findSmallestNodeHelper( root , returnValue );

			if ( temp == nullptr ) { // no smallest node found , but may have right children
				return root->getRightChild();
			}
			else { // smallest children found
				root->setLeftChild( temp );
				root->setData( returnValue );
				if ( root->unbalanced() ) this->doRotation( root );
				return root;
			}
		}
	}

	else if ( root->getData() > target ) root->setLeftChild( this->remove( root->getLeftChild() , target ) );
	else if ( root->getData() < target ) root->setRightChild( this->remove( root->getRightChild() , target ) );

	if ( root->unbalanced() ) this->doRotation( root );
	root->setHeight( root->getMaxHeight() );
	return root;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x1cf9
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %eax
cmpl %edx, %eax
jne 0x1d00
movq 0x10(%r14), %rax
orq 0x8(%r14), %rax
jne 0x1d8b
movl $0x20, %esi
movq %r14, %rdi
callq 0x10f0
movq $0x0, (%rsp)
xorl %eax, %eax
jmp 0x1de7
movl $0x8, %r15d
jg 0x1d10
movl $0x10, %r15d
jge 0x1d20
movq (%r14,%r15), %rsi
movq %rbx, %rdi
callq 0x1cb8
movq %rax, (%r14,%r15)
movq (%rsp), %rdx
movq 0x8(%rdx), %rsi
xorl %ecx, %ecx
movl $0x0, %eax
testq %rsi, %rsi
je 0x1d37
movl 0x18(%rsi), %eax
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0x1d43
movl 0x18(%rdx), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x2, %ecx
jb 0x1d5c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1b26
movq (%rsp), %rax
movq 0x8(%rax), %rsi
xorl %ecx, %ecx
movl $0x0, %edx
testq %rsi, %rsi
je 0x1d73
movl 0x18(%rsi), %edx
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x1d7f
movl 0x18(%rsi), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, 0x18(%rax)
jmp 0x1de7
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1df2
movq (%rsp), %r14
testq %rax, %rax
je 0x1dc0
movq %rax, 0x8(%r14)
movl 0xc(%rsp), %ecx
movl %ecx, (%r14)
movl 0x18(%rax), %eax
movq 0x10(%r14), %rcx
testq %rcx, %rcx
je 0x1dc6
movl 0x18(%rcx), %ecx
jmp 0x1dc8
addq $0x10, %r14
jmp 0x1de4
xorl %ecx, %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movq %rsp, %r14
cmpl $0x2, %ecx
jb 0x1de4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b26
movq (%r14), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::findSmallestNodeHelper(node<int>*, int&)
node< itemType >* AVLTree< itemType >::findSmallestNodeHelper( node< itemType > *root , itemType &returnValue ) {
	root = root->getLeftChild();

	if ( root == nullptr ); // no smallest node found;
	else { // smallest node found
		itemType first = root->getData() , second = 0x3f3f3f3f;
		node< itemType > *temp = this->findSmallestNode( root->getRightChild() , second );

		root->setRightChild( temp );

		returnValue = first > second ? first : second;

		if ( root->unbalanced() ) this->doRotation( root );
		root->setHeight( root->getMaxHeight() );
	}
	return root;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1eab
movq %rdx, %r14
movq %rdi, %rbx
movl (%rax), %ebp
leaq 0x14(%rsp), %r15
movl $0x3f3f3f3f, (%r15)     # imm = 0x3F3F3F3F
movq 0x10(%rax), %rsi
movq %r15, %rdx
callq 0x1ebc
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rcx)
movl (%r15), %edx
cmpl %edx, %ebp
cmovgl %ebp, %edx
movl %edx, (%r14)
movq 0x8(%rcx), %rsi
xorl %edx, %edx
movl $0x0, %ecx
testq %rsi, %rsi
je 0x1e5a
movl 0x18(%rsi), %ecx
testq %rax, %rax
je 0x1e62
movl 0x18(%rax), %edx
subl %edx, %ecx
movl %ecx, %eax
negl %eax
cmovsl %ecx, %eax
cmpl $0x2, %eax
jb 0x1e7d
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b26
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rsi
xorl %ecx, %ecx
movl $0x0, %edx
testq %rsi, %rsi
je 0x1e95
movl 0x18(%rsi), %edx
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x1ea1
movl 0x18(%rsi), %ecx
cmpl %ecx, %edx
cmovgl %edx, %ecx
incl %ecx
movl %ecx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::findSmallestNode(node<int>*, int&)
node< itemType >* AVLTree< itemType >::findSmallestNode( node< itemType > *root , itemType &returnValue ) {
	if ( root == nullptr ) return nullptr;

	if ( root->getRightChild() == nullptr ) {
		returnValue = root->getData();
		node< itemType > *temp = root->getLeftChild();

		delete root;
		root = nullptr;
		return temp;
	}
	root->setRightChild( this->findSmallestNode( root->getRightChild() , returnValue ) );
	if ( root != nullptr && root->unbalanced() ) this->doRotation( root );
	root->setHeight( root->getMaxHeight() );
	return root;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
testq %rsi, %rsi
je 0x1f59
movq %rsi, %r14
movq 0x10(%rsi), %rsi
testq %rsi, %rsi
je 0x1f5d
movq %rdi, %rbx
callq 0x1ebc
movq %rax, 0x10(%r14)
movq (%rsp), %rdx
testq %rdx, %rdx
je 0x1f2a
movq 0x8(%rdx), %rsi
xorl %ecx, %ecx
movl $0x0, %eax
testq %rsi, %rsi
je 0x1f05
movl 0x18(%rsi), %eax
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
je 0x1f11
movl 0x18(%rdx), %ecx
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpl $0x2, %ecx
jb 0x1f2a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1b26
movq (%rsp), %rbx
movq 0x8(%rbx), %rdx
xorl %eax, %eax
movl $0x0, %ecx
testq %rdx, %rdx
je 0x1f41
movl 0x18(%rdx), %ecx
movq 0x10(%rbx), %rdx
testq %rdx, %rdx
je 0x1f4d
movl 0x18(%rdx), %eax
cmpl %eax, %ecx
cmovgl %ecx, %eax
incl %eax
movl %eax, 0x18(%rbx)
jmp 0x1f7b
xorl %ebx, %ebx
jmp 0x1f7b
movl (%r14), %eax
movl %eax, (%rdx)
movq 0x8(%r14), %rbx
movl $0x20, %esi
movq %r14, %rdi
callq 0x10f0
movq $0x0, (%rsp)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::findPredecessor(node<int>*, int) const
itemType AVLTree< itemType >::findPredecessor( node< itemType > *root , itemType target ) const {
	if ( root == nullptr ) return INT_MIN;

	if ( root->getData() > target ) {
		return max( INT_MIN , findPredecessor( root->getLeftChild() , target ) );
	}
	else {
		return max( root->getData() , findPredecessor( root->getRightChild() , target ) );
	}
}

// Assembly:
movl $0x80000000, %eax       # imm = 0x80000000
testq %rsi, %rsi
je 0x1fa7
movl (%rsi), %ecx
cmpl %edx, %ecx
jle 0x1f9c
movq 0x8(%rsi), %rsi
jmp 0x1f8b
movq 0x10(%rsi), %rsi
cmpl %eax, %ecx
cmovgl %ecx, %eax
jmp 0x1f8b
retq
// File: /workspace/github_cpp_makefile_star2_O1/ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::inorderTraversal(node<int>*, void (*)(node<int>&, std::ostream&))
void AVLTree< itemType >::inorderTraversal( node< itemType > *root , void visit( node< itemType > &record , ostream& os ) ) {
	if ( root == nullptr ) return;
	this->inorderTraversal( root->getLeftChild() , visit );
	visit( *root , cout );
	this->inorderTraversal( root->getRightChild() , visit );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x3010(%rip), %r12      # 0x4fd0
testq %r14, %r14
je 0x1fe2
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1fa8
movq %r14, %rdi
movq %r12, %rsi
callq *%rbx
movq 0x10(%r14), %r14
jmp 0x1fc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::preorderTraversal(node<int>*, void (*)(node<int>&, std::ostream&))
void AVLTree< itemType >::preorderTraversal( node< itemType > *root , void visit( node< itemType > &record , ostream& os ) ) {
	if ( root == nullptr ) return;
	visit( *root , cout );
	this->preorderTraversal( root->getLeftChild() , visit );
	this->preorderTraversal( root->getRightChild() , visit );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2fca(%rip), %r12      # 0x4fd0
testq %r14, %r14
je 0x2028
movq %r14, %rdi
movq %r12, %rsi
callq *%rbx
movq 0x8(%r14), %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1fee
movq 0x10(%r14), %r14
jmp 0x2006
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ambersun1234[P]AVL_Tree/src/avl.h
// Function: AVLTree<int>::postorderTraversal(node<int>*, void (*)(node<int>&, std::ostream&))
void AVLTree< itemType >::postorderTraversal( node< itemType > *root , void visit( node< itemType > &record , ostream& os ) ) {
	if ( root == nullptr ) return;
	this->postorderTraversal( root->getLeftChild() , visit );
	this->postorderTraversal( root->getRightChild() , visit );
	visit( *root , cout );
}

// Assembly:
testq %rsi, %rsi
je 0x2073
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rsi
movq %rdx, %r15
callq 0x2034
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2034
movq 0x2f6a(%rip), %rsi      # 0x4fd0
movq %rbx, %rdi
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
jmpq *%rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/JMMackenzie[P]binary_to_jass/bin_to_jass_disk.cpp
// Function: read_u32(_IO_FILE*)
uint32_t read_u32(FILE* f)
{
    uint32_t x;
    size_t ret = fread(&x, sizeof(uint32_t), 1, f);
    if (feof(f)) {
        return 0;
    }
    if (ret != 1) {
        exit(EXIT_FAILURE);
    }
    return x;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x4(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
movq %r14, %rcx
callq 0x22a0
movq %rax, %rbx
movq %r14, %rdi
callq 0x22c0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x2577
cmpq $0x1, %rbx
jne 0x257f
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/JMMackenzie[P]binary_to_jass/bin_to_jass_disk.cpp
// Function: read_uint32_list(std::vector<unsigned int, std::allocator<unsigned int>>&, _IO_FILE*)
void read_uint32_list(std::vector<uint32_t>& list, FILE* f)
{
    uint32_t list_len = read_u32(f);
    list.resize(list_len);
    if (list_len != 0) {
        read_u32s(f, list.data(), list_len);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x253c
movl %eax, %ebp
movl %eax, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x4138
testl %ebp, %ebp
je 0x25f2
movq (%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2589
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/JMMackenzie[P]binary_to_jass/bin_to_jass_disk.cpp
// Function: usage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void usage(std::string program) {
  std::cerr << program << " <ds2i_prefix> <docid file> <lexicon file>"
            << "<max quantized score [256 = 8 bit quant, 512 = 9 bit quant]><q|G [QMX, EliasGammaSIMD]>\n";
  std::cerr << "e.g. " << program << " wsj wsj.documents wsj.terms 256 G\n";
  exit(EXIT_FAILURE);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5a45e(%rip), %r14     # 0x5dfe8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x55607(%rip), %rsi     # 0x591a3
movq %rax, %rdi
callq 0x21d0
leaq 0x55623(%rip), %rsi     # 0x591ce
movq %rax, %rdi
callq 0x21d0
leaq 0x5566d(%rip), %rsi     # 0x59227
movq %r14, %rdi
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21b0
leaq 0x55659(%rip), %rsi     # 0x5922d
movq %rax, %rdi
callq 0x21d0
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/JMMackenzie[P]binary_to_jass/compress_integer_elias_gamma_simd.cpp
// Function: JASS::compress_integer_elias_gamma_simd::compute_selector(unsigned char const*)
uint32_t compress_integer_elias_gamma_simd::compute_selector(const uint8_t *encodings)
		{
		uint32_t value = 0;
		int current;

		for (current = 0; current < 32; current++)
			if (encodings[current] == 0)
				break;

		/*
			Compute the permutation number
		*/
		for (current--; current >=  0; current--)
			{
			size_t number_of_0s = encodings[current];
			value <<= number_of_0s;
			value |= 1 << (number_of_0s - 1);
			}

		return value;
		}

// Assembly:
xorl %eax, %eax
cmpb $0x0, (%rdi,%rax)
je 0x57aaa
incq %rax
cmpq $0x20, %rax
jne 0x57a96
movl $0x20, %eax
testl %eax, %eax
jle 0x57aca
movl %eax, %edx
incq %rdx
xorl %eax, %eax
movb -0x2(%rdi,%rdx), %cl
shll %cl, %eax
decb %cl
btsl %ecx, %eax
decq %rdx
cmpq $0x1, %rdx
jg 0x57ab5
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JMMackenzie[P]binary_to_jass/compress_integer_elias_gamma_simd_vb.cpp
// Function: JASS::compress_integer_elias_gamma_simd_vb::decode(unsigned int*, unsigned long, void const*, unsigned long)
void compress_integer_elias_gamma_simd_vb::decode(integer *decoded, size_t integers_to_decode, const void *source_as_void, size_t source_length)
		{
		__m256i mask;
		const uint8_t *source = (const uint8_t *)source_as_void;
		size_t vb_length = *(const uint32_t *)source_as_void;
		const uint8_t *end_of_source = (const uint8_t *)source_as_void + source_length - vb_length;
		source += sizeof(uint32_t);
		__m256i *into = (__m256i *)decoded;
		uint64_t selector = 0;
		__m256i payload1;
		__m256i payload2;

		while (1)
			{
			if (selector == 0)
				{
				if (source >= end_of_source)
					break;
				selector = *(uint32_t *)source;
				payload1 = _mm256_loadu_si256((__m256i *)(source + 4));
				payload2 = _mm256_loadu_si256((__m256i *)(source + 36));
				source += 68;
				}

			uint32_t width = (uint32_t)find_first_set_bit(selector);
			mask = _mm256_loadu_si256((__m256i *)mask_set[width]);
			_mm256_storeu_si256(into, _mm256_and_si256(payload1, mask));
			_mm256_storeu_si256(into + 1, _mm256_and_si256(payload2, mask));
			payload1 = _mm256_srli_epi32(payload1, width);
			payload2 = _mm256_srli_epi32(payload2, width);

			into += 2;
			selector >>= width;
			}

		if (vb_length != 0)
			compress_integer_variable_byte::decode((integer *)into, vb_length, source, vb_length);
		}

// Assembly:
movq %rcx, %rax
movl (%rcx), %edx
addq %rcx, %r8
subq %rdx, %r8
addq $0x4, %rax
xorl %r10d, %r10d
leaq 0x1ee1(%rip), %r9       # 0x5a4c0
testq %r10, %r10
jne 0x585fa
cmpq %r8, %rax
jae 0x58640
movl (%rax), %r10d
vmovdqu 0x4(%rax), %ymm0
vmovdqu 0x24(%rax), %ymm1
addq $0x44, %rax
testq %r10, %r10
je 0x58605
bsfq %r10, %rcx
jmp 0x5860a
movl $0x40, %ecx
incq %rcx
vmovd %ecx, %xmm2
movl %ecx, %r11d
shll $0x6, %r11d
vmovdqa (%r11,%r9), %ymm3
vpand %ymm0, %ymm3, %ymm4
vmovdqu %ymm4, (%rsi)
vpand %ymm1, %ymm3, %ymm3
vpsrld %xmm2, %ymm0, %ymm0
vmovdqu %ymm3, 0x20(%rsi)
vpsrld %xmm2, %ymm1, %ymm1
addq $0x40, %rsi
shrq %cl, %r10
jmp 0x585df
testq %rdx, %rdx
je 0x58653
movq %rax, %rcx
movq %rdx, %r8
vzeroupper
jmp 0x58658
vzeroupper
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/JMMackenzie[P]binary_to_jass/./compress_integer_variable_byte.h
// Function: JASS::compress_integer_variable_byte::decode(unsigned int*, unsigned long, void const*, unsigned long)
static inline void static_decode(integer *decoded, size_t integers_to_decode, const void *source_as_void, size_t source_length)
				{
				const uint8_t *source = static_cast<const uint8_t *>(source_as_void);
				const uint8_t *end = source + source_length;		// compute the stopping condition

				while (source < end)
					{
					decompress_into(decoded, source);
					decoded++;
					}
				}

// Assembly:
testq %r8, %r8
jle 0x586f5
addq %rcx, %r8
movzbl (%rcx), %eax
testb %al, %al
js 0x586a8
movl %eax, (%rsi)
movzbl 0x1(%rcx), %edx
shll $0x7, %eax
testb %dl, %dl
js 0x586b2
orl %edx, %eax
movl %eax, (%rsi)
movzbl 0x2(%rcx), %edx
shll $0x7, %eax
testb %dl, %dl
js 0x586be
orl %edx, %eax
movl %eax, (%rsi)
movzbl 0x3(%rcx), %edx
shll $0x7, %eax
testb %dl, %dl
js 0x586ca
orl %edx, %eax
movl %eax, (%rsi)
movzbl 0x4(%rcx), %edx
testb %dl, %dl
js 0x586d6
addq $0x4, %rcx
jmp 0x586e8
andl $0x7f, %eax
movl $0x1, %edx
jmp 0x586e3
andl $0x7f, %edx
orl %edx, %eax
movl $0x2, %edx
jmp 0x586e3
andl $0x7f, %edx
orl %edx, %eax
movl $0x3, %edx
jmp 0x586e3
andl $0x7f, %edx
orl %edx, %eax
movl $0x4, %edx
jmp 0x586e3
shll $0x7, %eax
andl $0x7f, %edx
orl %edx, %eax
movl $0x5, %edx
movl %eax, (%rsi)
addq %rdx, %rcx
addq $0x4, %rsi
cmpq %r8, %rcx
jb 0x58664
retq