LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Merulo[P]CompilerJFTT/src/SymbolTable.cpp
// Function: SymbolTable::checkConstTableAccess(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long long)
std::string SymbolTable::checkConstTableAccess(std::string tableName, unsigned long long value)
{
    auto table = _tables[tableName];
    if (value < table.beginIndex)
    {
        return std::to_string(value) + " out of lower bound of " + tableName;
    }
    if (value > table.endIndex)
    {
        return std::to_string(value) + " out of upper bound of " + tableName;
    }

    return "";
}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
movq %rdx, 0x18(%rsp)
movq %rsi, %rax
movq 0x18(%rsp), %rsi
movq %rdi, 0x20(%rsp)
movq %rdi, %rdx
movq %rdx, 0x28(%rsp)
movq %rdi, 0x100(%rsp)
movq %rax, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq 0xf8(%rsp), %rdi
addq $0x70, %rdi
callq 0x21be0
movq (%rax), %rcx
movq %rcx, 0xc8(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0xd0(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0xd8(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
cmpq 0xd0(%rsp), %rax
jae 0x210b7
movq 0xe8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x1f260
movq 0x10(%rsp), %rsi
leaq 0x30451(%rip), %rdx     # 0x5147e
leaq 0xa8(%rsp), %rdi
callq 0x4fd0
jmp 0x2103c
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x5020
jmp 0x21055
leaq 0xa8(%rsp), %rdi
callq 0x46e8
leaq 0x88(%rsp), %rdi
callq 0x46e8
jmp 0x211b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x210a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x46e8
leaq 0x88(%rsp), %rdi
callq 0x46e8
jmp 0x211c0
movq 0xe8(%rsp), %rax
cmpq 0xd8(%rsp), %rax
jbe 0x21165
movq 0xe8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1f260
movq 0x8(%rsp), %rsi
leaq 0x303a6(%rip), %rdx     # 0x51496
leaq 0x58(%rsp), %rdi
callq 0x4fd0
jmp 0x210fc
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x5020
jmp 0x21112
leaq 0x58(%rsp), %rdi
callq 0x46e8
leaq 0x38(%rsp), %rdi
callq 0x46e8
jmp 0x211b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x21159
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x46e8
leaq 0x38(%rsp), %rdi
callq 0x46e8
jmp 0x211c0
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4600
movq 0x20(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x2ff98(%rip), %rsi     # 0x5111b
callq 0x4f10
jmp 0x2118a
leaq 0x37(%rsp), %rdi
callq 0x43b0
jmp 0x211b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x43b0
jmp 0x211c0
movq 0x28(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x80(%rsp), %rdi
callq 0x45f0
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, (%rsp)
leaq 0x60(%rsp), %rdi
callq 0x21f50
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0xd0, %rdi
callq 0x21ac0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x60(%rsp), %rcx
movq %rcx, (%rax)
addq $0x100, %rdi            # imm = 0x100
movq %rdi, 0x10(%rsp)
callq 0x21ac0
movq 0x60(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x58(%rsp), %rdi
callq 0x21f50
movq (%rsp), %rdx
movq 0x8(%rsp), %rsi
addq $0x20, %rdx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x21f70
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x21ac0
movq %rax, 0x20(%rsp)
jmp 0x21341
movq 0x20(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x46e8
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46e8
movq 0x30(%rsp), %rdi
callq 0x45f0
nop
// File: 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:
subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x48(%rsp), %rsi
movq %rsi, 0x18(%rsp)
callq 0xd2c0
testb $0x1, %al
jne 0x21575
jmp 0x2157f
movb $0x1, 0x57(%rsp)
jmp 0x21618
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x40, %rdi
callq 0x21a10
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0x40, %rdi
callq 0x216c0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x216f0
testb $0x1, %al
jne 0x215bf
jmp 0x215c6
movb $0x1, 0x57(%rsp)
jmp 0x21618
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x100, %rdi            # imm = 0x100
callq 0x21a60
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x100, %rdi            # imm = 0x100
callq 0x21a90
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x21a40
testb $0x1, %al
jne 0x2160c
jmp 0x21613
movb $0x1, 0x57(%rsp)
jmp 0x21618
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xda30
movq 0x28(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x4050
jmp 0x27017
movq 0xb0(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x4050
jmp 0x2702b
movq 0xa8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x4050
jmp 0x27042
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
callq 0x297d0
movq %rax, 0x18(%rsp)
jmp 0x27057
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
leaq 0x40(%rsp), %rsi
callq 0x297e0
jmp 0x2706c
movq 0xb8(%rsp), %rdi
leaq 0x2a434(%rip), %rsi     # 0x514af
callq 0xdd10
movb %al, 0x17(%rsp)
jmp 0x27086
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x27090
jmp 0x270dc
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, (%rsp)
addq $0x28, %rdi
callq 0x297d0
movq %rax, 0x8(%rsp)
jmp 0x270b0
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x29850
jmp 0x270c0
jmp 0x270dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd490
jmp 0x270ee
leaq 0x40(%rsp), %rdi
callq 0xd490
addq $0xc8, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x45f0
nopl (%rax,%rax)
// File: 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:
subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4600
movq 0x20(%rsp), %rdx
leaq 0x29c3a(%rip), %rsi     # 0x514b4
leaq 0x90(%rsp), %rdi
callq 0x4f10
jmp 0x27889
movq 0x18(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0x3d2e0
jmp 0x278a5
leaq 0x90(%rsp), %rdi
callq 0x46e8
leaq 0x8f(%rsp), %rdi
callq 0x43b0
leaq 0x57(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4600
movq 0x10(%rsp), %rdx
leaq 0x29823(%rip), %rsi     # 0x510fd
leaq 0x58(%rsp), %rdi
callq 0x4f10
jmp 0x278e6
movq 0x18(%rsp), %rdi
movq 0xd8(%rsp), %rcx
leaq 0x58(%rsp), %rsi
leaq 0xb0(%rsp), %rdx
callq 0x26fc0
jmp 0x27907
leaq 0x58(%rsp), %rdi
callq 0x46e8
leaq 0x57(%rsp), %rdi
callq 0x43b0
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4600
movq 0x8(%rsp), %rdx
leaq 0x297c7(%rip), %rsi     # 0x510fd
leaq 0x30(%rsp), %rdi
callq 0x4f10
jmp 0x27942
movq 0x18(%rsp), %rdi
movq 0xd8(%rsp), %rdx
movq %rdi, %rcx
addq $0xd8, %rcx
leaq 0x30(%rsp), %rsi
callq 0x26fc0
jmp 0x27965
leaq 0x30(%rsp), %rdi
callq 0x46e8
leaq 0x2f(%rsp), %rdi
callq 0x43b0
movq 0x18(%rsp), %rdi
movq 0xd0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
leaq 0xb0(%rsp), %rcx
callq 0x26fc0
jmp 0x2799d
leaq 0xb0(%rsp), %rdi
callq 0x46e8
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x279e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x46e8
leaq 0x8f(%rsp), %rdi
callq 0x43b0
jmp 0x27a87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x27a23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x46e8
leaq 0x57(%rsp), %rdi
callq 0x43b0
jmp 0x27a7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x27a5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x46e8
leaq 0x2f(%rsp), %rdi
callq 0x43b0
jmp 0x27a7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x46e8
movq 0x80(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/FirstIR.cpp
// Function: FirstIR::endElse()
void FirstIR::endElse()
{
    Block s3 = _currentBlock.top();
    _currentBlock.pop();
    Block s2 = _currentBlock.top();
    _currentBlock.pop();
    Block b1 = generateBlock();
    _currentBlock.push(b1);
    Block s1 = _currentBlock.top();
    s3.blockJump = s1.blockName;
    _blocks.push_back(s3);
    _currentBlock.push(s2);
}

// Assembly:
subq $0x2b8, %rsp            # imm = 0x2B8
movq %rdi, 0x2b0(%rsp)
movq 0x2b0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x28, %rdi
movq %rdi, 0x18(%rsp)
callq 0x297d0
movq %rax, %rsi
leaq 0x210(%rsp), %rdi
callq 0x29ab0
movq 0x18(%rsp), %rdi
callq 0x29900
jmp 0x27e46
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x297d0
movq %rax, 0x8(%rsp)
jmp 0x27e5b
movq 0x8(%rsp), %rsi
leaq 0x160(%rsp), %rdi
callq 0x29ab0
jmp 0x27e6f
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x29900
jmp 0x27e7f
movq 0x10(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x3d200
jmp 0x27e93
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
leaq 0xc0(%rsp), %rsi
callq 0x298d0
jmp 0x27eab
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x297d0
movq %rax, (%rsp)
jmp 0x27ebf
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x29ab0
jmp 0x27ecf
leaq 0x288(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4050
jmp 0x27ee3
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x210(%rsp), %rsi
callq 0x29850
jmp 0x27efb
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
leaq 0x160(%rsp), %rsi
callq 0x298d0
jmp 0x27f13
leaq 0x20(%rsp), %rdi
callq 0x29a50
leaq 0xc0(%rsp), %rdi
callq 0x29a50
leaq 0x160(%rsp), %rdi
callq 0x29a50
leaq 0x210(%rsp), %rdi
callq 0x29a50
addq $0x2b8, %rsp            # imm = 0x2B8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x27fc6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x27fb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
jmp 0x27fac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x208(%rsp)
movl %eax, 0x204(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x29a50
leaq 0xc0(%rsp), %rdi
callq 0x29a50
leaq 0x160(%rsp), %rdi
callq 0x29a50
leaq 0x210(%rsp), %rdi
callq 0x29a50
movq 0x208(%rsp), %rdi
callq 0x45f0
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x28, %rdi
movq %rdi, 0x18(%rsp)
callq 0x297d0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x29ab0
movq 0x18(%rsp), %rdi
callq 0x29900
jmp 0x28023
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x297d0
movq %rax, 0x8(%rsp)
jmp 0x28038
movq 0x8(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x4050
jmp 0x2804c
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x30(%rsp), %rsi
callq 0x29850
jmp 0x28061
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x29900
jmp 0x28074
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x29900
jmp 0x28087
leaq 0x30(%rsp), %rdi
callq 0x29a50
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x29a50
movq 0x28(%rsp), %rdi
callq 0x45f0
nopl (%rax,%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, (%rsp)
addq $0x28, %rdi
movq %rdi, 0x10(%rsp)
callq 0x297d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x29850
movq 0x10(%rsp), %rdi
callq 0x29900
movq 0x8(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3d200
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x298d0
jmp 0x28130
movq 0x8(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
leaq 0x30(%rsp), %rsi
callq 0x298d0
jmp 0x28148
leaq 0x30(%rsp), %rdi
callq 0x29a50
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x29a50
movq 0x28(%rsp), %rdi
callq 0x45f0
nopl (%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x28, %rdi
movq %rdi, 0x18(%rsp)
callq 0x297d0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x29ab0
movq 0x18(%rsp), %rdi
callq 0x29900
jmp 0x281c3
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x297d0
movq %rax, 0x8(%rsp)
jmp 0x281db
movq 0x8(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x4050
jmp 0x281ef
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x29900
jmp 0x28202
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x30(%rsp), %rsi
callq 0x29850
jmp 0x28217
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x29900
jmp 0x2822a
leaq 0x30(%rsp), %rdi
callq 0x29a50
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x29a50
movq 0x28(%rsp), %rdi
callq 0x45f0
nop
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x28, %rdi
movq %rdi, 0x18(%rsp)
callq 0x297d0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x29ab0
movq 0x18(%rsp), %rdi
callq 0x29900
jmp 0x282a3
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x29900
jmp 0x282b6
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x29900
jmp 0x282c9
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x297d0
movq %rax, 0x8(%rsp)
jmp 0x282e1
movq 0x8(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x4050
jmp 0x282f5
movq 0x10(%rsp), %rdi
addq $0x118, %rdi            # imm = 0x118
callq 0x29900
jmp 0x28308
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x30(%rsp), %rsi
callq 0x29850
jmp 0x2831d
leaq 0x30(%rsp), %rdi
callq 0x29a50
addq $0xd8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x29a50
movq 0x28(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/FirstIR.cpp
// Function: FirstIR::closeForBlock()
void FirstIR::closeForBlock()
{
    //closes current block
    _blocks.push_back(_currentBlock.top());
    _currentBlock.pop();
    Block b1 = generateBlock();
    b1.blockName = b1.blockName + "_For_" +std::to_string(getForCounter()) + "_Content";
    _currentBlock.push(b1);
    _forBlocks.push(b1);       
}

// Assembly:
subq $0x178, %rsp            # imm = 0x178
movq %rdi, 0x170(%rsp)
movq 0x170(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
addq $0x28, %rdi
movq %rdi, 0x28(%rsp)
callq 0x297d0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x29850
movq 0x28(%rsp), %rdi
callq 0x29900
movq 0x30(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x3d200
movq 0x38(%rsp), %rsi
leaq 0x29105(%rip), %rdx     # 0x514d5
leaq 0x70(%rsp), %rdi
callq 0x299c0
jmp 0x283dc
callq 0x3d690
movl %eax, 0x1c(%rsp)
jmp 0x283e7
movl 0x1c(%rsp), %esi
leaq 0x40(%rsp), %rdi
callq 0x1d860
jmp 0x283f7
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0x29be0
jmp 0x28410
leaq 0x290c4(%rip), %rdx     # 0x514db
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x4fd0
jmp 0x2842e
leaq 0xd0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0xb0(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x4440
movq 0x8(%rsp), %rdi
callq 0x46e8
leaq 0x90(%rsp), %rdi
callq 0x46e8
leaq 0x40(%rsp), %rdi
callq 0x46e8
leaq 0x70(%rsp), %rdi
callq 0x46e8
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x28, %rdi
callq 0x298d0
jmp 0x2848d
movq 0x30(%rsp), %rdi
addq $0x168, %rdi            # imm = 0x168
leaq 0xd0(%rsp), %rsi
callq 0x298d0
jmp 0x284a8
leaq 0xd0(%rsp), %rdi
callq 0x29a50
addq $0x178, %rsp            # imm = 0x178
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x2851c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x28512
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x28508
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x46e8
leaq 0x40(%rsp), %rdi
callq 0x46e8
leaq 0x70(%rsp), %rdi
callq 0x46e8
leaq 0xd0(%rsp), %rdi
callq 0x29a50
movq 0x68(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
callq 0xda30
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x29765
movq (%rsp), %rdi
leaq 0x279d2(%rip), %rsi     # 0x510fd
callq 0x44a0
jmp 0x29732
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
addq $0x40, %rdi
callq 0x4050
jmp 0x2974a
jmp 0x297a7
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0xd490
jmp 0x297c6
movq (%rsp), %rdi
leaq 0x27df2(%rip), %rsi     # 0x51562
callq 0x44a0
jmp 0x29777
movq 0x10(%rsp), %rax
movq (%rax), %rsi
leaq 0x18(%rsp), %rdi
callq 0x1f260
jmp 0x2978b
movq (%rsp), %rdi
addq $0x40, %rdi
leaq 0x18(%rsp), %rsi
callq 0x4440
leaq 0x18(%rsp), %rdi
callq 0x46e8
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x297bc
movq (%rsp), %rdi
callq 0xd490
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x45f0
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x29d30
movq %rax, %rcx
movq 0x18(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x2c627
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x29d50
movq %rax, %rdi
addq $0x58, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x2c570
jmp 0x2c5ea
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x29d50
movq %rax, %rdi
addq $0x38, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x2c591
jmp 0x2c5ea
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x29d50
movq %rax, %rdi
addq $0x78, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x2c5b2
jmp 0x2c5ea
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x1, %rsi
callq 0x29d50
movq 0x20(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rsi
callq 0x29d50
movq 0x10(%rsp), %rsi
movq %rax, %rdi
addq $0x78, %rdi
callq 0x4050
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rsi
callq 0x29d50
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x29850
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x2c526
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
callq 0x29910
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x29850
addq $0x48, %rsp
retq
nop
// File: Merulo[P]CompilerJFTT/src/IRs/SecondIR.cpp
// Function: SecondIR::optimize()
void SecondIR::optimize()
{
    removeDivAndMod();
    removeUnusedIterators();
    removeAddSubSmallConst();
    searchForMulAndDiv();
    removeUnusedCalculations();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x2c960
movq 0x8(%rsp), %rdi
callq 0x2d0e0
movq 0x8(%rsp), %rdi
callq 0x2d660
movq 0x8(%rsp), %rdi
callq 0x2d740
movq 0x8(%rsp), %rdi
callq 0x2d900
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/SecondIR.cpp
// Function: SecondIR::searchForMulAndDiv()
void SecondIR::searchForMulAndDiv()
{
    for(auto& b : _blocks)
    {
        for(size_t i = 0; i < b.lines.size(); i++)
        {
            if (b.lines[i].operation == "MUL")
            {
                checkPowerOfTwoMul(b.lines[i], b, i);
            }
            if (b.lines[i].operation == "DIV")
            {
                checkPowerOfTwoDiv(b.lines[i], b, i);
            }       
            if (b.lines[i].operation == "MOD")
            {
                checkTwoMod(b.lines[i], b, i);
            }     
        }
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x10, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x29fd0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x2a870
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x30be0
testb $0x1, %al
jne 0x2d792
jmp 0x2d8ef
leaq 0x30(%rsp), %rdi
callq 0x2bda0
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0xfbf0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2d8de
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x310d0
movq %rax, %rdi
leaq 0x23cc8(%rip), %rsi     # 0x514b8
callq 0xdd10
testb $0x1, %al
jne 0x2d7fb
jmp 0x2d825
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x310d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x2ed10
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x310d0
movq %rax, %rdi
leaq 0x23c7a(%rip), %rsi     # 0x514bc
callq 0xdd10
testb $0x1, %al
jne 0x2d84d
jmp 0x2d877
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x310d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x2f1a0
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x310d0
movq %rax, %rdi
leaq 0x23c2c(%rip), %rsi     # 0x514c0
callq 0xdd10
testb $0x1, %al
jne 0x2d89f
jmp 0x2d8c9
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x310d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x2f650
jmp 0x2d8cb
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x2d7aa
jmp 0x2d8e0
leaq 0x30(%rsp), %rdi
callq 0x30c20
jmp 0x2d77a
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/SecondIR.cpp
// Function: SecondIR::removeUnusedCalculations()
void SecondIR::removeUnusedCalculations()
{
    for(auto& b : _blocks)
    {
        for(auto line = b.lines.begin(); line != b.lines.end(); line++)
        {
            if (_symbolTable->isItVariable(line->one))
            {
                checkOperations(line, b);
            }
        }
    }


}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x10, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x29fd0
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x2a870
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x30be0
testb $0x1, %al
jne 0x2d96a
jmp 0x2da6e
leaq 0x80(%rsp), %rdi
callq 0x2bda0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
addq $0x20, %rdi
callq 0xe3f0
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
addq $0x20, %rdi
callq 0xe380
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xec10
testb $0x1, %al
jne 0x2d9ba
jmp 0x2da5a
movq 0x20(%rsp), %rdi
callq 0xdde0
movq %rax, 0x8(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x30d40
movq %rax, %rsi
addq $0x20, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4180
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x21540
movb %al, 0x1f(%rsp)
jmp 0x2d9fe
leaq 0x40(%rsp), %rdi
callq 0x46e8
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x2da12
jmp 0x2da42
movq 0x20(%rsp), %rdi
movq 0x70(%rsp), %rdx
leaq 0x68(%rsp), %rsi
callq 0x2fa40
jmp 0x2da42
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x46e8
jmp 0x2da76
jmp 0x2da44
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x30e00
movq %rax, 0x28(%rsp)
jmp 0x2d98f
jmp 0x2da5c
leaq 0x80(%rsp), %rdi
callq 0x30c20
jmp 0x2d94f
addq $0x98, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x45f0
// File: Merulo[P]CompilerJFTT/src/IRs/SecondIR.cpp
// Function: SecondIR::stripVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Block&)
void SecondIR::stripVariable(std::string variable, Block& b)
{
    for(auto i = b.lines.begin(); i != b.lines.end(); i++)
    {
        if (i->one == variable || i->two == variable)
        {
            i = b.lines.erase(i);
            i--;
        }
    }
}

// Assembly:
subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0xe3f0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0xe380
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xec10
testb $0x1, %al
jne 0x2e066
jmp 0x2e108
leaq 0x38(%rsp), %rdi
callq 0x30d40
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0xd2c0
testb $0x1, %al
jne 0x2e0a6
leaq 0x38(%rsp), %rdi
callq 0x30d40
movq 0x8(%rsp), %rsi
movq %rax, %rdi
addq $0x40, %rdi
callq 0xd2c0
testb $0x1, %al
jne 0x2e0a6
jmp 0x2e0f0
movq 0x40(%rsp), %rax
addq $0x20, %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xe3b0
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x30d50
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x30dc0
movq %rax, 0x18(%rsp)
jmp 0x2e0f2
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x30e00
movq %rax, 0x10(%rsp)
jmp 0x2e03b
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0xd8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xc0(%rsp), %rdi
addq $0x20, %rdi
callq 0xe380
movq 0x30(%rsp), %rdi
movq %rax, 0xb8(%rsp)
leaq 0xb8(%rsp), %rsi
callq 0x1fba0
testb $0x1, %al
jne 0x2faaa
jmp 0x2faaf
jmp 0x2fc81
movq 0x28(%rsp), %rax
addq $0xb8, %rax
movq %rax, 0x20(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x30d40
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x31110
movq 0x28(%rsp), %rdi
movq %rax, 0xb0(%rsp)
addq $0xb8, %rdi
callq 0x31150
movq %rax, 0xa8(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x310f0
testb $0x1, %al
jne 0x2fb15
jmp 0x2fb1a
jmp 0x2fc81
movq 0x28(%rsp), %rdi
callq 0x3d6a0
movq 0xc8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x30d40
movq %rax, %rsi
addq $0x20, %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x4180
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0xa0(%rsp), %rsi
callq 0x2fca0
movb %al, 0x1f(%rsp)
jmp 0x2fb8c
leaq 0x80(%rsp), %rdi
callq 0x46e8
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x2fba6
jmp 0x2fc81
movq 0xc8(%rsp), %rdi
callq 0x30d40
movq %rax, %rdi
leaq 0x21979(%rip), %rsi     # 0x51536
callq 0x310a0
testb $0x1, %al
jne 0x2fbc8
jmp 0x2fc40
movq 0xc0(%rsp), %rax
addq $0x20, %rax
movq %rax, (%rsp)
movq 0xc8(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0xe3b0
movq (%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x30d50
movq %rax, 0x68(%rsp)
movq 0xc8(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, (%rax)
movq 0xc8(%rsp), %rdi
xorl %esi, %esi
callq 0x30dc0
movq %rax, 0x58(%rsp)
jmp 0x2fc7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x46e8
jmp 0x2fc89
movq 0x28(%rsp), %rdi
callq 0xdde0
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x21660
movq 0xc8(%rsp), %rdi
callq 0x30d40
movq %rax, %rdi
addq $0x20, %rdi
leaq 0x38(%rsp), %rsi
callq 0x4440
leaq 0x38(%rsp), %rdi
callq 0x46e8
jmp 0x2fc81
addq $0xd8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::isDeterministic()
bool FourthIR::isDeterministic()
{
    for (auto& p : _notYetConvertedBlocks)
    {
        for(auto& l : p.block.lines)
        {
            if (l.operation == "READ")
            {
                return false;
            }
        }
    }
    return true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
addq $0xb8, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x39020
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x39050
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x39080
testb $0x1, %al
jne 0x3248f
jmp 0x3252b
leaq 0x38(%rsp), %rdi
callq 0x390c0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe3f0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xe380
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xec10
testb $0x1, %al
jne 0x324df
jmp 0x3251a
leaq 0x18(%rsp), %rdi
callq 0xfb10
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x1f03c(%rip), %rsi     # 0x51536
callq 0xdd10
testb $0x1, %al
jne 0x32505
jmp 0x3250c
movb $0x0, 0x57(%rsp)
jmp 0x32530
jmp 0x3250e
leaq 0x18(%rsp), %rdi
callq 0xf950
jmp 0x324ca
jmp 0x3251c
leaq 0x38(%rsp), %rdi
callq 0x390d0
jmp 0x32477
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0xc8, %rsp
movq %rdx, 0x30(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x1, 0xd0(%rax)
movq 0xb8(%rsp), %rdi
addq $0x78, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x37753
movq 0xb8(%rsp), %rsi
movq %rsi, 0x20(%rsp)
addq $0x78, %rsi
leaq 0x90(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4180
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x38190
jmp 0x3771b
leaq 0x90(%rsp), %rdi
callq 0x46e8
jmp 0x37851
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x46e8
jmp 0x37859
movq 0xb8(%rsp), %rdi
addq $0x58, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x3784f
movq 0xb8(%rsp), %rdi
addq $0x38, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x3784f
movq 0xb8(%rsp), %rsi
movq %rsi, 0x10(%rsp)
addq $0x58, %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4180
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x38870
jmp 0x377c0
leaq 0x60(%rsp), %rdi
callq 0x46e8
movq 0xb8(%rsp), %rsi
movq %rsi, (%rsp)
addq $0x38, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4180
movq 0x38(%rsp), %rdi
movq (%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x38870
jmp 0x37803
leaq 0x40(%rsp), %rdi
callq 0x46e8
jmp 0x3784f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x46e8
jmp 0x37859
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x46e8
jmp 0x37859
jmp 0x37851
addq $0xc8, %rsp
retq
movq 0x88(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %r8, 0x20(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movq 0xb0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xdde0
movq 0x20(%rsp), %rsi
movq %rax, 0x28(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x4180
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x21540
movb %al, 0x3f(%rsp)
jmp 0x378e4
leaq 0x70(%rsp), %rdi
callq 0x46e8
movb 0x3f(%rsp), %al
testb $0x1, %al
jne 0x378f8
jmp 0x37928
movq 0x98(%rsp), %rax
movl $0x1, (%rax)
jmp 0x379ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x46e8
jmp 0x379b4
movq 0x18(%rsp), %rdi
callq 0xdde0
movq 0x20(%rsp), %rsi
movq %rax, (%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4180
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x213e0
movb %al, 0x17(%rsp)
jmp 0x3795e
leaq 0x40(%rsp), %rdi
callq 0x46e8
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x37972
jmp 0x3799c
movq 0x98(%rsp), %rax
movl $0x3, (%rax)
jmp 0x379aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x46e8
jmp 0x379b4
movq 0x98(%rsp), %rax
movl $0x2, (%rax)
jmp 0x379ac
addq $0xb8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x45f0
nop
// File: 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:
subq $0xa8, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x90(%rsp), %rsi
addq $0x78, %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x4180
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x39340
movq %rax, 0x30(%rsp)
jmp 0x37a22
leaq 0x68(%rsp), %rdi
callq 0x46e8
movq 0x30(%rsp), %rax
movq 0x20(%rsp), %rdi
movq %rax, 0x88(%rsp)
callq 0x3d6a0
movq 0x20(%rsp), %rdi
callq 0x39400
movq 0x18(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4180
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x37ae0
movb %al, 0x17(%rsp)
jmp 0x37a7e
leaq 0x38(%rsp), %rdi
callq 0x46e8
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x5b(%rsp)
movb 0x5b(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x46e8
jmp 0x37ad2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46e8
movq 0x60(%rsp), %rdi
callq 0x45f0
nopl (%rax)
// File: 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:
subq $0x158, %rsp            # imm = 0x158
movq %rcx, 0x30(%rsp)
movq %rsi, %rax
movq 0x30(%rsp), %rsi
movq %rsi, 0x38(%rsp)
movq %rdi, 0x150(%rsp)
movq %rax, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x110(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x4180
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x39340
movq %rax, 0x50(%rsp)
jmp 0x381fe
leaq 0x110(%rsp), %rdi
callq 0x46e8
movq 0x50(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x130(%rsp), %rax
testb $0x1, 0x1b0(%rax)
jne 0x382b5
movq 0x140(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5560
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x130(%rsp), %rsi
callq 0x32610
jmp 0x3825d
leaq 0x78(%rsp), %rdi
callq 0x38fe0
jmp 0x3831a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0x110(%rsp), %rdi
callq 0x46e8
jmp 0x38340
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x38fe0
jmp 0x38340
movq 0x38(%rsp), %rsi
movq 0x148(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4180
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x38350
jmp 0x38310
leaq 0x58(%rsp), %rdi
callq 0x46e8
addq $0x158, %rsp            # imm = 0x158
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x46e8
movq 0x108(%rsp), %rdi
callq 0x45f0
nopl (%rax)
// File: 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:
subq $0x158, %rsp            # imm = 0x158
movq %rcx, 0x30(%rsp)
movq %rsi, %rax
movq 0x30(%rsp), %rsi
movq %rsi, 0x38(%rsp)
movq %rdi, 0x150(%rsp)
movq %rax, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x110(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x4180
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x39340
movq %rax, 0x50(%rsp)
jmp 0x388de
leaq 0x110(%rsp), %rdi
callq 0x46e8
movq 0x50(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x130(%rsp), %rax
testb $0x1, 0x1b0(%rax)
jne 0x38995
movq 0x140(%rsp), %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x5560
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x130(%rsp), %rsi
callq 0x32610
jmp 0x3893d
leaq 0x78(%rsp), %rdi
callq 0x38fe0
jmp 0x389fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0x110(%rsp), %rdi
callq 0x46e8
jmp 0x38a20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x38fe0
jmp 0x38a20
movq 0x38(%rsp), %rsi
movq 0x148(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4180
movq 0x40(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x38350
jmp 0x389f0
leaq 0x58(%rsp), %rdi
callq 0x46e8
addq $0x158, %rsp            # imm = 0x158
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x108(%rsp)
movl %eax, 0x104(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x46e8
movq 0x108(%rsp), %rdi
callq 0x45f0
nopl (%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/FourthIR.hpp
// Function: FourthIR::getPairByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Pair& getPairByName(std::string name)
    {
        for(auto& pair : _notYetConvertedBlocks)
        {
            if (pair.block.blockName == name)
            {
                return pair;
            }
        }
        return _notYetConvertedBlocks.front();
    }

// Assembly:
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0xb8, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x39020
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x39050
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x39080
testb $0x1, %al
jne 0x3939a
jmp 0x393d7
leaq 0x20(%rsp), %rdi
callq 0x390c0
movq (%rsp), %rsi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xd2c0
testb $0x1, %al
jne 0x393bd
jmp 0x393c9
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x393ed
jmp 0x393cb
leaq 0x20(%rsp), %rdi
callq 0x390d0
jmp 0x39385
movq 0x8(%rsp), %rdi
addq $0xb8, %rdi
callq 0x38fb0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x29950
movl 0x2c1ca(%rip), %esi     # 0x693f4
leaq 0x20(%rsp), %rdi
callq 0x1d860
jmp 0x3d236
leaq 0x143a8(%rip), %rsi     # 0x515e5
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1f210
jmp 0x3d24e
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4440
leaq 0x40(%rsp), %rdi
callq 0x46e8
leaq 0x20(%rsp), %rdi
callq 0x46e8
movl 0x2c17e(%rip), %eax     # 0x693f4
addl $0x1, %eax
movl %eax, 0x2c175(%rip)     # 0x693f4
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x3d2c0
jmp 0x3d2b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x3d2ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x46e8
jmp 0x3d2ca
movq (%rsp), %rdi
callq 0x29a50
movq 0x8(%rsp), %rax
addq $0x78, %rsp
retq
movq (%rsp), %rdi
callq 0x29a50
movq 0x18(%rsp), %rdi
callq 0x45f0
nopl (%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/IRBase.cpp
// Function: IRBase::getVariable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string IRBase::getVariable(std::string value)
{
    // std::cerr<<"generating variable with "<<value<<std::endl;
    std::string result = "variable_" + std::to_string(_nextGeneratedVariableSuffix);
    _nextGeneratedVariableSuffix++;
    if (!_symbolTable)
    {
        std::cout<<"SYMBOL TABLE NOT INITALIZED"<<std::endl;
        exit(2);
    }
    _symbolTable->addConst(result, value);
    return result;
}

// Assembly:
subq $0xc8, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0xaf(%rsp)
movl 0x2c0c4(%rip), %esi     # 0x693f0
leaq 0x88(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x1d860
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
leaq 0x1426d(%rip), %rsi     # 0x515bc
callq 0x1f210
jmp 0x3d356
leaq 0x88(%rsp), %rdi
callq 0x46e8
movq 0x20(%rsp), %rdi
movl 0x2c082(%rip), %eax     # 0x693f0
addl $0x1, %eax
movl %eax, 0x2c079(%rip)     # 0x693f0
callq 0x3dec0
testb $0x1, %al
jne 0x3d3f0
movq 0x2bc39(%rip), %rdi     # 0x68fc0
leaq 0x14238(%rip), %rsi     # 0x515c6
callq 0x4320
movq %rax, 0x8(%rsp)
jmp 0x3d39a
movq 0x8(%rsp), %rdi
movq 0x2bbea(%rip), %rsi     # 0x68f90
callq 0x4380
jmp 0x3d3ad
movl $0x2, %edi
callq 0x4420
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x46e8
jmp 0x3d4b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x3d4ae
movq 0x20(%rsp), %rdi
callq 0xdde0
movq 0x28(%rsp), %rsi
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
callq 0x4180
jmp 0x3d40f
movq 0x10(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x4180
jmp 0x3d420
movq (%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x205c0
jmp 0x3d435
leaq 0x38(%rsp), %rdi
callq 0x46e8
leaq 0x58(%rsp), %rdi
callq 0x46e8
movb $0x1, 0xaf(%rsp)
testb $0x1, 0xaf(%rsp)
jne 0x3d4a1
jmp 0x3d497
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x3d48b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46e8
leaq 0x58(%rsp), %rdi
callq 0x46e8
jmp 0x3d4ae
movq 0x28(%rsp), %rdi
callq 0x46e8
movq 0x18(%rsp), %rax
addq $0xc8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x46e8
movq 0x80(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)