LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b47b
movb $0x1, %bpl
testq %rdx, %rdx
je 0x1b4b0
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x42b0
testl %eax, %eax
je 0x1b4b0
leaq 0x40(%rbx), %rdi
movq %r14, %rsi
callq 0x1bab4
leaq 0x48(%rbx), %rcx
movb $0x1, %bpl
cmpq %rcx, %rax
jne 0x1b4b0
leaq 0x100(%rbx), %rdi
movq %r14, %rsi
callq 0x1bafa
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_O1/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 0x1caa1
movq 0x70(%rbx), %rax
movl $0x1e0, %edi            # imm = 0x1E0
addq -0x8(%rax), %rdi
addq $-0x80, %rdi
movq %rsp, %rsi
callq 0x1f9be
leaq 0x1b9cb(%rip), %rsi     # 0x3847f
movq %r14, %rdi
callq 0x40d0
testl %eax, %eax
jne 0x1cae7
leaq 0x10(%rbx), %rdi
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
jne 0x1cadb
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
callq 0x1f9e8
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x1cafe
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1cb15
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1cb30
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 0xbf10
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b402(%rip), %rsi     # 0x38484
leaq 0x1b3fe(%rip), %rdx     # 0x38487
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x54fc
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2b8d6
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x1d0bd
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1aff7(%rip), %rsi     # 0x380c5
leaq 0x1aff4(%rip), %rdx     # 0x380c9
movq %rsp, %rdi
callq 0x54fc
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rcx
callq 0x1ca1c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d106
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x1afb2(%rip), %rsi     # 0x380c5
leaq 0x1afaf(%rip), %rdx     # 0x380c9
callq 0x54fc
leaq 0xd8(%r15), %rcx
movq %rsp, %rsi
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1ca1c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d14a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ca1c
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d178
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x1d1a7
jmp 0x1d18c
jmp 0x1d1a7
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1d1aa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x1d1aa
movq %rax, %rbx
leaq 0x30(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x1d1c4
movq (%r13), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0x1d1b3
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d9b8
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1fa8a
movq %r14, %rdi
callq 0x20488
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
jne 0x1d9e8
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 0x1f9e8
addq $0x118, %rbx            # imm = 0x118
movq %rbx, %rdi
callq 0x20488
movq %rbx, %rdi
callq 0x20488
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1da42
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1da5d
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1da78
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xbf5e
movq -0x20(%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1daa0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1fa18
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1daee
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
callq 0x1f9e8
movq %r14, %rdi
callq 0x20488
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2b716
movq %r14, %rdi
movq %r15, %rsi
callq 0x201dc
addq $0x118, %rbx            # imm = 0x118
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x201dc
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1db4e
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1db69
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1db84
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0xbf5e
movq -0x20(%rbx), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1dbac
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 0x1fa18
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1dbf4
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1fa8a
movq %r14, %rdi
callq 0x20488
movq 0x148(%rbx), %rsi
cmpq 0x150(%rbx), %rsi
jne 0x1dc2d
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 0x20488
addq $0x10, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f9e8
movq %r14, %rdi
callq 0x20488
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dc8a
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dca5
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dcc0
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xbf5e
movq -0x20(%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1dce8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1fa18
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1dd30
movq 0x70(%rbx), %rax
movl $0x1e0, %esi            # imm = 0x1E0
addq -0x8(%rax), %rsi
addq $-0xa0, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1fa8a
movq %r14, %rdi
callq 0x20488
leaq 0x118(%rbx), %r14
movq %r14, %rdi
callq 0x20488
movq %r14, %rdi
callq 0x20488
movq 0x148(%rbx), %rsi
cmpq 0x150(%rbx), %rsi
jne 0x1dd80
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 0x20488
addq $0x10, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f9e8
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ddce
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dde9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1de04
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xbf5e
movq -0x20(%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1de2c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
addq $0xa8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1fa18
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f8d8
leaq 0x18813(%rip), %rcx     # 0x380c5
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 0x1f998
leaq 0x18c42(%rip), %rcx     # 0x38521
movl $0x5, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4440
movq (%r15), %r15
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x1f94e
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x1f947
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x1f94c
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x1f94e
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x1f911
addl $-0x3, %esi
jmp 0x1f94e
addl $-0x2, %esi
jmp 0x1f94e
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 0x1a028
movq %r14, %rdi
movq %r12, %rsi
callq 0x4380
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x1f998
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 0x1f9ab
movq %rax, %r14
movq %rbx, %rdi
callq 0xbf10
movq %r14, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq 0x8(%rsi), %rsi
movq %rsi, %rcx
subq %rax, %rcx
cmpq $0xa0, %rcx
je 0x207c6
leaq 0x10(%rbx), %r15
xorl %r12d, %r12d
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
xorl %ebp, %ebp
cmpq $0x0, 0x60(%rax,%r12)
jne 0x20791
cmpq $0x0, 0x40(%rax,%r12)
jne 0x20791
cmpq $0x0, 0x80(%rax,%r12)
jne 0x20791
leaq (%rax,%r12), %rdi
addq $0x78, %rdi
leaq (%rax,%r12), %rsi
addq $0xa0, %rsi
callq 0x4170
movq (%r14), %rsi
addq %r12, %rsi
movq %r15, %rdi
callq 0x1f9e8
incq %rbp
movq (%r14), %rax
movq 0x8(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x5, %rcx
imulq %r13, %rcx
decq %rcx
addq $0xa0, %r12
cmpq %rcx, %rbp
jb 0x2075e
addq $0x10, %rbx
addq $-0xa0, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f9e8
nop
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/IRs/SecondIR.cpp
// Function: SecondIR::removeEmptyBlocks()
void SecondIR::removeEmptyBlocks()
{
    for(auto& b : _blocks)
    {
        if (b.lines.size() == 0)
        {
            std::string jumpBlockName = b.blockJump;
            for(auto& bb : _blocks)
            {
                if (bb.blockJump == b.blockName)
                {
                    bb.blockJump = jumpBlockName;
                    continue;
                }
                if (bb.blockIfTrue == b.blockName)
                {
                    bb.blockIfTrue = jumpBlockName;
                    continue;
                }
                if (bb.blockIfFalse == b.blockName)
                {
                    bb.blockIfFalse = jumpBlockName;
                    continue;
                }
            }
        }
    }
    for(auto it = _blocks.begin(); it != _blocks.end(); it++)
    {
        if (it->lines.size() == 0)
        {
            it = _blocks.erase(it);
            it--;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %r12
movq 0x18(%rdi), %rcx
cmpq %rcx, %r12
je 0x2092a
leaq 0x18(%rsp), %r14
movq %rbx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%r12), %rax
cmpq 0x20(%r12), %rax
jne 0x2091a
movq %r14, 0x8(%rsp)
movq 0x78(%r12), %rsi
movq 0x80(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xca12
movq 0x10(%rbx), %rbp
movq 0x18(%rbx), %rbx
cmpq %rbx, %rbp
je 0x208f4
leaq 0x58(%rbp), %r15
movq 0x28(%r15), %rdx
movq 0x8(%r12), %r13
cmpq %r13, %rdx
jne 0x20885
leaq 0x78(%rbp), %r14
testq %rdx, %rdx
je 0x208cc
movq (%r12), %rsi
movq 0x20(%r15), %rdi
callq 0x42b0
testl %eax, %eax
je 0x208cc
movq -0x18(%r15), %rdx
cmpq %r13, %rdx
jne 0x208a8
leaq 0x38(%rbp), %r14
testq %rdx, %rdx
je 0x208cc
movq (%r12), %rsi
movq -0x20(%r15), %rdi
callq 0x42b0
testl %eax, %eax
je 0x208cc
movq 0x8(%r15), %rdx
cmpq %r13, %rdx
jne 0x208d9
movq %r15, %r14
testq %rdx, %rdx
je 0x208cc
movq (%r12), %rsi
movq (%r15), %rdi
callq 0x42b0
movq %r15, %r14
testl %eax, %eax
jne 0x208d9
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x4170
movl $0xa0, %eax
addq %rax, %rbp
addq %r15, %rax
addq $0x48, %r15
cmpq %rbx, %r15
movq %rax, %r15
jne 0x2085d
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %r14
cmpq %r14, %rdi
je 0x20910
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x30(%rsp), %rbx
movq 0x28(%rsp), %rcx
addq $0xa0, %r12
cmpq %rcx, %r12
jne 0x20819
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
je 0x2095f
leaq 0x10(%rbx), %r14
movq 0x28(%rax), %rcx
cmpq 0x20(%rax), %rcx
jne 0x20953
movq %r14, %rdi
movq %rax, %rsi
callq 0x241c0
addq $-0xa0, %rax
addq $0xa0, %rax
cmpq 0x18(%rbx), %rax
jne 0x20938
addq $0x38, %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 0x2098d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x209c0
movq %rbx, %rdi
callq 0x20ede
movq %rbx, %rdi
callq 0x2158e
movq %rbx, %rdi
callq 0x21604
movq %rbx, %rdi
popq %rbx
jmp 0x2170a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23450
movq %rdx, %r14
movq %rdi, %r15
addq $0xb8, %rdi
callq 0x243bc
leaq 0xc0(%r15), %rcx
cmpq %rcx, %rax
jne 0x23450
movq %r15, %rdi
callq 0x2be1c
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 0xca12
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x23486
movl %eax, %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x233e7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
testb %bpl, %bpl
je 0x23450
movq (%rbx), %rdi
leaq 0x15110(%rip), %rsi     # 0x38506
callq 0x40d0
testl %eax, %eax
je 0x23417
addq $0x20, %r14
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x242a4
addq $-0x68, %rax
movq %rax, (%rbx)
jmp 0x23450
movq (%r15), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x1b4c8
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x4380
movq (%r14), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x23450
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 0x2347e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x28dfe
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x78(%r14), %rsi
addq %rsi, %rdx
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0xca12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x29616
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x28e90
movq (%r13), %rsi
incq %rsi
callq 0x42a0
jmp 0x28e90
movq 0x60(%r14), %rdx
testq %rdx, %rdx
je 0x28e90
cmpq $0x0, 0x40(%r14)
je 0x28e90
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x58(%r14), %rsi
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0xca12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x29cb4
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x28e54
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 0xca12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x29cb4
movq 0x20(%rsp), %rdi
jmp 0x28de4
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x28eb9
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x28eb9
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x28eca
movq (%r13), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xca12
movq %r12, %rdi
movq %r13, %rsi
callq 0x1b450
movl %eax, %ebp
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x28f31
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x42a0
movl $0x1, %eax
testb %bpl, %bpl
jne 0x28f89
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 0xca12
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b39a
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x28f82
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 0x28fb0
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x28fc0
movq (%rbx), %rsi
incq %rsi
callq 0x42a0
movq %r14, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xca12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2a144
movq %rax, %r15
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x29023
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x2be1c
movq 0xb8(%rbx), %rax
movq 0xc0(%rbx), %rcx
cmpq %rcx, %rax
je 0x2904d
movb $0x0, 0x98(%rax)
addq $0x1b8, %rax            # imm = 0x1B8
jmp 0x29039
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 0xca12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x290c4
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x29092
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 0x290bb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xca12
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2a144
movq %rax, %r15
movq (%rbp), %rdi
cmpq %r14, %rdi
je 0x29679
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42a0
cmpb $0x0, 0x1b0(%r15)
je 0x296d5
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 0xca12
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r12, %r8
callq 0x29798
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x29754
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x29754
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x5614
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x249dc
leaq 0xb8(%rsp), %rbx
movq %rbx, %rdi
callq 0xbe28
movq -0x28(%rbx), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x29724
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29745
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x29754
callq 0xc384
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2a05c
jmp 0x2978f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x2978f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xca12
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2a144
movq %rax, %r15
movq (%rbp), %rdi
cmpq %r14, %rdi
je 0x29d17
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x42a0
cmpb $0x0, 0x1b0(%r15)
je 0x29d73
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 0xca12
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r12, %r8
callq 0x29798
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x29df2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x29df2
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x5614
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x249dc
leaq 0xb8(%rsp), %rbx
movq %rbx, %rdi
callq 0xbe28
movq -0x28(%rbx), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x29dc2
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29de3
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x42a0
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x29df2
callq 0xc384
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2a05c
jmp 0x29e2d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x29e2d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1abaa(%rip), %ebp     # 0x4632c
movl $0x1, %eax
cmpl $0xa, %ebp
jb 0x2b7d0
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %ebp, %edx
cmpl $0x63, %edx
jbe 0x2b7c9
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x2b7ce
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x2b7d0
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x2b798
addl $-0x3, %eax
jmp 0x2b7d0
addl $-0x2, %eax
jmp 0x2b7d0
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 0x1878f
leaq 0xcd95(%rip), %rcx      # 0x38592
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 0x2b837
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x2b83f
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 0x2b87b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2b891
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
incl 0x1aa95(%rip)           # 0x4632c
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 0x2b8c5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x2b8c5
movq %rax, %r14
movq %rbx, %rdi
callq 0x1fa18
movq %r14, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a670(%rip), %ebp     # 0x46330
movl $0x1, %eax
cmpl $0xa, %ebp
jb 0x2bd0e
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %ebp, %edx
cmpl $0x63, %edx
jbe 0x2bd07
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0x2bd0c
cmpl $0x2710, %edx           # imm = 0x2710
jb 0x2bd0e
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0x2bcd6
addl $-0x3, %eax
jmp 0x2bd0e
addl $-0x2, %eax
jmp 0x2bd0e
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 0x1878f
leaq 0xc85e(%rip), %rcx      # 0x38599
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 0x2bd75
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x2bd7d
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 0x2bdb9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2bdcf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
incl 0x1a55b(%rip)           # 0x46330
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 0x2be03
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
jmp 0x2be03
movq %rax, %r14
movq %rbx, %rdi
callq 0x1fa18
movq %r14, %rdi
callq 0x44c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, %rbx
movq (%rdx), %r14
movq 0x8(%rdx), %rbp
movq %rsi, 0x10(%rsp)
movq %rbp, %r13
subq %r14, %r13
sarq $0x5, %r13
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %r13
sarq $0x2, %r13
testq %r13, %r13
jle 0x2bf1e
movq %rbx, 0x8(%rsp)
leaq (,%r13,4), %rbx
addq %r13, %rbx
shlq $0x7, %rbx
addq %r14, %rbx
incq %r13
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2c1e6
testb %al, %al
jne 0x2bf89
leaq 0xa0(%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x2c1e6
testb %al, %al
jne 0x2bf8c
leaq 0x140(%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x2c1e6
testb %al, %al
jne 0x2bf8c
leaq 0x1e0(%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x2c1e6
testb %al, %al
jne 0x2bf8c
addq $0x280, %r14            # imm = 0x280
decq %r13
cmpq $0x1, %r13
jg 0x2be9b
movq %rbx, %r14
movq 0x8(%rsp), %rbx
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
movq %rbp, %rax
subq %r14, %rax
sarq $0x5, %rax
imulq %rcx, %rax
cmpq $0x1, %rax
je 0x2bf71
cmpq $0x2, %rax
je 0x2bf59
movq %rbp, %r15
cmpq $0x3, %rax
jne 0x2bf91
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2c1e6
testb %al, %al
jne 0x2bf84
addq $0xa0, %r14
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2c1e6
testb %al, %al
jne 0x2bf84
addq $0xa0, %r14
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2c1e6
testb %al, %al
cmoveq %rbp, %r14
movq %r14, %r15
jmp 0x2bf91
movq %r14, %r15
movq 0x8(%rsp), %rbx
cmpq %rbp, %r15
jne 0x2bfea
movq 0x1a02b(%rip), %r14     # 0x45fc8
leaq 0xc606(%rip), %rsi      # 0x385aa
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 $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c098
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 0x2c14c
leaq 0x210(%rsp), %rdi
callq 0x4100
movq 0x19f44(%rip), %rax     # 0x45fb0
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 0x2c106
movq 0x19f51(%rip), %r14     # 0x45ff0
leaq 0xc530(%rip), %rsi      # 0x385d6
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 0x2c14c
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 0x2c144
movq %rax, %rbx
leaq 0x210(%rsp), %rdi
callq 0x4100
jmp 0x2c13a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4410
movq %rbx, %rdi
callq 0x44c0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xb8, %rsp
movq %rdi, 0x8(%rsp)
movq 0x20(%rsi), %r13
movq %rsi, 0x10(%rsp)
movq 0x28(%rsi), %rbx
cmpq %rbx, %r13
sete %r15b
je 0x2d3ae
movq %rdx, %r12
xorl %ebp, %ebp
movq 0x8(%r13), %rdx
cmpq 0x8(%r12), %rdx
jne 0x2d363
testq %rdx, %rdx
je 0x2d360
movq (%r12), %rsi
movq (%r13), %rdi
callq 0x42b0
testl %eax, %eax
movzbl %bpl, %ebp
movl $0x1, %eax
cmovel %eax, %ebp
jmp 0x2d363
movb $0x1, %bpl
movb $0x1, %r14b
testb $0x1, %bpl
je 0x2d39a
movl $0x1, %ecx
movq %r13, %rdi
leaq 0xb1e0(%rip), %rsi      # 0x3855b
xorl %edx, %edx
callq 0x44a0
cmpq $-0x1, %rax
jne 0x2d39a
cmpq $0x0, 0x8(%r13)
je 0x2d39a
movl 0x60(%r13), %eax
movl %eax, 0x4(%rsp)
xorl %r14d, %r14d
testb %r14b, %r14b
je 0x2d3ae
addq $0x68, %r13
cmpq %rbx, %r13
sete %r15b
jne 0x2d333
jmp 0x2d3ae
testb $0x1, %r15b
movl 0x4(%rsp), %ebx
je 0x2d46a
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x2d574
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fa8a
movq %r14, %rsi
callq 0x2d29a
movl %eax, %ebx
movq 0x78(%r14), %rdi
leaq 0xa0(%rsp), %rax
cmpq %rax, %rdi
je 0x2d406
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x80(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d427
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d442
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0xbf5e
movq -0x20(%r14), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x2d46a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x42a0
movl %ebx, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/IRs/FifthIR.hpp
// Function: FifthIR::getNextBlock(Block&)
Block& getNextBlock(Block& start)
    {
        bool found = false;
        for (auto& b : _blocks)
        {
            if (found)
            {
                return b;
            }
            if (b == start)
            {
                found = true;
            }
        }
        return start;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x10(%rdi), %r15
movq 0x18(%rdi), %r12
cmpq %r12, %r15
je 0x2d5f6
movq (%rbx), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %r13
xorl %ebp, %ebp
xorl %eax, %eax
movq %r15, %rcx
testb $0x1, %bpl
jne 0x2d5da
movq 0x8(%r15), %rdx
cmpq %r13, %rdx
jne 0x2d5d1
testq %rdx, %rdx
je 0x2d5d5
movq (%r15), %rdi
movq (%rsp), %rsi
callq 0x42b0
testl %eax, %eax
movzbl %bpl, %eax
movl $0x1, %ecx
cmovel %ecx, %eax
jmp 0x2d5d7
movl %ebp, %eax
jmp 0x2d5d7
movb $0x1, %al
movq %r14, %rcx
testb $0x1, %bpl
jne 0x2d5f3
addq $0xa0, %r15
movq %rcx, %r14
movl %eax, %ebp
cmpq %r12, %r15
jne 0x2d59e
jmp 0x2d5f6
movq %rcx, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/IRs/FifthIR.hpp
// Function: FifthIR::replace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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 replace(std::string& str, const std::string& from, const std::string& to) {
        size_t start_pos = str.find(from);
        if(start_pos == std::string::npos)
        {
            return;
        }
        if(start_pos + from.length() != str.length())
        {
            return;
        }
        str.replace(start_pos, from.length(), to);
        return;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x44a0
cmpq $-0x1, %rax
je 0x2d652
movq 0x8(%r15), %rdx
leaq (%rdx,%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x2d652
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq %r14, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x4300
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::legalize()
void ThirdIR::legalize()
{
    removeCopyWithSameArguments();
    searchForTwoTablesWithSameOperation();
    legalizeSpecificJumps();
    legalizeJumps();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2d690
movq %rbx, %rdi
callq 0x2d720
movq %rbx, %rdi
callq 0x2db70
movq %rbx, %rdi
popq %rbx
jmp 0x2ddf2
// File: /workspace/github_cpp_makefile_star2_O1/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::checkVariablesAreSameTable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool ThirdIR::checkVariablesAreSameTable(std::string one, std::string two)
{
    if (one.find("(") == std::string::npos)
    {
        return false;
    }
    if (two.find("(") == std::string::npos)
    {
        return false;
    }
    std::string oneArray = one.substr(0, one.find("("));
    std::string twoArray = two.substr(0, two.find("("));
    return oneArray == twoArray;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
leaq 0xb4e9(%rip), %rsi      # 0x395bd
xorl %ebx, %ebx
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
callq 0x44a0
cmpq $-0x1, %rax
je 0x2e1c0
leaq 0xb4c7(%rip), %rsi      # 0x395bd
xorl %ebx, %ebx
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x44a0
cmpq $-0x1, %rax
je 0x2e1c0
leaq 0xb4a5(%rip), %rbx      # 0x395bd
movl $0x1, %ecx
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x44a0
movq %rsp, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x42c0
movl $0x1, %ecx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x44a0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x42c0
movq 0x8(%rsp), %rdx
cmpq 0x28(%rsp), %rdx
jne 0x2e184
testq %rdx, %rdx
je 0x2e188
movq 0x20(%rsp), %rsi
movq (%rsp), %rdi
callq 0x42b0
testl %eax, %eax
sete %bl
jmp 0x2e18a
xorl %ebx, %ebx
jmp 0x2e18a
movb $0x1, %bl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e1a5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e1c0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e1ea
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44c0