LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::addTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long long, unsigned long long)
std::string SymbolTable::addTable(std::string name, ull beginIndex, ull endIndex)
{
    if (isNameTaken(name))
    {
        return "second " + name + " declaration!";
    }
    if (beginIndex > endIndex)
    {
        return "wrong " + name + " table size!";
    }
    Table t;
    t.beginIndex = beginIndex;
    t.endIndex = endIndex;
    _tables[name] = t;
    return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rcx, 0x20(%rsp)
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0xc7aa
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1a4ca
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a7ab
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
je 0x1a7d6
leaq 0x1cbde(%rip), %rsi     # 0x37395
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5344
leaq 0x1cbd1(%rip), %rsi     # 0x3739d
movq %r15, %rdi
callq 0x4510
jmp 0x1a808
movq 0x20(%rsp), %r15
cmpq %r12, %r15
jbe 0x1a864
leaq 0x1cbe5(%rip), %rsi     # 0x373d0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x5344
leaq 0x1cbd7(%rip), %rsi     # 0x373d7
movq %r15, %rdi
callq 0x4510
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x1a82a
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1a830
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a8a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x1a8a1
addq $0x70, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x1b324
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
movq %r12, 0x10(%rax)
movw $0x0, 0x18(%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1c84d(%rip), %rdx     # 0x370e3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x53cc
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1a8b5
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1a8e7
movq 0x10(%rsp), %rsi
jmp 0x1a8df
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1a8e7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::checkVariableExists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string SymbolTable::checkVariableExists(std::string name)
{
    if (name.find("(") != std::string::npos)
    {
        name = name.substr(0, name.find("("));
    }

    if (! isNameTaken(name))
    {
        return "undeclared variable " + name;
    }
    if (_variables.find(name) != _variables.end())
    {
        _variables[name].isInitialized = true;
    }
    return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1dcaf(%rip), %rsi     # 0x385bd
movl $0x1, %ecx
movq %rdx, %rdi
xorl %edx, %edx
callq 0x44a0
cmpq $-0x1, %rax
je 0x1a974
leaq 0x1dc93(%rip), %rsi     # 0x385bd
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x44a0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x42c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x4380
movq (%r12), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1a974
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xc7aa
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a4ca
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1a9b8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
je 0x1a9fe
leaq 0x40(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b7f6
addq $0x48, %r15
cmpq %r15, %rax
je 0x1a9e3
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b22c
movb $0x1, (%rax)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1c6f2(%rip), %rdx     # 0x370e3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x53cc
jmp 0x1aa10
leaq 0x1c9df(%rip), %rsi     # 0x373e4
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5344
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1aa3c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::checkVariableExistsAndIsInitialized(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string SymbolTable::checkVariableExistsAndIsInitialized(std::string name)
{
    if (name.find("(") != std::string::npos)
    {
        name = name.substr(0, name.find("("));
    }

    if (! isNameTaken(name))
    {
        return "undeclared variable " + name;
    }
    if (_variables.find(name) != _variables.end())
    {
        if (! _variables[name].isInitialized)
        {
            return "using uninitialized variable " + name;
        }
    }

    return "";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x1da7f(%rip), %rsi     # 0x385bd
movl $0x1, %ecx
movq %rdx, %rdi
xorl %edx, %edx
callq 0x44a0
cmpq $-0x1, %rax
je 0x1aba4
leaq 0x1da63(%rip), %rsi     # 0x385bd
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x44a0
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x42c0
movq %r14, %rdi
movq %r12, %rsi
callq 0x4380
movq (%r12), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1aba4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xc7aa
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a4ca
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1abe8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
je 0x1ac30
leaq 0x40(%r15), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b7f6
addq $0x48, %r15
cmpq %r15, %rax
je 0x1ac15
movq %r12, %rdi
movq %r14, %rsi
callq 0x1b22c
cmpb $0x0, (%rax)
je 0x1ac39
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x1c4c0(%rip), %rdx     # 0x370e3
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x53cc
jmp 0x1ac4b
leaq 0x1c7ad(%rip), %rsi     # 0x373e4
jmp 0x1ac40
leaq 0x1c7f0(%rip), %rsi     # 0x37430
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5344
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1ac77
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::addToIterators(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SymbolTable::addToIterators(std::string name)
{
    Iterator i;
    _currentIterators[name] = i;
    _allIterators[name] = i;
    Iterator iForControl;
    std::string newName = name + forControlName;
    _allIterators[newName] = iForControl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0xd0, %rdi
callq 0x1b2a8
xorl %r12d, %r12d
movq %r12, (%rax)
leaq 0x100(%r14), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b2a8
movq %r12, (%rax)
addq $0x20, %r14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1b41c
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b2a8
movq $0x0, (%rax)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b066
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b090
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::isItVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool SymbolTable::isItVariable(std::string var)
{
    if (var == extraVariable)
    {
        return true;
    }
    if (_variables.find(var) != _variables.end())
    {
        return true;
    }
    if (_allIterators.find(var) != _allIterators.end())
    {
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
cmpq 0x8(%rdi), %rdx
jne 0x1b1bd
movb $0x1, %bpl
testq %rdx, %rdx
je 0x1b1f2
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x42b0
testl %eax, %eax
je 0x1b1f2
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x1b7f6
leaq 0x48(%rbx), %rcx
movb $0x1, %bpl
cmpq %rcx, %rax
jne 0x1b1f2
leaq 0x100(%rbx), %rdi
movq %r14, %rsi
callq 0x1b83c
addq $0x108, %rbx            # imm = 0x108
cmpq %rbx, %rax
setne %bpl
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FirstIR.cpp
// Function: FirstIR::addNewCode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FirstIR::addNewCode(cStrRef operation, cStrRef one, cStrRef two)
{
    Line line;
    line.operation = operation;
    line.one = one;
    line.two = two;
    _currentBlock.top().lines.push_back(line);
    if (operation == "HALT")
    {
        _blocks.push_back(_currentBlock.top());
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x30(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movq %rsp, %rdi
callq 0x4170
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x4170
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x4170
movq 0x58(%rbx), %rdi
cmpq 0x60(%rbx), %rdi
jne 0x1c7fd
movq 0x70(%rbx), %rax
movl $0x1e0, %edi            # imm = 0x1E0
addq -0x8(%rax), %rdi
addq $-0x80, %rdi
movq %rsp, %rsi
callq 0x1f6f6
leaq 0x1ac6f(%rip), %rsi     # 0x3747f
movq %r14, %rdi
callq 0x40d0
testl %eax, %eax
jne 0x1c843
leaq 0x10(%rbx), %rdi
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
jne 0x1c837
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
callq 0x1f720
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x1c85a
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1c871
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1c88c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbca2
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FirstIR.cpp
// Function: FirstIR::handleNonCommutativeOperation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FirstIR::handleNonCommutativeOperation(cStrRef resultName, cStrRef operation)
{
    std::string reg = getVariable("NAN");
    addNewCode("COPY", reg, resultName);
    addNewCode("COPY", resultName, _firstExtraParameter);
    addNewCode(operation, resultName, reg);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1a6ce(%rip), %rsi     # 0x37484
leaq 0x1a6ca(%rip), %rdx     # 0x37487
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x53cc
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2b63a
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x1cdf1
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a2c3(%rip), %rsi     # 0x370c5
leaq 0x1a2c0(%rip), %rdx     # 0x370c9
movq %rsp, %rdi
callq 0x53cc
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1c778
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1ce3a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1a27e(%rip), %rsi     # 0x370c5
leaq 0x1a27b(%rip), %rdx     # 0x370c9
callq 0x53cc
leaq 0xd8(%r15), %rcx
movq %rsp, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1c778
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1ce7e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1c778
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ceac
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1cedb
jmp 0x1cec0
jmp 0x1cedb
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1cede
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x1cede
movq %rax, %rbx
leaq 0x30(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x1cef8
movq (%r13), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0x1cee7
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FirstIR.cpp
// Function: FirstIR::endIf()
void FirstIR::endIf()
{
    Block endOfTrueBlock = _currentBlock.top();
    _currentBlock.pop();
    endOfTrueBlock.blockJump = _currentBlock.top().blockName;
    _blocks.push_back(endOfTrueBlock);
    _conditionBlocks.pop();
    _conditionBlocks.pop();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq 0x58(%rdi), %rsi
cmpq 0x60(%rdi), %rsi
jne 0x1d6ec
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1f7c2
movq %r14, %rdi
callq 0x201c0
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
jne 0x1d71c
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
leaq 0x80(%rsp), %rdi
callq 0x4170
leaq 0x10(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1f720
addq $0x118, %rbx            # imm = 0x118
movq %rbx, %rdi
callq 0x201c0
movq %rbx, %rdi
callq 0x201c0
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d776
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d791
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d7ac
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xbcf0
movq -0x20(%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1d7d4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f750
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FirstIR.cpp
// Function: FirstIR::closeConditionBlock()
void FirstIR::closeConditionBlock()
{
    //closes current block
    _blocks.push_back(_currentBlock.top());
    _currentBlock.pop();
    Block b1 = generateBlock();
    _currentBlock.push(b1);
    _conditionBlocks.push(b1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
addq $0x10, %rdi
leaq 0x28(%rbx), %r14
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
jne 0x1d822
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
callq 0x1f720
movq %r14, %rdi
callq 0x201c0
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b47a
movq %r14, %rdi
movq %r15, %rsi
callq 0x1ff14
addq $0x118, %rbx            # imm = 0x118
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ff14
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d882
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d89d
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d8b8
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0xbcf0
movq -0x20(%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1d8e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1f750
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FirstIR.cpp
// Function: FirstIR::endWhileDo()
void FirstIR::endWhileDo()
{
    Block endOfTrueBlock = _currentBlock.top();
    _currentBlock.pop();
    endOfTrueBlock.blockJump = _conditionBlocks.top().blockName;
    _conditionBlocks.pop();
    _blocks.push_back(endOfTrueBlock);  
    _conditionBlocks.pop();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq 0x58(%rdi), %rsi
cmpq 0x60(%rdi), %rsi
jne 0x1d928
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1f7c2
movq %r14, %rdi
callq 0x201c0
movq 0x148(%rbx), %rsi
cmpq 0x150(%rbx), %rsi
jne 0x1d961
movq 0x160(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
leaq 0x80(%rsp), %rdi
callq 0x4170
leaq 0x118(%rbx), %r14
movq %r14, %rdi
callq 0x201c0
addq $0x10, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f720
movq %r14, %rdi
callq 0x201c0
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d9be
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d9d9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d9f4
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xbcf0
movq -0x20(%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1da1c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f750
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FirstIR.cpp
// Function: FirstIR::endDoWhile()
void FirstIR::endDoWhile()
{
    Block endOfTrueBlock = _currentBlock.top();
    _currentBlock.pop();
    _conditionBlocks.pop();
    _conditionBlocks.pop();
    endOfTrueBlock.blockJump = _conditionBlocks.top().blockName;
    _conditionBlocks.pop();
    _blocks.push_back(endOfTrueBlock);       
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq 0x58(%rdi), %rsi
cmpq 0x60(%rdi), %rsi
jne 0x1da64
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1f7c2
movq %r14, %rdi
callq 0x201c0
leaq 0x118(%rbx), %r14
movq %r14, %rdi
callq 0x201c0
movq %r14, %rdi
callq 0x201c0
movq 0x148(%rbx), %rsi
cmpq 0x150(%rbx), %rsi
jne 0x1dab4
movq 0x160(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
leaq 0x80(%rsp), %rdi
callq 0x4170
movq %r14, %rdi
callq 0x201c0
addq $0x10, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f720
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1db02
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1db1d
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1db38
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xbcf0
movq -0x20(%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1db60
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f750
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FirstIR.cpp
// Function: FirstIR::getLine(Data)
Line FirstIR::getLine(Data d)
{
    Line l;
    if (!d.name.empty())
    {
        l.operation = "COPY";
        l.two = d.name;
    }
    else
    {
        l.operation = "CONST";
        l.two = std::to_string(d.value);
    }

    return l;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r14
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
cmpq %rax, 0x10(%rdx)
je 0x1f610
leaq 0x17adb(%rip), %rcx     # 0x370c5
movl $0x4, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4440
addq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4170
jmp 0x1f6d0
leaq 0x17f0a(%rip), %rcx     # 0x37521
movl $0x5, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4440
movq (%r15), %r15
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x1f686
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x1f67f
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x1f684
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x1f686
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x1f649
addl $-0x3, %esi
jmp 0x1f686
addl $-0x2, %esi
jmp 0x1f686
decl %esi
movl %esi, %esi
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsp, %rdi
xorl %edx, %edx
callq 0x4330
movq %rsp, %r12
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x19d66
movq %r14, %rdi
movq %r12, %rsi
callq 0x4380
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x1f6d0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1f6e3
movq %rax, %r14
movq %rbx, %rdi
callq 0xbca2
movq %r14, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/SecondIR.cpp
// Function: SecondIR::addSimpleJumps(std::vector<Block, std::allocator<Block>>)
void SecondIR::addSimpleJumps(std::vector<Block> b)
{
    for(size_t i = 0; i < b.size() - 1; i++)
    {
        if (b[i].blockIfFalse.empty() && b[i].blockIfTrue.empty() && b[i].blockJump.empty())
        {
            b[i].blockJump = b[i + 1].blockName;
        }
        _blocks.push_back(b[i]);
    }
    _blocks.push_back(b.back());
    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
movq %rax, %rcx
subq %rsi, %rcx
cmpq $0xa0, %rcx
je 0x204fd
leaq 0x10(%rbx), %r15
xorl %r12d, %r12d
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
xorl %ebp, %ebp
cmpq $0x0, 0x60(%rsi,%r12)
jne 0x204cb
cmpq $0x0, 0x40(%rsi,%r12)
jne 0x204cb
cmpq $0x0, 0x80(%rsi,%r12)
jne 0x204cb
leaq (%rsi,%r12), %rdi
addq $0x78, %rdi
addq %r12, %rsi
addq $0xa0, %rsi
callq 0x4170
movq (%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x1f720
incq %rbp
movq (%r14), %rsi
movq 0x8(%r14), %rax
movq %rax, %rcx
subq %rsi, %rcx
sarq $0x5, %rcx
imulq %r13, %rcx
decq %rcx
addq $0xa0, %r12
cmpq %rcx, %rbp
jb 0x20496
addq $0x10, %rbx
addq $-0xa0, %rax
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f720
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/SecondIR.cpp
// Function: SecondIR::optimize()
void SecondIR::optimize()
{
    removeDivAndMod();
    removeUnusedIterators();
    removeAddSubSmallConst();
    searchForMulAndDiv();
    removeUnusedCalculations();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2070a
movq %rbx, %rdi
callq 0x20c20
movq %rbx, %rdi
callq 0x212d0
movq %rbx, %rdi
callq 0x21346
movq %rbx, %rdi
popq %rbx
jmp 0x2144c
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/SecondIR.cpp
// Function: SecondIR::checkOperations(__gnu_cxx::__normal_iterator<Line*, std::vector<Line, std::allocator<Line>>>&, Block&)
void SecondIR::checkOperations(std::vector<Line>::iterator& line, Block& b)
{
    if (line == b.lines.end())
    {
        return;
    }
    if (_banned.find(line->operation) != _banned.end())
    {
        return;
    } 
    resetBlocks();
    if (canRemove(line, b, line->one))
    {
        if (line->operation != "READ")
        {
            line = b.lines.erase(line);
            line--;
        }
        else
        {
            line->one = _symbolTable->getExtraVariable();
        }
    }



}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq (%rsi), %rsi
cmpq 0x28(%rdx), %rsi
je 0x231b8
movq %rdx, %r14
movq %rdi, %r15
addq $0xb8, %rdi
callq 0x24168
leaq 0xc0(%r15), %rcx
cmpq %rcx, %rax
jne 0x231b8
movq %r15, %rdi
callq 0x2bb80
movq (%rbx), %r12
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xc7aa
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x231ee
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2314f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
je 0x231b8
movq (%rbx), %rdi
leaq 0x143a8(%rip), %rsi     # 0x37506
callq 0x40d0
testl %eax, %eax
je 0x2317f
addq $0x20, %r14
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x24050
addq $-0x68, %rax
movq %rax, (%rbx)
jmp 0x231b8
movq (%r15), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1b20a
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x4380
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x231b8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x231e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::continueConverting(Pair&, RegisterBlock)
void FourthIR::continueConverting(Pair& pair, RegisterBlock rb)
{
    _removeConsts = true;
     
    if (!pair.block.blockJump.empty())
    {
        convertNextBlock(pair, rb, pair.block.blockJump);
    }
    else if (!pair.block.blockIfFalse.empty() && !pair.block.blockIfTrue.empty())
    {
        convertSplitBlock(pair, rb, pair.block.blockIfFalse);
        convertSplitBlock(pair, rb, pair.block.blockIfTrue);
    }

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movb $0x1, 0xd0(%rdi)
movq 0x80(%rsi), %rdx
testq %rdx, %rdx
je 0x28b90
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x78(%r14), %rsi
addq %rsi, %rdx
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0xc7aa
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x2935e
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x28c22
movq (%r13), %rsi
incq %rsi
callq 0x42a0
jmp 0x28c22
movq 0x60(%r14), %rdx
testq %rdx, %rdx
je 0x28c22
cmpq $0x0, 0x40(%r14)
je 0x28c22
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x58(%r14), %rsi
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0xc7aa
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x29a02
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x28be6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xc7aa
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x29a02
movq 0x20(%rsp), %rdi
jmp 0x28b76
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x28c4b
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x28c4b
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x28c5c
movq (%r13), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::updateRegisterState(Block&, RegisterBlock&, Register&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FourthIR::updateRegisterState(Block& b, RegisterBlock& rb, Register& r, std::string name)
{
    if (_symbolTable->isItVariable(name))
    {
        r.state = RegisterState::VARIABLE;
    }
    else if (_symbolTable->isItTable(name))
    {
        r.state = RegisterState::TABLE;
    }
    else
    {
        r.state = RegisterState::CONST;
    }       
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r14
movq %rcx, (%rsp)
movq %rdi, %r15
movq (%rdi), %r12
leaq 0x38(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r8), %rsi
movq 0x8(%r8), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0xc7aa
movq %r12, %rdi
movq %r13, %rsi
callq 0x1b192
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x28cc3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
movl $0x1, %eax
testb %bpl, %bpl
jne 0x28d1b
movq (%r15), %r15
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xc7aa
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b0dc
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x28d14
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movzbl %bpl, %eax
orl $0x2, %eax
movq (%rsp), %rcx
movl %eax, (%rcx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
jmp 0x28d42
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x28d52
movq (%rbx), %rsi
incq %rsi
callq 0x42a0
movq %r14, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::isThisVariableUsed(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Block&)
bool FourthIR::isThisVariableUsed(std::string name, Block& block)
{
    Block& nextBlock = getPairByName(block.blockJump).block;
    resetBlocks();
    restPairBlocks();
    bool result = recursiveUsageTest(name , nextBlock);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x78(%rdx), %rsi
movq 0x80(%rdx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0xc7aa
movq %rbx, %rdi
movq %r12, %rsi
callq 0x29e92
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x28db5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x2bb80
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
cmpq %rcx, %rax
je 0x28ddf
movb $0x0, 0x98(%rax)
addq $0x1b8, %rax            # imm = 0x1B8
jmp 0x28dcb
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0xc7aa
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x28e56
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x28e24
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x28e4d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::convertNextBlock(Pair&, RegisterBlock&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FourthIR::convertNextBlock(Pair& pair, RegisterBlock& rb, std::string name)
{
    Pair& next = getPairByName(name);
    if (!next.registerBlockIsSet)
    {
        RegisterBlock copy(rb);
        convertBlockToAssembler(next, copy);   
        return;         
    }
    alignRegisters(pair, next, rb, name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0xc7aa
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x29e92
movq %rax, %r15
movq (%rbp), %rdi
cmpq %r14, %rdi
je 0x293c1
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42a0
cmpb $0x0, 0x1b0(%r15)
je 0x2941d
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0xc7aa
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r12, %r8
callq 0x294e0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2949c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x2949c
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x54ec
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2475c
leaq 0xb8(%rsp), %rbx
movq %rbx, %rdi
callq 0xbbba
movq -0x28(%rbx), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x2946c
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2948d
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x2949c
callq 0xc11c
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x29daa
jmp 0x294d7
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x294d7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::convertSplitBlock(Pair&, RegisterBlock&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void FourthIR::convertSplitBlock(Pair& pair, RegisterBlock& rb, std::string name)
{
    Pair& next = getPairByName(name);
    if (!next.registerBlockIsSet)
    {
        RegisterBlock copy(rb);
        convertBlockToAssembler(next, copy);   
        return;         
    }
    alignRegisters(pair, next, rb, name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, 0x8(%rsp)
movq %rdi, %rbx
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0xc7aa
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x29e92
movq %rax, %r15
movq (%rbp), %rdi
cmpq %r14, %rdi
je 0x29a65
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42a0
cmpb $0x0, 0x1b0(%r15)
je 0x29ac1
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0xc7aa
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r12, %r8
callq 0x294e0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x29b40
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x29b40
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x54ec
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2475c
leaq 0xb8(%rsp), %rbx
movq %rbx, %rdi
callq 0xbbba
movq -0x28(%rbx), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x29b10
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29b31
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x29b40
callq 0xc11c
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x29daa
jmp 0x29b7b
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x29b7b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/IRBase.cpp
// Function: IRBase::generateBlock()
Block IRBase::generateBlock()
{
    Block block;
    block.blockName = "Block_" + std::to_string(_blockCounter);
    _blockCounter++;
    return block;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movb %al, 0x48(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x88(%rdi), %rcx
movq %rcx, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb %al, 0x88(%rdi)
movb %al, 0x98(%rdi)
movl 0x19e46(%rip), %ebp     # 0x4532c
movl $0x1, %eax
cmpl $0xa, %ebp
jb 0x2b534
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %ebp, %edx
cmpl $0x63, %edx
jbe 0x2b52d
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x2b532
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x2b534
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x2b4fc
addl $-0x3, %eax
jmp 0x2b534
addl $-0x2, %eax
jmp 0x2b534
decl %eax
movl %eax, %esi
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rdi
xorl %edx, %edx
callq 0x4330
movq %rsp, %r14
movq (%r14), %rdi
movl 0x8(%r14), %esi
movl %ebp, %edx
callq 0x1853f
leaq 0xc031(%rip), %rcx      # 0x37592
movl $0x6, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4300
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2b59b
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x2b5a3
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x2b5df
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2b5f5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
incl 0x19d31(%rip)           # 0x4532c
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2b629
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x2b629
movq %rax, %r14
movq %rbx, %rdi
callq 0x1f750
movq %r14, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/IRBase.cpp
// Function: IRBase::generateConditionBlock()
Block IRBase::generateConditionBlock()
{
    Block block;
    block.blockName = "Block_Condition_" + std::to_string(_conditionCounter);
    _conditionCounter++;
    return block;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movb %al, 0x48(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x88(%rdi), %rcx
movq %rcx, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb %al, 0x88(%rdi)
movb %al, 0x98(%rdi)
movl 0x1990c(%rip), %ebp     # 0x45330
movl $0x1, %eax
cmpl $0xa, %ebp
jb 0x2ba72
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %ebp, %edx
cmpl $0x63, %edx
jbe 0x2ba6b
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x2ba70
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x2ba72
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x2ba3a
addl $-0x3, %eax
jmp 0x2ba72
addl $-0x2, %eax
jmp 0x2ba72
decl %eax
movl %eax, %esi
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rsp, %rdi
xorl %edx, %edx
callq 0x4330
movq %rsp, %r14
movq (%r14), %rdi
movl 0x8(%r14), %esi
movl %ebp, %edx
callq 0x1853f
leaq 0xbafa(%rip), %rcx      # 0x37599
movl $0x10, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4300
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x2bad9
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x2bae1
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4380
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x2bb1d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2bb33
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
incl 0x197f7(%rip)           # 0x45330
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2bb67
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x2bb67
movq %rax, %r14
movq %rbx, %rdi
callq 0x1f750
movq %r14, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/IRBase.cpp
// Function: IRBase::getBlockByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Block, std::allocator<Block>>&)
Block& IRBase::getBlockByName(std::string searched, std::vector<Block>& blocks)
{
    auto result = std::find_if(blocks.begin(), blocks.end(),
    [&searched](auto& tested){
        return searched == tested.blockName;
    });     
    if (result == blocks.end())
    {
        std::cout<<"problem with getBlockByName, searching for="<<searched<<std::endl;
    }
    return *result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdx), %r12
movq 0x8(%rdx), %r13
movq %r13, %rax
subq %r12, %rax
movq %rax, %rbp
sarq $0x5, %rbp
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %rbp
sarq $0x2, %rbp
testq %rbp, %rbp
jle 0x2bc76
leaq (,%rbp,4), %r14
addq %rbp, %r14
shlq $0x7, %r14
addq %r12, %r14
incq %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2bf32
testb %al, %al
jne 0x2bcd5
leaq 0xa0(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2bf32
testb %al, %al
jne 0x2bcd8
leaq 0x140(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2bf32
testb %al, %al
jne 0x2bcd8
leaq 0x1e0(%r12), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2bf32
testb %al, %al
jne 0x2bcd8
addq $0x280, %r12            # imm = 0x280
decq %rbp
cmpq $0x1, %rbp
jg 0x2bbf0
movq %r13, %rax
subq %r14, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
jmp 0x2bc79
movq %r12, %r14
sarq $0x5, %rax
imulq %rcx, %rax
cmpq $0x1, %rax
je 0x2bcbf
cmpq $0x2, %rax
je 0x2bca9
cmpq $0x3, %rax
jne 0x2bcdf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bf32
testb %al, %al
jne 0x2bcd0
addq $0xa0, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bf32
testb %al, %al
jne 0x2bcd0
addq $0xa0, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bf32
testb %al, %al
cmoveq %r13, %r14
movq %r14, %r15
jmp 0x2bcd8
movq %r12, %r15
cmpq %r13, %r15
jne 0x2bd36
jmp 0x2bce2
movq %r13, %r15
movq 0x192df(%rip), %r14     # 0x44fc8
leaq 0xb8ba(%rip), %rsi      # 0x375aa
movl $0x2b, %edx
movq %r14, %rdi
callq 0x4310
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x4310
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41c0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/IRBase.cpp
// Function: IRBase::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void IRBase::print(cStrRef fileName)
{
    std::streambuf * buf;
    if (fileName.empty())
    {
        std::cerr<<"**************************"<<std::endl;
        buf = std::cerr.rdbuf();
        std::ostream out(buf);
        writeToStream(out);
    }
    else
    {
        std::ofstream output(fileName);
        buf = output.rdbuf();
        std::ostream out(buf);
        writeToStream(out);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x318, %rsp            # imm = 0x318
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x2bde4
leaq 0x8(%rsp), %rdi
movl $0x10, %edx
callq 0x4520
leaq 0x10(%rsp), %r14
leaq 0x208(%rsp), %rdi
movq %r14, %rsi
callq 0x4120
leaq 0x208(%rsp), %rsi
movq %rbx, %rdi
callq 0x2be98
leaq 0x210(%rsp), %rdi
callq 0x4100
movq 0x191f8(%rip), %rax     # 0x44fb0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x100(%rsp), %rbx
movq %rcx, -0xf8(%rbx)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
movq %r14, %rdi
callq 0x4230
movq %rbx, %rdi
jmp 0x2be52
movq 0x19205(%rip), %r14     # 0x44ff0
leaq 0xb7e4(%rip), %rsi      # 0x375d6
movl $0x1a, %edx
movq %r14, %rdi
callq 0x4310
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x4270
movsbl %al, %esi
movq %r14, %rdi
callq 0x4030
movq %rax, %rdi
callq 0x41c0
movq (%r14), %rax
movq -0x18(%rax), %rax
movq 0xe8(%r14,%rax), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4120
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2be98
leaq 0x10(%rsp), %rdi
callq 0x4100
addq $0x318, %rsp            # imm = 0x318
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4100
jmp 0x2be90
movq %rax, %rbx
leaq 0x210(%rsp), %rdi
callq 0x4100
jmp 0x2be86
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4410
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O3/Merulo[P]CompilerJFTT/src/IRs/FifthIR.cpp
// Function: FifthIR::getFirstInstructionAfter(Block&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FifthIR::getFirstInstructionAfter(Block& b, std::string name)
{
    bool found = false;
    for(auto& line : b.lines)
    {
        if (line.operation == name)
        {
            found = true;
        }

        if (found && line.operation.find("#") == std::string::npos && !line.operation.empty())
        {
            return line.operationNumber;
        }
    }
    Block next = getNextBlock(b);
    return getFirstInstructionInBlock(next);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, (%rsp)
movq 0x20(%rsi), %r12
movq 0x28(%rsi), %rbp
cmpq %rbp, %r12
je 0x2d0b3
movq %rdx, %r15
xorl %r14d, %r14d
leaq 0xa50b(%rip), %r13      # 0x3755b
movq 0x8(%r12), %rdx
cmpq 0x8(%r15), %rdx
jne 0x2d07d
testq %rdx, %rdx
je 0x2d083
movq (%r15), %rsi
movq (%r12), %rdi
callq 0x42b0
testl %eax, %eax
sete %al
orb %r14b, %al
testb $0x1, %al
jne 0x2d083
xorl %r14d, %r14d
jmp 0x2d0aa
testb $0x1, %r14b
je 0x2d078
movl $0x1, %ecx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x44a0
movb $0x1, %r14b
cmpq $-0x1, %rax
jne 0x2d0aa
cmpq $0x0, 0x8(%r12)
jne 0x2d16c
addq $0x68, %r12
cmpq %rbp, %r12
jne 0x2d050
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x2d266
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1f7c2
movq %r14, %rsi
callq 0x2cfc0
movl %eax, %ebx
movq 0x78(%r14), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x2d0fa
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d115
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d130
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xbcf0
movq -0x20(%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2d158
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x60(%r12), %ebx
jmp 0x2d158
nop