LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
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 0x2be1e(%rip), %esi     # 0x693f8
leaq 0x20(%rsp), %rdi
callq 0x1d860
jmp 0x3d5e6
leaq 0x13fff(%rip), %rsi     # 0x515ec
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x1f210
jmp 0x3d5fe
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x4440
leaq 0x40(%rsp), %rdi
callq 0x46e8
leaq 0x20(%rsp), %rdi
callq 0x46e8
movl 0x2bdd2(%rip), %eax     # 0x693f8
addl $0x1, %eax
movl %eax, 0x2bdc9(%rip)     # 0x693f8
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x3d670
jmp 0x3d667
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x3d67a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x46e8
jmp 0x3d67a
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::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:
subq $0x48, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x29fd0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2a870
movq (%rsp), %rsi
movq %rax, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3d7e0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2a870
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3dee0
testb $0x1, %al
jne 0x3d79b
jmp 0x3d7c9
movq 0x2b81e(%rip), %rdi     # 0x68fc0
leaq 0x13e54(%rip), %rsi     # 0x515fd
callq 0x4320
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movq 0x2b7cc(%rip), %rsi     # 0x68f90
callq 0x4380
leaq 0x28(%rsp), %rdi
callq 0x2bda0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x478, %rsp            # imm = 0x478
movq %rdi, 0x470(%rsp)
movq %rsi, 0x468(%rsp)
movq 0x470(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x468(%rsp), %rdi
callq 0x45b0
testb $0x1, %al
jne 0x3d8aa
jmp 0x3d950
movq 0x2b73f(%rip), %rdi     # 0x68ff0
movq %rdi, 0x18(%rsp)
leaq 0x13d6c(%rip), %rsi     # 0x51629
callq 0x4320
movq %rax, %rdi
movq 0x2b6c4(%rip), %rsi     # 0x68f90
callq 0x4380
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x41a0
movq %rax, 0x460(%rsp)
movq 0x460(%rsp), %rsi
leaq 0x350(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x4150
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3da30
jmp 0x3d918
leaq 0x350(%rsp), %rdi
callq 0x4560
jmp 0x3da0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x348(%rsp)
movl %eax, 0x344(%rsp)
leaq 0x350(%rsp), %rdi
callq 0x4560
jmp 0x3da16
movq 0x468(%rsp), %rsi
leaq 0x140(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x10, %edx
callq 0x4670
movq 0x8(%rsp), %rdi
callq 0x4630
movq %rax, 0x10(%rsp)
jmp 0x3d980
movq 0x10(%rsp), %rax
movq %rax, 0x460(%rsp)
movq 0x460(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4150
jmp 0x3d9a1
movq 0x28(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3da30
jmp 0x3d9b2
leaq 0x30(%rsp), %rdi
callq 0x4560
leaq 0x140(%rsp), %rdi
callq 0x4500
jmp 0x3da0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x348(%rsp)
movl %eax, 0x344(%rsp)
jmp 0x3d9ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x348(%rsp)
movl %eax, 0x344(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4560
leaq 0x140(%rsp), %rdi
callq 0x4500
jmp 0x3da16
addq $0x478, %rsp            # imm = 0x478
retq
movq 0x348(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rdi
leaq 0x13656(%rip), %rsi     # 0x5159c
callq 0x4320
movq %rax, %rdi
movq 0xa8(%rsp), %rsi
callq 0x42d0
movq %rax, %rdi
movq 0x2b02b(%rip), %rsi     # 0x68f90
callq 0x4380
movq 0xa8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x1f8a0
movq %rax, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x1f8d0
movq %rax, 0x90(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1fab0
testb $0x1, %al
jne 0x3dfc6
jmp 0x3e05d
leaq 0x98(%rsp), %rdi
callq 0x1faf0
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0xfb20
movq 0xb0(%rsp), %rdi
leaq 0x1312b(%rip), %rsi     # 0x5111a
callq 0x4320
movq %rax, 0x10(%rsp)
jmp 0x3dffb
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3e540
movq %rax, 0x8(%rsp)
jmp 0x3e011
movq 0x8(%rsp), %rdi
movq 0x2af73(%rip), %rsi     # 0x68f90
callq 0x4380
jmp 0x3e024
leaq 0x28(%rsp), %rdi
callq 0xd490
leaq 0x98(%rsp), %rdi
callq 0x1fb00
jmp 0x3dfa8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd490
jmp 0x3e184
movq 0xa8(%rsp), %rdi
addq $0x38, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x3e0a9
movq 0xb0(%rsp), %rdi
leaq 0x135c3(%rip), %rsi     # 0x51644
callq 0x4320
movq %rax, %rdi
movq 0xa8(%rsp), %rsi
addq $0x38, %rsi
callq 0x42d0
movq %rax, %rdi
movq 0x2aeec(%rip), %rsi     # 0x68f90
callq 0x4380
movq 0xa8(%rsp), %rdi
addq $0x58, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x3e0f5
movq 0xb0(%rsp), %rdi
leaq 0x13580(%rip), %rsi     # 0x5164d
callq 0x4320
movq %rax, %rdi
movq 0xa8(%rsp), %rsi
addq $0x58, %rsi
callq 0x42d0
movq %rax, %rdi
movq 0x2aea0(%rip), %rsi     # 0x68f90
callq 0x4380
movq 0xa8(%rsp), %rdi
addq $0x78, %rdi
callq 0x45b0
testb $0x1, %al
jne 0x3e141
movq 0xb0(%rsp), %rdi
leaq 0x1353e(%rip), %rsi     # 0x51657
callq 0x4320
movq %rax, %rdi
movq 0xa8(%rsp), %rsi
addq $0x78, %rsi
callq 0x42d0
movq %rax, %rdi
movq 0x2ae54(%rip), %rsi     # 0x68f90
callq 0x4380
movq 0xb0(%rsp), %rdi
leaq 0x13511(%rip), %rsi     # 0x51661
callq 0x4320
movq %rax, %rdi
movq 0xa8(%rsp), %rsi
callq 0x42d0
movq %rax, %rdi
movq 0x2ae21(%rip), %rsi     # 0x68f90
callq 0x4380
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x45f0
nop
// File: Merulo[P]CompilerJFTT/src/IRs/FifthIR.cpp
// Function: FifthIR::getFirstInstructionInBlock(Block&)
int FifthIR::getFirstInstructionInBlock(Block& b)
{
    for(auto& line : b.lines)
    {
        if (line.operation.find("#") == std::string::npos && !line.operation.empty())
        {
            return line.operationNumber;
        }
    }
    return -1;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe3f0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe380
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xec10
testb $0x1, %al
jne 0x3f5bf
jmp 0x3f60f
leaq 0x10(%rsp), %rdi
callq 0xfb10
movq %rax, (%rsp)
movq (%rsp), %rdi
leaq 0x11fc4(%rip), %rsi     # 0x5159c
xorl %eax, %eax
movl %eax, %edx
callq 0x46b0
cmpq $-0x1, %rax
jne 0x3f601
movq (%rsp), %rdi
callq 0x45b0
testb $0x1, %al
jne 0x3f601
movq (%rsp), %rax
movl 0x60(%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x3f617
jmp 0x3f603
leaq 0x10(%rsp), %rdi
callq 0xf950
jmp 0x3f5aa
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: 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:
subq $0xf8, %rsp
movq %rdx, (%rsp)
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0xd7(%rsp)
movq 0xe0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0xe3f0
movq %rax, 0xc0(%rsp)
movq 0xc8(%rsp), %rdi
callq 0xe380
movq %rax, 0xb8(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xec10
testb $0x1, %al
jne 0x3f6b4
jmp 0x3f749
leaq 0xc0(%rsp), %rdi
callq 0xfb10
movq (%rsp), %rsi
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0xd2c0
testb $0x1, %al
jne 0x3f6e0
jmp 0x3f6e8
movb $0x1, 0xd7(%rsp)
testb $0x1, 0xd7(%rsp)
je 0x3f735
movq 0xb0(%rsp), %rdi
leaq 0x11e9b(%rip), %rsi     # 0x5159c
xorl %eax, %eax
movl %eax, %edx
callq 0x46b0
cmpq $-0x1, %rax
jne 0x3f735
movq 0xb0(%rsp), %rdi
callq 0x45b0
testb $0x1, %al
jne 0x3f735
movq 0xb0(%rsp), %rax
movl 0x60(%rax), %eax
movl %eax, 0xf4(%rsp)
jmp 0x3f788
jmp 0x3f737
leaq 0xc0(%rsp), %rdi
callq 0xf950
jmp 0x3f696
movq 0x8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
callq 0x3fae0
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x29ab0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3f570
movl %eax, 0xf4(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x29a50
movl 0xf4(%rsp), %eax
addq $0xf8, %rsp
retq
nopw (%rax,%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/FifthIR.cpp
// Function: FifthIR::onlyComments(Block&)
bool FifthIR::onlyComments(Block& b)
{
    for(auto& l : b.lines)
    {
        if (l.operation.find("#") == std::string::npos && l.operation != "JUMP")
        {
            return false;
        }
    }

    return true;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe3f0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe380
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xec10
testb $0x1, %al
jne 0x3f7ef
jmp 0x3f842
leaq 0x10(%rsp), %rdi
callq 0xfb10
movq %rax, (%rsp)
movq (%rsp), %rdi
leaq 0x11d94(%rip), %rsi     # 0x5159c
xorl %eax, %eax
movl %eax, %edx
callq 0x46b0
cmpq $-0x1, %rax
jne 0x3f834
movq (%rsp), %rdi
leaq 0x119a2(%rip), %rsi     # 0x511c4
callq 0x310a0
testb $0x1, %al
jne 0x3f82d
jmp 0x3f834
movb $0x0, 0x37(%rsp)
jmp 0x3f847
jmp 0x3f836
leaq 0x10(%rsp), %rdi
callq 0xf950
jmp 0x3f7da
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x29fd0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x2a870
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x30be0
testb $0x1, %al
jne 0x3f8bc
jmp 0x3f98e
leaq 0x40(%rsp), %rdi
callq 0x2bda0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe3f0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xe380
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xec10
testb $0x1, %al
jne 0x3f90c
jmp 0x3f97d
leaq 0x20(%rsp), %rdi
callq 0xfb10
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x3fba0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x3fba0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x40, %rsi
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x3fba0
leaq 0x20(%rsp), %rdi
callq 0xf950
jmp 0x3f8f7
jmp 0x3f97f
leaq 0x40(%rsp), %rdi
callq 0x30c20
jmp 0x3f8a4
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movb $0x0, 0x2f(%rsp)
addq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x29fd0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2a870
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x30be0
testb $0x1, %al
jne 0x3fb34
jmp 0x3fb7e
leaq 0x18(%rsp), %rdi
callq 0x2bda0
movq %rax, 0x8(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x3fb56
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x3fb88
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x29d70
testb $0x1, %al
jne 0x3fb6b
jmp 0x3fb70
movb $0x1, 0x2f(%rsp)
jmp 0x3fb72
leaq 0x18(%rsp), %rdi
callq 0x30c20
jmp 0x3fb1f
movq 0x30(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x46d0
movq %rax, 0x20(%rsp)
cmpq $-0x1, 0x20(%rsp)
jne 0x3fbda
jmp 0x3fc4a
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4520
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4520
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
je 0x3fc17
jmp 0x3fc4a
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x4520
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x28(%rsp), %rcx
callq 0x4130
addq $0x48, %rsp
retq
nop
// File: Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::legalize()
void ThirdIR::legalize()
{
    removeCopyWithSameArguments();
    searchForTwoTablesWithSameOperation();
    legalizeSpecificJumps();
    legalizeJumps();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3fcc0
movq 0x8(%rsp), %rdi
callq 0x3fe30
movq 0x8(%rsp), %rdi
callq 0x40310
movq 0x8(%rsp), %rdi
callq 0x40630
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::removeCopyWithSameArguments()
void ThirdIR::removeCopyWithSameArguments()
{
    for(auto& b : _blocks)
    {
        for(auto i = b.lines.begin(); i != b.lines.end(); i++)
        {
            if (i->operation == "COPY" && i->one == i->two)
            {
                i = b.lines.erase(i);
                i--;
            }
        }
    }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x29fd0
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2a870
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x30be0
testb $0x1, %al
jne 0x3fd0d
jmp 0x3fe20
leaq 0x50(%rsp), %rdi
callq 0x2bda0
movq %rax, 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 0x3fd5a
jmp 0x3fe0f
leaq 0x38(%rsp), %rdi
callq 0x30d40
movq %rax, %rdi
leaq 0x1138f(%rip), %rsi     # 0x510fd
callq 0xdd10
testb $0x1, %al
jne 0x3fd79
jmp 0x3fdf7
leaq 0x38(%rsp), %rdi
callq 0x30d40
addq $0x20, %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x30d40
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq $0x40, %rsi
callq 0xd2c0
testb $0x1, %al
jne 0x3fdad
jmp 0x3fdf7
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 0x3fdf9
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x30e00
movq %rax, 0x10(%rsp)
jmp 0x3fd2f
jmp 0x3fe11
leaq 0x50(%rsp), %rdi
callq 0x30c20
jmp 0x3fcf5
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %rax
movq 0x10(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %rax, 0x88(%rsp)
movq %rdi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
leaq 0x11c75(%rip), %rsi     # 0x526cf
xorl %eax, %eax
movl %eax, %edx
callq 0x46b0
cmpq $-0x1, %rax
jne 0x40a76
movb $0x0, 0x97(%rsp)
jmp 0x40b47
movq 0x20(%rsp), %rdi
leaq 0x11c4d(%rip), %rsi     # 0x526cf
xorl %eax, %eax
movl %eax, %edx
callq 0x46b0
cmpq $-0x1, %rax
jne 0x40a9e
movb $0x0, 0x97(%rsp)
jmp 0x40b47
movq 0x18(%rsp), %rdi
leaq 0x11c25(%rip), %rsi     # 0x526cf
movq %rsi, (%rsp)
xorl %eax, %eax
movl %eax, %edx
movq %rdx, 0x8(%rsp)
callq 0x46b0
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x58(%rsp), %rdi
callq 0x4350
movq (%rsp), %rsi
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
callq 0x46b0
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rcx
leaq 0x38(%rsp), %rdi
callq 0x4350
jmp 0x40aff
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xd2c0
andb $0x1, %al
movb %al, 0x97(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46e8
leaq 0x58(%rsp), %rdi
callq 0x46e8
jmp 0x40b47
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x46e8
jmp 0x40b58
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x128, %rsp            # imm = 0x128
movb %dl, %al
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
andb $0x1, %al
movb %al, 0x117(%rsp)
movq 0x120(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x118(%rsp), %rsi
callq 0x41850
testb $0x1, %al
jne 0x40e62
jmp 0x40e83
testb $0x1, 0x117(%rsp)
jne 0x40e83
movq 0x10(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0x41dd0
jmp 0x40fc0
movq 0x10(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0x41850
testb $0x1, %al
jne 0x40e9b
jmp 0x40ebc
testb $0x1, 0x117(%rsp)
je 0x40ebc
movq 0x10(%rsp), %rdi
movq 0x118(%rsp), %rsi
callq 0x42190
jmp 0x40fc0
movq 0x118(%rsp), %rdi
addq $0x20, %rdi
callq 0x11660
movq %rax, %rsi
leaq 0xa8(%rsp), %rdi
callq 0xfb20
movq 0x118(%rsp), %rdi
addq $0x20, %rdi
callq 0x428a0
movq 0x118(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xc8(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x4180
jmp 0x40f0f
leaq 0xe8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x4180
jmp 0x40f23
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rsi
movzbl 0x117(%rsp), %r9d
andl $0x1, %r9d
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rcx
leaq 0x38(%rsp), %r8
callq 0x41420
jmp 0x40f53
leaq 0x38(%rsp), %rdi
callq 0x46e8
leaq 0x68(%rsp), %rdi
callq 0x46e8
movq 0x118(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x4180
jmp 0x40f87
movq (%rsp), %rsi
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x416b0
jmp 0x40f9c
leaq 0x18(%rsp), %rdi
callq 0x46e8
leaq 0x88(%rsp), %rdi
callq 0x46e8
leaq 0xa8(%rsp), %rdi
callq 0xd490
addq $0x128, %rsp            # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x41041
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x41000
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46e8
leaq 0x68(%rsp), %rdi
callq 0x46e8
jmp 0x41041
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x41034
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x46e8
leaq 0x88(%rsp), %rdi
callq 0x46e8
leaq 0xa8(%rsp), %rdi
callq 0xd490
movq 0x60(%rsp), %rdi
callq 0x45f0
nopl (%rax,%rax)
// File: 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:
subq $0x198, %rsp            # imm = 0x198
movq %r8, (%rsp)
movq %rcx, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
movb %r9b, %al
movq %rdi, %r9
movq %r9, 0x10(%rsp)
movq %rdi, 0x190(%rsp)
movq %rsi, 0x188(%rsp)
movq %rdx, 0x180(%rsp)
movq %rcx, 0x178(%rsp)
movq %r8, 0x170(%rsp)
andb $0x1, %al
movb %al, 0x16f(%rsp)
movq 0x188(%rsp), %rdi
movb $0x0, 0x16e(%rsp)
callq 0xdde0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x21660
leaq 0x100(%rsp), %rdi
callq 0xda30
jmp 0x414a2
leaq 0xfc54(%rip), %rsi      # 0x510fd
leaq 0x100(%rsp), %rdi
callq 0x44a0
jmp 0x414b8
movq 0x18(%rsp), %rsi
leaq 0x120(%rsp), %rdi
callq 0x4050
jmp 0x414cc
movq 0x8(%rsp), %rsi
leaq 0x140(%rsp), %rdi
callq 0x4050
jmp 0x414e0
movq 0x180(%rsp), %rdi
addq $0x20, %rdi
leaq 0x100(%rsp), %rsi
callq 0x297e0
jmp 0x414fb
testb $0x1, 0x16f(%rsp)
je 0x415c4
leaq 0x88(%rsp), %rdi
callq 0xda30
jmp 0x41518
leaq 0xfbb7(%rip), %rsi      # 0x510d6
leaq 0x88(%rsp), %rdi
callq 0x44a0
jmp 0x4152e
movq 0x18(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0x4050
jmp 0x41542
movq 0x180(%rsp), %rdi
addq $0x20, %rdi
leaq 0x88(%rsp), %rsi
callq 0x297e0
jmp 0x4155d
leaq 0x88(%rsp), %rdi
callq 0xd490
jmp 0x415c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
jmp 0x4168b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
jmp 0x41665
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x88(%rsp), %rdi
callq 0xd490
jmp 0x41665
leaq 0x20(%rsp), %rdi
callq 0xda30
jmp 0x415d0
leaq 0xfaf7(%rip), %rsi      # 0x510ce
leaq 0x20(%rsp), %rdi
callq 0x44a0
jmp 0x415e3
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x4050
jmp 0x415f4
movq (%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x4050
jmp 0x41604
movq 0x180(%rsp), %rdi
addq $0x20, %rdi
leaq 0x20(%rsp), %rsi
callq 0x297e0
jmp 0x4161c
movb $0x1, 0x16e(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd490
leaq 0x100(%rsp), %rdi
callq 0xd490
testb $0x1, 0x16e(%rsp)
jne 0x4167e
jmp 0x41674
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf8(%rsp)
movl %eax, 0xf4(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xd490
leaq 0x100(%rsp), %rdi
callq 0xd490
jmp 0x4168b
movq 0x18(%rsp), %rdi
callq 0x46e8
movq 0x10(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
retq
movq 0x18(%rsp), %rdi
callq 0x46e8
movq 0xf8(%rsp), %rdi
callq 0x45f0
nopw %cs:(%rax,%rax)
// File: Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::insertJumps(Block&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void ThirdIR::insertJumps(Block&b, std::string var)
{
    Line jzero;
    jzero.operation = "JZERO";
    jzero.one = var;
    jzero.two = "#"+b.blockIfFalse;
    b.lines.push_back(jzero);

    Line jump;
    jump.operation = "JUMP";
    jump.two = "#"+b.blockIfTrue;
    b.lines.push_back(jump);
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdx, 0x10(%rsp)
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
leaq 0xd8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xda30
movq 0x18(%rsp), %rdi
leaq 0xfac2(%rip), %rsi      # 0x511b4
callq 0x44a0
jmp 0x416f9
movq 0x10(%rsp), %rsi
leaq 0xf8(%rsp), %rdi
callq 0x4050
jmp 0x4170d
movq 0x148(%rsp), %rdx
addq $0x58, %rdx
leaq 0xfe7c(%rip), %rsi      # 0x5159c
leaq 0xa8(%rsp), %rdi
callq 0x5070
jmp 0x4172f
leaq 0x118(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x4440
movq 0x8(%rsp), %rdi
callq 0x46e8
movq 0x148(%rsp), %rdi
addq $0x20, %rdi
leaq 0xd8(%rsp), %rsi
callq 0x297e0
jmp 0x4176e
leaq 0x40(%rsp), %rdi
callq 0xda30
jmp 0x4177a
leaq 0xfa43(%rip), %rsi      # 0x511c4
leaq 0x40(%rsp), %rdi
callq 0x44a0
jmp 0x4178d
movq 0x148(%rsp), %rdx
addq $0x38, %rdx
leaq 0xfdfc(%rip), %rsi      # 0x5159c
leaq 0x20(%rsp), %rdi
callq 0x5070
jmp 0x417ac
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rsi, (%rsp)
callq 0x4440
movq (%rsp), %rdi
callq 0x46e8
movq 0x148(%rsp), %rdi
addq $0x20, %rdi
leaq 0x40(%rsp), %rsi
callq 0x297e0
jmp 0x417e3
leaq 0x40(%rsp), %rdi
callq 0xd490
leaq 0xd8(%rsp), %rdi
callq 0xd490
addq $0x158, %rsp            # imm = 0x158
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x41836
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xd490
leaq 0xd8(%rsp), %rdi
callq 0xd490
movq 0xd0(%rsp), %rdi
callq 0x45f0
// File: Merulo[P]CompilerJFTT/src/IRs/ThirdIR.cpp
// Function: ThirdIR::legalizeZeroJump(Block&)
void ThirdIR::legalizeZeroJump(Block& b)
{
    Line lastLine = b.lines.back();
    b.lines.clear();

    std::string argument = lastLine.one;
    if (_symbolTable->isConst(argument))
    {
        argument = lastLine.two;
    }
    Line l;
    l.operation = "JZERO";
    l.one = argument;
    l.two = "#" + b.blockIfTrue;
    b.lines.push_back(l);

    Line l2;
    l2.operation = "JUMP";
    l2.two = "#" + b.blockIfFalse;
    b.lines.push_back(l2);
}

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x1f8(%rsp), %rdi
addq $0x20, %rdi
callq 0x11660
movq %rax, %rsi
leaq 0x190(%rsp), %rdi
callq 0xfb20
movq 0x1f8(%rsp), %rdi
addq $0x20, %rdi
callq 0x1f100
leaq 0x1b0(%rsp), %rsi
leaq 0x170(%rsp), %rdi
callq 0x4180
jmp 0x425dd
movq 0x28(%rsp), %rdi
callq 0xdde0
movq %rax, 0x20(%rsp)
leaq 0x140(%rsp), %rdi
leaq 0x170(%rsp), %rsi
callq 0x4180
jmp 0x42603
movq 0x20(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x20600
movb %al, 0x1f(%rsp)
jmp 0x4261b
leaq 0x140(%rsp), %rdi
callq 0x46e8
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x42632
jmp 0x426a3
leaq 0x1d0(%rsp), %rsi
leaq 0x170(%rsp), %rdi
callq 0x4050
jmp 0x42649
jmp 0x426a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x168(%rsp)
movl %eax, 0x164(%rsp)
jmp 0x4283e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x168(%rsp)
movl %eax, 0x164(%rsp)
jmp 0x42831
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x168(%rsp)
movl %eax, 0x164(%rsp)
leaq 0x140(%rsp), %rdi
callq 0x46e8
jmp 0x42831
leaq 0xd8(%rsp), %rdi
callq 0xda30
jmp 0x426b2
leaq 0xeafb(%rip), %rsi      # 0x511b4
leaq 0xd8(%rsp), %rdi
callq 0x44a0
jmp 0x426c8
leaq 0xf8(%rsp), %rdi
leaq 0x170(%rsp), %rsi
callq 0x4050
jmp 0x426df
movq 0x1f8(%rsp), %rdx
addq $0x38, %rdx
leaq 0xeeaa(%rip), %rsi      # 0x5159c
leaq 0xb8(%rsp), %rdi
callq 0x5070
jmp 0x42701
leaq 0x118(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
movq %rsi, 0x10(%rsp)
callq 0x4440
movq 0x10(%rsp), %rdi
callq 0x46e8
movq 0x1f8(%rsp), %rdi
addq $0x20, %rdi
leaq 0xd8(%rsp), %rsi
callq 0x297e0
jmp 0x42740
leaq 0x50(%rsp), %rdi
callq 0xda30
jmp 0x4274c
leaq 0xea71(%rip), %rsi      # 0x511c4
leaq 0x50(%rsp), %rdi
callq 0x44a0
jmp 0x4275f
movq 0x1f8(%rsp), %rdx
addq $0x58, %rdx
leaq 0xee2a(%rip), %rsi      # 0x5159c
leaq 0x30(%rsp), %rdi
callq 0x5070
jmp 0x4277e
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rsi, 0x8(%rsp)
callq 0x4440
movq 0x8(%rsp), %rdi
callq 0x46e8
movq 0x1f8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x50(%rsp), %rsi
callq 0x297e0
jmp 0x427b7
leaq 0x50(%rsp), %rdi
callq 0xd490
leaq 0xd8(%rsp), %rdi
callq 0xd490
leaq 0x170(%rsp), %rdi
callq 0x46e8
leaq 0x190(%rsp), %rdi
callq 0xd490
addq $0x208, %rsp            # imm = 0x208
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x168(%rsp)
movl %eax, 0x164(%rsp)
jmp 0x42824
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x168(%rsp)
movl %eax, 0x164(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xd490
leaq 0xd8(%rsp), %rdi
callq 0xd490
leaq 0x170(%rsp), %rdi
callq 0x46e8
leaq 0x190(%rsp), %rdi
callq 0xd490
movq 0x168(%rsp), %rdi
callq 0x45f0
nopl (%rax,%rax)
// File: Merulo[P]CompilerJFTT/src/External/Scanner.cpp
// Function: yy_try_NUL_trans(int)
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 1;
	if ( yy_accept[yy_current_state] )
		{
		(yy_last_accepting_state) = yy_current_state;
		(yy_last_accepting_cpos) = yy_cp;
		}
	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
		{
		yy_current_state = (int) yy_def[yy_current_state];
		if ( yy_current_state >= 92 )
			yy_c = yy_meta[yy_c];
		}
	yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
	yy_is_jam = (yy_current_state == 91);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x25942(%rip), %rax     # 0x69450
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xddef(%rip), %rax      # 0x51910
cmpw $0x0, (%rax,%rcx,2)
je 0x43b3c
movl -0x4(%rbp), %eax
movl %eax, 0x2592b(%rip)     # 0x6945c
movq -0x10(%rbp), %rax
movq %rax, 0x25924(%rip)     # 0x69460
jmp 0x43b3e
movslq -0x4(%rbp), %rcx
leaq 0xdf97(%rip), %rax      # 0x51ae0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0xde73(%rip), %rax      # 0x519d0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x43b93
movslq -0x4(%rbp), %rcx
leaq 0xe02f(%rip), %rax      # 0x51ba0
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x5c, -0x4(%rbp)
jl 0x43b91
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0xe0d5(%rip), %rax      # 0x51c60
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x43b3e
movslq -0x4(%rbp), %rcx
leaq 0xdf42(%rip), %rax      # 0x51ae0
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0xe0de(%rip), %rax      # 0x51c90
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x5b, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x43bd5
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x43bdb
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: Merulo[P]CompilerJFTT/src/External/Parser.cpp
// Function: yy_symbol_print(_IO_FILE*, yysymbol_kind_t, Data const*)
static void
yy_symbol_print (FILE *yyo,
                 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
{
  YYFPRINTF (yyo, "%s %s (",
             yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));

  yy_symbol_value_print (yyo, yykind, yyvaluep);
  YYFPRINTF (yyo, ")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x28, -0xc(%rbp)
jge 0x4806e
leaq 0xa669(%rip), %rax      # 0x526d1
movq %rax, -0x28(%rbp)
jmp 0x4807b
leaq 0xa662(%rip), %rax      # 0x526d7
movq %rax, -0x28(%rbp)
jmp 0x4807b
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %edi
callq 0x48ba0
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0xa62c(%rip), %rsi      # 0x526c9
movb $0x0, %al
callq 0x44d0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x48bc0
movq -0x8(%rbp), %rdi
leaq 0x9475(%rip), %rsi      # 0x51534
movb $0x0, %al
callq 0x44d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Merulo[P]CompilerJFTT/src/External/Parser.cpp
// Function: yytnamerr(char*, char const*)
static YYPTRDIFF_T
yytnamerr (char *yyres, const char *yystr)
{
  if (*yystr == '"')
    {
      YYPTRDIFF_T yyn = 0;
      char const *yyp = yystr;
      for (;;)
        switch (*++yyp)
          {
          case '\'':
          case ',':
            goto do_not_strip_quotes;

          case '\\':
            if (*++yyp != '\\')
              goto do_not_strip_quotes;
            else
              goto append;

          append:
          default:
            if (yyres)
              yyres[yyn] = *yyp;
            yyn++;
            break;

          case '"':
            if (yyres)
              yyres[yyn] = '\0';
            return yyn;
          }
    do_not_strip_quotes: ;
    }

  if (yyres)
    return yystpcpy (yyres, yystr) - yyres;
  else
    return yystrlen (yystr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x22, %eax
jne 0x48d74
movq $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
incq %rcx
movq %rcx, -0x28(%rbp)
movsbl 0x1(%rax), %eax
movl %eax, -0x2c(%rbp)
subl $0x22, %eax
je 0x48d50
jmp 0x48cec
movl -0x2c(%rbp), %eax
subl $0x27, %eax
je 0x48d0a
jmp 0x48cf6
movl -0x2c(%rbp), %eax
subl $0x2c, %eax
je 0x48d0a
jmp 0x48d00
movl -0x2c(%rbp), %eax
subl $0x5c, %eax
je 0x48d0c
jmp 0x48d2a
jmp 0x48d72
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl 0x1(%rax), %eax
cmpl $0x5c, %eax
je 0x48d26
jmp 0x48d72
jmp 0x48d28
jmp 0x48d2a
cmpq $0x0, -0x10(%rbp)
je 0x48d42
movq -0x28(%rbp), %rax
movb (%rax), %dl
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x48d6d
cmpq $0x0, -0x10(%rbp)
je 0x48d63
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48da2
jmp 0x48cd0
jmp 0x48d74
cmpq $0x0, -0x10(%rbp)
je 0x48d95
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4360
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x48da2
movq -0x18(%rbp), %rdi
callq 0x4190
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: GouMinghao[P]graspnms/./geo.cpp
// Function: operator<<(std::ostream&, Mat3x3)
ostream& operator<<(ostream& out,Mat3x3 m)
{
    out<<"Matrix 3x3:\n";
    for (int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            out <<m.data[i][j]<<" ";
        }
        out<<endl;
    }
    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x10a3a(%rip), %rsi     # 0x1c1f9
callq 0xb3b0
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0xb834
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0xb819
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0xb640
movq %rax, %rdi
leaq 0x109fd(%rip), %rsi     # 0x1c206
callq 0xb3b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xb7d8
movq -0x8(%rbp), %rdi
movq 0x1770c(%rip), %rsi     # 0x22f30
callq 0xb400
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb7cb
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: GouMinghao[P]graspnms/./geo.cpp
// Function: Mat3x3::Mat3x3(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>, int)
Mat3x3::Mat3x3(vector<double> v0,vector<double> v1,vector<double> v2,int type)
{
    for(int i = 0;i < 3; i++)
    {
        if(type == 1) // column vector
        {
            (this->data)[i][0] = v0[i];
            (this->data)[i][1] = v1[i];
            (this->data)[i][2] = v2[i];
        }
        else if(type == 0) // row vector
        {
            (this->data)[0][i] = v0[i];
            (this->data)[1][i] = v1[i];
            (this->data)[2][i] = v2[i];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq %rcx, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jge 0xba6d
cmpl $0x1, -0x24(%rbp)
jne 0xb9f0
movq -0x48(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x161a0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, (%rax)
movslq -0x28(%rbp), %rsi
callq 0x161a0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x8(%rax)
movslq -0x28(%rbp), %rsi
callq 0x161a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movslq -0x28(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x10(%rax)
jmp 0xba5d
cmpl $0x0, -0x24(%rbp)
jne 0xba5b
movq -0x48(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x161a0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movslq -0x28(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movslq -0x28(%rbp), %rsi
callq 0x161a0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movslq -0x28(%rbp), %rcx
movsd %xmm0, 0x18(%rax,%rcx,8)
movslq -0x28(%rbp), %rsi
callq 0x161a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movsd (%rcx), %xmm0
movslq -0x28(%rbp), %rcx
movsd %xmm0, 0x30(%rax,%rcx,8)
jmp 0xba5d
jmp 0xba5f
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xb967
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: GouMinghao[P]graspnms/./geo.cpp
// Function: Mat3x3::T()
Mat3x3 Mat3x3::T()
{
    Mat3x3 m;
    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            (m.data)[i][j] = this -> data[j][i];
        }
    }
    return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0xb840
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0xbb56
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0xbb49
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movslq -0xc(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbb08
jmp 0xbb4b
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbafb
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: GouMinghao[P]graspnms/./geo.cpp
// Function: Mat3x3::matmul(Mat3x3)
Mat3x3 Mat3x3::matmul(Mat3x3 m)
{
    // using ikj will be faster
    // in fact, for 3x3 matrix it doesn't matter
    Mat3x3 rm;
    for(int i = 0;i < 3;i++)
    {
        for(int k = 0;k < 3;k++)
        {
            int j;
            for(j = 0; j < 3; j++)
            {
                rm.data[i][j] += this->data[i][k]*m.data[k][j];
            }
        }
    }
    return rm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xb840
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0xbc34
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0xbc24
movl $0x0, -0x14(%rbp)
cmpl $0x3, -0x14(%rbp)
jge 0xbc17
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdx
movslq -0xc(%rbp), %rsi
imulq $0x18, %rsi, %rsi
addq %rsi, %rdx
movslq -0x10(%rbp), %rsi
movsd (%rdx,%rsi,8), %xmm0
movslq -0x10(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movslq -0x14(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xbbb1
jmp 0xbc19
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbba4
jmp 0xbc26
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbb93
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: GouMinghao[P]graspnms/./geo.cpp
// Function: get_vector_3(double, double, double)
vector<double> get_vector_3(double d1,double d2,double d3)
{
    vector<double> v;
    v.reserve(3);
    v.push_back(d1);
    v.push_back(d2);
    v.push_back(d3);
    return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x161c0
movq -0x40(%rbp), %rdi
movl $0x3, %esi
callq 0x161e0
jmp 0xbc7f
movq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x162e0
jmp 0xbc8e
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x162e0
jmp 0xbc9d
movq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x162e0
jmp 0xbcac
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xbcd8
jmp 0xbccf
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x16350
jmp 0xbce2
movq -0x40(%rbp), %rdi
callq 0x16350
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xb5d0
nopl (%rax,%rax)
// File: GouMinghao[P]graspnms/./geo.cpp
// Function: norm(std::vector<double, std::allocator<double>>)
double norm(vector<double> v)
{
    double sum = 0;
    for(int i=0;i < v.size();i++)
    {
        sum += pow(v[i],2.0);
    }
    return sqrt(sum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x164d0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xc55f
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x161a0
movsd (%rax), %xmm0
movsd 0xfad3(%rip), %xmm1     # 0x1c018
callq 0xb5c0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc50f
movsd -0x10(%rbp), %xmm0
callq 0xb2d0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: GouMinghao[P]graspnms/./geo.cpp
// Function: cross(std::vector<double, std::allocator<double>>, std::vector<double, std::allocator<double>>)
vector<double> cross(vector<double> v1,vector<double> v2)
{
    return get_vector_3
    (
        v1[1] * v2[2] - v1[2] * v2[1],
        v1[2] * v2[0] - v1[0] * v2[2],
        v1[0] * v2[1] - v1[1] * v2[0]
    );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x58(%rbp)
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x1, %esi
callq 0x161a0
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x88(%rbp)
movl $0x2, %esi
callq 0x161a0
movq -0x60(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
movl $0x2, %esi
callq 0x161a0
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x90(%rbp)
movl $0x1, %esi
callq 0x161a0
movsd -0x90(%rbp), %xmm1
movsd -0x88(%rbp), %xmm0
movsd -0x80(%rbp), %xmm2
movq -0x60(%rbp), %rdi
mulsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x2, %esi
callq 0x161a0
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x70(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x161a0
movq -0x60(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x161a0
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x78(%rbp)
movl $0x2, %esi
callq 0x161a0
movsd -0x78(%rbp), %xmm1
movsd -0x70(%rbp), %xmm0
movsd -0x68(%rbp), %xmm2
movq -0x60(%rbp), %rdi
mulsd (%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x161a0
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x1, %esi
callq 0x161a0
movq -0x60(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x1, %esi
callq 0x161a0
movq -0x58(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x50(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x161a0
movsd -0x50(%rbp), %xmm3
movsd -0x48(%rbp), %xmm2
movsd -0x40(%rbp), %xmm4
movq -0x38(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd (%rax), %xmm3
movq %xmm3, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm3
mulsd %xmm4, %xmm2
addsd %xmm3, %xmm2
callq 0xbc40
movq -0x20(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nop