LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateStdCall(Node*, _IO_FILE*)
bool TranslateStdCall(Node* node, FILE* file)
{
    assert(node);
    assert(file);

    if (strcmp(node->left->value.name, "scan") == 0)
    {
        fprintf(file, "nepravdoi()");
        return true;
    }

    if (strcmp(node->left->value.name, "print") == 0)
    {
        fprintf(file, "govoru(");
        TranslateParams(node->right, file);
        fprintf(file, ");\n");
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x518b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x51aa
movq %rdi, %r14
movq 0x18(%rdi), %rax
movq 0x8(%rax), %r15
leaq 0x2377(%rip), %rsi      # 0x7489
movq %r15, %rdi
callq 0x2140
testl %eax, %eax
je 0x5135
leaq 0x2375(%rip), %rsi      # 0x749a
movq %r15, %rdi
callq 0x2140
testl %eax, %eax
je 0x5144
xorl %eax, %eax
jmp 0x5180
leaq 0x2352(%rip), %rdi      # 0x748e
pushq $0xb
popq %rsi
pushq $0x1
popq %rdx
jmp 0x5176
leaq 0x2355(%rip), %rdi      # 0x74a0
pushq $0x7
popq %rsi
pushq $0x1
popq %r15
movq %r15, %rdx
movq %rbx, %rcx
callq 0x21b0
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x51c9
leaq 0x22cc(%rip), %rdi      # 0x743c
pushq $0x3
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x21b0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xf4a(%rip), %rdi       # 0x60dc
leaq 0x20bb(%rip), %rsi      # 0x7254
leaq 0x22c3(%rip), %rcx      # 0x7463
movl $0xbd, %edx
callq 0x2090
leaq 0x167a(%rip), %rdi      # 0x682b
leaq 0x209c(%rip), %rsi      # 0x7254
leaq 0x22a4(%rip), %rcx      # 0x7463
movl $0xbe, %edx
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/translator.cpp
// Function: TranslateParams(Node*, _IO_FILE*)
void TranslateParams(Node* node, FILE* file)
{
    assert(file);

    if (node != nullptr)
    {
        while (node->right != nullptr)
        {
            node = node->right;
        }

        TranslateExpression(node->left, file);
        node = node->parent;

        while (node->type == ARG_TYPE)
        {
            fprintf(file, ", ");
            TranslateExpression(node->left, file);
            node = node->parent;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x5238
testq %rdi, %rdi
je 0x5229
movq %rsi, %rbx
movq %rdi, %r13
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x51e4
leaq 0x237a(%rip), %r14      # 0x7571
pushq $0x2
popq %r15
pushq $0x1
popq %r12
movq 0x18(%r13), %rdi
movq %rbx, %rsi
callq 0x4dca
movq 0x10(%r13), %r13
cmpl $0x5, (%r13)
jne 0x5229
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x21b0
jmp 0x51ff
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15ec(%rip), %rdi      # 0x682b
leaq 0x200e(%rip), %rsi      # 0x7254
leaq 0x22ff(%rip), %rcx      # 0x754c
movl $0x12e, %edx            # imm = 0x12E
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/vssense[P]Compiler/src/front-end/translator.cpp
// Function: IntToDrevniyRus(_IO_FILE*, int)
void IntToDrevniyRus(FILE* file, int number)
{
    assert(file);

    if (number == 0)
    {
        fprintf(file, "����");
        return;
    }

    bool NeededBracket = false;
    if (number < 0)
    {
        fprintf(file, "(������� - ��������) * ");
        number *= -1;
        if (number - 1 > rank)
        {
            NeededBracket = true;
        }
    }

    if (NeededBracket)
    {
        fprintf(file, "(");
    }

    for (size_t power = 0; number > 0; ++power)
    {
        int digit = number % rank;
        fprintf(file, "%s", DIGITS[digit].rus_digit);

        for (size_t i = 0; i < power; ++i)
        {
            fprintf(file, " * ���������");
        }

        if (number > rank)
        {
            fprintf(file, " + ");
        }

        number /= rank;
    }

    if (NeededBracket)
    {
        fprintf(file, ")");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x53cc
movl %esi, %r14d
movq %rdi, %rbx
testl %esi, %esi
je 0x539a
jns 0x52ef
leaq 0x22d2(%rip), %rdi      # 0x7596
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0x21b0
movl %r14d, %eax
negl %r14d
cmpl $-0xc, %eax
ja 0x52ef
pushq $0x28
popq %rdi
movq %rbx, %rsi
callq 0x2120
movb $0x1, %al
movl %eax, -0x2c(%rbp)
jmp 0x52f6
movl $0x0, -0x2c(%rbp)
movq $0x0, -0x40(%rbp)
pushq $0x1
popq %r13
leaq 0x22a5(%rip), %r15      # 0x75ae
pushq $0xc
popq %r12
testl %r14d, %r14d
je 0x537b
movl %r14d, -0x34(%rbp)
movl %r14d, %eax
xorl %edx, %edx
pushq $0xa
popq %rcx
divl %ecx
movl %eax, -0x30(%rbp)
shll $0x5, %edx
leaq 0x4933(%rip), %rax      # 0x9c60
movq (%rdx,%rax), %rdi
movq %rbx, %rsi
callq 0x20f0
movq -0x40(%rbp), %r14
subq $0x1, %r14
jb 0x5356
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x21b0
jmp 0x533d
cmpl $0xa, -0x34(%rbp)
jle 0x5371
leaq 0x2258(%rip), %rdi      # 0x75bb
pushq $0x3
popq %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x21b0
incq -0x40(%rbp)
movl -0x30(%rbp), %r14d
jmp 0x530d
cmpb $0x0, -0x2c(%rbp)
je 0x53bd
pushq $0x29
popq %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2120
leaq 0x10e8(%rip), %rdi      # 0x6489
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21b0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1458(%rip), %rdi      # 0x682b
leaq 0x1e7a(%rip), %rsi      # 0x7254
leaq 0x2193(%rip), %rcx      # 0x7574
movl $0x145, %edx            # imm = 0x145
callq 0x2090
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/order/cli.cpp
// Function: setFindAllOrders()
void setFindAllOrders() {
    skipFoundOrders = true;
    numSkipFoundOrders = 0;
    findOrders = "";

    for (int i = 0; i < ORDER_MAX; i++)
        foundOrders.push_back(true);
    for (int order : allOrders) {
        foundOrders[(size_t)order] = false;
        findOrders += std::to_string(order) +  ",";
    }
    findOrders.pop_back();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movb $0x1, 0xb1f1(%rip)      # 0x12661
andq $0x0, 0xb1d0(%rip)      # 0x12648
leaq 0xb171(%rip), %rdi      # 0x125f0
leaq 0x458b(%rip), %rsi      # 0xba11
callq 0x44c0
movl $0x4ed, %r14d           # imm = 0x4ED
leaq 0xb178(%rip), %rbx      # 0x12610
pushq $0x1
popq %rbp
subl $0x1, %r14d
jb 0x74ad
movq %rbx, %rdi
movl %ebp, %esi
callq 0x8682
jmp 0x749b
xorl %ebx, %ebx
leaq 0x8(%rsp), %r14
leaq 0x4242(%rip), %r15      # 0xb6fd
leaq 0x28(%rsp), %r12
leaq 0xb129(%rip), %r13      # 0x125f0
cmpq $0x120, %rbx            # imm = 0x120
je 0x752b
leaq 0xadc9(%rip), %rax      # 0x122a0
movl (%rbx,%rax), %eax
movslq %eax, %rbp
leaq 0xb12c(%rip), %rdi      # 0x12610
movq %rbp, %rsi
callq 0x86c0
notq %rdx
andq %rdx, (%rax)
movq %r14, %rdi
movl %ebp, %esi
callq 0x8719
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x86fa
movq %r13, %rdi
movq %r12, %rsi
callq 0x44e0
movq %r12, %rdi
callq 0x4508
movq %r14, %rdi
callq 0x4508
addq $0x4, %rbx
jmp 0x74c7
leaq 0xb0be(%rip), %rdi      # 0x125f0
callq 0x4330
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x7558
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4508
leaq 0x8(%rsp), %rdi
callq 0x4508
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/order/./SchwartzGeneratorReduce.hpp
// Function: SchwartzGeneratorReduce<AlgorithmTally, std::vector<unsigned long long, std::allocator<unsigned long long>>>::~SchwartzGeneratorReduce()
virtual ~SchwartzGeneratorReduce() {
            if (interior != NULL) {
                for (TallyType* t : *interior)
                    delete t;
                delete interior;
            }
        }

// Assembly:
leaq 0x914b(%rip), %rax      # 0x11a60
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x8984
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rax), %r12
movq 0x8(%rax), %r13
pushq $0x10
popq %r14
cmpq %r13, %r12
je 0x895f
movq (%r12), %r15
testq %r15, %r15
je 0x894e
movq %r15, %rdi
callq 0x8e1e
movq %r15, %rdi
movq %r14, %rsi
callq 0x42e0
addq $0x8, %r12
jmp 0x8938
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x8970
movq %rbx, %rdi
callq 0x8d44
pushq $0x18
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x42e0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/order/./AlgorithmTally.hpp
// Function: Algorithms::combine(AlgorithmTally const*, AlgorithmTally const*) const
virtual AlgorithmTally* combine(const AlgorithmTally* left, const AlgorithmTally* right) const {
            AlgorithmTally* at = init();
            at->algorithms->insert(at->algorithms->end(), left->algorithms->begin(), left->algorithms->end());
            at->algorithms->insert(at->algorithms->end(), right->algorithms->begin(), right->algorithms->end());
            return at;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
movq 0x8(%rax), %rdi
movq 0x8(%rdi), %rsi
movq 0x8(%r14), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x8eb6
movq 0x8(%r15), %rdi
movq 0x8(%rdi), %rsi
movq 0x8(%rbx), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
callq 0x8eb6
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/order/./AlgorithmTally.hpp
// Function: Algorithms::accum(AlgorithmTally*, unsigned long long) const
virtual void accum(AlgorithmTally* accumulator, unsigned long long int index) const {
            unsigned long long int x = accumulator->algorithm->getAlgorithmNumber();
            *(accumulator->algorithm) += (index - x);
            if (!(*(accumulator->algorithm).*re)())
                accumulator->algorithms->push_back(index);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rdx, 0x8(%rsp)
movq (%rsi), %rdi
callq 0x4c06
subq %rax, %r14
movq (%rbx), %rdi
movq %r14, %rsi
callq 0x4b00
movq (%rbx), %rdi
movq 0x28(%r15), %rax
addq 0x30(%r15), %rdi
testb $0x1, %al
je 0x8ca6
movq (%rdi), %rcx
movq -0x1(%rcx,%rax), %rax
callq *%rax
testb %al, %al
jne 0x8cba
movq 0x8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9086
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/chuckwolber[P]Cube/order/./SchwartzGeneratorReduce.hpp
// Function: SchwartzGeneratorReduce<AlgorithmTally, std::vector<unsigned long long, std::allocator<unsigned long long>>>::reduce(unsigned long)
bool reduce(size_t i) {
            if (i < n_threads - 1) {
                auto handle = std::async(std::launch::async, &SchwartzGeneratorReduce::reduce, this, right(i));
                reduce(left(i));
                handle.wait();
                interior->at(i) = combine(value(left(i)), value(right(i)));
            } else {
                TallyType* tally = init();
                unsigned long long int start = getStart(i);
                unsigned long long int end = getEnd(start);
                for (unsigned long long int j = start; j < end; ++j)
                    accum(tally, j);
                interior->at(i) = tally;
            }
            return true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
decq %rax
cmpq %rsi, %rax
jbe 0x9a93
leaq -0x2a(%rip), %rax       # 0x99d8
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
andq $0x0, 0x8(%rdx)
leaq 0x18(%rsp), %rcx
movq %r14, (%rcx)
leaq 0x2(,%rbx,2), %r15
leaq 0x10(%rsp), %r8
movq %r15, (%r8)
movq %rsp, %rdi
pushq $0x1
popq %rsi
callq 0x9b17
leaq 0x1(,%rbx,2), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x99d8
movq %rsp, %rdi
callq 0x9c36
movq %r14, %rdi
movq %r12, %rsi
callq 0x9b08
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x9b08
movq (%r14), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq *0x18(%rcx)
movq %rax, %r15
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x9c48
movq %r15, (%rax)
leaq 0x8(%rsp), %rdi
callq 0xa8aa
jmp 0x9ae3
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rax, %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9c6a
movq %rax, %r12
movq %r14, %rdi
movq %rax, %rsi
callq 0x9c92
movq %rax, %r13
cmpq %r13, %r12
jae 0x9ad4
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x28(%rax)
incq %r12
jmp 0x9abb
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x9c48
movq %r15, (%rax)
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa8aa
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/tismith[P]tmp-play/church.cpp
// Function: main
int main() {
    std::cout << "AND(TRUE,TRUE) == ";
    std::cout << (typeid(AND::F<TRUE,TRUE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;

    std::cout << "AND(FALSE,TRUE) == ";
    std::cout << (typeid(AND::F<FALSE,TRUE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;

    std::cout << "OR(FALSE,TRUE) == ";
    std::cout << (typeid(OR::F<FALSE,TRUE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;

#if 0
    std::cout << "NOT(TRUE) == ";
    std::cout << (typeid(NOT::F<TRUE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;

    std::cout << "NOT(FALSE) == ";
    std::cout << (typeid(NOT::F<FALSE>::TYPE) == typeid(TRUE)); 
    std::cout << std::endl;
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x2e11(%rip), %rbx      # 0x3fd8
leaq 0xe36(%rip), %rsi       # 0x2004
movq %rbx, %rdi
callq 0x1050
leaq 0x2bbb(%rip), %r14      # 0x3d98
movq %r14, %rdi
movq %r14, %rsi
callq 0x1264
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1080
movq %rbx, %rdi
callq 0x1030
leaq 0xe15(%rip), %rsi       # 0x2017
movq %rbx, %rdi
callq 0x1050
leaq 0x2b97(%rip), %rdi      # 0x3da8
movq %r14, %rsi
callq 0x1264
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1080
movq %rbx, %rdi
callq 0x1030
leaq 0xdf8(%rip), %rsi       # 0x202b
movq %rbx, %rdi
callq 0x1050
movq %r14, %rdi
movq %r14, %rsi
callq 0x1264
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1080
movq %rbx, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CRangeDecoder::Init()
bool CRangeDecoder::Init()
{
  Corrupted = false;
  Range = 0xFFFFFFFF;
  Code = 0;
  Perplexity = 0.f;

  Byte b = InStream->ReadByte();

  for (int i = 0; i < 4; i++)
    Code = (Code << 8) | InStream->ReadByte();

  if (b != 0 || Code == Range)
    Corrupted = true;
  return b == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, (%rdi)
andl $0x0, 0x14(%rdi)
movq 0x8(%rdi), %rdi
callq 0x3400
movl %eax, %r14d
pushq $0x4
popq %r15
subl $0x1, %r15d
jb 0x245c
movl 0x4(%rbx), %r12d
shll $0x8, %r12d
movq 0x8(%rbx), %rdi
callq 0x3400
movzbl %al, %eax
orl %r12d, %eax
movl %eax, 0x4(%rbx)
jmp 0x243a
testb %r14b, %r14b
jne 0x2468
movl 0x4(%rbx), %eax
cmpl (%rbx), %eax
jne 0x246c
movb $0x1, 0x10(%rbx)
testb %r14b, %r14b
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CRangeDecoder::DecodeDirectBits(unsigned int)
UInt32 CRangeDecoder::DecodeDirectBits(unsigned numBits)
{
  Perplexity += numBits;
  UInt32 res = 0;
  do
  {
    Range >>= 1;
    Code -= Range;
    UInt32 t = 0 - ((UInt32)Code >> 31);
    Code += Range & t;

    if (Code == Range)
      Corrupted = true;

    Normalize();
    res <<= 1;
    res += t + 1;
  }
  while (--numBits);
  return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
cvtsi2ss %rax, %xmm0
addss 0x14(%rdi), %xmm0
movss %xmm0, 0x14(%rdi)
xorl %r15d, %r15d
movl (%r14), %eax
movl 0x4(%r14), %ecx
shrl %eax
movl %eax, (%r14)
subl %eax, %ecx
movl %ecx, %r12d
sarl $0x1f, %r12d
movl %r12d, %edx
andl %eax, %edx
addl %ecx, %edx
movl %edx, 0x4(%r14)
cmpl %eax, %edx
jne 0x2501
movb $0x1, 0x10(%r14)
movq %r14, %rdi
callq 0x247c
leal (%r12,%r15,2), %r15d
incl %r15d
decl %ebx
jne 0x24d8
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CRangeDecoder::DecodeBit(unsigned short*)
unsigned CRangeDecoder::DecodeBit(CProb *prob)
{
  unsigned v = *prob;
  UInt32 bound = (Range >> kNumBitModelTotalBits) * v;
  unsigned symbol;
  if (Code < bound)
  {
    Perplexity += -log2(v/2048.f);
    v += ((1 << kNumBitModelTotalBits) - v) >> kNumMoveBits;
    Range = bound;
    symbol = 0;
  }
  else
  {
    Perplexity += -log2(1.f-v/2048.f);
    v -= v >> kNumMoveBits;
    Code -= bound;
    Range -= bound;
    symbol = 1;
  }
  *prob = (CProb)v;
  Normalize();
  return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movzwl (%rsi), %r13d
movl (%rdi), %r12d
shrl $0xb, %r12d
imull %r13d, %r12d
cvtsi2ss %r13d, %xmm0
mulss 0x3ab4(%rip), %xmm0     # 0x6004
cmpl %r12d, 0x4(%rdi)
jae 0x257c
callq 0x21b0
movss 0x14(%rbx), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
movl $0x800, %eax            # imm = 0x800
subl %r13d, %eax
shrl $0x5, %eax
addl %r13d, %eax
xorl %r15d, %r15d
jmp 0x25ba
movss 0x3a84(%rip), %xmm1     # 0x6008
subss %xmm0, %xmm1
movaps %xmm1, %xmm0
callq 0x21b0
movss 0x14(%rbx), %xmm1
subss %xmm0, %xmm1
movss %xmm1, 0x14(%rbx)
movl %r13d, %eax
shrl $0x5, %eax
subl %eax, %r13d
subl %r12d, 0x4(%rbx)
movl (%rbx), %eax
subl %r12d, %eax
pushq $0x1
popq %r15
movl %eax, %r12d
movl %r13d, %eax
movl %r12d, (%rbx)
movw %ax, (%r14)
movq %rbx, %rdi
callq 0x247c
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: BitTreeReverseDecode(unsigned short*, unsigned int, CRangeDecoder*)
unsigned BitTreeReverseDecode(CProb *probs, unsigned numBits, CRangeDecoder *rc)
{
  unsigned m = 1;
  unsigned symbol = 0;
  for (unsigned i = 0; i < numBits; i++)
  {
    unsigned bit = rc->DecodeBit(&probs[m]);
    m <<= 1;
    m += bit;
    symbol |= (bit << i);
  }
  return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movl %esi, %r14d
movq %rdi, %r15
pushq $0x1
popq %rbx
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpl %r13d, %r14d
je 0x2623
movl %ebx, %eax
leaq (%r15,%rax,2), %rsi
movq -0x30(%rbp), %rdi
callq 0x2520
leal (%rax,%rbx,2), %ebx
movl %r13d, %ecx
shll %cl, %eax
orl %r12d, %eax
incl %r13d
movl %eax, %r12d
jmp 0x25fc
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CInputStream::ReadByte()
Byte ReadByte()
  {
    int c = getc(File);
    if (c < 0)
      throw "Unexpected end of file";
    Processed++;
    return (Byte)c;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2050
testl %eax, %eax
js 0x3420
incq 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x20a0
leaq 0x2cc0(%rip), %rcx      # 0x60ef
movq %rcx, (%rax)
movq 0x5b87(%rip), %rsi      # 0x8fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLzmaDecoder::Init()
void Init()
  {
    InitLiterals();
    InitDist();

    INIT_PROBS(IsMatch);
    INIT_PROBS(IsRep);
    INIT_PROBS(IsRepG0);
    INIT_PROBS(IsRepG1);
    INIT_PROBS(IsRepG2);
    INIT_PROBS(IsRep0Long);

    LenDecoder.Init();
    RepLenDecoder.Init();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x39dc
movq %rbx, %rdi
callq 0x3a0e
xorl %eax, %eax
cmpq $0xc0, %rax
je 0x3473
movw $0x400, 0x3ae(%rbx,%rax,2) # imm = 0x400
incq %rax
jmp 0x345c
xorl %eax, %eax
cmpq $0xc, %rax
je 0x348a
movw $0x400, 0x52e(%rbx,%rax,2) # imm = 0x400
incq %rax
jmp 0x3475
xorl %eax, %eax
cmpq $0xc, %rax
je 0x34a1
movw $0x400, 0x546(%rbx,%rax,2) # imm = 0x400
incq %rax
jmp 0x348c
xorl %eax, %eax
cmpq $0xc, %rax
je 0x34b8
movw $0x400, 0x55e(%rbx,%rax,2) # imm = 0x400
incq %rax
jmp 0x34a3
xorl %eax, %eax
cmpq $0xc, %rax
je 0x34cf
movw $0x400, 0x576(%rbx,%rax,2) # imm = 0x400
incq %rax
jmp 0x34ba
xorl %eax, %eax
cmpq $0xc0, %rax
je 0x34e8
movw $0x400, 0x58e(%rbx,%rax,2) # imm = 0x400
incq %rax
jmp 0x34d1
leaq 0x70e(%rbx), %rdi
callq 0x3a6c
addq $0xb12, %rbx            # imm = 0xB12
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3a6c
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: COutWindow::PutByte(unsigned char)
void PutByte(Byte b)
  {
    TotalPos++;
    Buf[Pos++] = b;
    if (Pos == Size)
    {
      Pos = 0;
      IsFull = true;
    }
    OutStream.WriteByte(b);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
incl 0x14(%rdi)
movq (%rdi), %rax
movl 0x8(%rdi), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x8(%rdi)
movb %sil, (%rax,%rcx)
movl 0x8(%rdi), %eax
cmpl 0xc(%rdi), %eax
jne 0x36fb
andl $0x0, 0x8(%rdi)
movb $0x1, 0x10(%rdi)
addq $0x18, %rdi
movzbl %sil, %esi
popq %rbp
jmp 0x3cec
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLenDecoder::Decode(CRangeDecoder*, unsigned int)
unsigned Decode(CRangeDecoder *rc, unsigned posState)
  {
    if (rc->DecodeBit(&Choice) == 0)
      return LowCoder[posState].Decode(rc);
    if (rc->DecodeBit(&Choice2) == 0)
      return 8 + MidCoder[posState].Decode(rc);
    return 16 + HighCoder.Decode(rc);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x2520
testl %eax, %eax
je 0x3753
leaq 0x2(%r14), %rsi
movq %rbx, %rdi
callq 0x2520
testl %eax, %eax
je 0x3774
addq $0x204, %r14            # imm = 0x204
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ebe
addl $0x10, %eax
jmp 0x3791
movl %r15d, %eax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0x4, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3e7e
movl %r15d, %eax
shlq $0x4, %rax
leaq (%r14,%rax), %rdi
addq $0x104, %rdi            # imm = 0x104
movq %rbx, %rsi
callq 0x3e7e
addl $0x8, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLzmaDecoder::DecodeDistance(unsigned int)
unsigned DecodeDistance(unsigned len)
  {
    unsigned lenState = len;
    if (lenState > kNumLenToPosStates - 1)
      lenState = kNumLenToPosStates - 1;

    unsigned posSlot = PosSlotDecoder[lenState].Decode(&RangeDec);
    if (posSlot < 4)
      return posSlot;

    unsigned numDirectBits = (unsigned)((posSlot >> 1) - 1);
    UInt32 dist = ((2 | (posSlot & 1)) << numDirectBits);
    if (posSlot < kEndPosModelIndex)
      dist += BitTreeReverseDecode(PosDecoders + dist - posSlot, numDirectBits, &RangeDec);
    else
    {
      dist += RangeDec.DecodeDirectBits(numDirectBits - kNumAlignBits) << kNumAlignBits;
      dist += AlignDecoder.ReverseDecode(&RangeDec);
    }
    return dist;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x3, %esi
pushq $0x3
popq %rax
cmovbl %esi, %eax
shll $0x7, %eax
addq %rax, %rdi
addq $0xa8, %rdi
movq %rbx, %rsi
callq 0x3f00
cmpl $0x4, %eax
jb 0x382f
movl %eax, %esi
shrl %esi
leal -0x1(%rsi), %ecx
movl %eax, %r15d
andl $0x1, %r15d
orl $0x2, %r15d
shll %cl, %r15d
cmpl $0xd, %eax
ja 0x3808
movl %r15d, %edx
leaq (%rbx,%rdx,2), %rdi
movl %eax, %eax
addq %rax, %rax
subq %rax, %rdi
addq $0x2c8, %rdi            # imm = 0x2C8
movl %ecx, %esi
movq %rbx, %rdx
callq 0x25db
jmp 0x382c
addl $-0x5, %esi
movq %rbx, %rdi
callq 0x24b4
movl %eax, %r14d
shll $0x4, %r14d
leaq 0x2a8(%rbx), %rdi
movq %rbx, %rsi
callq 0x3f40
addl %r14d, %eax
addl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLzmaDecoder::DecodeProperties(unsigned char const*)
void DecodeProperties(const Byte *properties)
  {
    unsigned d = properties[0];
    if (d >= (9 * 5 * 5))
      throw "Incorrect LZMA properties";
    lc = d % 9;
    d /= 9;
    pb = d / 5;
    lp = d % 5;
    dictSizeInProperties = 0;
    for (int i = 0; i < 4; i++)
      dictSizeInProperties |= (UInt32)properties[i + 1] << (8 * i);
    dictSize = dictSizeInProperties;
    if (dictSize < LZMA_DIC_MIN)
      dictSize = LZMA_DIC_MIN;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rsi), %al
cmpb $-0x1f, %al
jae 0x3955
movzbl %al, %ecx
movb $0x9, %dl
movl %ecx, %eax
divb %dl
movl %eax, %edx
movzbl %ah, %eax
movl %eax, 0x8c(%rdi)
movb $0x2d, %r8b
movl %ecx, %eax
divb %r8b
movzbl %al, %eax
movl %eax, 0x90(%rdi)
movzbl %dl, %eax
movb $0x5, %cl
divb %cl
movzbl %ah, %eax
movl %eax, 0x94(%rdi)
incq %rsi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, 0x9c(%rdi)
cmpq $0x20, %rcx
je 0x3940
movzbl (%rsi), %edx
shll %cl, %edx
orl %edx, %eax
addq $0x8, %rcx
incq %rsi
jmp 0x3924
cmpl $0x1001, %eax           # imm = 0x1001
movl $0x1000, %ecx           # imm = 0x1000
cmovael %eax, %ecx
movl %ecx, 0x98(%rdi)
popq %rbp
retq
pushq $0x8
popq %rdi
callq 0x20a0
leaq 0x28b3(%rip), %rcx      # 0x6217
movq %rcx, (%rax)
movq 0x5652(%rip), %rsi      # 0x8fc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x2210
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLzmaDecoder::InitDist()
void InitDist()
  {
    for (unsigned i = 0; i < kNumLenToPosStates; i++)
      PosSlotDecoder[i].Init();
    AlignDecoder.Init();
    INIT_PROBS(PosDecoders);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
xorl %r15d, %r15d
cmpq $0x200, %r15            # imm = 0x200
je 0x3a3d
leaq (%r14,%r15), %rdi
callq 0x3ab8
subq $-0x80, %r15
jmp 0x3a25
leaq 0x2a8(%rbx), %rdi
callq 0x3ad2
xorl %eax, %eax
cmpq $0x73, %rax
je 0x3a60
movw $0x400, 0x2c8(%rbx,%rax,2) # imm = 0x400
incq %rax
jmp 0x3a4b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CLenDecoder::Init()
void Init()
  {
    Choice = PROB_INIT_VAL;
    Choice2 = PROB_INIT_VAL;
    HighCoder.Init();
    for (unsigned i = 0; i < (1 << kNumPosBitsMax); i++)
    {
      LowCoder[i].Init();
      MidCoder[i].Init();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x4000400, (%rdi)      # imm = 0x4000400
addq $0x204, %rdi            # imm = 0x204
callq 0x3aec
addq $0x104, %rbx            # imm = 0x104
pushq $0x10
popq %r14
subq $0x1, %r14
jb 0x3ab3
leaq -0x100(%rbx), %rdi
callq 0x3b08
movq %rbx, %rdi
callq 0x3b08
addq $0x10, %rbx
jmp 0x3a93
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: CBitTreeDecoder<3u>::Decode(CRangeDecoder*)
unsigned Decode(CRangeDecoder *rc)
  {
    unsigned m = 1;
    for (unsigned i = 0; i < NumBits; i++)
      m = (m << 1) + rc->DecodeBit(&Probs[m]);
    return m - ((unsigned)1 << NumBits);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rbx
pushq $0x3
popq %r12
subl $0x1, %r12d
jb 0x3eaf
movl %ebx, %eax
leaq (%r15,%rax,2), %rsi
movq %r14, %rdi
callq 0x2520
leal (%rax,%rbx,2), %ebx
jmp 0x3e96
addl $-0x8, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: COutWindow::Create(unsigned int)
void Create(UInt32 dictSize)
  {
    Buf = new Byte[dictSize];
    Pos = 0;
    Size = dictSize;
    IsFull = false;
    TotalPos = 0;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %edi
callq 0x2030
movq %rax, (%r14)
andl $0x0, 0x8(%r14)
movl %ebx, 0xc(%r14)
movb $0x0, 0x10(%r14)
andl $0x0, 0x14(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: ColorGradient::createDefaultHeatMapGradient()
void createDefaultHeatMapGradient()
  {
    color.clear();
    color.push_back(ColorPoint(0, 0, 0,   0.0f));      // Blue.
    color.push_back(ColorPoint(0, 0, 1,   0.2f));     // Cyan.
    color.push_back(ColorPoint(0, 1, 0,   0.5f));      // Green.
    color.push_back(ColorPoint(1, 1, 0,   0.7f));     // Yellow.
    color.push_back(ColorPoint(1, 0, 0,   0.9f));      // Red.
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x402f
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %r14
movaps %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43d0
movaps 0x1fd4(%rip), %xmm0     # 0x6020
movups %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43d0
movaps 0x1fce(%rip), %xmm0     # 0x6030
movups %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43d0
movaps 0x1fc8(%rip), %xmm0     # 0x6040
movups %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43d0
movaps 0x1fc2(%rip), %xmm0     # 0x6050
movups %xmm0, (%r14)
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x43d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: ColorGradient::createViridisHeatMapGradient()
void createViridisHeatMapGradient()
  {
    color.clear();
    color.push_back(ColorPoint(0x44/255.f,0x02/255.f,0x55/255.f,   0.0f));
    color.push_back(ColorPoint(0x2C/255.f,0x70/255.f,0x8E/255.f,   0.33f));
    color.push_back(ColorPoint(0x3D/255.f,0xBB/255.f,0x74/255.f,   0.66f));
    color.push_back(ColorPoint(0xFA/255.f,0xE6/255.f,0x22/255.f,   1.f));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x40c3
movq %rax, 0x8(%rbx)
movaps 0x1f96(%rip), %xmm0     # 0x6060
leaq -0x20(%rbp), %r14
movups %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43d0
movaps 0x1f8c(%rip), %xmm0     # 0x6070
movups %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43d0
movaps 0x1f86(%rip), %xmm0     # 0x6080
movups %xmm0, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43d0
movaps 0x1f80(%rip), %xmm0     # 0x6090
movups %xmm0, (%r14)
leaq -0x20(%rbp), %rsi
movq %rbx, %rdi
callq 0x43d0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: ColorGradient::printScale[abi:cxx11](int)
std::string printScale(int width)
  {
    std::stringstream ss;
    for (int i = 0; i < width; i++) {
      float val = (i*1.f)/width;
      float r,g,b;
      getColorAtValue(val, r,g,b);
      ss << realcolor::fg(r,g,b) << "━";
    }
    ss << realcolor::reset;
    return ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, -0x40(%rbp)
leaq -0x1e8(%rbp), %rdi
callq 0x20d0
cvtsi2ss %r14d, %xmm0
movss %xmm0, -0x2c(%rbp)
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
leaq -0x60(%rbp), %r13
leaq 0x20c6(%rip), %rbx      # 0x6239
cmpl %r12d, %r14d
je 0x41d4
cvtsi2ss %r12d, %xmm0
divss -0x2c(%rbp), %xmm0
movq %r15, %rdi
leaq -0x38(%rbp), %rsi
leaq -0x34(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0x4568
movss -0x38(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
movss -0x30(%rbp), %xmm2
movq %r13, %rdi
callq 0x4646
leaq -0x1d8(%rbp), %rdi
movq %r13, %rsi
callq 0x2120
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2130
movq %r13, %rdi
callq 0x2080
incl %r12d
jmp 0x4173
leaq -0x1d8(%rbp), %rdi
callq 0x4373
movq -0x40(%rbp), %rbx
leaq -0x1d0(%rbp), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq -0x1e8(%rbp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4218
jmp 0x4218
movq %rax, %rbx
jmp 0x4229
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x2080
leaq -0x1e8(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/blackle[P]LZMA-Vizualizer/LzmaSpec.cpp
// Function: ColorGradient::get[abi:cxx11](float)
std::string get(const float value)
  {
    float r,g,b;
    getColorAtValue(value, r,g,b);
    std::stringstream ss;
    ss << realcolor::bg(r,g,b) << realcolor::fg(1.f-r,1.f-g,1.f-b);
    return ss.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, %rbx
leaq -0x2c(%rbp), %r14
leaq -0x28(%rbp), %r15
leaq -0x24(%rbp), %r12
movq %rsi, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x4568
leaq -0x1f8(%rbp), %rdi
callq 0x20d0
movss (%r14), %xmm0
movss (%r15), %xmm1
movss (%r12), %xmm2
leaq -0x70(%rbp), %rdi
callq 0x47ff
leaq -0x1e8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x2120
movq %rax, %r14
movss 0x1d36(%rip), %xmm2     # 0x6008
movaps %xmm2, %xmm0
subss -0x2c(%rbp), %xmm0
movaps %xmm2, %xmm1
subss -0x28(%rbp), %xmm1
subss -0x24(%rbp), %xmm2
leaq -0x50(%rbp), %rdi
callq 0x4646
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x2120
leaq -0x50(%rbp), %rdi
callq 0x2080
leaq -0x70(%rbp), %rdi
callq 0x2080
leaq -0x1e0(%rbp), %rsi
movq %rbx, %rdi
callq 0x21e0
leaq -0x1f8(%rbp), %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x435c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x2080
jmp 0x4351
jmp 0x434e
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x2080
jmp 0x435f
movq %rax, %rbx
leaq -0x1f8(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x2240
// File: /workspace/github_cpp_makefile_star2_O2/huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: Trim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Trim(string& str)
{
    string::size_type pos = str.find_last_not_of(' ');
    if(pos != string::npos)
    {
        str.erase(pos + 1);
        pos = str.find_first_not_of(' ');
        if(pos != string::npos) str.erase(0, pos);
    }
    else str.erase(str.begin(), str.end());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x20
popq %rsi
pushq $-0x1
popq %rdx
callq 0x21c0
cmpq $-0x1, %rax
je 0x261d
incq %rax
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x20b0
pushq $0x20
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2240
cmpq $-0x1, %rax
je 0x2635
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20b0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2090
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: GetBBTime[abi:cxx11]()
string GetBBTime()
{
    string ret = "";
    char buf[256];
    struct tm* local;
    time_t t;

    t = time(NULL);
    local = localtime(&t);

    sprintf(buf, "%02d:%02d:%02d", local->tm_hour, local->tm_min, local->tm_sec);
    ret += buf;

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
leaq 0x2dda(%rip), %rsi      # 0x542e
leaq -0x120(%rbp), %rdx
callq 0x28e4
xorl %edi, %edi
callq 0x2250
leaq -0x18(%rbp), %rdi
movq %rax, (%rdi)
callq 0x21f0
movl 0x8(%rax), %edx
movl (%rax), %r8d
movl 0x4(%rax), %ecx
leaq 0x2981(%rip), %rsi      # 0x5004
leaq -0x120(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x2080
movq %rbx, %rdi
movq %r14, %rsi
callq 0x23d0
movq %rbx, %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2140
movq %r14, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: DelSockFdFromSet(int)
void DelSockFdFromSet(int sockFd)
{
    if ((sockFd > 0) && (FD_ISSET(sockFd, &gReadSockFdSet)))
    {
        FD_CLR(sockFd, &gReadSockFdSet);
    }

    if ((sockFd > 0) && (FD_ISSET(sockFd, &gWriteSockFdSet)))
    {
        FD_CLR(sockFd, &gWriteSockFdSet);
    }

    while ((gMaxSockFd > 0) && (!FD_ISSET(gMaxSockFd, &gReadSockFdSet)))
    {
        gMaxSockFd--;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x7796(%rip), %rax      # 0x9eb0
testl %edi, %edi
jle 0x2760
movl %edi, %edx
shrl $0x6, %edx
movabsq $0x1, %rsi
movl %edi, %ecx
shlq %cl, %rsi
movq (%rax,%rdx,8), %r8
btq %rdi, %r8
movq %rsi, %rcx
notq %rcx
jae 0x2749
andq %rcx, %r8
movq %r8, (%rax,%rdx,8)
leaq 0x77e0(%rip), %rdi      # 0x9f30
movq (%rdi,%rdx,8), %r8
testq %rsi, %r8
je 0x2760
andq %rcx, %r8
movq %r8, (%rdi,%rdx,8)
movl 0x784a(%rip), %ecx      # 0x9fb0
testl %ecx, %ecx
jle 0x2783
movl %ecx, %edx
shrl $0x6, %edx
movq (%rax,%rdx,8), %rdx
btq %rcx, %rdx
jb 0x2783
decl %ecx
movl %ecx, 0x782f(%rip)      # 0x9fb0
jmp 0x2766
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: CloseSockFd(int)
void CloseSockFd(int sockFd)
{
    if (sockFd > 0)
    {
        gRunnerManager.DeleteRunner(sockFd);
        DelSockFdFromSet(sockFd);
        
        close(sockFd);        
    }
}

// Assembly:
testl %edi, %edi
jle 0x27b3
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leaq 0x76d8(%rip), %rdi      # 0x9e70
movl %ebx, %esi
callq 0x4574
movl %ebx, %edi
callq 0x270f
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x23e0
retq
// File: /workspace/github_cpp_makefile_star2_O2/huanghuide[P]SimpleNetworkTunnel/Common.cpp
// Function: SockSendPacket(int, char*, int)
int SockSendPacket(int sockFd, char* buf, int bufLen)
{
    int ret = -1;

    if ((sockFd > 0) && (buf != NULL) && (bufLen > 0))
    {
        int nLeft = bufLen;        
        int nSend = 0;
        int tmpRet = 0;
        int errCount = 0;

        while (nLeft > 0)
        {
            tmpRet = send(sockFd, (buf + nSend), nLeft, 0);

            if (tmpRet < 0)
            {
                if (/*(errno == EAGAIN) || */(errno == EWOULDBLOCK) || (errno == EINTR) || (errno == EINPROGRESS))
                {
                    errCount++;
                    
                    if (errCount > 5)
                    {
                        gLog.Write("SockSendPacket: error count exceeds 2 times! errno %d\n", errno);
                        break;
                    }
                    else
                    {
                        usleep(1000);
                        continue;
                    }
                }
                else
                {
                    gLog.Write("SockSendPacket: send socket error! errno %d\n", errno);
                    break;
                }
            }
            else if (tmpRet == 0)
            {
                ret = 0;
                break;
            }
            else
            {
                errCount = 0;
                
                nLeft -= tmpRet;
                nSend += tmpRet;
                ret = nSend;
            }
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
testl %edi, %edi
setle %al
testq %rsi, %rsi
sete %cl
testl %edx, %edx
setle %dl
orb %al, %dl
orb %cl, %dl
jne 0x2846
movq %rsi, %r15
movl %edi, %r12d
xorl %ecx, %ecx
pushq $-0x1
popq %rax
pushq $0x5
popq %rbx
testl %r14d, %r14d
jle 0x286c
movl %eax, -0x30(%rbp)
movl %ecx, -0x2c(%rbp)
movl %ecx, %r13d
addq %r15, %r13
movl %r14d, %r14d
movl %r12d, %edi
movq %r13, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2160
testl %eax, %eax
jns 0x2838
callq 0x2040
movl (%rax), %edx
cmpl $0x4, %edx
je 0x2827
cmpl $0x73, %edx
je 0x2827
cmpl $0xb, %edx
jne 0x2854
subl $0x1, %ebx
jb 0x284b
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2360
jmp 0x27fd
je 0x287b
subl %eax, %r14d
movl -0x2c(%rbp), %ecx
addl %eax, %ecx
movl %ecx, %eax
jmp 0x27e6
pushq $-0x1
popq %rax
jmp 0x286c
leaq 0x27c1(%rip), %rsi      # 0x5013
jmp 0x285b
leaq 0x27ef(%rip), %rsi      # 0x504a
leaq 0x7606(%rip), %rdi      # 0x9e68
xorl %eax, %eax
callq 0x360c
movl -0x30(%rbp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x286c
// File: /workspace/github_cpp_makefile_star2_O2/huanghuide[P]SimpleNetworkTunnel/InnerInitiator.cpp
// Function: InnerInitiator::SocketRead(int)
void InnerInitiator::SocketRead(int sockFd)
{
    int newSockFd = accept(mSockFd, (sockaddr*)&mAddr, (socklen_t*)&mAddrLen);

    if (newSockFd > 0)
    {
        InnerRunner* pInnerRunner = new InnerRunner();
        
        if (pInnerRunner != NULL)
        {
            pInnerRunner->SetSockFd(newSockFd);
            //printf("New INNER runner socket. newSockFd %d\n", newSockFd);
        
            AddSockFdIntoSet(newSockFd);            
            gRunnerManager.AddRunner(newSockFd, pInnerRunner);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0xc(%rdi), %eax
leaq 0x28(%rdi), %rsi
leaq 0x38(%rdi), %rdx
movl %eax, %edi
callq 0x20e0
testl %eax, %eax
jle 0x2ee8
movl %eax, %ebx
pushq $0x30
popq %rdi
callq 0x2280
movq %rax, %r14
movq %rax, %rdi
callq 0x2f10
movl %ebx, 0xc(%r14)
movl %ebx, %edi
callq 0x26c1
leaq 0x6f96(%rip), %rdi      # 0x9e70
movl %ebx, %esi
movq %r14, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x45b6
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x23a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/huanghuide[P]SimpleNetworkTunnel/InnerRunner.cpp
// Function: InnerRunner::SendPendingMsg()
void InnerRunner::SendPendingMsg()
{
    if (mSockFd > 0)
    {
        for (int index = 0; index < mSendMsg.size(); index++)
        {
        	char* msgPos = ((char*)(mSendMsg[index].c_str()));
        	int msgLen = mSendMsg[index].length();

        	char* msgBuf = new char[msgLen + 1];

        	memset(msgBuf, 0, msgLen + 1);
        	memcpy(msgBuf, msgPos, msgLen);

            //printf("INNER: Send message to client. mSockFd %d, length %d\n", mSockFd, msgLen);
            //PrintBuf(msgBuf, msgLen);

        	if ((gRoleType == MIDDLE) || (gRoleType == SERVER))
        	{
        		for (int index = 0; index < msgLen; index++)
        		{
        			msgBuf[index] = msgBuf[index] ^ SIMPLE_XOR_VALUE;
        		}
        	}

            int sendBytes = SockSendPacket(mSockFd, msgBuf, msgLen);

            if (sendBytes <= 0)
            {
            	delete [] msgBuf;
                ClearAll();

                return;
            }

            delete [] msgBuf;
        }

        mSendMsg.clear();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, 0xc(%rdi)
jle 0x30b4
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
xorl %edx, %edx
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %rdx, %rcx
jbe 0x30c3
movq %rdx, -0x38(%rbp)
movq %rdx, %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %r13
movq 0x8(%rax,%rcx), %r15
leal 0x1(%r15), %eax
movslq %eax, %r14
movq %r14, %rdi
callq 0x2030
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2190
movslq %r15d, %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2210
leaq 0x51a4(%rip), %rax      # 0x8208
movl (%rax), %eax
decl %eax
cmpl $0x1, %eax
ja 0x308a
testl %r15d, %r15d
movl $0x0, %eax
cmovgl %r15d, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x308a
xorb $-0x5b, (%r12,%rcx)
incq %rcx
jmp 0x307b
movl 0xc(%rbx), %edi
movq %r12, %rsi
movl %r15d, %edx
callq 0x27b4
movl %eax, %r14d
movq %r12, %rdi
callq 0x2320
testl %r14d, %r14d
jle 0x30da
movq -0x38(%rbp), %rdx
incq %rdx
jmp 0x3004
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq -0x30(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x32e2
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x320e
// File: /workspace/github_cpp_makefile_star2_O2/huanghuide[P]SimpleNetworkTunnel/InnerRunner.cpp
// Function: InnerRunner::SocketRead(int)
void InnerRunner::SocketRead(int sockFd)
{
    bool successFlag = false;

    char buf[MSG_LEN];
    int recvLen = 0;

    while (true)
    {
        recvLen = recv(mSockFd, buf, MSG_LEN, 0);

        if (recvLen > 0)
        {
            if (mOuterRunner == NULL)
            {
                mOuterRunner = new OuterRunner(this);
            }

        	if ((gRoleType == MIDDLE) || (gRoleType == SERVER))
        	{
        		for (int index = 0; index < recvLen; index++)
        		{
        			buf[index] = buf[index] ^ SIMPLE_XOR_VALUE;
        		}
        	}

            //printf("INNER: Receive message from client. SockFd %d, length %d\n", mSockFd, recvLen);
            //PrintBuf(buf, recvLen);
            
            ProcessDataMessage(buf, recvLen);
            successFlag = true;

            break;
        }
        else if (recvLen == 0)
        {
            // socket is closed normally
            successFlag = false;
            
            break;
        }
        else
        {
            if ((errno == EWOULDBLOCK) || (errno == EINTR) || (errno == EINPROGRESS)) 
            {
                usleep(1000);
                continue;
            }
            else 
            {
                gLog.Write("InnerRunner::SocketRead: socket closed abnormally. errno %d\n", errno);
                successFlag = false;
                
                break;
            }
        }
    }

    if (!successFlag)
    {
        ClearAll();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rdi, %rbx
leaq -0x820(%rbp), %r15
movl 0xc(%rbx), %edi
movl $0x800, %edx            # imm = 0x800
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x20f0
movq %rax, %r14
testl %r14d, %r14d
jg 0x314c
je 0x31c2
callq 0x2040
movl (%rax), %edx
cmpl $0x4, %edx
je 0x3140
cmpl $0x73, %edx
je 0x3140
cmpl $0xb, %edx
jne 0x31ad
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2360
jmp 0x310a
cmpq $0x0, 0x28(%rbx)
jne 0x316d
pushq $0x60
popq %rdi
callq 0x2280
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3cf4
movq %r15, 0x28(%rbx)
leaq 0x5094(%rip), %rax      # 0x8208
movl (%rax), %eax
decl %eax
cmpl $0x1, %eax
ja 0x3199
movl %r14d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x3199
xorb $-0x5b, -0x820(%rbp,%rcx)
incq %rcx
jmp 0x3187
leaq -0x820(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x31ee
jmp 0x31ca
leaq 0x6cb4(%rip), %rdi      # 0x9e68
leaq 0x2046(%rip), %rsi      # 0x5201
xorl %eax, %eax
callq 0x360c
movq %rbx, %rdi
callq 0x320e
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x23a0
// File: /workspace/github_cpp_makefile_star2_O2/huanghuide[P]SimpleNetworkTunnel/InnerRunner.cpp
// Function: InnerRunner::ClearAll()
void InnerRunner::ClearAll()
{
    //printf("Error! Clear all! SockFd %d\n", mSockFd);
    
    if (mOuterRunner != NULL)
    {
        delete mOuterRunner;
        mOuterRunner = NULL;
    }

    delete this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x322b
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x28(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0x8(%rax)