LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ActionStmtsNode::toString[abi:cxx11]()
string ActionStmtsNode::toString() {
    ostringstream oss;
    for (auto as : *list_) {
        oss << as->toString();
    }
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1f0(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xaa7b0
movq -0x1e0(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x190(%rbp)
movq -0x190(%rbp), %rdi
callq 0xb6410
movq %rax, -0x198(%rbp)
movq -0x190(%rbp), %rdi
callq 0xb62a0
movq %rax, -0x1a0(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xc0ca0
testb $0x1, %al
jne 0xbf90f
jmp 0xbf9a0
leaq -0x198(%rbp), %rdi
callq 0xc0ce0
movq (%rax), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1c8(%rbp), %rdi
callq *%rax
jmp 0xbf93d
leaq -0x188(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xaa4c0
jmp 0xbf952
leaq -0x1c8(%rbp), %rdi
callq 0xaabe8
leaq -0x198(%rbp), %rdi
callq 0xc0d00
jmp 0xbf8f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xbf9d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xaabe8
jmp 0xbf9d1
movq -0x1f0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xbf9b5
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x1e8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x1d0(%rbp), %rdi
callq 0xaaa60
nopl (%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ActionNode::ActionNode(AstNode*, AstNode*, AstNode*)
ActionNode::ActionNode(AstNode* name, AstNode* params, AstNode* stmts) {
    nodeType_ = typeid(*this).name();
    name_ = dynamic_cast<NameNode*>(name);
    name_->parent_ = this;
    params_ = dynamic_cast<ActionParamsNode*>(params);
    params_->parent_ = this;
    stmts_ = dynamic_cast<ActionStmtsNode*>(stmts);
    stmts_->parent_ = this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xb2f00
movq -0x38(%rbp), %rax
leaq 0xb32e8(%rip), %rcx     # 0x172d08
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, %rax
jne 0xbfa34
callq 0xaa640
jmp 0xbfa34
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
callq 0xb2f90
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0xaa7c0
jmp 0xbfa56
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xbfa9f
movq -0x40(%rbp), %rdi
leaq 0xb2b71(%rip), %rsi     # 0x1725e0
leaq 0xb2f1a(%rip), %rdx     # 0x172990
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x48(%rbp)
jmp 0xbfaa7
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xb2fd0
jmp 0xbfb57
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0xbfaa7
movq -0x38(%rbp), %rcx
movq -0x48(%rbp), %rax
movq %rax, 0x40(%rcx)
movq 0x40(%rcx), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xbfaea
movq -0x50(%rbp), %rdi
leaq 0xb2b0c(%rip), %rsi     # 0x1725e0
leaq 0xb3245(%rip), %rdx     # 0x172d20
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x58(%rbp)
jmp 0xbfaf2
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xbfaf2
movq -0x38(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rax, 0x48(%rcx)
movq 0x48(%rcx), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xbfb35
movq -0x60(%rbp), %rdi
leaq 0xb2ac1(%rip), %rsi     # 0x1725e0
leaq 0xb3212(%rip), %rdx     # 0x172d38
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x68(%rbp)
jmp 0xbfb3d
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0xbfb3d
movq -0x38(%rbp), %rcx
movq -0x68(%rbp), %rax
movq %rax, 0x50(%rcx)
movq 0x50(%rcx), %rax
movq %rcx, 0x30(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xaaa60
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ActionNode::toString[abi:cxx11]()
string ActionNode::toString() {
    ostringstream oss;
    oss << "action " << name_->toString()
                     << "(" << params_->toString() << ") {\n"
        << stmts_->toString()
        << "}\n";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x220(%rbp)
movq %rdi, %rax
movq %rax, -0x218(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0xaa7b0
movq -0x208(%rbp), %rdi
leaq 0x7a64b(%rip), %rsi     # 0x13a2fb
callq 0xaa540
movq %rax, -0x200(%rbp)
jmp 0xbfcbe
movq -0x210(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1b8(%rbp), %rdi
callq *%rax
jmp 0xbfcda
movq -0x200(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x228(%rbp)
jmp 0xbfcf6
movq -0x228(%rbp), %rdi
leaq 0x7e285(%rip), %rsi     # 0x13df89
callq 0xaa540
movq %rax, -0x230(%rbp)
jmp 0xbfd12
movq -0x210(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1d8(%rbp), %rdi
callq *%rax
jmp 0xbfd2e
movq -0x230(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x238(%rbp)
jmp 0xbfd4a
movq -0x238(%rbp), %rdi
leaq 0x7e23e(%rip), %rsi     # 0x13df96
callq 0xaa540
movq %rax, -0x240(%rbp)
jmp 0xbfd66
movq -0x210(%rbp), %rax
movq 0x50(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1f8(%rbp), %rdi
callq *%rax
jmp 0xbfd82
movq -0x240(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x248(%rbp)
jmp 0xbfd9e
movq -0x248(%rbp), %rdi
leaq 0x7abfd(%rip), %rsi     # 0x13a9a9
callq 0xaa540
jmp 0xbfdb3
leaq -0x1f8(%rbp), %rdi
callq 0xaabe8
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
movq -0x220(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xbfdec
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x218(%rbp), %rax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xbfe7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xbfe6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xbfe62
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0xaabe8
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x190(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: FieldNode::toString[abi:cxx11]()
string FieldNode::toString() {
    ostringstream oss;
    oss << headerName_->toString()
        << "."
        << fieldName_->toString();
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f0(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xaa7b0
movq -0x1e0(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1a8(%rbp), %rdi
callq *%rax
jmp 0xc8b17
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x1f8(%rbp)
jmp 0xc8b33
movq -0x1f8(%rbp), %rdi
leaq 0x730b0(%rip), %rsi     # 0x13bbf1
callq 0xaa540
movq %rax, -0x200(%rbp)
jmp 0xc8b4f
movq -0x1e0(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1d8(%rbp), %rdi
callq *%rax
jmp 0xc8b6b
movq -0x200(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xaa4c0
jmp 0xc8b80
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
leaq -0x1a8(%rbp), %rdi
callq 0xaabe8
movq -0x1f0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xc8bad
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0xc8c1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0xc8c0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
leaq -0x1a8(%rbp), %rdi
callq 0xaabe8
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x1b0(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: FieldsNode::toString[abi:cxx11]()
string FieldsNode::toString() {
    bool first = true;
    ostringstream oss;

    for (auto fld : *this->list_) {
        if (first) {
            first = false;
        } else {
            oss << ", ";
        }
        oss << fld->toString();
    }
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xaa7b0
movq -0x1e8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x198(%rbp)
movq -0x198(%rbp), %rdi
callq 0xb7b80
movq %rax, -0x1a0(%rbp)
movq -0x198(%rbp), %rdi
callq 0xb7a10
movq %rax, -0x1a8(%rbp)
leaq -0x1a0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xcb0f0
testb $0x1, %al
jne 0xc8d53
jmp 0xc8e0d
leaq -0x1a0(%rbp), %rdi
callq 0xcb130
movq (%rax), %rax
movq %rax, -0x1b0(%rbp)
testb $0x1, -0x11(%rbp)
je 0xc8d75
movb $0x0, -0x11(%rbp)
jmp 0xc8da3
leaq 0x734cb(%rip), %rsi     # 0x13c247
leaq -0x190(%rbp), %rdi
callq 0xaa540
jmp 0xc8d8a
jmp 0xc8da3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0xc8e3e
movq -0x1b0(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1e0(%rbp), %rdi
callq *%rax
jmp 0xc8dbb
leaq -0x190(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xaa4c0
jmp 0xc8dd0
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
leaq -0x1a0(%rbp), %rdi
callq 0xcb150
jmp 0xc8d37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
jmp 0xc8e3e
movq -0x1f8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xaa580
jmp 0xc8e22
leaq -0x190(%rbp), %rdi
callq 0xaa130
movq -0x1f0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0xaa130
movq -0x1b8(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: P4RMalleableFieldNode::mapAltToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int P4RMalleableFieldNode::mapAltToInt(std::string input) {
    int val_int = 0;
    for (FieldNode* alt : *varAlts_->fields_->list_) {
        if (alt->toString().compare(input)==0) {
            return val_int;
        } else {
            val_int += 1;
        }
    }
    return -1;    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, -0x1c(%rbp)
movq 0x58(%rax), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb7b80
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb7a10
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xcb0f0
testb $0x1, %al
jne 0xc9592
jmp 0xc9617
leaq -0x30(%rbp), %rdi
callq 0xcb130
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq *%rax
movq -0x88(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0xaa060
movl %eax, -0x7c(%rbp)
jmp 0xc95ce
leaq -0x60(%rbp), %rdi
callq 0xaabe8
movl -0x7c(%rbp), %eax
cmpl $0x0, %eax
jne 0xc95fe
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc961e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xaabe8
jmp 0xc962a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc9609
leaq -0x30(%rbp), %rdi
callq 0xcb150
jmp 0xc957c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: P4RMalleableTableNode::P4RMalleableTableNode(AstNode*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
P4RMalleableTableNode::P4RMalleableTableNode(AstNode* table, std::string pragma) {
    nodeType_ = typeid(*this).name();
    table_ = dynamic_cast<TableNode*>(table);

    pragmaTransformed_ = false;
    pragma_ = pragma;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xb2f00
movq -0x30(%rbp), %rdi
leaq 0xa9bd8(%rip), %rax     # 0x173248
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x50, %rdi
movq %rdi, -0x38(%rbp)
callq 0xaa7f0
movq -0x30(%rbp), %rax
cmpq $0x0, %rax
jne 0xc9695
callq 0xaa640
jmp 0xc9695
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
callq 0xb2f90
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0xaa7c0
jmp 0xc96b7
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xc9706
movq -0x48(%rbp), %rdi
leaq 0xa8f10(%rip), %rsi     # 0x1725e0
leaq 0xa9721(%rip), %rdx     # 0x172df8
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x50(%rbp)
jmp 0xc970e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xaabe8
movq -0x30(%rbp), %rdi
callq 0xb2fd0
jmp 0xc9733
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xc970e
movq -0x40(%rbp), %rsi
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, 0x40(%rdi)
movb $0x0, 0x48(%rdi)
addq $0x50, %rdi
callq 0xaa070
jmp 0xc972d
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xaaa60
nopl (%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: P4RMalleableTableNode::toString[abi:cxx11]()
string P4RMalleableTableNode::toString() {
    ostringstream oss;
    if(pragma_.compare("")!=0) {
        oss << pragma_ << "\n";
    }
        
    if (!removed_) {
        oss << " malleable ";
    }

    oss << table_->toString();
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d0(%rbp)
movq %rdi, %rax
movq %rax, -0x1c8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0x188(%rbp), %rdi
callq 0xaa7b0
movq -0x1c0(%rbp), %rdi
addq $0x50, %rdi
leaq 0x721e6(%rip), %rsi     # 0x13bba3
callq 0xaa180
cmpl $0x0, %eax
je 0xc9a15
movq -0x1c0(%rbp), %rsi
addq $0x50, %rsi
leaq -0x188(%rbp), %rdi
callq 0xaa4c0
movq %rax, -0x1d8(%rbp)
jmp 0xc99e7
movq -0x1d8(%rbp), %rdi
leaq 0x703df(%rip), %rsi     # 0x139dd4
callq 0xaa540
jmp 0xc99fc
jmp 0xc9a15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xc9ac5
movq -0x1c0(%rbp), %rax
testb $0x1, 0x38(%rax)
jne 0xc9a39
leaq 0x708a5(%rip), %rsi     # 0x13a2ce
leaq -0x188(%rbp), %rdi
callq 0xaa540
jmp 0xc9a37
jmp 0xc9a39
movq -0x1c0(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1b8(%rbp), %rdi
callq *%rax
jmp 0xc9a55
leaq -0x188(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xaa4c0
jmp 0xc9a6a
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
movq -0x1d0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xc9a8b
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x1c8(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x190(%rbp), %rdi
callq 0xaaa60
nopl (%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: P4RInitBlockNode::P4RInitBlockNode(AstNode*, AstNode*)
P4RInitBlockNode::P4RInitBlockNode(AstNode* name, AstNode* body) {
    nodeType_ = typeid(*this).name();
    name_ = dynamic_cast<NameNode*>(name);
    name_->parent_ = this;
    body_ = dynamic_cast<BodyNode*>(body);
    body_->parent_ = this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xb2f00
movq -0x30(%rbp), %rax
leaq 0xa93a4(%rip), %rcx     # 0x173290
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, %rax
jne 0xc9f00
callq 0xaa640
jmp 0xc9f00
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
callq 0xb2f90
movq -0x30(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0xaa7c0
jmp 0xc9f22
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xc9f68
movq -0x38(%rbp), %rdi
leaq 0xa86a5(%rip), %rsi     # 0x1725e0
leaq 0xa8a4e(%rip), %rdx     # 0x172990
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x40(%rbp)
jmp 0xc9f70
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb2fd0
jmp 0xc9fd5
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xc9f70
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rax, 0x40(%rcx)
movq 0x40(%rcx), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xc9fb3
movq -0x48(%rbp), %rdi
leaq 0xa8643(%rip), %rsi     # 0x1725e0
leaq 0xa8b24(%rip), %rdx     # 0x172ac8
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x50(%rbp)
jmp 0xc9fbb
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xc9fbb
movq -0x30(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rax, 0x48(%rcx)
movq 0x48(%rcx), %rax
movq %rcx, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xaaa60
nop
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: P4RInitBlockNode::toString[abi:cxx11]()
string P4RInitBlockNode::toString() {
    if (removed_) {
        return "";
    }

    ostringstream oss;
    oss << "initialization " 
        << name_->toString()
        << " {\n"
        << body_->toString()
        << "}";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
testb $0x1, 0x38(%rax)
je 0xca069
leaq -0x11(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0xaaa70
movq -0x1f8(%rbp), %rdi
movq -0x200(%rbp), %rdx
leaq 0x71b69(%rip), %rsi     # 0x13bba3
callq 0xaa7d0
jmp 0xca041
leaq -0x11(%rbp), %rdi
callq 0xaa5f0
jmp 0xca1c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xaa5f0
jmp 0xca1d2
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x210(%rbp)
callq 0xaa7b0
movq -0x210(%rbp), %rdi
leaq 0x7025f(%rip), %rsi     # 0x13a2e9
callq 0xaa540
movq %rax, -0x208(%rbp)
jmp 0xca098
movq -0x1e8(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1c0(%rbp), %rdi
callq *%rax
jmp 0xca0b4
movq -0x208(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x218(%rbp)
jmp 0xca0d0
movq -0x218(%rbp), %rdi
leaq 0x73eb9(%rip), %rsi     # 0x13df97
callq 0xaa540
movq %rax, -0x220(%rbp)
jmp 0xca0ec
movq -0x1e8(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1e0(%rbp), %rdi
callq *%rax
jmp 0xca108
movq -0x220(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x228(%rbp)
jmp 0xca124
movq -0x228(%rbp), %rdi
leaq 0x71e66(%rip), %rsi     # 0x13bf98
callq 0xaa540
jmp 0xca139
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
leaq -0x1c0(%rbp), %rdi
callq 0xaabe8
movq -0x1f8(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xaa580
jmp 0xca166
leaq -0x1a0(%rbp), %rdi
callq 0xaa130
jmp 0xca1c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xca1b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xca1a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
leaq -0x1c0(%rbp), %rdi
callq 0xaabe8
leaq -0x1a0(%rbp), %rdi
callq 0xaa130
jmp 0xca1d2
movq -0x1f0(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xaaa60
nopl (%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: P4RReactionNode::toString[abi:cxx11]()
string P4RReactionNode::toString() {
    if (removed_) {
        return "";
    }

    ostringstream oss;
    oss << "reaction " 
        << name_->toString()
        << " (" 
        << args_->toString()
        << " ) {\n"
        << body_->toString()
        << "}";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x218(%rbp)
movq %rdi, %rax
movq %rax, -0x210(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x208(%rbp)
testb $0x1, 0x38(%rax)
je 0xca589
leaq -0x11(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0xaaa70
movq -0x218(%rbp), %rdi
movq -0x220(%rbp), %rdx
leaq 0x71649(%rip), %rsi     # 0x13bba3
callq 0xaa7d0
jmp 0xca561
leaq -0x11(%rbp), %rdi
callq 0xaa5f0
jmp 0xca75c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0xaa5f0
jmp 0xca76c
leaq -0x1a0(%rbp), %rdi
movq %rdi, -0x230(%rbp)
callq 0xaa7b0
movq -0x230(%rbp), %rdi
leaq 0x6fd4f(%rip), %rsi     # 0x13a2f9
callq 0xaa540
movq %rax, -0x228(%rbp)
jmp 0xca5b8
movq -0x208(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1c0(%rbp), %rdi
callq *%rax
jmp 0xca5d4
movq -0x228(%rbp), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x238(%rbp)
jmp 0xca5f0
movq -0x238(%rbp), %rdi
leaq 0x7398a(%rip), %rsi     # 0x13df88
callq 0xaa540
movq %rax, -0x240(%rbp)
jmp 0xca60c
movq -0x208(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1e0(%rbp), %rdi
callq *%rax
jmp 0xca628
movq -0x240(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x248(%rbp)
jmp 0xca644
movq -0x248(%rbp), %rdi
leaq 0x73943(%rip), %rsi     # 0x13df95
callq 0xaa540
movq %rax, -0x250(%rbp)
jmp 0xca660
movq -0x208(%rbp), %rax
movq 0x50(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x200(%rbp), %rdi
callq *%rax
jmp 0xca67c
movq -0x250(%rbp), %rdi
leaq -0x200(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x258(%rbp)
jmp 0xca698
movq -0x258(%rbp), %rdi
leaq 0x718f2(%rip), %rsi     # 0x13bf98
callq 0xaa540
jmp 0xca6ad
leaq -0x200(%rbp), %rdi
callq 0xaabe8
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
leaq -0x1c0(%rbp), %rdi
callq 0xaabe8
movq -0x218(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xaa580
jmp 0xca6e6
leaq -0x1a0(%rbp), %rdi
callq 0xaa130
jmp 0xca75c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xca74e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xca742
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xca736
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x200(%rbp), %rdi
callq 0xaabe8
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
leaq -0x1c0(%rbp), %rdi
callq 0xaabe8
leaq -0x1a0(%rbp), %rdi
callq 0xaa130
jmp 0xca76c
movq -0x210(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: ReactionArgsNode::toString[abi:cxx11]()
string ReactionArgsNode::toString() {
    bool first = true;
    ostringstream oss;
    for (auto ra : *list_) {
        if (first) {
            first = false;
        } else {
            oss << ", ";
        }
        oss << ra->toString();
    }
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movb $0x1, -0x11(%rbp)
leaq -0x190(%rbp), %rdi
callq 0xaa7b0
movq -0x1e8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x198(%rbp)
movq -0x198(%rbp), %rdi
callq 0xb73b0
movq %rax, -0x1a0(%rbp)
movq -0x198(%rbp), %rdi
callq 0xb7240
movq %rax, -0x1a8(%rbp)
leaq -0x1a0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xcb210
testb $0x1, %al
jne 0xca893
jmp 0xca94d
leaq -0x1a0(%rbp), %rdi
callq 0xcb250
movq (%rax), %rax
movq %rax, -0x1b0(%rbp)
testb $0x1, -0x11(%rbp)
je 0xca8b5
movb $0x0, -0x11(%rbp)
jmp 0xca8e3
leaq 0x7198b(%rip), %rsi     # 0x13c247
leaq -0x190(%rbp), %rdi
callq 0xaa540
jmp 0xca8ca
jmp 0xca8e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0xca97e
movq -0x1b0(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1e0(%rbp), %rdi
callq *%rax
jmp 0xca8fb
leaq -0x190(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xaa4c0
jmp 0xca910
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
leaq -0x1a0(%rbp), %rdi
callq 0xcb270
jmp 0xca877
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
jmp 0xca97e
movq -0x1f8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xaa580
jmp 0xca962
leaq -0x190(%rbp), %rdi
callq 0xaa130
movq -0x1f0(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x190(%rbp), %rdi
callq 0xaa130
movq -0x1b8(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: ReactionArgNode::ReactionArgNode(ReactionArgNode::ArgType const&, AstNode*, AstNode*, AstNode*)
ReactionArgNode::ReactionArgNode(const ArgType& argType, AstNode* arg, AstNode* index1, AstNode* index2)
                                 : argType_(argType) {
    nodeType_ = typeid(*this).name();
    arg_ = arg;
    arg_->parent_ = this;

    index1_ = dynamic_cast<IntegerNode*>(index1);
    index2_ = dynamic_cast<IntegerNode*>(index2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xb2f00
movq -0x40(%rbp), %rax
leaq 0xa8904(%rip), %rcx     # 0x1732d8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x3c(%rax)
cmpq $0x0, %rax
jne 0xca9f1
callq 0xaa640
jmp 0xca9f1
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
callq 0xb2f90
movq -0x40(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0xaa7c0
jmp 0xcaa13
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rax, 0x40(%rcx)
movq 0x40(%rcx), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xcaa6d
movq -0x48(%rbp), %rdi
leaq 0xa7ba0(%rip), %rsi     # 0x1725e0
leaq 0xa8009(%rip), %rdx     # 0x172a50
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x50(%rbp)
jmp 0xcaa75
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xb2fd0
jmp 0xcaaca
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0xcaa75
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xcaab0
movq -0x58(%rbp), %rdi
leaq 0xa7b46(%rip), %rsi     # 0x1725e0
leaq 0xa7faf(%rip), %rdx     # 0x172a50
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x60(%rbp)
jmp 0xcaab8
xorl %eax, %eax
movq %rax, -0x60(%rbp)
jmp 0xcaab8
movq -0x40(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, 0x50(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: MblRefNode::deepCopy()
MblRefNode* MblRefNode::deepCopy() {
    auto newNode = new MblRefNode(name_->deepCopy());
    newNode->transformed_ = transformed_;
    newNode->transformedHeader_ = transformedHeader_;
    newNode->transformedField_ = transformedField_;

    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x88, %edi
callq 0xaa560
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x30(%rbp)
movq 0x80(%rax), %rdi
callq 0xcb290
movq %rax, -0x28(%rbp)
jmp 0xcacab
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0xcab10
jmp 0xcacba
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movb 0x39(%rsi), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x39(%rax)
addq $0x40, %rsi
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0xaa070
movq -0x38(%rbp), %rsi
addq $0x60, %rsi
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0xaa070
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xaa4e0
movq -0x18(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: MblRefNode::toString[abi:cxx11]()
string MblRefNode::toString() {
    if (transformed_) {
        if (!inReaction_) {
            return transformedHeader_ + "." + transformedField_;
        }
    } else {
        ostringstream oss;
        oss << "${" << name_->toString() << "}";
        return oss.str();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1f0(%rbp)
movq %rdi, %rax
movq %rax, -0x1e8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
testb $0x1, 0x39(%rax)
je 0xcade1
movq -0x1e0(%rbp), %rax
testb $0x1, 0x3a(%rax)
jne 0xcaddc
movq -0x1e0(%rbp), %rsi
addq $0x40, %rsi
leaq 0x70e6d(%rip), %rdx     # 0x13bbf1
leaq -0x30(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
callq 0xcb380
movq -0x1e0(%rbp), %rdx
movq -0x1f0(%rbp), %rdi
movq -0x1f8(%rbp), %rsi
addq $0x60, %rdx
callq 0xcb330
jmp 0xcadb4
leaq -0x30(%rbp), %rdi
callq 0xaabe8
jmp 0xcaec5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xaabe8
jmp 0xcaed5
jmp 0xcaec3
leaq -0x1b8(%rbp), %rdi
movq %rdi, -0x208(%rbp)
callq 0xaa7b0
movq -0x208(%rbp), %rdi
leaq 0x6f501(%rip), %rsi     # 0x13a303
callq 0xaa540
movq %rax, -0x200(%rbp)
jmp 0xcae10
movq -0x1e0(%rbp), %rax
movq 0x80(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1d8(%rbp), %rdi
callq *%rax
jmp 0xcae2f
movq -0x200(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x210(%rbp)
jmp 0xcae4b
movq -0x210(%rbp), %rdi
leaq 0x7113f(%rip), %rsi     # 0x13bf98
callq 0xaa540
jmp 0xcae60
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
movq -0x1f0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xaa580
jmp 0xcae81
leaq -0x1b8(%rbp), %rdi
callq 0xaa130
jmp 0xcaec5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xcaeb5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
leaq -0x1b8(%rbp), %rdi
callq 0xaa130
jmp 0xcaed5
ud2
movq -0x1e8(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xaaa60
nop
// File: eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: UnanchoredNode::UnanchoredNode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
UnanchoredNode::UnanchoredNode(string* newCode, string* objType,
                               string* objName) {
    nodeType_ = typeid(*this).name();
    codeBlob_ = newCode;
    objType_ = objType;
    objName_ = objName;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xb2f00
movq -0x38(%rbp), %rax
leaq 0xa83f8(%rip), %rcx     # 0x173308
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, %rax
jne 0xcaf24
callq 0xaa640
jmp 0xcaf24
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
callq 0xb2f90
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0xaa7c0
jmp 0xcaf46
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x50(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xb2fd0
movq -0x28(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/compile/compile_c.cpp
// Function: generateDialogueArgStart(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int)
void generateDialogueArgStart(ostringstream& oss_reaction_mirror, int ing_iso_opt, int egr_iso_opt) {

    // Shared tmp variables
    oss_reaction_mirror << "  int __mantis__reg_flags=1;\n"
                       << "  int __mantis__value_count;\n"
                       << "  int __mantis__num_actually_read;\n"
                       << "  int __mantis__i;\n";
    // Take snapshots of ing/egr metrics
    if(((unsigned int)ing_iso_opt) & 0b1) {
        oss_reaction_mirror << "  __mantis__mbl_updated_ing=1;\n"
                           // Update data plane working copy
                           << "\n  __mantis__flip_mv_ing;\n"
                           << "\n  __mantis__mod_vars_ing;\n"
                           << "\n  __mantis__flip_mv_ing;\n"
                           << "\n  __mantis__mbl_updated_ing=0;\n";  
    }
    if(((unsigned int)egr_iso_opt) & 0b1) {
        oss_reaction_mirror << "  __mantis__mbl_updated_egr=1;\n"
                           // Update data plane working copy
                           << "\n  __mantis__flip_mv_egr;\n"
                           << "\n  __mantis__mod_vars_egr;\n"
                           << "\n  __mantis__flip_mv_egr;\n"
                           << "\n  __mantis__mbl_updated_egr=0;\n";  
    }    

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x651e1(%rip), %rsi     # 0x13ba2e
callq 0xaa540
movq %rax, %rdi
leaq 0x651f0(%rip), %rsi     # 0x13ba4c
callq 0xaa540
movq %rax, %rdi
leaq 0x651ff(%rip), %rsi     # 0x13ba6a
callq 0xaa540
movq %rax, %rdi
leaq 0x65214(%rip), %rsi     # 0x13ba8e
callq 0xaa540
movl -0xc(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd68d6
movq -0x8(%rbp), %rdi
leaq 0x6520d(%rip), %rsi     # 0x13baa2
callq 0xaa540
movq %rax, %rdi
leaq 0x6521e(%rip), %rsi     # 0x13bac2
callq 0xaa540
movq %rax, %rdi
leaq 0x6522a(%rip), %rsi     # 0x13badd
callq 0xaa540
movq %rax, %rdi
leaq 0x65200(%rip), %rsi     # 0x13bac2
callq 0xaa540
movq %rax, %rdi
leaq 0x65228(%rip), %rsi     # 0x13baf9
callq 0xaa540
movl -0x10(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd692d
movq -0x8(%rbp), %rdi
leaq 0x6522e(%rip), %rsi     # 0x13bb1a
callq 0xaa540
movq %rax, %rdi
leaq 0x6523f(%rip), %rsi     # 0x13bb3a
callq 0xaa540
movq %rax, %rdi
leaq 0x6524b(%rip), %rsi     # 0x13bb55
callq 0xaa540
movq %rax, %rdi
leaq 0x65221(%rip), %rsi     # 0x13bb3a
callq 0xaa540
movq %rax, %rdi
leaq 0x65249(%rip), %rsi     # 0x13bb71
callq 0xaa540
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/compile/compile_p4.cpp
// Function: transformPragma(std::vector<AstNode*, std::allocator<AstNode*>>*)
void transformPragma(vector<AstNode*>* astNodes) {
    // For now, a simple increment of stage index
	for (auto node : *astNodes) {
        if(typeContains(node, "TableNode")) {
            if (typeContains(node, "P4R")) {
                P4RMalleableTableNode* tablenode = dynamic_cast<P4RMalleableTableNode*>(node);
                tablenode->transformPragma();
            } else {
                TableNode* tablenode = dynamic_cast<TableNode*>(node);
                tablenode->transformPragma();
            }
        }
    }    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb2ae0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb2b10
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xb2b40
testb $0x1, %al
jne 0x117844
jmp 0x117927
leaq -0x18(%rbp), %rdi
callq 0xb2b80
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x2465a(%rip), %rsi     # 0x13beb9
callq 0x12c730
testb $0x1, %al
jne 0x11786d
jmp 0x117917
movq -0x28(%rbp), %rdi
leaq 0x2431a(%rip), %rsi     # 0x13bb92
callq 0x12c730
testb $0x1, %al
jne 0x117883
jmp 0x1178cd
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x1178b2
movq -0x40(%rbp), %rdi
leaq 0x5ad44(%rip), %rsi     # 0x1725e0
leaq 0x5badd(%rip), %rdx     # 0x173380
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x48(%rbp)
jmp 0x1178ba
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x1178ba
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xc9740
jmp 0x117915
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x1178fc
movq -0x50(%rbp), %rdi
leaq 0x5acfa(%rip), %rsi     # 0x1725e0
leaq 0x5b50b(%rip), %rdx     # 0x172df8
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x58(%rbp)
jmp 0x117904
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x117904
movq -0x58(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xbd9b0
jmp 0x117917
jmp 0x117919
leaq -0x18(%rbp), %rdi
callq 0xb2ba0
jmp 0x11782e
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: typeContains(AstNode*, char const*)
bool typeContains(AstNode* n, const char* type) {
    if (n->nodeType_.find(string(type)) != string::npos) {
        return true;    
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xaaa70
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xaa7d0
jmp 0x12c774
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xaabb0
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xaabe8
leaq -0x39(%rbp), %rdi
callq 0xaa5f0
movq -0x70(%rbp), %rax
cmpq $-0x1, %rax
je 0x12c7c2
movb $0x1, -0x1(%rbp)
jmp 0x12c7c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xaa5f0
jmp 0x12c7d1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xaaa60
nopw (%rax,%rax)
// File: eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: p4KeywordMatches(P4ExprNode*, char const*)
bool p4KeywordMatches(P4ExprNode* n, const char* type) {
    if (n->keyword_->word_->compare(string(type)) == 0) {
        return true;    
    } else {
        return false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xaaa70
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xaa7d0
jmp 0x12c828
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xaa060
movl %eax, -0x6c(%rbp)
jmp 0x12c83a
leaq -0x38(%rbp), %rdi
callq 0xaabe8
leaq -0x39(%rbp), %rdi
callq 0xaa5f0
movl -0x6c(%rbp), %eax
cmpl $0x0, %eax
jne 0x12c888
movb $0x1, -0x1(%rbp)
jmp 0x12c88c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x12c87d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xaabe8
leaq -0x39(%rbp), %rdi
callq 0xaa5f0
jmp 0x12c897
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xaaa60
// File: eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findBlackbox(std::vector<AstNode*, std::allocator<AstNode*>> const&)
vector<P4ExprNode*> findBlackbox(const std::vector<AstNode*>& astNodes) {
    vector<P4ExprNode*> ret;
    for (auto node : astNodes) {
        if (typeContains(node, "P4ExprNode")) {
            P4ExprNode* exprNode = dynamic_cast<P4ExprNode*>(node);
            if (exprNode->keyword_->toString().find("blackbox") != string::npos) {
                ret.push_back(exprNode);
            }
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x12f890
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb8280
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb82b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x12f810
testb $0x1, %al
jne 0x12cdff
jmp 0x12cf08
leaq -0x28(%rbp), %rdi
callq 0x12f850
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq 0x1184f(%rip), %rsi     # 0x13e669
callq 0x12c730
movb %al, -0x81(%rbp)
jmp 0x12ce27
movb -0x81(%rbp), %al
testb $0x1, %al
jne 0x12ce36
jmp 0x12cef8
movq -0x38(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x12ce88
movq -0x90(%rbp), %rdi
leaq 0x4578b(%rip), %rsi     # 0x1725e0
leaq 0x45f0c(%rip), %rdx     # 0x172d68
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x98(%rbp)
jmp 0x12ce93
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x127ca0
jmp 0x12cf28
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0x12ce93
movq -0x98(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x70(%rbp), %rdi
callq *%rax
jmp 0x12ceb4
leaq -0x70(%rbp), %rdi
leaq 0x111c3(%rip), %rsi     # 0x13e082
xorl %eax, %eax
movl %eax, %edx
callq 0xaab90
movq %rax, -0xa0(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xaabe8
movq -0xa0(%rbp), %rax
cmpq $-0x1, %rax
je 0x12cef6
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x12f8b0
jmp 0x12cef4
jmp 0x12cef6
jmp 0x12cef8
jmp 0x12cefa
leaq -0x28(%rbp), %rdi
callq 0x12f870
jmp 0x12cde9
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x12cf1b
movq -0x80(%rbp), %rdi
callq 0x127ca0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findMalleableRefs(std::vector<MblRefNode*, std::allocator<MblRefNode*>>*, std::vector<AstNode*, std::allocator<AstNode*>> const&)
void findMalleableRefs(vector<MblRefNode*>* varRefs,
                      const vector<AstNode*>& astNodes) {
    for (AstNode* node : astNodes) {
        if (typeContains(node, "MblRefNode")) {
            MblRefNode* varRef = dynamic_cast<MblRefNode*>(node);
            varRefs->push_back(varRef);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb8280
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb82b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12f810
testb $0x1, %al
jne 0x12d1f8
jmp 0x12d27a
leaq -0x20(%rbp), %rdi
callq 0x12f850
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
leaq 0xcc0d(%rip), %rsi      # 0x139e20
callq 0x12c730
testb $0x1, %al
jne 0x12d21e
jmp 0x12d26a
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x12d24d
movq -0x40(%rbp), %rdi
leaq 0x453a9(%rip), %rsi     # 0x1725e0
leaq 0x461ea(%rip), %rdx     # 0x173428
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x48(%rbp)
jmp 0x12d255
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x12d255
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x12fa10
jmp 0x12d26c
leaq -0x20(%rbp), %rdi
callq 0x12f870
jmp 0x12d1e2
addq $0x50, %rsp
popq %rbp
retq
// File: eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findTableReadStmt(TableNode const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool findTableReadStmt(const TableNode& table, const string& fieldName) {
    TableReadStmtsNode* reads = table.reads_;
    for (TableReadStmtNode* trs : *reads->list_) {
        if (typeContains(trs->field_, "StrNode")) {
            StrNode* sn = dynamic_cast<StrNode*>(trs->field_);
            if (*sn->word_ == fieldName) {
                return true;
            }
        }
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb44d0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb4360
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc0070
testb $0x1, %al
jne 0x12d528
jmp 0x12d5c4
leaq -0x30(%rbp), %rdi
callq 0xc00b0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0x1114d(%rip), %rsi     # 0x13e694
callq 0x12c730
testb $0x1, %al
jne 0x12d552
jmp 0x12d5b4
movq -0x40(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x12d585
movq -0x50(%rbp), %rdi
leaq 0x45071(%rip), %rsi     # 0x1725e0
leaq 0x4547a(%rip), %rdx     # 0x1729f0
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x58(%rbp)
jmp 0x12d58d
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0x12d58d
movq -0x58(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0xfef60
testb $0x1, %al
jne 0x12d5ac
jmp 0x12d5b2
movb $0x1, -0x1(%rbp)
jmp 0x12d5c8
jmp 0x12d5b4
jmp 0x12d5b6
leaq -0x30(%rbp), %rdi
callq 0xc00d0
jmp 0x12d512
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: eniac[P]Mantis/src/compile/find_nodes.cpp
// Function: findInitBlock(std::vector<AstNode*, std::allocator<AstNode*>>)
P4RInitBlockNode* findInitBlock(std::vector<AstNode*> astNodes){
    // Currently get a single node, easily generalize to multiple distributed init/reaction block
	for (auto node : astNodes) {
		if (node->nodeType_.find(string("InitBlockNode")) != string::npos) {
			P4RInitBlockNode * iNode = dynamic_cast<P4RInitBlockNode *>(node);
			return iNode;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb2ae0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xb2b10
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb2b40
testb $0x1, %al
jne 0x12d863
jmp 0x12d958
leaq -0x20(%rbp), %rdi
callq 0xb2b80
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xaaa70
movq -0x78(%rbp), %rdx
leaq 0x10def(%rip), %rsi     # 0x13e686
leaq -0x50(%rbp), %rdi
callq 0xaa7d0
jmp 0x12d8a2
movq -0x80(%rbp), %rdi
leaq -0x50(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xaabb0
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xaabe8
leaq -0x51(%rbp), %rdi
callq 0xaa5f0
movq -0x88(%rbp), %rax
cmpq $-0x1, %rax
je 0x12d948
movq -0x30(%rbp), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, %rax
je 0x12d928
movq -0x90(%rbp), %rdi
leaq 0x44ce8(%rip), %rsi     # 0x1725e0
leaq 0x45ac9(%rip), %rdx     # 0x1733c8
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x98(%rbp)
jmp 0x12d933
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0xaa5f0
jmp 0x12d96d
xorl %eax, %eax
movq %rax, -0x98(%rbp)
jmp 0x12d933
movq -0x98(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12d960
jmp 0x12d94a
leaq -0x20(%rbp), %rdi
callq 0xb2ba0
jmp 0x12d84d
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)