LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ArgsNode::toString[abi:cxx11]()
string ArgsNode::toString() {
    bool first = true;
    ostringstream oss;
    for (auto bw : *list_) {
        if (first) {
            first = false;
        } else {
            oss << ", ";
        }
        oss << bw->toString();
    }
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
leaq -0x1c8(%rbp), %r14
movq %r14, %rdi
callq 0x415a0
movq 0x40(%r15), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r12
movb $0x1, %al
leaq -0x50(%rbp), %r15
cmpq %r12, %rbx
je 0x4909b
movq (%rbx), %r13
testb $0x1, %al
jne 0x49074
movq %r14, %rdi
leaq 0x31ef0(%rip), %rsi     # 0x7af5f
callq 0x413d0
movq (%r13), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41380
movq %r15, %rdi
callq 0x418c8
addq $0x8, %rbx
xorl %eax, %eax
jmp 0x49059
leaq -0x1c0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x416b0
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x490d3
jmp 0x490d3
movq %rax, %rbx
jmp 0x490e4
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x418c8
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ActionParamNode::deepCopy()
ActionParamNode* ActionParamNode::deepCopy() {
    AstNode* newParam = param_;
    if (param_->nodeType_.find("MblRefNode") != string::npos) {
        newParam = dynamic_cast<MblRefNode*>(param_)->deepCopy();
    }
    auto newNode = new ActionParamNode(newParam);
    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rbx
leaq 0x10(%rbx), %rdi
leaq 0x2fc93(%rip), %rsi     # 0x78df0
xorl %edx, %edx
callq 0x41880
cmpq $-0x1, %rax
je 0x4918e
movq 0x40(%r14), %rdi
leaq 0x4b51b(%rip), %rsi     # 0x94690
leaq 0x4c35c(%rip), %rdx     # 0x954d8
xorl %ecx, %ecx
callq 0x41480
movq %rax, %rdi
callq 0x4dc0e
movq %rax, %rbx
pushq $0x48
popq %rdi
callq 0x413f0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x490f8
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x413a0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ActionParamsNode::deepCopy()
ActionParamsNode* ActionParamsNode::deepCopy() {
    auto newNode = new ActionParamsNode();
    for (auto ap : *list_) {
        auto newParam = ap->deepCopy();
        newNode->push_back(newParam);
    }

    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x48
popq %rdi
callq 0x413f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x491dc
movq 0x40(%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x49267
movq (%r14), %rdi
callq 0x49144
movq %rbx, %rdi
movq %rax, %rsi
callq 0x445c4
addq $0x8, %r14
jmp 0x49249
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x413a0
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ActionParamsNode::toString[abi:cxx11]()
string ActionParamsNode::toString(){
    bool first = true;
    ostringstream oss;
    for (auto ap : *list_) {
        if (first) {
            first = false;
        } else {
            oss << ", ";
        }
        oss << ap->toString();
    }
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
leaq -0x1c8(%rbp), %r14
movq %r14, %rdi
callq 0x415a0
movq 0x40(%r15), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r12
movb $0x1, %al
leaq -0x50(%rbp), %r15
cmpq %r12, %rbx
je 0x49305
movq (%rbx), %r13
testb $0x1, %al
jne 0x492de
movq %r14, %rdi
leaq 0x31c86(%rip), %rsi     # 0x7af5f
callq 0x413d0
movq (%r13), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41380
movq %r15, %rdi
callq 0x418c8
addq $0x8, %rbx
xorl %eax, %eax
jmp 0x492c3
leaq -0x1c0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x416b0
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4933d
jmp 0x4933d
movq %rax, %rbx
jmp 0x4934e
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x418c8
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ActionStmtNode::ActionStmtNode(AstNode*, AstNode*, ActionStmtNode::ActionStmtType, AstNode*, AstNode*)
ActionStmtNode::ActionStmtNode(AstNode* name1, AstNode* args, ActionStmtType type, AstNode* name2, AstNode* index) {
    nodeType_ = typeid(*this).name();
    name1_ = dynamic_cast<NameNode*>(name1);
    name2_ = dynamic_cast<NameNode*>(name2);
    if(args) {
        args_ = dynamic_cast<ArgsNode*>(args);
        args_->parent_ = this;
    }

    index_ = dynamic_cast<IntegerNode*>(index);
    type_ = type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r13
movl %ecx, -0x2c(%rbp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0x448c4
leaq 0x4b9f2(%rip), %rax     # 0x94d80
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x2fc06(%rip), %rsi     # 0x78fa2
callq 0x41850
testq %r14, %r14
je 0x493c0
leaq 0x4b2e3(%rip), %rsi     # 0x94690
leaq 0x4b68c(%rip), %rdx     # 0x94a40
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x41480
jmp 0x493c2
xorl %eax, %eax
movq %rax, 0x40(%rbx)
testq %r13, %r13
je 0x493e5
leaq 0x4b2be(%rip), %rsi     # 0x94690
leaq 0x4b667(%rip), %rdx     # 0x94a40
movq %r13, %rdi
xorl %ecx, %ecx
callq 0x41480
jmp 0x493e7
xorl %eax, %eax
movq %rax, 0x48(%rbx)
testq %r12, %r12
je 0x49410
leaq 0x4b299(%rip), %rsi     # 0x94690
leaq 0x4b98a(%rip), %rdx     # 0x94d88
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x58(%rbx)
movq %rbx, 0x30(%rax)
testq %r15, %r15
je 0x4942f
leaq 0x4b274(%rip), %rsi     # 0x94690
leaq 0x4b6dd(%rip), %rdx     # 0x94b00
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x41480
jmp 0x49431
xorl %eax, %eax
movq %rax, 0x50(%rbx)
movl -0x2c(%rbp), %eax
movl %eax, 0x3c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ActionStmtNode::toString[abi:cxx11]()
string ActionStmtNode::toString() {
    ostringstream oss;
    if(type_==ActionStmtType::NAME_ARGLIST) {
        oss << " " 
            << name1_->toString()
            << "("
            << args_->toString() 
            << ");\n";
    } else if (type_==ActionStmtType::PROG_EXEC) {
        oss << " " 
            << name1_->toString() 
            << " . "
            << name2_->toString()
            << " ( "
            << args_->toString()
            << " );\n";
    } else {
        oss << "parsing error!\n";
    }
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x415a0
movl 0x3c(%r14), %eax
cmpl $0x1, %eax
je 0x4955f
testl %eax, %eax
jne 0x49610
leaq 0x31b59(%rip), %rsi     # 0x7b051
leaq -0x1f0(%rbp), %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x3372a(%rip), %rsi     # 0x7cc51
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x58(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2f8b2(%rip), %rsi     # 0x78e04
movq %rax, %rdi
callq 0x413d0
jmp 0x495fc
leaq 0x31aeb(%rip), %rsi     # 0x7b051
leaq -0x1f0(%rbp), %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2f866(%rip), %rsi     # 0x78dfb
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2f83f(%rip), %rsi     # 0x78dff
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x58(%r14), %rsi
movq (%rsi), %rax
leaq -0x78(%rbp), %rdi
callq *(%rax)
leaq -0x78(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2f818(%rip), %rsi     # 0x78e03
movq %rax, %rdi
callq 0x413d0
leaq -0x78(%rbp), %rdi
callq 0x418c8
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x58(%rbp), %rdi
callq 0x418c8
jmp 0x49623
leaq 0x2f7f1(%rip), %rsi     # 0x78e08
leaq -0x1f0(%rbp), %rdi
callq 0x413d0
leaq -0x1e8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1f0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49669
jmp 0x49679
jmp 0x49679
jmp 0x49687
jmp 0x49687
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x418c8
jmp 0x4966c
jmp 0x49669
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x4967c
jmp 0x49679
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
jmp 0x4968a
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ActionStmtsNode::deepCopy()
ActionStmtsNode* ActionStmtsNode::deepCopy() {
    auto newNode = new ActionStmtsNode();
    for (auto as : *list_) {
        auto newStmt = as->deepCopy();
        newNode->push_back(newStmt);
    }

    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x48
popq %rdi
callq 0x413f0
movq %rax, %rbx
movq %rax, %rdi
callq 0x4969e
movq 0x40(%r14), %rax
movq (%rax), %r14
movq 0x8(%rax), %r15
cmpq %r15, %r14
je 0x49729
movq (%r14), %rdi
callq 0x4945e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x445f6
addq $0x8, %r14
jmp 0x4970b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x413a0
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1c0(%rbp), %r14
movq %r14, %rdi
callq 0x415a0
movq 0x40(%r15), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
leaq -0x48(%rbp), %r15
cmpq %r13, %r12
je 0x497ac
movq (%r12), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41380
movq %r15, %rdi
callq 0x418c8
addq $0x8, %r12
jmp 0x49782
leaq -0x1b8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1c0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x497de
movq %rax, %rbx
jmp 0x497ef
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x418c8
leaq -0x1c0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x448c4
leaq 0x4b59e(%rip), %rax     # 0x94dc8
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x2f77b(%rip), %rsi     # 0x78fb3
callq 0x41850
leaq 0x4ae4c(%rip), %r13     # 0x94690
leaq 0x4b1f5(%rip), %rdx     # 0x94a40
movq %r12, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x40(%rbx)
movq %rbx, 0x30(%rax)
leaq 0x4b569(%rip), %rdx     # 0x94dd0
movq %r15, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x48(%rbx)
movq %rbx, 0x30(%rax)
leaq 0x4b565(%rip), %rdx     # 0x94de8
movq %r14, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x50(%rbx)
movq %rbx, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1f0(%rbp), %r15
movq %r15, %rdi
callq 0x415a0
leaq 0x2f8fd(%rip), %rsi     # 0x79293
movq %r15, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x78(%rbp), %rdi
callq *(%rax)
leaq -0x78(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x33290(%rip), %rsi     # 0x7cc51
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x33272(%rip), %rsi     # 0x7cc5e
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x50(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2fcaa(%rip), %rsi     # 0x796c1
movq %rax, %rdi
callq 0x413d0
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x78(%rbp), %rdi
callq 0x418c8
leaq -0x1e8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1f0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49a7a
jmp 0x49a8d
jmp 0x49a88
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x49a7d
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
jmp 0x49a90
movq %rax, %rbx
jmp 0x49a99
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x418c8
leaq -0x1f0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: P4RMalleableValueNode::toString[abi:cxx11]()
string P4RMalleableValueNode::toString() {
    if (removed_) {
        return "";
    }

    ostringstream oss;
    oss << "Malleable value " << name_->toString() << " {\n" 
        << " " << varWidth_->toString() << "\n"
        << " " << varInit_->toString() << "\n"
        << "}";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
cmpb $0x1, 0x38(%rsi)
jne 0x4c72c
leaq 0x2e1a3(%rip), %rsi     # 0x7a8bb
leaq -0x1f0(%rbp), %rdx
movq %rbx, %rdi
callq 0x411c0
jmp 0x4c831
movq %rsi, %r14
leaq -0x1f0(%rbp), %r15
movq %r15, %rdi
callq 0x415a0
leaq 0x2caf7(%rip), %rsi     # 0x7923c
movq %r15, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x78(%rbp), %rdi
callq *(%rax)
leaq -0x78(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x304ef(%rip), %rsi     # 0x7cc5f
movq %rax, %rdi
callq 0x413d0
leaq 0x2e8d2(%rip), %rsi     # 0x7b051
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2c5fa(%rip), %rsi     # 0x78da4
movq %rax, %rdi
callq 0x413d0
leaq 0x2e898(%rip), %rsi     # 0x7b051
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x50(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2c5c0(%rip), %rsi     # 0x78da4
movq %rax, %rdi
callq 0x413d0
leaq 0x2e4bd(%rip), %rsi     # 0x7acb0
movq %rax, %rdi
callq 0x413d0
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x78(%rbp), %rdi
callq 0x418c8
leaq -0x1e8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1f0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c85b
jmp 0x4c869
jmp 0x4c848
movq %rax, %rbx
jmp 0x4c875
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x4c85e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
jmp 0x4c86c
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x418c8
leaq -0x1f0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1d0(%rbp), %rdi
callq 0x415a0
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x1d0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x41380
leaq 0x2df9f(%rip), %rsi     # 0x7a909
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x1c8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1d0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4c9de
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x4c9e6
jmp 0x4c9e3
movq %rax, %rbx
jmp 0x4c9ef
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x1d0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
leaq -0x1c8(%rbp), %r14
movq %r14, %rdi
callq 0x415a0
movq 0x40(%r15), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r12
movb $0x1, %al
leaq -0x50(%rbp), %r15
cmpq %r12, %rbx
je 0x4cac3
movq (%rbx), %r13
testb $0x1, %al
jne 0x4ca9c
movq %r14, %rdi
leaq 0x2e4c8(%rip), %rsi     # 0x7af5f
callq 0x413d0
movq (%r13), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41380
movq %r15, %rdi
callq 0x418c8
addq $0x8, %rbx
xorl %eax, %eax
jmp 0x4ca81
leaq -0x1c0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x416b0
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4cafb
jmp 0x4cafb
movq %rax, %rbx
jmp 0x4cb0c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x418c8
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: P4RMalleableFieldNode::toString[abi:cxx11]()
string P4RMalleableFieldNode::toString() {
    if (removed_) {
        return "";
    }

    ostringstream oss;
    oss << "malleable field " << name_->toString() << " {\n" 
        << " " << varWidth_->toString() << "\n"
        << " " << varInit_->toString() << "\n"
        << " " << varAlts_->toString() << "\n"
        << "}";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, %rbx
cmpb $0x1, 0x38(%rsi)
jne 0x4cd34
leaq 0x2db9b(%rip), %rsi     # 0x7a8bb
leaq -0x210(%rbp), %rdx
movq %rbx, %rdi
callq 0x411c0
jmp 0x4ce85
movq %rsi, %r14
leaq -0x210(%rbp), %r15
movq %r15, %rdi
callq 0x415a0
leaq 0x2c508(%rip), %rsi     # 0x79255
movq %r15, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x98(%rbp), %rdi
callq *(%rax)
leaq -0x98(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2fee1(%rip), %rsi     # 0x7cc5f
movq %rax, %rdi
callq 0x413d0
leaq 0x2e2c4(%rip), %rsi     # 0x7b051
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x78(%rbp), %rdi
callq *(%rax)
leaq -0x78(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2bfec(%rip), %rsi     # 0x78da4
movq %rax, %rdi
callq 0x413d0
leaq 0x2e28a(%rip), %rsi     # 0x7b051
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x50(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2bfb2(%rip), %rsi     # 0x78da4
movq %rax, %rdi
callq 0x413d0
leaq 0x2e250(%rip), %rsi     # 0x7b051
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x58(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2bf78(%rip), %rsi     # 0x78da4
movq %rax, %rdi
callq 0x413d0
leaq 0x2de75(%rip), %rsi     # 0x7acb0
movq %rax, %rdi
callq 0x413d0
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x78(%rbp), %rdi
callq 0x418c8
leaq -0x98(%rbp), %rdi
callq 0x418c8
leaq -0x208(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x210(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4ceb1
jmp 0x4cebf
jmp 0x4cecd
jmp 0x4ce9e
movq %rax, %rbx
jmp 0x4cedc
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x4ceb4
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
jmp 0x4cec2
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x418c8
jmp 0x4ced0
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x418c8
leaq -0x210(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, -0x30(%rbp)
movq 0x58(%rdi), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbx
xorl %r14d, %r14d
leaq -0x50(%rbp), %r15
cmpq %rbx, %r13
je 0x4cf55
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *(%rax)
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x41040
movl %eax, %r12d
movq %r15, %rdi
callq 0x418c8
testl %r12d, %r12d
je 0x4cf5a
incl %r14d
addq $0x8, %r13
jmp 0x4cf1f
pushq $-0x1
popq %rax
jmp 0x4cf5d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x418c8
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq 0x448c4
leaq 0x48368(%rip), %rax     # 0x95308
movq %rax, (%rbx)
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
andq $0x0, 0x58(%rbx)
leaq 0x50(%rbx), %r15
movb $0x0, 0x60(%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x2c33e(%rip), %rsi     # 0x79301
callq 0x41850
testq %r12, %r12
je 0x4cfe7
leaq 0x476bc(%rip), %rsi     # 0x94690
leaq 0x47ecd(%rip), %rdx     # 0x94ea8
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x41480
jmp 0x4cfe9
xorl %eax, %eax
movq %rax, 0x40(%rbx)
movb $0x0, 0x48(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x41290
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x418c8
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x415a0
leaq 0x50(%r14), %r15
leaq 0x2d704(%rip), %rsi     # 0x7a8bb
movq %r15, %rdi
callq 0x41130
testl %eax, %eax
je 0x4d1e1
leaq -0x1b0(%rbp), %rdi
movq %r15, %rsi
callq 0x41380
leaq 0x2bbcb(%rip), %rsi     # 0x78da4
movq %rax, %rdi
callq 0x413d0
cmpb $0x0, 0x38(%r14)
jne 0x4d1fb
leaq 0x2c077(%rip), %rsi     # 0x79266
leaq -0x1b0(%rbp), %rdi
callq 0x413d0
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x1b0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x41380
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1b0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x4d260
jmp 0x4d25d
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x448c4
leaq 0x47e92(%rip), %rax     # 0x95350
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x2be6a(%rip), %rsi     # 0x79336
callq 0x41850
leaq 0x471b8(%rip), %r12     # 0x94690
leaq 0x47561(%rip), %rdx     # 0x94a40
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x40(%rbx)
movq %rbx, 0x30(%rax)
leaq 0x4767d(%rip), %rdx     # 0x94b78
movq %r14, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x48(%rbx)
movq %rbx, 0x30(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
cmpb $0x1, 0x38(%rsi)
jne 0x4d560
leaq 0x2d36f(%rip), %rsi     # 0x7a8bb
leaq -0x1d0(%rbp), %rdx
movq %rbx, %rdi
callq 0x411c0
jmp 0x4d604
movq %rsi, %r14
leaq -0x1d0(%rbp), %r15
movq %r15, %rdi
callq 0x415a0
leaq 0x2bd08(%rip), %rsi     # 0x79281
movq %r15, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2f6bb(%rip), %rsi     # 0x7cc5f
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2d6e1(%rip), %rsi     # 0x7acb0
movq %rax, %rdi
callq 0x413d0
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x1c8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1d0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d62c
jmp 0x4d627
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x4d62f
movq %rax, %rbx
jmp 0x4d638
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x1d0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/ast/ast_nodes_p4r.cpp
// Function: P4RReactionNode::P4RReactionNode(AstNode*, AstNode*, AstNode*)
P4RReactionNode::P4RReactionNode(AstNode* name, AstNode* args, AstNode* body) {
    nodeType_ = typeid(*this).name();
    name_ = dynamic_cast<NameNode*>(name);
    name_->parent_ = this;
    args_ = dynamic_cast<ReactionArgsNode*>(args);
    args_->parent_ = this;
    if(body->nodeType_.find("EmptyNode")!=string::npos) {
        // if body is empty node
        body_ = new BodyNode(NULL, NULL, new BodyWordNode(BodyWordNode::STRING, new StrNode(new string(""))));
    } else {
        body_ = dynamic_cast<BodyNode*>(body);
    }
    body_->parent_ = this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x448c4
leaq 0x47cf3(%rip), %rax     # 0x95368
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x2bcc6(%rip), %rsi     # 0x79349
callq 0x41850
leaq 0x47001(%rip), %r13     # 0x94690
leaq 0x473aa(%rip), %rdx     # 0x94a40
movq %r12, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x40(%rbx)
movq %rbx, 0x30(%rax)
leaq 0x47df6(%rip), %rdx     # 0x954a8
movq %r15, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x41480
movq %rax, 0x48(%rbx)
movq %rbx, 0x30(%rax)
leaq 0x10(%r14), %rdi
leaq 0x2b685(%rip), %rsi     # 0x78d57
xorl %edx, %edx
callq 0x41880
cmpq $-0x1, %rax
je 0x4d748
pushq $0x60
popq %rdi
callq 0x413f0
movq %rax, %r14
pushq $0x50
popq %rdi
callq 0x413f0
movq %rax, %r15
pushq $0x48
popq %rdi
callq 0x413f0
movq %rax, %r12
pushq $0x20
popq %rdi
callq 0x413f0
movq %rax, %r13
leaq 0x2d1a9(%rip), %rsi     # 0x7a8bb
leaq -0x31(%rbp), %rdx
movq %rax, %rdi
callq 0x411c0
movq %r12, %rdi
movq %r13, %rsi
callq 0x44730
pushq $0x3
popq %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x46ba0
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x46fa6
jmp 0x4d76d
testq %r14, %r14
je 0x4d76a
leaq 0x46f3c(%rip), %rsi     # 0x94690
leaq 0x4741d(%rip), %rdx     # 0x94b78
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x41480
movq %rax, %r14
jmp 0x4d76d
xorl %r14d, %r14d
movq %r14, 0x50(%rbx)
movq %rbx, 0x30(%r14)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d7b4
jmp 0x4d7a6
jmp 0x4d798
movq %rax, -0x30(%rbp)
movq %r13, %rdi
callq 0x413a0
jmp 0x4d79c
movq %rax, -0x30(%rbp)
movq %r12, %rdi
callq 0x413a0
jmp 0x4d7aa
movq %rax, -0x30(%rbp)
movq %r15, %rdi
callq 0x413a0
jmp 0x4d7b8
movq %rax, -0x30(%rbp)
movq %r14, %rdi
callq 0x413a0
jmp 0x4d7c6
movq %rax, -0x30(%rbp)
movq %rbx, %rdi
callq 0x44900
movq -0x30(%rbp), %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
cmpb $0x1, 0x38(%rsi)
jne 0x4d80c
leaq 0x2d0c3(%rip), %rsi     # 0x7a8bb
leaq -0x1f0(%rbp), %rdx
movq %rbx, %rdi
callq 0x411c0
jmp 0x4d8e4
movq %rsi, %r14
leaq -0x1f0(%rbp), %r15
movq %r15, %rdi
callq 0x415a0
leaq 0x2ba6c(%rip), %rsi     # 0x79291
movq %r15, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x40(%r14), %rsi
movq (%rsi), %rax
leaq -0x78(%rbp), %rdi
callq *(%rax)
leaq -0x78(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2f400(%rip), %rsi     # 0x7cc50
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x48(%r14), %rsi
movq (%rsi), %rax
leaq -0x58(%rbp), %rdi
callq *(%rax)
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2f3e2(%rip), %rsi     # 0x7cc5d
movq %rax, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x50(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2d40a(%rip), %rsi     # 0x7acb0
movq %rax, %rdi
callq 0x413d0
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x58(%rbp), %rdi
callq 0x418c8
leaq -0x78(%rbp), %rdi
callq 0x418c8
leaq -0x1e8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1f0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4d909
jmp 0x4d91c
jmp 0x4d917
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x4d90c
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
jmp 0x4d91f
movq %rax, %rbx
jmp 0x4d928
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x418c8
leaq -0x1f0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
leaq -0x1c8(%rbp), %r14
movq %r14, %rdi
callq 0x415a0
movq 0x40(%r15), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r12
movb $0x1, %al
leaq -0x50(%rbp), %r15
cmpq %r12, %rbx
je 0x4d9fb
movq (%rbx), %r13
testb $0x1, %al
jne 0x4d9d4
movq %r14, %rdi
leaq 0x2d590(%rip), %rsi     # 0x7af5f
callq 0x413d0
movq (%r13), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x41380
movq %r15, %rdi
callq 0x418c8
addq $0x8, %rbx
xorl %eax, %eax
jmp 0x4d9b9
leaq -0x1c0(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x416b0
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4da33
jmp 0x4da33
movq %rax, %rbx
jmp 0x4da44
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x418c8
leaq -0x1c8(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
callq 0x448c4
leaq 0x47917(%rip), %rax     # 0x95398
movq %rax, (%rbx)
movl (%r13), %eax
movl %eax, 0x3c(%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x2b8d8(%rip), %rsi     # 0x7936e
callq 0x41850
movq %r12, 0x40(%rbx)
movq %rbx, 0x30(%r12)
testq %r15, %r15
je 0x4dac3
leaq 0x46be0(%rip), %rsi     # 0x94690
leaq 0x47049(%rip), %rdx     # 0x94b00
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x41480
jmp 0x4dac5
xorl %eax, %eax
movq %rax, 0x48(%rbx)
testq %r14, %r14
je 0x4dae8
leaq 0x46bbb(%rip), %rsi     # 0x94690
leaq 0x47024(%rip), %rdx     # 0x94b00
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x41480
jmp 0x4daea
xorl %eax, %eax
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x88, %edi
callq 0x413f0
movq %rax, %rbx
movq 0x80(%r14), %rdi
callq 0x4def0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4db2c
movb 0x39(%r14), %al
movb %al, 0x39(%rbx)
leaq 0x40(%r14), %rsi
leaq 0x40(%rbx), %rdi
callq 0x41290
addq $0x60, %r14
movq %rbx, %rdi
addq $0x60, %rdi
movq %r14, %rsi
callq 0x41290
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x413a0
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x39(%rsi)
jne 0x4dcd4
leaq 0x40(%r14), %rsi
leaq 0x2cc64(%rip), %rdx     # 0x7a909
leaq -0x1b0(%rbp), %r15
movq %r15, %rdi
callq 0x4df81
addq $0x60, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4df58
leaq -0x1b0(%rbp), %rdi
callq 0x418c8
jmp 0x4dd44
leaq -0x1b0(%rbp), %r15
movq %r15, %rdi
callq 0x415a0
leaq 0x2b5b1(%rip), %rsi     # 0x7929b
movq %r15, %rdi
callq 0x413d0
movq %rax, %r15
movq 0x80(%r14), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %rdi
callq *(%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x41380
leaq 0x2cf98(%rip), %rsi     # 0x7acb0
movq %rax, %rdi
callq 0x413d0
leaq -0x38(%rbp), %rdi
callq 0x418c8
leaq -0x1a8(%rbp), %rsi
movq %rbx, %rdi
callq 0x416b0
leaq -0x1b0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4dd76
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x418c8
jmp 0x4dd85
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x418c8
jmp 0x4dd79
movq %rax, %rbx
leaq -0x1b0(%rbp), %rdi
callq 0x410e0
movq %rbx, %rdi
callq 0x41790
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x448c4
leaq 0x47617(%rip), %rax     # 0x953c8
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x2b5ce(%rip), %rsi     # 0x7938d
callq 0x41850
movq %r12, 0x40(%rbx)
movq %r15, 0x48(%rbx)
movq %r14, 0x50(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x44900
movq %r14, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
leaq 0x28928(%rip), %rsi     # 0x7a746
callq 0x413d0
leaq 0x2893a(%rip), %rsi     # 0x7a764
movq %rax, %rdi
callq 0x413d0
leaq 0x28949(%rip), %rsi     # 0x7a782
movq %rax, %rdi
callq 0x413d0
leaq 0x2895e(%rip), %rsi     # 0x7a7a6
movq %rax, %rdi
callq 0x413d0
testb $0x1, %r15b
je 0x51ea0
leaq 0x2895d(%rip), %rsi     # 0x7a7ba
movq %rbx, %rdi
callq 0x413d0
leaq 0x2896e(%rip), %r15     # 0x7a7da
movq %rax, %rdi
movq %r15, %rsi
callq 0x413d0
leaq 0x28977(%rip), %rsi     # 0x7a7f5
movq %rax, %rdi
callq 0x413d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x413d0
leaq 0x28979(%rip), %rsi     # 0x7a811
movq %rax, %rdi
callq 0x413d0
testb $0x1, %r14b
jne 0x51eb1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2897a(%rip), %rsi     # 0x7a832
movq %rbx, %rdi
callq 0x413d0
leaq 0x2898b(%rip), %rbx     # 0x7a852
movq %rax, %rdi
movq %rbx, %rsi
callq 0x413d0
leaq 0x28994(%rip), %rsi     # 0x7a86d
movq %rax, %rdi
callq 0x413d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x413d0
leaq 0x28996(%rip), %rsi     # 0x7a889
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x413d0
// File: /workspace/github_cpp_makefile_star2_O2/eniac[P]Mantis/src/compile/compile_c.cpp
// Function: generateHdlPool(std::vector<AstNode*, std::allocator<AstNode*>>, std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&, int, int)
void generateHdlPool(std::vector<AstNode*> nodeArray, ostringstream& oss_mbl_init, int ing_iso_opt, int egr_iso_opt) {
    // Max number of alts
    for (auto n : nodeArray) {
        if (typeContains(n, "P4RMalleableFieldNode")) {
            auto v = dynamic_cast<P4RMalleableFieldNode*>(n);

            string var_name = *v->name_->word_;

            int num_alt = 0;

            for (FieldNode* tmp_alt : *v->varAlts_->fields_->list_) {
                num_alt += 1;
            }
            PRINT_VERBOSE("Number of alts for %s: %d \n", var_name.c_str(), num_alt);
            if(num_alt > num_max_alts) {
                num_max_alts = num_alt;
            }            
       }
    }

    if(((unsigned int)ing_iso_opt) & 0b10 || ((unsigned int)egr_iso_opt) & 0b10) {
        oss_mbl_init << "  bool __mantis__indicator_hdls"
                     << "[" << std::to_string(kNumUserHdls) << "];\n";
    }    
    // Malloc handler array over linked list for random access, memoization cache omitted
    // oss_mbl_init << "  hdls = (uint32_t *)calloc("
    //              << kNumUserHdls << "*2*" << std::to_string(num_max_alts)
    //              << ", sizeof(uint32_t)"
    //              << ");\n\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, -0x30(%rbp)
movl %edx, -0x2c(%rbp)
movq %rsi, -0x38(%rbp)
movq (%rdi), %rbx
movq 0x8(%rdi), %r15
leaq 0x2375c(%rip), %r12     # 0x7af08
leaq -0x58(%rbp), %r13
cmpq %r15, %rbx
je 0x5782f
movq (%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x71cf8
testb %al, %al
je 0x57829
testq %r14, %r14
je 0x577e9
movq %r14, %rdi
leaq 0x3ceba(%rip), %rsi     # 0x94690
leaq 0x3dc3b(%rip), %rdx     # 0x95418
xorl %ecx, %ecx
callq 0x41480
movq %rax, %r14
jmp 0x577ec
xorl %r14d, %r14d
movq 0x40(%r14), %rax
movq 0x40(%rax), %rsi
movq %r13, %rdi
callq 0x415b0
movq 0x58(%r14), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
shrq $0x3, %rax
cmpl %eax, 0x3ec7b(%rip)     # 0x96494
jge 0x57821
movl %eax, 0x3ec73(%rip)     # 0x96494
movq %r13, %rdi
callq 0x418c8
addq $0x8, %rbx
jmp 0x577b0
movl -0x30(%rbp), %eax
orl -0x2c(%rbp), %eax
testb $0x2, %al
je 0x5788f
leaq 0x237a7(%rip), %rsi     # 0x7afe7
movq -0x38(%rbp), %rdi
callq 0x413d0
leaq 0x23348(%rip), %rsi     # 0x7ab98
movq %rax, %rdi
callq 0x413d0
movq %rax, %rbx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movl $0x1388, %esi           # imm = 0x1388
callq 0x49e1c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x41380
leaq 0x23343(%rip), %rsi     # 0x7abc1
movq %rax, %rdi
callq 0x413d0
leaq -0x58(%rbp), %rdi
callq 0x418c8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x418c8
movq %rbx, %rdi
callq 0x41790
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r13
movq 0x8(%rdi), %r14
leaq 0x117ed(%rip), %rbx     # 0x7abd1
leaq 0x2b2a5(%rip), %r15     # 0x94690
cmpq %r14, %r13
je 0x69450
movq (%r13), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x71cf8
testb %al, %al
je 0x6944a
movq %r12, %rdi
leaq 0x1149d(%rip), %rsi     # 0x7a8aa
callq 0x71cf8
movq %r12, %rdi
movq %r15, %rsi
testb %al, %al
je 0x69434
leaq 0x2c00d(%rip), %rdx     # 0x95430
xorl %ecx, %ecx
callq 0x41480
movq %rax, %rdi
callq 0x4d020
jmp 0x6944a
leaq 0x2ba6d(%rip), %rdx     # 0x94ea8
xorl %ecx, %ecx
callq 0x41480
movq %rax, %rdi
callq 0x48648
addq $0x8, %r13
jmp 0x693eb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq