LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x15fa7
movq %rdx, %r14
movq %rdi, %r15
addq $0xb8, %rdi
callq 0x16974
leaq 0xc0(%r15), %rcx
cmpq %rcx, %rax
jne 0x15fa7
movq %r15, %rdi
callq 0x1b192
movq (%rbx), %r12
leaq 0x20(%r12), %rsi
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x4390
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq 0x15fcc
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x4548
testb %bpl, %bpl
je 0x15fa7
movq (%rbx), %rdi
leaq 0xd5a7(%rip), %rsi      # 0x23506
callq 0x16742
testb %al, %al
je 0x15f80
addq $0x20, %r14
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x166a4
addq $-0x68, %rax
movq %rax, (%rbx)
jmp 0x15fa7
movq (%r15), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x109b6
movq (%rbx), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x4340
movq %r14, %rdi
callq 0x4548
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::parse(std::vector<Block, std::allocator<Block>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void FourthIR::parse(std::vector<Block> bs, std::string fileName, bool useEmulator)
{
    for(auto& b : bs)
    {
        Pair p;
        p.block = b;
        _notYetConvertedBlocks.push_back(p);
    }

    if (isDeterministic() && useEmulator)
    {
        _blocks = bs;
        std::string tmpFile = "tmp.ir";
        print(tmpFile);
        EmulatorRunner er;
        bool value = er.emulate(tmpFile, fileName);
        _blocks = {};
        if (value)
        {
            exit(0);
        }
    }

    _symbolTable->assignMemory();
    convertToAssembler();

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %ecx, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %rbp
leaq 0xb8(%rdi), %r13
leaq 0x50(%rsp), %r14
cmpq %rbp, %r15
je 0x16a53
movq %r14, %rdi
callq 0x19b86
movq %r14, %rdi
movq %r15, %rsi
callq 0x19bdc
movq %r13, %rdi
movq %r14, %rsi
callq 0x19c38
movq %r14, %rdi
callq 0x19c68
addq $0xa0, %r15
jmp 0x16a1f
movq %rbx, %rdi
callq 0x16b6c
testb %al, 0x4(%rsp)
je 0x16afa
leaq 0x10(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x19c8e
leaq 0xca90(%rip), %rsi      # 0x2350b
leaq 0x50(%rsp), %rdi
leaq 0x3(%rsp), %rdx
callq 0x4a54
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b308
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x4390
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x4390
leaq 0x3(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x48ec
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x4548
leaq 0x30(%rsp), %rdi
callq 0x4548
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x19d6e
testb %bpl, %bpl
jne 0x16b1c
leaq 0x50(%rsp), %rdi
callq 0x4548
movq (%rbx), %rdi
callq 0x101b4
movq %rbx, %rdi
callq 0x16bca
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x4320
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4548
jmp 0x16b35
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x4548
jmp 0x16b4b
jmp 0x16b48
movq %rax, %rbx
jmp 0x16b64
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4548
jmp 0x16b64
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x19c68
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::handleWrite(RegisterBlock&, Block&, Line&)
void FourthIR::handleWrite(RegisterBlock& rb, Block& b, Line& l)
{    
    Register& r = rb.getRegister(l.one, b, {}, true, true);
    r.variableName = l.one;

    b.lines.push_back({"PUT", r.name});     
    updateRegisterState(b, rb, r, l.one);

    if (_symbolTable->isConst(l.one) && _removeConsts)
    {
        r.variableName = "";
        r.state = RegisterState::UNKNOWN;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %r15
leaq 0xd0(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4390
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
pushq $0x1
popq %r8
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movl %r8d, %r9d
callq 0x5ec6
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x9106
leaq 0xd0(%rsp), %rdi
callq 0x4548
leaq 0x30(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4180
leaq 0xc110(%rip), %rsi      # 0x23527
leaq 0x90(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4a54
leaq 0x10(%r14), %rsi
leaq 0x70(%rsp), %rdi
callq 0x4390
leaq 0xbca5(%rip), %rsi      # 0x230e3
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x4a54
leaq 0xf0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x816a
addq $0x20, %r13
leaq 0xf0(%rsp), %rsi
movq %r13, %rdi
callq 0x8f90
leaq 0xf0(%rsp), %rdi
callq 0x81fe
leaq 0x50(%rsp), %rdi
callq 0x4548
leaq 0x70(%rsp), %rdi
callq 0x4548
leaq 0x90(%rsp), %rdi
callq 0x4548
leaq 0xb0(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x4390
movq %rbx, %rdi
movq %r14, %rcx
movq %r13, %r8
callq 0x192a6
leaq 0xb0(%rsp), %rdi
callq 0x4548
movq (%rbx), %r13
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x4390
movq %r13, %rdi
movq %rbp, %rsi
callq 0x10282
testb %al, %al
je 0x17528
movb 0xd0(%rbx), %bl
leaq 0x30(%rsp), %rdi
callq 0x4548
cmpb $0x1, %bl
jne 0x17532
leaq 0xbbc9(%rip), %rsi      # 0x230e3
movq %r12, %rdi
callq 0x44e0
andl $0x0, (%r14)
jmp 0x17532
leaq 0x30(%rsp), %rdi
callq 0x4548
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x175b2
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
jmp 0x175b2
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0x81fe
jmp 0x17570
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x4548
jmp 0x1757f
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x4548
jmp 0x1758e
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x175b2
movq %rax, %rbx
jmp 0x175b7
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9106
leaq 0xd0(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::handleRead(RegisterBlock&, Block&, Line&)
void FourthIR::handleRead(RegisterBlock& rb, Block& b, Line& l)
{   
    Register& r = rb.getRegister(l.one, b, {}, true, false);
    r.variableName = l.one;
    r.needToSafe = true;

    b.lines.push_back({"GET", r.name});    
    updateRegisterState(b, rb, r, l.one);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
addq $0x20, %r14
leaq 0xa8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x4390
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
pushq $0x1
popq %r8
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
xorl %r9d, %r9d
callq 0x5ec6
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x9106
leaq 0xa8(%rsp), %rdi
callq 0x4548
leaq 0x30(%r15), %rdi
movq %r14, %rsi
callq 0x4180
movb $0x1, 0x50(%r15)
leaq 0xbee1(%rip), %rsi      # 0x2352b
leaq 0x68(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x4a54
movq %r15, %rsi
addq $0x10, %rsi
leaq 0x48(%rsp), %rdi
callq 0x4390
leaq 0xba72(%rip), %rsi      # 0x230e3
leaq 0x28(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x4a54
leaq 0xc8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0x816a
addq $0x20, %r12
leaq 0xc8(%rsp), %rsi
movq %r12, %rdi
callq 0x8f90
leaq 0xc8(%rsp), %rdi
callq 0x81fe
leaq 0x28(%rsp), %rdi
callq 0x4548
leaq 0x48(%rsp), %rdi
callq 0x4548
leaq 0x68(%rsp), %rdi
callq 0x4548
leaq 0x88(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x4390
movq %rbx, %rdi
movq %r15, %rcx
movq %r12, %r8
callq 0x192a6
leaq 0x88(%rsp), %rdi
callq 0x4548
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
jmp 0x1777b
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x81fe
jmp 0x1773c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4548
jmp 0x1774b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4548
jmp 0x1775a
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0x1777b
movq %rax, %rbx
jmp 0x17780
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x9106
leaq 0xa8(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/FourthIR.cpp
// Function: FourthIR::handleSimpleOperation(RegisterBlock&, Block&, Line&)
void FourthIR::handleSimpleOperation(RegisterBlock& rb, Block& b, Line& l)
{    
    Register& r = rb.getRegister(l.one, b, {}, true, true);
    if (l.operation == "DEC" || l.operation == "INC" || l.operation == "HALF")
    {
        r.needToSafe = true;
    }

    b.lines.push_back({l.operation, r.name, l.two});     

    updateRegisterState(b, rb, r, l.one);
    r.variableName = l.one;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rcx), %rbx
leaq 0xa0(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x4390
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
andq $0x0, 0x10(%rcx)
pushq $0x1
popq %r8
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movl %r8d, %r9d
callq 0x5ec6
movq %rax, %r15
movq %rsp, %rdi
callq 0x9106
leaq 0xa0(%rsp), %rdi
callq 0x4548
leaq 0xb146(%rip), %rsi      # 0x2309a
movq %r13, %rdi
callq 0x8453
testb %al, %al
jne 0x17f86
leaq 0xb137(%rip), %rsi      # 0x2309e
movq %r13, %rdi
callq 0x8453
testb %al, %al
jne 0x17f86
leaq 0xb20d(%rip), %rsi      # 0x23187
movq %r13, %rdi
callq 0x8453
testb %al, %al
je 0x17f8b
movb $0x1, 0x50(%r15)
leaq 0x60(%rsp), %rdi
movq %r13, %rsi
callq 0x4390
leaq 0x10(%r15), %rsi
leaq 0x40(%rsp), %rdi
callq 0x4390
addq $0x40, %r13
leaq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0x4390
leaq 0xc0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq 0x816a
addq $0x20, %r12
leaq 0xc0(%rsp), %rsi
movq %r12, %rdi
callq 0x8f90
leaq 0xc0(%rsp), %rdi
callq 0x81fe
leaq 0x20(%rsp), %rdi
callq 0x4548
leaq 0x40(%rsp), %rdi
callq 0x4548
leaq 0x60(%rsp), %rdi
callq 0x4548
leaq 0x80(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4390
movq %r14, %rdi
movq %r15, %rcx
movq %r12, %r8
callq 0x192a6
leaq 0x80(%rsp), %rdi
callq 0x4548
addq $0x30, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4180
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
jmp 0x180bb
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x81fe
jmp 0x18083
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4548
jmp 0x18092
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4548
jmp 0x180a1
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0x180bb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9106
leaq 0xa0(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/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)
cmpq $0x0, 0x80(%rsi)
je 0x19221
leaq 0x78(%r14), %rsi
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x4390
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x1970a
movq %r12, %rdi
callq 0x4548
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
cmpq $0x0, 0x60(%r14)
je 0x19213
cmpq $0x0, 0x40(%r14)
je 0x19213
leaq 0x58(%r14), %rsi
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x4390
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x19ab4
leaq 0x38(%r14), %r13
leaq 0x20(%rsp), %rdi
callq 0x4548
movq %rsp, %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x4390
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x19ab4
jmp 0x1920b
movq %rax, %rbx
movq %rsp, %r12
jmp 0x19295
movq %rax, %rbx
jmp 0x19295
movq %rax, %rbx
leaq 0x40(%rsp), %r12
movq %r12, %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rcx, %rbx
movq %rdi, %r12
movq (%rdi), %r13
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r8, %rsi
callq 0x4390
movq %r13, %rdi
movq %r14, %rsi
callq 0x10950
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x4548
testb %bpl, %bpl
je 0x192f1
pushq $0x1
popq %rax
jmp 0x19323
movq (%r12), %r12
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x4390
movq %r12, %rdi
movq %r14, %rsi
callq 0x108c4
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x4548
movzbl %bpl, %eax
orl $0x2, %eax
movl %eax, (%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19336
movq %rax, %rbx
movq %r14, %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x78(%rdx), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x4390
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19ec2
movq %rax, %r12
movq %r15, %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x1b192
movq %rbx, %rdi
callq 0x19f12
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4390
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x193e0
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x4548
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0xc8, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %rcx, %rsi
callq 0x4390
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x19ec2
movq %rax, %r15
movq %rbp, %rdi
callq 0x4548
cmpb $0x0, 0x1b0(%r15)
je 0x19780
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x4390
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r13, %r8
callq 0x197dc
movq %rsp, %rdi
callq 0x4548
jmp 0x197a8
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x4c30
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x16c54
leaq 0x40(%rsp), %rdi
callq 0x19d86
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x19d86
jmp 0x197d4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq 0xb8(%rdi), %rbx
movq 0xc0(%rdi), %r12
cmpq %r12, %rbx
je 0x19efb
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8141
testb %al, %al
jne 0x19f02
addq $0x1b8, %rbx            # imm = 0x1B8
jmp 0x19ede
movq 0xb8(%r14), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x19dec
movl 0x17409(%rip), %esi     # 0x32324
leaq 0x8(%rsp), %rdi
callq 0xf065
leaq 0x8666(%rip), %rsi      # 0x23592
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xfbe2
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4340
movq %r14, %rdi
callq 0x4548
leaq 0x8(%rsp), %rdi
callq 0x4548
incl 0x173c1(%rip)           # 0x32324
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4548
jmp 0x1af80
movq %rax, %r14
movq %rbx, %rdi
callq 0x13ad2
movq %r14, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x17376(%rip), %esi     # 0x32320
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0xf065
leaq 0x85ab(%rip), %rsi      # 0x23569
movq %rbx, %rdi
movq %r12, %rdx
callq 0xfbe2
leaq 0x48(%rsp), %rdi
callq 0x4548
incl 0x17347(%rip)           # 0x32320
movq (%r15), %r15
testq %r15, %r15
je 0x1b030
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x4390
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x4390
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
callq 0x10266
leaq 0x8(%rsp), %rdi
callq 0x4548
leaq 0x28(%rsp), %rdi
callq 0x4548
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x16f81(%rip), %rdi     # 0x31fb8
leaq 0x8535(%rip), %rsi      # 0x23573
callq 0x4270
movq %rax, %rdi
callq 0x4160
pushq $0x2
popq %rdi
callq 0x4320
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4548
jmp 0x1b065
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x4548
jmp 0x1b07e
movq %rax, %r14
leaq 0x48(%rsp), %rdi
jmp 0x1b081
movq %rax, %r14
movq %rbx, %rdi
callq 0x4548
movq %r14, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
callq 0x19dec
movl 0x17213(%rip), %esi     # 0x32328
leaq 0x8(%rsp), %rdi
callq 0xf065
leaq 0x8473(%rip), %rsi      # 0x23599
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xfbe2
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4340
movq %r14, %rdi
callq 0x4548
leaq 0x8(%rsp), %rdi
callq 0x4548
incl 0x171cb(%rip)           # 0x32328
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4548
jmp 0x1b17a
movq %rax, %r14
movq %rbx, %rdi
callq 0x13ad2
movq %r14, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/IRBase.cpp
// Function: IRBase::getBlockByName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Block, std::allocator<Block>>&)
Block& IRBase::getBlockByName(std::string searched, std::vector<Block>& blocks)
{
    auto result = std::find_if(blocks.begin(), blocks.end(),
    [&searched](auto& tested){
        return searched == tested.blockName;
    });     
    if (result == blocks.end())
    {
        std::cout<<"problem with getBlockByName, searching for="<<searched<<std::endl;
    }
    return *result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %r15
movq 0x8(%rdx), %r12
movq %r12, (%rsp)
subq %r15, %r12
movl $0xa0, %ecx
movq %r12, %rax
cqto
idivq %rcx
movq %rax, %rbp
sarq $0x2, %rbp
testq %rbp, %rbp
jle 0x1b258
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8141
testb %al, %al
jne 0x1b29c
leaq 0xa0(%r15), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8141
testb %al, %al
jne 0x1b2c3
leaq 0x140(%r15), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8141
testb %al, %al
jne 0x1b2c3
leaq 0x1e0(%r15), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8141
testb %al, %al
jne 0x1b2c3
addq $0x280, %r15            # imm = 0x280
decq %rbp
addq $-0x280, %r12           # imm = 0xFD80
jmp 0x1b1e3
movl $0xa0, %ecx
movq %r12, %rax
cqto
idivq %rcx
cmpq $0x1, %rax
je 0x1b2ae
cmpq $0x2, %rax
je 0x1b28d
cmpq $0x3, %rax
jne 0x1b2a1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8141
testb %al, %al
jne 0x1b29c
addq $0xa0, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8141
testb %al, %al
je 0x1b2a7
movq %r15, %r13
jmp 0x1b2c3
movq (%rsp), %r13
jmp 0x1b2c3
addq $0xa0, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8141
testb %al, %al
movq (%rsp), %r13
cmovneq %r15, %r13
cmpq 0x8(%r14), %r13
jne 0x1b2ef
movq 0x16ce8(%rip), %rdi     # 0x31fb8
leaq 0x82d3(%rip), %rsi      # 0x235aa
callq 0x4270
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4250
movq %rax, %rdi
callq 0x4160
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1b364
leaq 0x118(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x44f0
leaq 0x120(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4120
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1b3fe
leaq 0x10(%rsp), %rdi
callq 0x40f0
leaq 0x118(%rsp), %rdi
callq 0x43e0
jmp 0x1b3b9
movq 0x16c7d(%rip), %r14     # 0x31fe8
leaq 0x8264(%rip), %rsi      # 0x235d6
movq %r14, %rdi
callq 0x4270
movq %rax, %rdi
callq 0x4160
movq (%r14), %rax
movq -0x18(%rax), %rax
movq 0xe8(%r14,%rax), %rsi
leaq 0x118(%rsp), %r14
movq %r14, %rdi
callq 0x4120
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b3fe
leaq 0x120(%rsp), %rdi
callq 0x40f0
addq $0x318, %rsp            # imm = 0x318
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x40f0
jmp 0x1b3f5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x40f0
jmp 0x1b3e8
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x43e0
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/DataTypes/Block.hpp
// Function: operator<<(std::ostream&, Block const&)
std::ostream& operator<<(std::ostream& os, const Block& b)
    {
        os << "#"<< b.blockName << std::endl;
        for(auto l : b.lines)
        {
            os <<"\t" << l << std::endl;
        }
        if (!b.blockIfTrue.empty())
        {
            os << "#ifTrue "<< b.blockIfTrue << std::endl;
        }
        if (!b.blockIfFalse.empty())
        {
            os << "#ifFalse "<< b.blockIfFalse << std::endl;
        }
        if (!b.blockJump.empty())
        {
            os << "#jump to "<<b.blockJump << std::endl;
        }
        os << "#end of " << b.blockName << std::endl;
        return os;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x80bf(%rip), %rsi      # 0x2355b
callq 0x4270
movq %rax, %rdi
movq %r14, %rsi
callq 0x4250
movq %rax, %rdi
callq 0x4160
movq 0x20(%r14), %r15
movq 0x28(%r14), %rbp
movq %rsp, %r12
leaq 0x7c1c(%rip), %r13      # 0x230e2
cmpq %rbp, %r15
je 0x1b502
movq %r12, %rdi
movq %r15, %rsi
callq 0x8a26
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4270
movq %rax, %rdi
movq %r12, %rsi
callq 0x1b742
movq %rax, %rdi
callq 0x4160
movq %r12, %rdi
callq 0x81fe
addq $0x68, %r15
jmp 0x1b4c6
cmpq $0x0, 0x40(%r14)
je 0x1b52f
leaq 0x38(%r14), %r15
leaq 0x80dd(%rip), %rsi      # 0x235f1
movq %rbx, %rdi
callq 0x4270
movq %rax, %rdi
movq %r15, %rsi
callq 0x4250
movq %rax, %rdi
callq 0x4160
cmpq $0x0, 0x60(%r14)
je 0x1b55c
leaq 0x58(%r14), %r15
leaq 0x80b9(%rip), %rsi      # 0x235fa
movq %rbx, %rdi
callq 0x4270
movq %rax, %rdi
movq %r15, %rsi
callq 0x4250
movq %rax, %rdi
callq 0x4160
cmpq $0x0, 0x80(%r14)
je 0x1b58c
leaq 0x78(%r14), %r15
leaq 0x8093(%rip), %rsi      # 0x23604
movq %rbx, %rdi
callq 0x4270
movq %rax, %rdi
movq %r15, %rsi
callq 0x4250
movq %rax, %rdi
callq 0x4160
leaq 0x807b(%rip), %rsi      # 0x2360e
movq %rbx, %rdi
callq 0x4270
movq %rax, %rdi
movq %r14, %rsi
callq 0x4250
movq %rax, %rdi
callq 0x4160
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x81fe
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/FifthIR.cpp
// Function: FifthIR::removeJumps()
void FifthIR::removeJumps()
{
    for(auto b = _blocks.begin(); b != _blocks.end(); b++)
    {
        if (onlyComments(*b))
        {
            if ((*b).lines.back().operation == "JUMP")
            {
                std::string arg = (*b).lines.back().two;
                arg.erase(0, 1);
                Block& current = getBlockByName(arg, _blocks);
                replaceJump((*b), current);  
                b = _blocks.erase(b);
                b--;
            }
        }
    }
    for(auto it = _blocks.begin() + 1; it != _blocks.end(); it++)
    {
        Block& previous = *(it-1);
        Block& current = *it;
        if(previous.lines.back().two == "#" + current.blockName)
        {
            previous.lines.erase(previous.lines.end() - 1);
            if (onlyComments(previous))
            {
                replaceJump(previous, current);
            }
        }
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq 0x10(%rdi), %r14
leaq 0x8(%rsp), %r13
leaq 0x28(%rsp), %rbp
cmpq 0x18(%rbx), %r14
je 0x1bac3
movq %r14, %rsi
callq 0x1bfa2
testb %al, %al
je 0x1bab7
movq 0x28(%r14), %rdi
addq $-0x68, %rdi
leaq 0x774a(%rip), %rsi      # 0x2318c
callq 0x8453
testb %al, %al
je 0x1bab7
movq 0x28(%r14), %rsi
addq $-0x28, %rsi
movq %r13, %rdi
callq 0x4390
movq %r13, %rdi
xorl %esi, %esi
pushq $0x1
popq %rdx
callq 0x4080
movq %rbp, %rdi
movq %r13, %rsi
callq 0x4390
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x1b1b0
movq %rax, %r12
movq %rbp, %rdi
callq 0x4548
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1c000
movq %r15, %rdi
movq %r14, %rsi
callq 0x1669e
movq %rax, %r14
addq $-0xa0, %r14
movq %r13, %rdi
callq 0x4548
addq $0xa0, %r14
jmp 0x1ba19
movq (%r15), %r13
leaq 0x7a8e(%rip), %r15      # 0x2355b
leaq 0x8(%rsp), %r12
leaq 0xa0(%r13), %rbp
cmpq %r14, %rbp
je 0x1bb43
movq 0x28(%r13), %r14
addq $-0x28, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x4acd
movq %r14, %rdi
movq %r12, %rsi
callq 0x8141
movl %eax, %r14d
movq %r12, %rdi
callq 0x4548
testb %r14b, %r14b
je 0x1bb3a
leaq 0x20(%r13), %rdi
movq 0x28(%r13), %rsi
addq $-0x68, %rsi
callq 0x166a4
movq %r13, %rsi
callq 0x1bfa2
testb %al, %al
je 0x1bb3a
movq %rbx, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x1c000
movq 0x18(%rbx), %r14
movq %rbp, %r13
jmp 0x1bad2
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1bb65
jmp 0x1bb65
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4548
jmp 0x1bb68
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/FifthIR.cpp
// Function: FifthIR::getFirstInstructionAfter(Block&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int FifthIR::getFirstInstructionAfter(Block& b, std::string name)
{
    bool found = false;
    for(auto& line : b.lines)
    {
        if (line.operation == name)
        {
            found = true;
        }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, (%rsp)
movq 0x20(%rsi), %r12
movq 0x28(%rsi), %rbp
xorl %r14d, %r14d
leaq 0x763c(%rip), %r13      # 0x2355b
cmpq %rbp, %r12
je 0x1bf59
movq %r12, %rdi
movq %r15, %rsi
callq 0x8141
orb %al, %r14b
testb $0x1, %r14b
je 0x1bf53
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x4520
cmpq $-0x1, %rax
jne 0x1bf53
cmpq $0x0, 0x8(%r12)
jne 0x1bf9b
addq $0x68, %r12
jmp 0x1bf1f
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x1c0e2
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x13b04
movq %r14, %rsi
callq 0x1bea0
movl %eax, %ebx
movq %r14, %rdi
callq 0x13ad2
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x60(%r12), %ebx
jmp 0x1bf87
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/FifthIR.cpp
// Function: FifthIR::replaceJump(Block&, Block&)
void FifthIR::replaceJump(Block& previous, Block& current)
{
    for(auto& b : _blocks)
    {
        for(auto& l : b.lines)
        {
            replace(l.operation, previous.blockName, current.blockName);
            replace(l.one, previous.blockName, current.blockName);
            replace(l.two, previous.blockName, current.blockName);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %r13
movq 0x18(%rdi), %rax
movq %rax, (%rsp)
cmpq (%rsp), %r13
je 0x1c079
movq 0x20(%r13), %r12
movq 0x28(%r13), %rbp
cmpq %rbp, %r12
je 0x1c070
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1c122
leaq 0x20(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1c122
leaq 0x40(%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1c122
addq $0x68, %r12
jmp 0x1c02e
addq $0xa0, %r13
jmp 0x1c020
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
movq 0x18(%rdi), %r15
xorl %eax, %eax
cmpq %r15, %r14
je 0x1c111
testb $0x1, %al
jne 0x1c111
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8141
addq $0xa0, %r14
jmp 0x1c0f4
cmpq %r15, %r14
cmovneq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %rdi
movq %rdx, %rsi
xorl %edx, %edx
callq 0x4530
cmpq $-0x1, %rax
je 0x1c164
movq 0x8(%r15), %rdx
leaq (%rdx,%rax), %rcx
cmpq 0x8(%r14), %rcx
jne 0x1c164
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x4110
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::legalize()
void ThirdIR::legalize()
{
    removeCopyWithSameArguments();
    searchForTwoTablesWithSameOperation();
    legalizeSpecificJumps();
    legalizeJumps();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1c1a4
movq %rbx, %rdi
callq 0x1c21e
movq %rbx, %rdi
callq 0x1c45a
movq %rbx, %rdi
popq %rbx
jmp 0x1c5e0
// File: /workspace/github_cpp_makefile_star2_O2/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, %rbx
movq %rsi, %r15
leaq 0x7d7b(%rip), %rsi      # 0x245bd
xorl %r14d, %r14d
movq %r15, %rdi
xorl %edx, %edx
callq 0x4520
cmpq $-0x1, %rax
je 0x1c8dc
leaq 0x7d5d(%rip), %rsi      # 0x245bd
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4520
cmpq $-0x1, %rax
je 0x1c8dc
leaq 0x7d43(%rip), %r14      # 0x245bd
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4520
movq %rsp, %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x42a0
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4520
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x42a0
movq %rsp, %rbx
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8141
movl %eax, %r14d
movq %r15, %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4548
movl %r14d, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4548
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::legalizeJLS(Block&, bool)
void ThirdIR::legalizeJLS(Block& b, bool inc)
{
    if (checkZeroJump(b) && !inc)
    {
        std::swap(b.lines.back().one, b.lines.back().two);
        legalizeJumpWithZero(b);
        return;
    }
    if (checkZeroJump(b) && inc)
    {
        std::swap(b.lines.back().one, b.lines.back().two);
        legalizeJumpWithEqualZero(b);
        return;
    }
    Line lastLine = b.lines.back();
    b.lines.pop_back();

    std::string var = calculateDiff(b, lastLine.two, lastLine.one, inc);
    insertJumps(b, var);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1d0c2
xorb $0x1, %al
orb %bpl, %al
je 0x1c958
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d0c2
andb %bpl, %al
cmpb $0x1, %al
jne 0x1c981
movq 0x28(%rbx), %rsi
leaq -0x48(%rsi), %rdi
addq $-0x28, %rsi
callq 0x41f0
movq %r14, %rdi
movq %rbx, %rsi
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1d630
movq 0x28(%rbx), %rsi
leaq -0x48(%rsi), %rdi
addq $-0x28, %rsi
callq 0x41f0
movq %r14, %rdi
movq %rbx, %rsi
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1d34a
leaq 0x20(%rbx), %r15
movq 0x28(%rbx), %rsi
addq $-0x68, %rsi
leaq 0x80(%rsp), %rdi
callq 0x8a26
movq %r15, %rdi
callq 0x1db72
leaq 0xc0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x4390
leaq 0xa0(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x4390
movzbl %bpl, %r9d
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1cd8a
leaq 0x20(%rsp), %rdi
callq 0x4548
leaq 0x40(%rsp), %rdi
callq 0x4548
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
callq 0x4390
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x1cf44
movq %rsp, %rdi
callq 0x4548
leaq 0x60(%rsp), %rdi
callq 0x4548
leaq 0x80(%rsp), %rdi
callq 0x81fe
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4548
jmp 0x1ca4d
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0x1ca6b
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4548
jmp 0x1ca66
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4548
jmp 0x1ca75
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x81fe
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::legalizeJMR(Block&, bool)
void ThirdIR::legalizeJMR(Block& b, bool inc)
{
    if (checkZeroJump(b) && !inc)
    {
        legalizeJumpWithZero(b);
        return;
    }
    if (checkZeroJump(b) && inc)
    {
        legalizeJumpWithEqualZero(b);
        return;
    }

    Line lastLine = b.lines.back();
    b.lines.pop_back();

    std::string var = calculateDiff(b, lastLine.one, lastLine.two, inc);
    insertJumps(b, var);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1d0c2
xorb $0x1, %al
orb %bpl, %al
je 0x1cad5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d0c2
andb %bpl, %al
cmpb $0x1, %al
jne 0x1caed
movq %r14, %rdi
movq %rbx, %rsi
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1d630
movq %r14, %rdi
movq %rbx, %rsi
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1d34a
leaq 0x20(%rbx), %r15
movq 0x28(%rbx), %rsi
addq $-0x68, %rsi
leaq 0x80(%rsp), %rdi
callq 0x8a26
movq %r15, %rdi
callq 0x1db72
leaq 0xa0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x4390
leaq 0xc0(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x4390
movzbl %bpl, %r9d
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1cd8a
leaq 0x20(%rsp), %rdi
callq 0x4548
leaq 0x40(%rsp), %rdi
callq 0x4548
movq %rsp, %rdi
leaq 0x60(%rsp), %rsi
callq 0x4390
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x1cf44
movq %rsp, %rdi
callq 0x4548
leaq 0x60(%rsp), %rdi
callq 0x4548
leaq 0x80(%rsp), %rdi
callq 0x81fe
addq $0xe8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4548
jmp 0x1cbb9
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
jmp 0x1cbd7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x4548
jmp 0x1cbd2
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4548
jmp 0x1cbe1
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x81fe
movq %rbx, %rdi
callq 0x4490
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::legalizeEquality(Block&)
void ThirdIR::legalizeEquality(Block& b)
{
    if (checkZeroJump(b))
    {
        legalizeZeroJump(b);
        return;
    }
    b.lines.insert(b.lines.begin() + b.lines.size() - 1, {"#DO NOT REMOVE CONST"});
    Line lastLine = b.lines.back();
    legalizeJLS(b, true);
    b.lines.back().one = lastLine.one;
    b.lines.back().two = lastLine.two;
    legalizeJMR(b, true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1d0c2
testb %al, %al
je 0x1cc28
movq %r14, %rdi
movq %rbx, %rsi
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1d92e
movq 0x28(%rbx), %r15
leaq 0x68df(%rip), %rsi      # 0x23512
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x4a54
leaq 0x649a(%rip), %rsi      # 0x230e3
leaq 0x28(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x4a54
leaq 0x6484(%rip), %rsi      # 0x230e3
leaq 0x8(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0x4a54
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0x816a
leaq 0x20(%rbx), %rdi
addq $-0x68, %r15
leaq 0x68(%rsp), %rdx
movq %r15, %rsi
callq 0x1db86
leaq 0x68(%rsp), %rdi
callq 0x81fe
leaq 0x8(%rsp), %rdi
callq 0x4548
leaq 0x28(%rsp), %rdi
callq 0x4548
leaq 0x48(%rsp), %rdi
callq 0x4548
movq 0x28(%rbx), %rsi
addq $-0x68, %rsi
leaq 0x68(%rsp), %rdi
callq 0x8a26
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1c8fc
leaq 0x88(%rsp), %rsi
movq 0x28(%rbx), %rdi
addq $-0x48, %rdi
callq 0x4180
leaq 0xa8(%rsp), %rsi
movq 0x28(%rbx), %rdi
addq $-0x28, %rdi
callq 0x4180
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ca8a
leaq 0x68(%rsp), %rdi
callq 0x81fe
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x81fe
jmp 0x1cd45
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4548
jmp 0x1cd54
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x4548
jmp 0x1cd63
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x4548
jmp 0x1cd81
movq %rax, %rbx
jmp 0x1cd81
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x81fe
movq %rbx, %rdi
callq 0x4490
nop
// File: /workspace/github_cpp_makefile_star2_O2/Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::calculateDiff(Block&, 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)
std::string ThirdIR::calculateDiff(Block& b, std::string one, std::string two, bool inc)
{
    std::string var = _symbolTable->getExtraVariable();
    
    Line copyLine;
    copyLine.operation = "COPY";
    copyLine.one = var;
    copyLine.two = one;
    b.lines.push_back(copyLine);
    
    if (inc)
    {
        Line incLine;
        incLine.operation = "INC";
        incLine.one = var;
        b.lines.push_back(incLine);
    }

    Line subLine;
    subLine.operation = "SUB";
    subLine.one = var;
    subLine.two = two;
    b.lines.push_back(subLine);    

    return var;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x109b6
leaq 0x78(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x62d6(%rip), %rsi      # 0x230c5
leaq 0x68(%rsp), %rdi
callq 0x44e0
leaq 0x88(%rsp), %rdi
movq %rbx, %rsi
callq 0x4180
leaq 0xa8(%rsp), %rdi
movq %r12, %rsi
callq 0x4180
addq $0x20, %r14
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0x13a3e
leaq 0x10(%rsp), %r12
testb %bpl, %bpl
je 0x1ce91
leaq 0x30(%rsp), %rax
movq %r12, -0x30(%rax)
andq $0x0, -0x28(%rax)
xorl %ecx, %ecx
movb %cl, -0x20(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x6235(%rip), %rsi      # 0x2309e
movq %rsp, %rdi
callq 0x44e0
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x4180
movq %rsp, %rsi
movq %r14, %rdi
callq 0x13a3e
movq %rsp, %rdi
callq 0x81fe
leaq 0x30(%rsp), %rax
movq %r12, -0x30(%rax)
andq $0x0, -0x28(%rax)
xorl %ecx, %ecx
movb %cl, -0x20(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x61d0(%rip), %rsi      # 0x23096
movq %rsp, %rdi
callq 0x44e0
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x4180
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x4180
movq %rsp, %rsi
movq %r14, %rdi
callq 0x13a3e
movq %rsp, %rdi
callq 0x81fe
leaq 0x68(%rsp), %rdi
callq 0x81fe
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1cf1a
movq %rax, %r14
movq %rsp, %rdi
callq 0x81fe
jmp 0x1cf2a
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x81fe
movq %rbx, %rdi
callq 0x4548
movq %r14, %rdi
callq 0x4490