LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lucaong[P]elixir_mlx90640/src/MLX90640_API.cpp
// Function: MLX90640_SetControlRegister(unsigned char, unsigned short)
int MLX90640_SetControlRegister(uint8_t slaveAddr, uint16_t value)
{
    uint16_t controlRegister1;
    int error;
    
    error = MLX90640_I2CRead(slaveAddr, 0x800D, 1, &controlRegister1);
    if(error == 0)
    {
        value = (controlRegister1 & 0b1110000000000000) | (value & 0b0001111111111111);
        error = MLX90640_I2CWrite(slaveAddr, 0x800D, value);
    }    
    
    return error;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %si, %ax
movb %dil, %cl
movb %cl, -0x1(%rbp)
movw %ax, -0x4(%rbp)
movl $0x800d, %esi           # imm = 0x800D
movl $0x1, %edx
leaq -0x6(%rbp), %rcx
movzbl -0x1(%rbp), %edi
callq 0x5b10
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x5a85
movzwl -0x6(%rbp), %eax
andl $0xe000, %eax           # imm = 0xE000
movzwl -0x4(%rbp), %ecx
andl $0x1fff, %ecx           # imm = 0x1FFF
orl %ecx, %eax
movw %ax, -0x4(%rbp)
movb -0x1(%rbp), %al
movl $0x800d, %esi           # imm = 0x800D
movzbl %al, %edi
movzwl -0x4(%rbp), %edx
callq 0x5ce0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: lucaong[P]elixir_mlx90640/src/MLX90640_LINUX_I2C_Driver.cpp
// Function: MLX90640_I2CWrite(unsigned char, unsigned short, unsigned short)
int MLX90640_I2CWrite(uint8_t slaveAddr, uint16_t writeAddress, uint16_t data)
{ 
  char cmd[4] = {(char)(writeAddress >> 8), (char)(writeAddress & 0x00FF), (char)(data >> 8), (char)(data & 0x00FF)};
  int result;

  struct i2c_msg i2c_messages[1];
  struct i2c_rdwr_ioctl_data i2c_messageset[1];

  i2c_messages[0].addr = slaveAddr;
  i2c_messages[0].flags = 0;
  i2c_messages[0].len = 4;
  i2c_messages[0].buf = cmd;

  i2c_messageset[0].msgs = i2c_messages;
  i2c_messageset[0].nmsgs = 1;

  if (ioctl(i2c_fd, I2C_RDWR, &i2c_messageset) < 0) {
    printf("I2C Write Error!\n");
    return -1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %dx, %ax
movw %si, %cx
movb %dil, %dl
movb %dl, -0x5(%rbp)
movw %cx, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movzwl -0x8(%rbp), %eax
sarl $0x8, %eax
movb %al, -0xe(%rbp)
movzwl -0x8(%rbp), %eax
andl $0xff, %eax
movb %al, -0xd(%rbp)
movzwl -0xa(%rbp), %eax
sarl $0x8, %eax
movb %al, -0xc(%rbp)
movzwl -0xa(%rbp), %eax
andl $0xff, %eax
movb %al, -0xb(%rbp)
movzbl -0x5(%rbp), %eax
movw %ax, -0x30(%rbp)
movw $0x0, -0x2e(%rbp)
movw $0x4, -0x2c(%rbp)
leaq -0xe(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x1, -0x38(%rbp)
movl 0x461b(%rip), %edi      # 0xa374
movl $0x707, %esi            # imm = 0x707
leaq -0x40(%rbp), %rdx
movb $0x0, %al
callq 0x10e0
cmpl $0x0, %eax
jge 0x5d85
leaq 0x397(%rip), %rdi       # 0x610c
movb $0x0, %al
callq 0x1040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d8c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: tobias93[P]piano/rtaudio/tests/playraw.cpp
// Function: usage()
void usage( void ) {
  // Error function in case of incorrect command-line
  // argument specifications
  std::cout << "\nuseage: playraw N fs file <device> <channelOffset>\n";
  std::cout << "    where N = number of channels,\n";
  std::cout << "    fs = the sample rate, \n";
  std::cout << "    file = the raw file to play,\n";
  std::cout << "    device = optional device to use (default = 0),\n";
  std::cout << "    and channelOffset = an optional channel offset on the device (default = 0).\n\n";
  exit( 0 );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xe955(%rip), %rdi      # 0x16fd0
leaq 0x9982(%rip), %rsi      # 0x12004
callq 0x8210
movq 0xe942(%rip), %rdi      # 0x16fd0
leaq 0x99a4(%rip), %rsi      # 0x12039
callq 0x8210
movq 0xe92f(%rip), %rdi      # 0x16fd0
leaq 0x99b4(%rip), %rsi      # 0x1205c
callq 0x8210
movq 0xe91c(%rip), %rdi      # 0x16fd0
leaq 0x99bd(%rip), %rsi      # 0x12078
callq 0x8210
movq 0xe909(%rip), %rdi      # 0x16fd0
leaq 0x99cc(%rip), %rsi      # 0x1209a
callq 0x8210
movq 0xe8f6(%rip), %rdi      # 0x16fd0
leaq 0x99ed(%rip), %rsi      # 0x120ce
callq 0x8210
xorl %edi, %edi
callq 0x8300
nopl (%rax)
// File: tobias93[P]piano/rtaudio/tests/playraw.cpp
// Function: output(void*, void*, unsigned int, double, unsigned int, void*)
int output( void *outputBuffer, void * /*inputBuffer*/, unsigned int nBufferFrames,
            double /*streamTime*/, RtAudioStreamStatus /*status*/, void *data )
{
  OutputData *oData = (OutputData*) data;

  // In general, it's not a good idea to do file input in the audio
  // callback function but I'm doing it here because I don't know the
  // length of the file we are reading.
  unsigned int count = fread( outputBuffer, oData->channels * sizeof( MY_TYPE ), nBufferFrames, oData->fd);
  if ( count < nBufferFrames ) {
    unsigned int bytes = (nBufferFrames - count) * oData->channels * sizeof( MY_TYPE );
    unsigned int startByte = count * oData->channels * sizeof( MY_TYPE );
    memset( (char *)(outputBuffer)+startByte, 0, bytes );
    return 1;
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
shlq %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
movq -0x40(%rbp), %rax
movq (%rax), %rcx
callq 0x83c0
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x878b
movl -0x1c(%rbp), %eax
subl -0x44(%rbp), %eax
movq -0x40(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, %eax
shlq %rax
movl %eax, -0x48(%rbp)
movl -0x44(%rbp), %eax
movq -0x40(%rbp), %rcx
imull 0x8(%rcx), %eax
movl %eax, %eax
shlq %rax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4c(%rbp), %eax
addq %rax, %rdi
movl -0x48(%rbp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x8130
movl $0x1, -0x4(%rbp)
jmp 0x8792
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/getput.cc
// Function: main
int main()
{
	char ch;
	while (cin.get(ch))
        cout.put(ch);
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2dfa(%rip), %rdi      # 0x3fe0
leaq -0x5(%rbp), %rsi
callq 0x1070
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x1060
testb $0x1, %al
jne 0x1204
jmp 0x1216
movq 0x2dc5(%rip), %rdi      # 0x3fd0
movsbl -0x5(%rbp), %esi
callq 0x1030
jmp 0x11df
movq 0x2db3(%rip), %rdi      # 0x3fd0
movq 0x2d9c(%rip), %rsi      # 0x3fc0
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: eniac[P]Mantis/./include/ast_nodes.h
// Function: InputNode::InputNode(AstNode*, AstNode*)
InputNode(AstNode* next, AstNode* expression) {
        nodeType_ = typeid(*this).name();
        next_ = dynamic_cast<InputNode*>(next);
        expression_ = expression;
        expression_->parent_ = this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %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 0xc0584(%rip), %rcx     # 0x172900
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, %rax
jne 0xb2390
callq 0xaa640
jmp 0xb2390
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 0xb23b2
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xb23f8
movq -0x38(%rbp), %rdi
leaq 0xc0215(%rip), %rsi     # 0x1725e0
leaq 0xc0546(%rip), %rdx     # 0x172918
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x40(%rbp)
jmp 0xb2400
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb2fd0
jmp 0xb2422
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xb2400
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rax, 0x40(%rcx)
movq -0x18(%rbp), %rax
movq %rax, 0x48(%rcx)
movq 0x48(%rcx), %rax
movq %rcx, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xaaa60
nopl (%rax,%rax)
// File: eniac[P]Mantis/./include/ast_nodes.h
// Function: InputNode::toString[abi:cxx11]()
string toString() {
        ostringstream oss;
        if (next_) {
            oss << next_->toString() << "\n";
        }
        oss << expression_->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
cmpq $0x0, 0x40(%rax)
je 0xb30e2
movq -0x1e0(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1a8(%rbp), %rdi
callq *%rax
jmp 0xb3069
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x1f8(%rbp)
jmp 0xb3085
movq -0x1f8(%rbp), %rdi
leaq 0x86d41(%rip), %rsi     # 0x139dd4
callq 0xaa540
jmp 0xb309a
leaq -0x1a8(%rbp), %rdi
callq 0xaabe8
jmp 0xb30e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0xb316e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0xaabe8
jmp 0xb316e
movq -0x1e0(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1d8(%rbp), %rdi
callq *%rax
jmp 0xb30fe
leaq -0x188(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xaa4c0
jmp 0xb3113
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
movq -0x1f0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xb3134
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)
leaq -0x1d8(%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_p4.cpp
// Function: BodyWordNode::deepCopy()
BodyWordNode* BodyWordNode::deepCopy() {
    AstNode* newContents = contents_;
    if (wordType_ == WordType::VARREF) {
        newContents = dynamic_cast<MblRefNode*>(contents_)->deepCopy();
    }

    auto newNode = new BodyWordNode(wordType_, newContents);
    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x10(%rbp)
cmpl $0x0, 0x3c(%rax)
jne 0xba5ea
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xba5d5
movq -0x38(%rbp), %rdi
leaq 0xb8021(%rip), %rsi     # 0x1725e0
leaq 0xb8e62(%rip), %rdx     # 0x173428
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x40(%rbp)
jmp 0xba5dd
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xba5dd
movq -0x40(%rbp), %rdi
callq 0xcac70
movq %rax, -0x10(%rbp)
movl $0x50, %edi
callq 0xaa560
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x48(%rbp)
movl 0x3c(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0xba4d0
jmp 0xba610
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xaa4e0
movq -0x20(%rbp), %rdi
callq 0xaaa60
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: operator*(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
static string operator*(std::string str, int count)
{
    string ret;
    for(auto i = 0; i<count; i++) {
        ret = ret + str;
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xaa7f0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xbaea5
movq -0x68(%rbp), %rdx
movq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xc0d20
jmp 0xbae6d
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xaa6d0
leaq -0x40(%rbp), %rdi
callq 0xaabe8
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xbae52
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0xaabe8
jmp 0xbaec2
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0xbaeb8
movq -0x60(%rbp), %rdi
callq 0xaabe8
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xaaa60
nopl (%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: BodyNode::BodyNode(AstNode*, AstNode*, AstNode*)
BodyNode::BodyNode(AstNode* bodyOuter, AstNode* bodyInner, AstNode* str) {

    nodeType_ = typeid(*this).name();
    bodyOuter_ = dynamic_cast<BodyNode*>(bodyOuter);
    if (bodyOuter_) bodyOuter_->parent_ = this;
    bodyInner_ = dynamic_cast<BodyNode*>(bodyInner);
    if (bodyInner_) {
        bodyInner_->parent_ = this;
    }
    str_ = dynamic_cast<BodyWordNode*>(str);
    if (str_) {
        str_->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 0xb7b80(%rip), %rcx     # 0x172a80
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x1, 0x58(%rax)
cmpq $0x0, %rax
jne 0xbaf1b
callq 0xaa640
jmp 0xbaf1b
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 0xbaf3d
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xbaf86
movq -0x40(%rbp), %rdi
leaq 0xb768a(%rip), %rsi     # 0x1725e0
leaq 0xb7b6b(%rip), %rdx     # 0x172ac8
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x48(%rbp)
jmp 0xbaf8e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xb2fd0
jmp 0xbb05f
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0xbaf8e
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x40(%rax)
cmpq $0x0, 0x40(%rax)
je 0xbafad
movq -0x38(%rbp), %rcx
movq 0x40(%rcx), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xbafdc
movq -0x50(%rbp), %rdi
leaq 0xb761a(%rip), %rsi     # 0x1725e0
leaq 0xb7afb(%rip), %rdx     # 0x172ac8
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x58(%rbp)
jmp 0xbafe4
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xbafe4
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x48(%rax)
cmpq $0x0, 0x48(%rax)
je 0xbb003
movq -0x38(%rbp), %rcx
movq 0x48(%rcx), %rax
movq %rcx, 0x30(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xbb032
movq -0x60(%rbp), %rdi
leaq 0xb75c4(%rip), %rsi     # 0x1725e0
leaq 0xb7a75(%rip), %rdx     # 0x172a98
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x68(%rbp)
jmp 0xbb03a
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0xbb03a
movq -0x38(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x50(%rax)
cmpq $0x0, 0x50(%rax)
je 0xbb059
movq -0x38(%rbp), %rcx
movq 0x50(%rcx), %rax
movq %rcx, 0x30(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xaaa60
nopl (%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: P4RegisterNode::toString[abi:cxx11]()
string P4RegisterNode::toString() {
    ostringstream oss;
    oss << "register " 
        << name_->toString() 
        << " {\n"
        << "  " << body_->toString()
        << "}\n\n";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x200(%rbp)
movq %rdi, %rax
movq %rax, -0x1f8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1e8(%rbp)
callq 0xaa7b0
movq -0x1e8(%rbp), %rdi
leaq 0x7e160(%rip), %rsi     # 0x139da0
callq 0xaa540
movq %rax, -0x1e0(%rbp)
jmp 0xbbc4e
movq -0x1f0(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1b8(%rbp), %rdi
callq *%rax
jmp 0xbbc6a
movq -0x1e0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x208(%rbp)
jmp 0xbbc86
movq -0x208(%rbp), %rdi
leaq 0x82303(%rip), %rsi     # 0x13df97
callq 0xaa540
movq %rax, -0x210(%rbp)
jmp 0xbbca2
movq -0x210(%rbp), %rdi
leaq 0x80688(%rip), %rsi     # 0x13c338
callq 0xaa540
movq %rax, -0x218(%rbp)
jmp 0xbbcbe
movq -0x1f0(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1d8(%rbp), %rdi
callq *%rax
jmp 0xbbcda
movq -0x218(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x220(%rbp)
jmp 0xbbcf6
movq -0x220(%rbp), %rdi
leaq 0x82751(%rip), %rsi     # 0x13e455
callq 0xaa540
jmp 0xbbd0b
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
movq -0x200(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xbbd38
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x1f8(%rbp), %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xbbda6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xbbd9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x190(%rbp), %rdi
callq 0xaaa60
nop
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: NameListNode::toString[abi:cxx11]()
string NameListNode::toString() {
    if (nameList_) {
        ostringstream oss;
        oss << nameList_->toString()
            << ", "
            << name_->toString();
        return oss.str();
    } else {
        return name_->toString();
    }

}

// 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)
cmpq $0x0, 0x40(%rax)
je 0xbc986
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 0xbc882
leaq -0x188(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x1f8(%rbp)
jmp 0xbc89e
movq -0x1f8(%rbp), %rdi
leaq 0x7f99b(%rip), %rsi     # 0x13c247
callq 0xaa540
movq %rax, -0x200(%rbp)
jmp 0xbc8ba
movq -0x1e0(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1d8(%rbp), %rdi
callq *%rax
jmp 0xbc8d6
movq -0x200(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xaa4c0
jmp 0xbc8eb
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
leaq -0x1a8(%rbp), %rdi
callq 0xaabe8
movq -0x1f0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xbc918
leaq -0x188(%rbp), %rdi
callq 0xaa130
jmp 0xbc99d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0xbc978
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
jmp 0xbc96c
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
jmp 0xbc9ad
movq -0x1f0(%rbp), %rdi
movq -0x1e0(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
callq *(%rax)
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0xaaa60
nopl (%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: TableReadStmtNode::TableReadStmtNode(TableReadStmtNode::MatchType, AstNode*)
TableReadStmtNode::TableReadStmtNode(MatchType matchType, AstNode* field) {
    nodeType_ = typeid(*this).name();
    matchType_ = matchType;
    field_ = field;
    field_->parent_ = this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xb2f00
movq -0x30(%rbp), %rax
leaq 0xb6155(%rip), %rcx     # 0x172b40
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, %rax
jne 0xbc9ff
callq 0xaa640
jmp 0xbc9ff
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 0xbca21
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
movl %eax, 0x3c(%rcx)
movq -0x18(%rbp), %rax
movq %rax, 0x40(%rcx)
movq 0x40(%rcx), %rax
movq %rcx, 0x30(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb2fd0
movq -0x20(%rbp), %rdi
callq 0xaaa60
nop
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: TableReadStmtNode::toString[abi:cxx11]()
string TableReadStmtNode::toString() {
    ostringstream oss;
    oss << "    " << field_->toString() << " : ";
    switch(matchType_) {
        case EXACT: oss << "exact"; break;
        case TERNARY: oss << "ternary"; break;
    }
    oss << ";\n";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e0(%rbp)
movq %rdi, %rax
movq %rax, -0x1d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0xaa7b0
movq -0x1c8(%rbp), %rdi
leaq 0x7d30e(%rip), %rsi     # 0x139dbe
callq 0xaa540
movq %rax, -0x1c0(%rbp)
jmp 0xbcabe
movq -0x1d0(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1b8(%rbp), %rdi
callq *%rax
jmp 0xbcada
movq -0x1c0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x1e8(%rbp)
jmp 0xbcaf6
movq -0x1e8(%rbp), %rdi
leaq 0x81600(%rip), %rsi     # 0x13e104
callq 0xaa540
jmp 0xbcb0b
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
movq -0x1d0(%rbp), %rax
movl 0x3c(%rax), %eax
movl %eax, -0x1ec(%rbp)
testl %eax, %eax
je 0xbcb71
jmp 0xbcb2d
movl -0x1ec(%rbp), %eax
subl $0x1, %eax
je 0xbcb88
jmp 0xbcb9f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xbcbe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
jmp 0xbcbe5
leaq 0x7d24b(%rip), %rsi     # 0x139dc3
leaq -0x188(%rbp), %rdi
callq 0xaa540
jmp 0xbcb86
jmp 0xbcb9f
leaq 0x7d23a(%rip), %rsi     # 0x139dc9
leaq -0x188(%rbp), %rdi
callq 0xaa540
jmp 0xbcb9d
jmp 0xbcb9f
leaq 0x7d28f(%rip), %rsi     # 0x139e35
leaq -0x188(%rbp), %rdi
callq 0xaa540
jmp 0xbcbb4
movq -0x1e0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xbcbc9
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x1d8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x190(%rbp), %rdi
callq 0xaaa60
nopl (%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: TableReadStmtsNode::toString[abi:cxx11]()
string TableReadStmtsNode::toString() {
    ostringstream oss;
    for (auto rsn : *list_) {
        oss << rsn->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 0xb44d0
movq %rax, -0x198(%rbp)
movq -0x190(%rbp), %rdi
callq 0xb4360
movq %rax, -0x1a0(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xc0070
testb $0x1, %al
jne 0xbcd0f
jmp 0xbcda0
leaq -0x198(%rbp), %rdi
callq 0xc00b0
movq (%rax), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1c8(%rbp), %rdi
callq *%rax
jmp 0xbcd3d
leaq -0x188(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xaa4c0
jmp 0xbcd52
leaq -0x1c8(%rbp), %rdi
callq 0xaabe8
leaq -0x198(%rbp), %rdi
callq 0xc00d0
jmp 0xbccf3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xbcdd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xaabe8
jmp 0xbcdd1
movq -0x1f0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xbcdb5
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: TableActionStmtsNode::toString[abi:cxx11]()
string TableActionStmtsNode::toString() {
    ostringstream oss;
    for (auto asn : *list_) {
        oss << asn->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 0xb4ca0
movq %rax, -0x198(%rbp)
movq -0x190(%rbp), %rdi
callq 0xb4b30
movq %rax, -0x1a0(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xc0190
testb $0x1, %al
jne 0xbd10f
jmp 0xbd1a0
leaq -0x198(%rbp), %rdi
callq 0xc01d0
movq (%rax), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1c8(%rbp), %rdi
callq *%rax
jmp 0xbd13d
leaq -0x188(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xaa4c0
jmp 0xbd152
leaq -0x1c8(%rbp), %rdi
callq 0xaabe8
leaq -0x198(%rbp), %rdi
callq 0xc01f0
jmp 0xbd0f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xbd1d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xaabe8
jmp 0xbd1d1
movq -0x1f0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xbd1b5
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: TableNode::transformPragma()
void TableNode::transformPragma() {
    if(pragma_.compare("")!=0 && !pragmaTransformed_) {
        std::vector<string> tmp_v;
        boost::algorithm::split(tmp_v, pragma_, boost::algorithm::is_space());
        pragma_ = "";
        for(int i=0; i<tmp_v.size()-1; i++) {
            pragma_ += tmp_v[i];
            pragma_ += " ";            
        }
        int stage_num = stoi(tmp_v[tmp_v.size()-1]);
        stage_num ++;
        pragma_ += std::to_string(stage_num);

        pragmaTransformed_=true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x70, %rdi
leaq 0x7e1d1(%rip), %rsi     # 0x13bba3
callq 0xaa180
cmpl $0x0, %eax
je 0xbdbca
movq -0x78(%rbp), %rax
testb $0x1, 0x90(%rax)
jne 0xbdbca
leaq -0x20(%rbp), %rdi
callq 0xc0210
movq -0x78(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xaabc0
movq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xc0730
jmp 0xbda25
movq -0x88(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rdx
movl $0x1, %ecx
callq 0xc0670
jmp 0xbda40
leaq -0x30(%rbp), %rdi
callq 0xc0760
leaq -0x38(%rbp), %rdi
callq 0xaa810
movq -0x78(%rbp), %rdi
addq $0x70, %rdi
leaq 0x7e142(%rip), %rsi     # 0x13bba3
callq 0xaa7c0
jmp 0xbda68
movl $0x0, -0x48(%rbp)
movslq -0x48(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc04f0
movq %rax, %rcx
movq -0x90(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0xbdb1e
movslq -0x48(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0xc0510
movq -0x78(%rbp), %rdi
movq %rax, %rsi
addq $0x70, %rdi
callq 0xaa710
jmp 0xbdab9
movq -0x78(%rbp), %rdi
addq $0x70, %rdi
leaq 0x7e871(%rip), %rsi     # 0x13c339
callq 0xaa510
jmp 0xbdacf
jmp 0xbdad1
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xbda6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xbdaff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xc0760
leaq -0x38(%rbp), %rdi
callq 0xaa810
jmp 0xbdbbf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xbdbbf
leaq -0x20(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xc04f0
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
decq %rsi
callq 0xc0510
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xbff90
movl %eax, -0x94(%rbp)
jmp 0xbdb59
movl -0x94(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
incl %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %esi
leaq -0x70(%rbp), %rdi
callq 0xc0780
jmp 0xbdb78
movq -0x78(%rbp), %rdi
addq $0x70, %rdi
leaq -0x70(%rbp), %rsi
callq 0xaa710
jmp 0xbdb8b
leaq -0x70(%rbp), %rdi
callq 0xaabe8
movq -0x78(%rbp), %rax
movb $0x1, 0x90(%rax)
leaq -0x20(%rbp), %rdi
callq 0xc0530
jmp 0xbdbca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xaabe8
leaq -0x20(%rbp), %rdi
callq 0xc0530
jmp 0xbdbd3
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xaaa60
nopl (%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: FieldDecsNode::toString[abi:cxx11]()
string FieldDecsNode::toString() {
    ostringstream oss;
    for (auto fdn : *list_) {
        oss << fdn->toString() << endl;
    }
    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), %rax
movq %rax, -0x190(%rbp)
movq -0x190(%rbp), %rdi
callq 0xb5470
movq %rax, -0x198(%rbp)
movq -0x190(%rbp), %rdi
callq 0xb5300
movq %rax, -0x1a0(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0xc0940
testb $0x1, %al
jne 0xbdfbf
jmp 0xbe06f
leaq -0x198(%rbp), %rdi
callq 0xc0980
movq (%rax), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1c8(%rbp), %rdi
callq *%rax
jmp 0xbdfed
leaq -0x188(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x1f8(%rbp)
jmp 0xbe009
movq -0x1f8(%rbp), %rdi
movq 0xb5f51(%rip), %rsi     # 0x173f68
callq 0xaa5b0
jmp 0xbe01e
leaq -0x1c8(%rbp), %rdi
callq 0xaabe8
leaq -0x198(%rbp), %rdi
callq 0xc09a0
jmp 0xbdfa3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0xbe0a0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x1c8(%rbp), %rdi
callq 0xaabe8
jmp 0xbe0a0
movq -0x1f0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xbe084
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x1e8(%rbp), %rax
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x1d0(%rbp), %rdi
callq 0xaaa60
nopl (%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: HeaderTypeDeclarationNode::HeaderTypeDeclarationNode(AstNode*, AstNode*, AstNode*)
HeaderTypeDeclarationNode::HeaderTypeDeclarationNode(AstNode* name,
                                                     AstNode* field_decs,
                                                     AstNode* other_stmts) {
    nodeType_ = typeid(*this).name();
    name_ = dynamic_cast<NameNode*>(name);
    field_decs_ = dynamic_cast<FieldDecsNode*>(field_decs);
    other_stmts_ = other_stmts;
}

// 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 -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xb2f00
movq -0x38(%rbp), %rax
leaq 0xb4b28(%rip), %rcx     # 0x172c18
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, %rax
jne 0xbe104
callq 0xaa640
jmp 0xbe104
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 0xbe126
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xbe16c
movq -0x40(%rbp), %rdi
leaq 0xb44a1(%rip), %rsi     # 0x1725e0
leaq 0xb484a(%rip), %rdx     # 0x172990
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x48(%rbp)
jmp 0xbe174
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xb2fd0
jmp 0xbe1d1
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0xbe174
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xbe1af
movq -0x50(%rbp), %rdi
leaq 0xb4447(%rip), %rsi     # 0x1725e0
leaq 0xb4a90(%rip), %rdx     # 0x172c30
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x58(%rbp)
jmp 0xbe1b7
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xbe1b7
movq -0x38(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x48(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x50(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0xaaa60
nopw (%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: HeaderTypeDeclarationNode::toString[abi:cxx11]()
string HeaderTypeDeclarationNode::toString() {
    ostringstream oss;
    oss << "header_type " << name_->toString() << " {\n";
    oss << "  fields {\n";
    oss << field_decs_->toString();
    oss << "  }\n";
    oss << other_stmts_->toString();
    oss << "}\n\n";
    return oss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
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 0x7bbc5(%rip), %rsi     # 0x139df5
callq 0xaa540
movq %rax, -0x200(%rbp)
jmp 0xbe23e
movq -0x210(%rbp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1b8(%rbp), %rdi
callq *%rax
jmp 0xbe25a
movq -0x200(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0xaa4c0
movq %rax, -0x228(%rbp)
jmp 0xbe276
movq -0x228(%rbp), %rdi
leaq 0x7fd13(%rip), %rsi     # 0x13df97
callq 0xaa540
jmp 0xbe28b
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
leaq 0x7bb64(%rip), %rsi     # 0x139e02
leaq -0x188(%rbp), %rdi
callq 0xaa540
jmp 0xbe2ac
movq -0x210(%rbp), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1d8(%rbp), %rdi
callq *%rax
jmp 0xbe2c8
leaq -0x188(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0xaa4c0
jmp 0xbe2dd
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
leaq 0x7d38e(%rip), %rsi     # 0x13b67e
leaq -0x188(%rbp), %rdi
callq 0xaa540
jmp 0xbe2fe
movq -0x210(%rbp), %rax
movq 0x50(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1f8(%rbp), %rdi
callq *%rax
jmp 0xbe31a
leaq -0x188(%rbp), %rdi
leaq -0x1f8(%rbp), %rsi
callq 0xaa4c0
jmp 0xbe32f
leaq -0x1f8(%rbp), %rdi
callq 0xaabe8
leaq 0x80113(%rip), %rsi     # 0x13e455
leaq -0x188(%rbp), %rdi
callq 0xaa540
jmp 0xbe350
movq -0x220(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0xaa580
jmp 0xbe365
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x218(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0xbe3f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0xaabe8
jmp 0xbe3f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0xaabe8
jmp 0xbe3f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0xaabe8
leaq -0x188(%rbp), %rdi
callq 0xaa130
movq -0x190(%rbp), %rdi
callq 0xaaa60
nopl (%rax,%rax)
// File: eniac[P]Mantis/src/ast/ast_nodes_p4.cpp
// Function: ArgsNode::deepCopy()
ArgsNode* ArgsNode::deepCopy() {
    auto newNode = new ArgsNode();
    for (auto bw : *list_) {
        auto newArg = bw->deepCopy();
        newNode->push_back(newArg);
    }

    return newNode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x48, %edi
callq 0xaa560
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0xbe9b0
jmp 0xbea5f
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb6be0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb6a70
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc0a60
testb $0x1, %al
jne 0xbeaa0
jmp 0xbeaec
leaq -0x30(%rbp), %rdi
callq 0xc0aa0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xba580
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xb26b0
leaq -0x30(%rbp), %rdi
callq 0xc0ac0
jmp 0xbea8d
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xaa4e0
jmp 0xbeaf6
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xaaa60
nop
// File: 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
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 0xb6be0
movq %rax, -0x1a0(%rbp)
movq -0x198(%rbp), %rdi
callq 0xb6a70
movq %rax, -0x1a8(%rbp)
leaq -0x1a0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xc0a60
testb $0x1, %al
jne 0xbeb93
jmp 0xbec4d
leaq -0x1a0(%rbp), %rdi
callq 0xc0aa0
movq (%rax), %rax
movq %rax, -0x1b0(%rbp)
testb $0x1, -0x11(%rbp)
je 0xbebb5
movb $0x0, -0x11(%rbp)
jmp 0xbebe3
leaq 0x7d68b(%rip), %rsi     # 0x13c247
leaq -0x190(%rbp), %rdi
callq 0xaa540
jmp 0xbebca
jmp 0xbebe3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0xbec7e
movq -0x1b0(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1e0(%rbp), %rdi
callq *%rax
jmp 0xbebfb
leaq -0x190(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xaa4c0
jmp 0xbec10
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
leaq -0x1a0(%rbp), %rdi
callq 0xc0ac0
jmp 0xbeb77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
jmp 0xbec7e
movq -0x1f8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xaa580
jmp 0xbec62
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_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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x40(%rax), %rdi
addq $0x10, %rdi
leaq 0x7b0b5(%rip), %rsi     # 0x139e20
xorl %eax, %eax
movl %eax, %edx
callq 0xaab90
cmpq $-0x1, %rax
je 0xbedc2
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xbedad
movq -0x38(%rbp), %rdi
leaq 0xb3849(%rip), %rsi     # 0x1725e0
leaq 0xb468a(%rip), %rdx     # 0x173428
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x40(%rbp)
jmp 0xbedb5
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0xbedb5
movq -0x40(%rbp), %rdi
callq 0xcac70
movq %rax, -0x10(%rbp)
movl $0x48, %edi
callq 0xaa560
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rsi
callq 0xbeca0
jmp 0xbede1
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xaa4e0
movq -0x20(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x48, %edi
callq 0xaa560
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0xbee50
jmp 0xbeeff
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb5c40
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb5ad0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc0b80
testb $0x1, %al
jne 0xbef40
jmp 0xbef8c
leaq -0x30(%rbp), %rdi
callq 0xc0bc0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xbed40
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xb2630
leaq -0x30(%rbp), %rdi
callq 0xc0be0
jmp 0xbef2d
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xaa4e0
jmp 0xbef96
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xaaa60
nop
// File: 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
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 0xb5c40
movq %rax, -0x1a0(%rbp)
movq -0x198(%rbp), %rdi
callq 0xb5ad0
movq %rax, -0x1a8(%rbp)
leaq -0x1a0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xc0b80
testb $0x1, %al
jne 0xbf033
jmp 0xbf0ed
leaq -0x1a0(%rbp), %rdi
callq 0xc0bc0
movq (%rax), %rax
movq %rax, -0x1b0(%rbp)
testb $0x1, -0x11(%rbp)
je 0xbf055
movb $0x0, -0x11(%rbp)
jmp 0xbf083
leaq 0x7d1eb(%rip), %rsi     # 0x13c247
leaq -0x190(%rbp), %rdi
callq 0xaa540
jmp 0xbf06a
jmp 0xbf083
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0xbf11e
movq -0x1b0(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x1e0(%rbp), %rdi
callq *%rax
jmp 0xbf09b
leaq -0x190(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xaa4c0
jmp 0xbf0b0
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
leaq -0x1a0(%rbp), %rdi
callq 0xc0be0
jmp 0xbf017
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0xaabe8
jmp 0xbf11e
movq -0x1f8(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0xaa580
jmp 0xbf102
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_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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xb2f00
movq -0x48(%rbp), %rax
leaq 0xb3b46(%rip), %rcx     # 0x172cc0
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, %rax
jne 0xbf18e
callq 0xaa640
jmp 0xbf18e
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
callq 0xb2f90
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0xaa7c0
jmp 0xbf1b0
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xbf1f9
movq -0x50(%rbp), %rdi
leaq 0xb3417(%rip), %rsi     # 0x1725e0
leaq 0xb37c0(%rip), %rdx     # 0x172990
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x58(%rbp)
jmp 0xbf201
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0xb2fd0
jmp 0xbf2fd
xorl %eax, %eax
movq %rax, -0x58(%rbp)
jmp 0xbf201
movq -0x48(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xbf23c
movq -0x60(%rbp), %rdi
leaq 0xb33ba(%rip), %rsi     # 0x1725e0
leaq 0xb3763(%rip), %rdx     # 0x172990
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x68(%rbp)
jmp 0xbf244
xorl %eax, %eax
movq %rax, -0x68(%rbp)
jmp 0xbf244
movq -0x48(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, 0x48(%rax)
cmpq $0x0, -0x18(%rbp)
je 0xbf2a2
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0xbf286
movq -0x70(%rbp), %rdi
leaq 0xb3370(%rip), %rsi     # 0x1725e0
leaq 0xb3a61(%rip), %rdx     # 0x172cd8
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x78(%rbp)
jmp 0xbf28e
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0xbf28e
movq -0x48(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rax, 0x58(%rcx)
movq 0x58(%rcx), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0xbf2d4
movq -0x80(%rbp), %rdi
leaq 0xb3325(%rip), %rsi     # 0x1725e0
leaq 0xb378e(%rip), %rdx     # 0x172a50
xorl %eax, %eax
movl %eax, %ecx
callq 0xaa660
movq %rax, -0x88(%rbp)
jmp 0xbf2df
xorl %eax, %eax
movq %rax, -0x88(%rbp)
jmp 0xbf2df
movq -0x48(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rcx, 0x50(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x3c(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xaaa60
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x48, %edi
callq 0xaa560
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0xbf730
jmp 0xbf7df
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb6410
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb62a0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc0ca0
testb $0x1, %al
jne 0xbf820
jmp 0xbf86c
leaq -0x30(%rbp), %rdi
callq 0xc0ce0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xbf310
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0xb2670
leaq -0x30(%rbp), %rdi
callq 0xc0d00
jmp 0xbf80d
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xaa4e0
jmp 0xbf876
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xaaa60
nop