LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::read_file_instns(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void baseAccelSim::read_file_instns(string fileName)
{
	ifstream inFile(fileName.c_str());
	if(!inFile)
	{
		cout << "Cannot open and read file: " << fileName.c_str() << endl;
		exit (EXIT_FAILURE);
	}

	string line;
	while (getline(inFile,line))
  {
		instArr.push_back(stoull(line));
  }
  inFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rsi, -0x268(%rbp)
movq %rdi, %rax
movq -0x268(%rbp), %rdi
movq %rdi, -0x260(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x4a4170
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x46e8c0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x472d80
movb %al, -0x251(%rbp)
jmp 0x40c724
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x40c730
jmp 0x40c7a6
movq $0x61f900, %rdi         # imm = 0x61F900
leaq 0x1948d2(%rip), %rsi    # 0x5a1010
callq 0x492450
movq %rax, -0x270(%rbp)
jmp 0x40c74c
movq -0x260(%rbp), %rdi
callq 0x4a4170
movq -0x270(%rbp), %rdi
movq %rax, %rsi
callq 0x492450
movq %rax, -0x278(%rbp)
jmp 0x40c770
movq -0x278(%rbp), %rdi
movq $0x491d30, %rsi         # imm = 0x491D30
callq 0x490f40
jmp 0x40c785
movl $0x1, %edi
callq 0x4ec1e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x40c88d
leaq -0x248(%rbp), %rdi
callq 0x4a2620
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x4a5170
movq %rax, -0x280(%rbp)
jmp 0x40c7ce
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x472d70
movb %al, -0x281(%rbp)
jmp 0x40c7ec
movb -0x281(%rbp), %al
testb $0x1, %al
jne 0x40c7f8
jmp 0x40c85e
xorl %eax, %eax
movl %eax, %esi
leaq -0x248(%rbp), %rdi
movl $0xa, %edx
callq 0x40f740
movq %rax, -0x290(%rbp)
jmp 0x40c816
movq -0x290(%rbp), %rax
movq %rax, -0x250(%rbp)
leaq 0x211dfd(%rip), %rdi    # 0x61e628
leaq -0x250(%rbp), %rsi
callq 0x40f710
jmp 0x40c839
jmp 0x40c7b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x4a2730
jmp 0x40c88d
leaq -0x218(%rbp), %rdi
callq 0x46ee70
jmp 0x40c86c
leaq -0x248(%rbp), %rdi
callq 0x4a2730
leaq -0x218(%rbp), %rdi
callq 0x46f220
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x46f220
movq -0x220(%rbp), %rdi
callq 0x4d0770
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: main
int main(int argc, const char** argv)
{
	baseAccelSim accel;

	// parse arguments from command line
	parse_arguments(argc, argv);

	accel.read_inputs();
	accel.read_data();
	accel.read_accel_configurations();

	controller accelController;
	accelController.run(tensor_operands);

	printf("Done!! ticks are: %ld \n",tick);
	accel.write_data();
	accel.compare_golden_outputs();
	accel.free_memory();

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x404cc0
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x41a5e0
jmp 0x40ead0
leaq -0x18(%rbp), %rdi
callq 0x404d20
jmp 0x40eadb
leaq -0x18(%rbp), %rdi
callq 0x408ff0
jmp 0x40eae6
leaq -0x18(%rbp), %rdi
callq 0x40d3a0
jmp 0x40eaf1
leaq -0x148(%rbp), %rdi
callq 0x414fe0
jmp 0x40eaff
movq 0x20fa5a(%rip), %rsi    # 0x61e560
leaq -0x148(%rbp), %rdi
callq 0x416850
jmp 0x40eb14
movq 0x20fafd(%rip), %rsi    # 0x61e618
leaq 0x194a27(%rip), %rdi    # 0x5a3549
xorl %eax, %eax
callq 0x4f74b0
jmp 0x40eb2b
leaq -0x18(%rbp), %rdi
callq 0x409330
jmp 0x40eb36
leaq -0x18(%rbp), %rdi
callq 0x4098d0
jmp 0x40eb41
leaq -0x18(%rbp), %rdi
callq 0x40d780
movl $0x0, -0x4(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x416040
leaq -0x18(%rbp), %rdi
callq 0x404ce0
movl -0x4(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x40eb98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x416040
leaq -0x18(%rbp), %rdi
callq 0x404ce0
movq -0x20(%rbp), %rdi
callq 0x4d0770
nopw (%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::controller()
controller::controller()
{
  setup_PEs();
  setup_interconnect();
  setup_DMAC();
  setup_scratchpad();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x1ff8ad(%rip), %rax    # 0x6148a8
addq $0x10, %rax
movq %rax, (%rdi)
movb $0x0, 0xa0(%rdi)
movb $0x0, 0xa1(%rdi)
movb $0x0, 0xb8(%rdi)
movb $0x1, 0xc8(%rdi)
movb $0x0, 0xc9(%rdi)
movb $0x0, 0xca(%rdi)
movb $0x0, 0xcb(%rdi)
movb $0x0, 0xcc(%rdi)
movb $0x0, 0xcd(%rdi)
movb $0x1, 0xce(%rdi)
movb $0x1, 0xcf(%rdi)
movw $0x0, 0xd0(%rdi)
movw $0x0, 0xd2(%rdi)
movl $0x0, 0xf8(%rdi)
callq 0x4150a0
movq -0x10(%rbp), %rdi
callq 0x4156c0
movq -0x10(%rbp), %rdi
callq 0x415f30
movq -0x10(%rbp), %rdi
callq 0x415fd0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::reconfigure()
void controller::reconfigure()
{
  // One-time configuration of PEs
  for(uint16_t i=0; i < nRows_PE_Array; i++) {
    for(uint16_t j=0; j < nCols_PE_Array; j++) {
      PEs[i][j].setInsMem();
    }
  }

  current_SPM_pass = 0;
  current_RF_pass = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x0, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x416825
movw $0x0, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movq $0x61e5ae, %rcx         # imm = 0x61E5AE
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x416815
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0xa(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movzwl -0xc(%rbp), %eax
imulq $0x148, %rax, %rax      # imm = 0x148
addq %rax, %rdi
callq 0x4242a0
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x4167d2
jmp 0x416817
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x4167ba
movq $0x61e73a, %rax         # imm = 0x61E73A
movw $0x0, (%rax)
movq $0x61e738, %rax         # imm = 0x61E738
movw $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::run(unsigned short**)
void controller::run(data_type **tensor_operands)
{
  // reset configurations and counters
  reconfigure();

  while(!isFinished)
  {
    execute_controller_pre_tick();

    // execute networks for oututting data from PE array.
    // Controller reads data first, then output network should over-write
    // new data at the end of the tick.
    for(uint8_t i=0; i < outNetworks; i++) {
      network_outputs[i].execute();
    }

    // execute PEs
    for(uint16_t i=0; i < nRows_PE_Array; i++) {
  		for(uint16_t j=0; j < nCols_PE_Array; j++) {
  			PEs[i][j].executeAtTick();
  		}
  	}

    // execute networks for inputting data to PE array.
    // network reads data first, then controller should over-write
    // new data at the end of the tick.
    for(uint8_t i=0; i < inNetworks; i++) {
      network_inputs[i].execute();
    }

    // DMA controller advances its tick.
    DMAC->execute_tick();

    // execute controller logic
    advanceExecutionAtTick();

    // Update the global tick (cycle number).
    advanceTick();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4167a0
movq -0x20(%rbp), %rax
movb 0xa0(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x416882
jmp 0x416996
movq -0x20(%rbp), %rdi
callq 0x4169a0
movb $0x0, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
movq $0x61e5e4, %rcx         # imm = 0x61E5E4
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x4168c6
movq -0x20(%rbp), %rax
movq 0x88(%rax), %rdi
movzbl -0x11(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x41a360
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x41688f
movw $0x0, -0x14(%rbp)
movzwl -0x14(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x416937
movw $0x0, -0x16(%rbp)
movzwl -0x16(%rbp), %eax
movq $0x61e5ae, %rcx         # imm = 0x61E5AE
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x416927
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movzwl -0x16(%rbp), %eax
imulq $0x148, %rax, %rax      # imm = 0x148
addq %rax, %rdi
callq 0x423430
movw -0x16(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x16(%rbp)
jmp 0x4168e4
jmp 0x416929
movw -0x14(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x14(%rbp)
jmp 0x4168cc
movb $0x0, -0x17(%rbp)
movzbl -0x17(%rbp), %eax
movq $0x61c151, %rcx         # imm = 0x61C151
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x41696f
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rdi
movzbl -0x17(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
callq 0x419760
movb -0x17(%rbp), %al
addb $0x1, %al
movb %al, -0x17(%rbp)
jmp 0x41693b
movq -0x20(%rbp), %rax
movq 0xa8(%rax), %rdi
callq 0x418d70
movq -0x20(%rbp), %rdi
callq 0x416a60
movq -0x20(%rbp), %rdi
callq 0x416ba0
jmp 0x41686d
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::execute_controller_pre_tick()
void controller::execute_controller_pre_tick()
{
  bus_req_DMA = false;

  // reset only if ack is received.
  data_mov_SPM_DRAM_in_prog = (*bus_ack_from_DMA == true) ? false : data_mov_SPM_DRAM_in_prog;

  for(uint8_t network=0; network < outNetworks; network++)
    is_data_collected[network] = collect_data_via_write_network(network, collected_data + network);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, 0xb8(%rax)
movq 0xc0(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x4169d5
xorl %eax, %eax
movb %al, -0x19(%rbp)
jmp 0x4169e2
movq -0x18(%rbp), %rax
movb 0xc9(%rax), %al
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0xc9(%rax)
movb $0x0, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movq $0x61e5e4, %rcx         # imm = 0x61E5E4
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x416a4c
movq -0x18(%rbp), %rdi
movb -0x9(%rbp), %al
movq 0x118(%rdi), %rdx
movzbl -0x9(%rbp), %ecx
movslq %ecx, %rcx
shlq %rcx
addq %rcx, %rdx
movzbl %al, %esi
callq 0x417a80
movb %al, %dl
movq -0x18(%rbp), %rax
movq 0x110(%rax), %rax
movzbl -0x9(%rbp), %ecx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x4169f6
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::advanceExecutionAtTick()
void controller::advanceExecutionAtTick()
{
  if (acc_controller_state == init)
  {
    initialize();
  }
  else if (acc_controller_state == config_NoC)
  {
    configure_interconnect();
  }
  else if (acc_controller_state == exec_kernel)
  {
    execute_SPM_pass();
    execute_RF_pass();
  }
  else if(acc_controller_state == terminate_exec)
  {
    for(auto i=0; i < nRows_PE_Array; i++)
      for(auto j=0; j < nCols_PE_Array; j++)
        bus_trigger_PEs_exec[i][j] = 0;

    // acc_controller_state = terminate_exec;
    for(uint8_t i=0; i < inNetworks; i++)
    {
      configNetwork[i] = 0;
      forwardDataToNetwork[i] = 0;
      dataOutToNetwork[i] = 0;
    }
    isFinished = 1;
  }
  else
    assert("Undefined state for accelerator execution!");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x61e620, %rax         # imm = 0x61E620
cmpl $0x0, (%rax)
jne 0x416a8e
movq -0x20(%rbp), %rdi
callq 0x4175e0
jmp 0x416b9a
movq $0x61e620, %rax         # imm = 0x61E620
cmpl $0x1, (%rax)
jne 0x416aa8
movq -0x20(%rbp), %rdi
callq 0x4176b0
jmp 0x416b98
movq $0x61e620, %rax         # imm = 0x61E620
cmpl $0x2, (%rax)
jne 0x416acb
movq -0x20(%rbp), %rdi
callq 0x416bd0
movq -0x20(%rbp), %rdi
callq 0x417890
jmp 0x416b96
movq $0x61e620, %rax         # imm = 0x61E620
cmpl $0x3, (%rax)
jne 0x416b92
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x416b3b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq $0x61e5ae, %rcx         # imm = 0x61E5AE
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x416b2e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x416afa
jmp 0x416b30
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x416ae2
movb $0x0, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
movq $0x61c151, %rcx         # imm = 0x61C151
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x416b85
movq -0x20(%rbp), %rax
movq 0x58(%rax), %rcx
movzbl -0x11(%rbp), %edx
movb $0x0, (%rcx,%rdx)
movq 0x60(%rax), %rcx
movzbl -0x11(%rbp), %edx
movb $0x0, (%rcx,%rdx)
movq 0x68(%rax), %rax
movzbl -0x11(%rbp), %ecx
movw $0x0, (%rax,%rcx,2)
movb -0x11(%rbp), %al
addb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x416b3f
movq -0x20(%rbp), %rax
movb $0x1, 0xa0(%rax)
jmp 0x416b94
jmp 0x416b94
jmp 0x416b96
jmp 0x416b98
jmp 0x416b9a
addq $0x20, %rsp
popq %rbp
retq
// File: MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::initialize()
void controller::initialize()
{
  for(uint8_t i=0; i < totalNetworks; i++)
    cnt_data_distribution[i] = 0;
  acc_controller_state = config_NoC;

  for(uint8_t i=0; i < total_operands; i++) {
    spm_buffer_number_op_prefetch[i] = 1;
    spm_buffer_number_op_writeback[i] = 1;
    spm_buffer_number_op_comp_read[i] = 0;
    spm_buffer_number_op_comp_write[i] = 0;
  }

  PE_prefetch_RF_incomplete = true;
  PE_writeback_RF_incomplete = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movq $0x61c153, %rcx         # imm = 0x61C153
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x417625
movq -0x18(%rbp), %rax
movq 0x80(%rax), %rax
movzbl -0x9(%rbp), %ecx
movw $0x0, (%rax,%rcx,2)
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x4175f4
movq $0x61e620, %rax         # imm = 0x61E620
movl $0x1, (%rax)
movb $0x0, -0xa(%rbp)
movzbl -0xa(%rbp), %eax
movq $0x61e556, %rcx         # imm = 0x61E556
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x41769a
movq $0x61e718, %rax         # imm = 0x61E718
movq (%rax), %rax
movzbl -0xa(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movq $0x61e720, %rax         # imm = 0x61E720
movq (%rax), %rax
movzbl -0xa(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movq $0x61e728, %rax         # imm = 0x61E728
movq (%rax), %rax
movzbl -0xa(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movq $0x61e730, %rax         # imm = 0x61E730
movq (%rax), %rax
movzbl -0xa(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movb -0xa(%rbp), %al
addb $0x1, %al
movb %al, -0xa(%rbp)
jmp 0x417636
movq -0x18(%rbp), %rax
movb $0x1, 0xce(%rax)
movb $0x1, 0xcf(%rax)
popq %rbp
retq
nop
// File: MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::collect_data_via_write_network(unsigned char, unsigned short*)
bool controller::collect_data_via_write_network(uint8_t network, data_type* data)
{
  bool retVal = false;
  bool writeBack = false;
  data_type out_data = 0;
  for(uint16_t it=0; it < nRows_PE_Array; it++)
  {
    writeBack |= *(writeBackFromNetwork[network][it]);
    out_data |= *(dataInFromNetwork[network][it]);
  }
  if(writeBack)
  {
    *data = out_data;
    retVal = true;
  }

  return retVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
movw $0x0, -0x1c(%rbp)
movw $0x0, -0x1e(%rbp)
movzwl -0x1e(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x417b2c
movq -0x28(%rbp), %rax
movq 0x98(%rax), %rcx
movzbl -0x9(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
movzwl -0x1e(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movzbl %cl, %edx
movb -0x1a(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %edx, %ecx
cmpl $0x0, %ecx
setne %cl
andb $0x1, %cl
movb %cl, -0x1a(%rbp)
movq 0x90(%rax), %rax
movzbl -0x9(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movzwl -0x1e(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movzwl (%rax), %ecx
movzwl -0x1c(%rbp), %eax
orl %ecx, %eax
movw %ax, -0x1c(%rbp)
movw -0x1e(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x1e(%rbp)
jmp 0x417aae
testb $0x1, -0x1a(%rbp)
je 0x417b41
movw -0x1c(%rbp), %cx
movq -0x18(%rbp), %rax
movw %cx, (%rax)
movb $0x1, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::inc_RF_pass()
void controller::inc_RF_pass()
{
  current_RF_pass += 1;
  PE_prefetch_RF_incomplete = true;
  PE_writeback_RF_incomplete = true;
  counter_RF_pass_prefetch = 0;
  counter_RF_pass_writeback = 0;
  cnt_bus_trigger = 0;

  for(uint8_t i=0; i < inNetworks; i++)
  {
    configNetwork[i] = 0;
    forwardDataToNetwork[i] = 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0x61e738, %rcx         # imm = 0x61E738
movzwl (%rcx), %ecx
addl $0x1, %ecx
movw %cx, %dx
movq $0x61e738, %rcx         # imm = 0x61E738
movw %dx, (%rcx)
movb $0x1, 0xce(%rax)
movb $0x1, 0xcf(%rax)
movw $0x0, 0xd0(%rax)
movw $0x0, 0xd2(%rax)
movl $0x0, 0xf8(%rax)
movb $0x0, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movq $0x61c151, %rcx         # imm = 0x61C151
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x4184a0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
movzbl -0x9(%rbp), %edx
movb $0x0, (%rcx,%rdx)
movq 0x60(%rax), %rax
movzbl -0x9(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x418468
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::send_data_via_read_network(unsigned char, unsigned char, unsigned short, unsigned short)
void controller::send_data_via_read_network(uint8_t operand, uint8_t network, uint16_t idx_packet, data_type data)
{
  assert(idx_packet < size_packetArr[operand]);

  configNetwork[network] = 0;
  forwardDataToNetwork[network] = 1;

  rowTagDataToNetwork[network] = packetArr[operand][idx_packet].getColTag();
  colTagDataToNetwork[network] = packetArr[operand][idx_packet].getRowTag();
  dataOutToNetwork[network]    = data;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %r8w, %ax
movq %rdi, -0x8(%rbp)
movb %sil, -0x9(%rbp)
movb %dl, -0xa(%rbp)
movw %cx, -0xc(%rbp)
movw %ax, -0xe(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movzwl -0xc(%rbp), %eax
movq $0x61e5e8, %rcx         # imm = 0x61E5E8
movq (%rcx), %rcx
movzbl -0x9(%rbp), %edx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
jge 0x4188d3
jmp 0x4188f2
leaq 0x18b035(%rip), %rdi    # 0x5a390f
leaq 0x18ae2c(%rip), %rsi    # 0x5a370d
movl $0x25e, %edx            # imm = 0x25E
leaq 0x18b047(%rip), %rcx    # 0x5a3934
callq 0x4e53d0
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rcx
movzbl -0xa(%rbp), %edx
movb $0x0, (%rcx,%rdx)
movq 0x60(%rax), %rax
movzbl -0xa(%rbp), %ecx
movb $0x1, (%rax,%rcx)
movq $0x61e5f8, %rax         # imm = 0x61E5F8
movq (%rax), %rax
movzbl -0x9(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movzwl -0xc(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x4189a0
movb %al, %dl
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rax
movzbl -0xa(%rbp), %ecx
movb %dl, (%rax,%rcx)
movq $0x61e5f8, %rax         # imm = 0x61E5F8
movq (%rax), %rax
movzbl -0x9(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movzwl -0xc(%rbp), %eax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x418990
movb %al, %sil
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rcx
movzbl -0xa(%rbp), %edx
movb %sil, (%rcx,%rdx)
movw -0xe(%rbp), %dx
movq 0x68(%rax), %rax
movzbl -0xa(%rbp), %ecx
movw %dx, (%rax,%rcx,2)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: MPSLab-ASU[P]DiRAC/./include/dma.hh
// Function: void DMA::prefetch<unsigned short>(unsigned short*, unsigned short*, unsigned int)
void prefetch(Type *ptr_src, Type *ptr_dest, uint32_t count)
  {
    assert((*req_from_compute_device == true) && "Req signal from compute device is not generated.");
    assert((prefetch_in_progress == false) && "DMA cannot handle more than one prefetch request.");
    assert((writeback_in_progress == false) && "DMA cannot handle more than one read/write request.");

    uint64_t total_bytes = count;
    memcpy(ptr_dest, ptr_src, total_bytes);

    delay_prefetch = calculate_data_transfer_delay(total_bytes);
    prefetch_in_progress = true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0x29(%rbp)
jne 0x418a3b
movb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x418a3b
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x418a44
jmp 0x418a46
jmp 0x418a65
leaq 0x18b192(%rip), %rdi    # 0x5a3bdf
leaq 0x18b1e4(%rip), %rsi    # 0x5a3c38
movl $0x14, %edx
leaq 0x18b1e9(%rip), %rcx    # 0x5a3c49
callq 0x4e53d0
movq -0x38(%rbp), %rax
movb 0x11(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
jne 0x418a82
movb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x418a82
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x418a8b
jmp 0x418a8d
jmp 0x418aac
leaq 0x18b22c(%rip), %rdi    # 0x5a3cc0
leaq 0x18b19d(%rip), %rsi    # 0x5a3c38
movl $0x15, %edx
leaq 0x18b1a2(%rip), %rcx    # 0x5a3c49
callq 0x4e53d0
movq -0x38(%rbp), %rax
movb 0x12(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
jne 0x418ac9
movb $0x1, %al
movb %al, -0x3a(%rbp)
jmp 0x418ac9
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x418ad2
jmp 0x418ad4
jmp 0x418af3
leaq 0x18b270(%rip), %rdi    # 0x5a3d4b
leaq 0x18b156(%rip), %rsi    # 0x5a3c38
movl $0x16, %edx
leaq 0x18b15b(%rip), %rcx    # 0x5a3c49
callq 0x4e53d0
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x401070
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x418d00
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x1c(%rax)
movb $0x1, 0x11(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: MPSLab-ASU[P]DiRAC/./include/dma.hh
// Function: void DMA::write_back<unsigned short>(unsigned short*, unsigned short*, unsigned int)
void write_back(Type *ptr_src, Type *ptr_dest, uint32_t count)
  {
    assert((*req_from_compute_device == true) && "Req signal from compute device is not generated.");
    assert((prefetch_in_progress == false) && "DMA cannot handle more than one read/write request.");
    assert((writeback_in_progress == false) && "DMA cannot handle more than one read/write request.");

    uint64_t total_bytes = count;
    memcpy(ptr_dest, ptr_src, total_bytes);

    delay_write_back = calculate_data_transfer_delay(total_bytes);
    writeback_in_progress = true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
movb %al, -0x29(%rbp)
jne 0x418b6b
movb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x418b6b
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x418b74
jmp 0x418b76
jmp 0x418b95
leaq 0x18b062(%rip), %rdi    # 0x5a3bdf
leaq 0x18b0b4(%rip), %rsi    # 0x5a3c38
movl $0x23, %edx
leaq 0x18b215(%rip), %rcx    # 0x5a3da5
callq 0x4e53d0
movq -0x38(%rbp), %rax
movb 0x11(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x39(%rbp)
jne 0x418bb2
movb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x418bb2
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x418bbb
jmp 0x418bbd
jmp 0x418bdc
leaq 0x18b228(%rip), %rdi    # 0x5a3dec
leaq 0x18b06d(%rip), %rsi    # 0x5a3c38
movl $0x24, %edx
leaq 0x18b1ce(%rip), %rcx    # 0x5a3da5
callq 0x4e53d0
movq -0x38(%rbp), %rax
movb 0x12(%rax), %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x3a(%rbp)
jne 0x418bf9
movb $0x1, %al
movb %al, -0x3a(%rbp)
jmp 0x418bf9
movb -0x3a(%rbp), %al
testb $0x1, %al
jne 0x418c02
jmp 0x418c04
jmp 0x418c23
leaq 0x18b140(%rip), %rdi    # 0x5a3d4b
leaq 0x18b026(%rip), %rsi    # 0x5a3c38
movl $0x25, %edx
leaq 0x18b187(%rip), %rcx    # 0x5a3da5
callq 0x4e53d0
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x401070
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
callq 0x418d00
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x20(%rax)
movb $0x1, 0x12(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: MPSLab-ASU[P]DiRAC/./src/dma.cc
// Function: DMA::execute_tick()
void DMA::execute_tick()
{
  if (prefetch_in_progress)
  {
    if (count_prefetch < delay_prefetch)
    {
      // prefetch in progress
      ack_to_compute_device = false;
      count_prefetch += 1;
    }
    else if (count_prefetch == delay_prefetch)
    {
      // prefetch done
      ack_to_compute_device = true;
      count_prefetch = 0;
      prefetch_in_progress = false;
    }
    else
      assert("Should not reach here!");
  }
  else if(writeback_in_progress)
  {
    if (counter_write_back < delay_write_back)
    {
      ack_to_compute_device = false;
      counter_write_back += 1;
    }
    else if (counter_write_back == delay_write_back)
    {
      ack_to_compute_device = true;
      counter_write_back = 0;
      writeback_in_progress = false;
    }
    else
      assert("Should not reach here!");
  }
  else
    ack_to_compute_device = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x11(%rax)
je 0x418dcc
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jae 0x418da5
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movl 0x14(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x14(%rax)
jmp 0x418dca
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0x418dc6
movq -0x10(%rbp), %rax
movb $0x1, 0x10(%rax)
movl $0x0, 0x14(%rax)
movb $0x0, 0x11(%rax)
jmp 0x418dc8
jmp 0x418dc8
jmp 0x418dca
jmp 0x418e26
movq -0x10(%rbp), %rax
testb $0x1, 0x12(%rax)
je 0x418e1c
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x20(%rcx), %eax
jae 0x418df5
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x418e1a
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %eax
cmpl 0x20(%rcx), %eax
jne 0x418e16
movq -0x10(%rbp), %rax
movb $0x1, 0x10(%rax)
movl $0x0, 0x18(%rax)
movb $0x0, 0x12(%rax)
jmp 0x418e18
jmp 0x418e18
jmp 0x418e1a
jmp 0x418e24
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
jmp 0x418e26
popq %rbp
retq
nopl (%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/network.cc
// Function: MultiCastNetwork_Input::~MultiCastNetwork_Input()
MultiCastNetwork_Input::~MultiCastNetwork_Input()
{

  for(uint16_t i=0; i < nRows_PE_Array; i++) {
    delete[] colWiseMC[i];
  }
  delete[] colWiseMC;
  delete[] rowWiseMC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x0, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x4191ee
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0xa(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4191db
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x30(%rbp)
shlq $0x6, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x28(%rbp)
je 0x4191c6
movq -0x28(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0x40(%rbp)
callq 0x41a5d0
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x28(%rbp)
jne 0x4191a4
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
shlq $0x6, %rsi
addq $0x8, %rsi
callq 0x4248b0
jmp 0x4191dd
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x41914a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x419209
movq -0x48(%rbp), %rdi
callq 0x4248a0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x41927b
movq -0x50(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rcx), %rdx
movq %rdx, -0x60(%rbp)
shlq $0x6, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x58(%rbp)
je 0x419266
movq -0x58(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0x70(%rbp)
callq 0x41a5d0
movq -0x50(%rbp), %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x419244
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
shlq $0x6, %rsi
addq $0x8, %rsi
callq 0x4248b0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/network.cc
// Function: MultiCastNetwork_Input::execute()
void MultiCastNetwork_Input::execute()
{
  for(uint16_t i=0; i < nRows_PE_Array; i++) {
    for(uint16_t j=0; j < nCols_PE_Array; j++) {
      colWiseMC[i][j].execute();
    }
  }

  for(uint16_t i=0; i < nRows_PE_Array; i++) {
    rowWiseMC[i].execute();
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x0, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x4197e2
movw $0x0, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movq $0x61e5ae, %rcx         # imm = 0x61E5AE
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x4197d2
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0xa(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movzwl -0xc(%rbp), %eax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x419830
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x419792
jmp 0x4197d4
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x41977a
movw $0x0, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x41981f
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movzwl -0xe(%rbp), %eax
shlq $0x6, %rax
addq %rax, %rdi
callq 0x419830
movw -0xe(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xe(%rbp)
jmp 0x4197e8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/network.cc
// Function: MultiCastNetwork_Output::~MultiCastNetwork_Output()
MultiCastNetwork_Output::~MultiCastNetwork_Output()
{

  for(uint16_t i=0; i < nRows_PE_Array; i++) {
    delete[] colWiseMC[i];
  }
  delete[] colWiseMC;
  delete[] rowWiseMC;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x0, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x419eae
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0xa(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x419e9b
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rcx), %rax
movq %rax, -0x30(%rbp)
imulq $0x18, %rax, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x28(%rbp)
je 0x419e86
movq -0x28(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0x41a530
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x28(%rbp)
jne 0x419e64
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
imulq $0x18, %rax, %rsi
addq $0x8, %rsi
callq 0x4248b0
jmp 0x419e9d
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x419e0a
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x419ec9
movq -0x48(%rbp), %rdi
callq 0x4248a0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x419f3b
movq -0x50(%rbp), %rcx
movq %rcx, %rax
addq $-0x8, %rax
movq %rax, -0x68(%rbp)
movq -0x8(%rcx), %rax
movq %rax, -0x60(%rbp)
imulq $0x18, %rax, %rdx
movq %rcx, %rax
addq %rdx, %rax
cmpq %rax, %rcx
movq %rax, -0x58(%rbp)
je 0x419f26
movq -0x58(%rbp), %rdi
addq $-0x18, %rdi
movq %rdi, -0x70(%rbp)
callq 0x41a530
movq -0x50(%rbp), %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0x58(%rbp)
jne 0x419f04
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rax
imulq $0x18, %rax, %rsi
addq $0x8, %rsi
callq 0x4248b0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/network.cc
// Function: MultiCastNetwork_Output::execute()
void MultiCastNetwork_Output::execute()
{
  for(uint16_t i=0; i < nRows_PE_Array; i++) {
    rowWiseMC[i].execute(i, 0);
  }

  for(uint16_t i=0; i < nRows_PE_Array; i++) {
    for(uint16_t j=0; j < nCols_PE_Array; j++) {
      colWiseMC[i][j].execute(i, j);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movw $0x0, -0xa(%rbp)
movzwl -0xa(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x41a3b7
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movzwl -0xa(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
xorl %edx, %edx
movzwl -0xa(%rbp), %esi
callq 0x41a440
movw -0xa(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x41a37a
movw $0x0, -0xc(%rbp)
movzwl -0xc(%rbp), %eax
movq $0x61e5ac, %rcx         # imm = 0x61E5AC
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x41a430
movw $0x0, -0xe(%rbp)
movzwl -0xe(%rbp), %eax
movq $0x61e5ae, %rcx         # imm = 0x61E5AE
movzwl (%rcx), %ecx
cmpl %ecx, %eax
jge 0x41a420
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movzwl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
movzwl -0xe(%rbp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movw -0xc(%rbp), %ax
movzwl %ax, %esi
movzwl -0xe(%rbp), %edx
callq 0x41a440
movw -0xe(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xe(%rbp)
jmp 0x41a3d5
jmp 0x41a422
movw -0xc(%rbp), %ax
addw $0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x41a3bd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/network.cc
// Function: MultiCastController_OutputNetwork::execute(unsigned short, unsigned short)
void MultiCastController_OutputNetwork::execute(uint16_t rowId=0, uint16_t colId=0)
{
  uint16_t num_inputBus = (isRowWise_controller) ? nCols_PE_Array : 1;
  bool out_write_back = false;
  data_type out_data = 0;

  for(uint16_t it=0; it < num_inputBus; it++)
  {
    out_data     |= *(dataIn[it]);
    out_write_back |= *(writeBackIn[it]);
  }
  dataOut  = out_data;
  writeBackOut = out_write_back;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x14(%rax)
je 0x41a473
movq $0x61e5ae, %rax         # imm = 0x61E5AE
movzwl (%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0x41a47d
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x41a47d
movl -0x24(%rbp), %eax
movw %ax, -0xe(%rbp)
movb $0x0, -0xf(%rbp)
movw $0x0, -0x12(%rbp)
movw $0x0, -0x14(%rbp)
movzwl -0x14(%rbp), %eax
movzwl -0xe(%rbp), %ecx
cmpl %ecx, %eax
jge 0x41a4f2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movzwl -0x14(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
movzwl (%rcx), %edx
movzwl -0x12(%rbp), %ecx
orl %edx, %ecx
movw %cx, -0x12(%rbp)
movq (%rax), %rax
movzwl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %ecx
movb -0xf(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0xf(%rbp)
movw -0x14(%rbp), %ax
addw $0x1, %ax
movw %ax, -0x14(%rbp)
jmp 0x41a494
movq -0x20(%rbp), %rax
movw -0x12(%rbp), %cx
movw %cx, 0x12(%rax)
movb -0xf(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x10(%rax)
popq %rbp
retq
nopl (%rax)
// File: MPSLab-ASU[P]DiRAC/./src/../argparse/argparse.hpp
// Function: ArgumentParser::count(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
size_t count(const String& name) {
        // check if the name is an argument
        if (index_.count(delimit(name)) == 0) return 0;
        size_t N = index_[delimit(name)];
        Argument arg = arguments_[N];
        Any var = variables_[N];
        // check if the argument is a vector
        if (arg.fixed) {
            return !var.castTo<String>().empty();
        } else {
            return var.castTo<StringVector>().size();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x421e50
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
callq 0x421670
movq %rax, -0xe0(%rbp)
jmp 0x41bb4e
leaq -0x38(%rbp), %rdi
callq 0x4a2730
movq -0xe0(%rbp), %rax
cmpq $0x0, %rax
jne 0x41bb8b
movq $0x0, -0x8(%rbp)
jmp 0x41bd05
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4a2730
jmp 0x41bd12
movq -0x18(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x421e50
movq -0xf0(%rbp), %rdi
movq -0x100(%rbp), %rsi
callq 0x421f40
movq %rax, -0xf8(%rbp)
jmp 0x41bbbb
movq -0xf8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x108(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4a2730
movq -0x108(%rbp), %rax
movq -0xf0(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x88, %rdi
movq -0x50(%rbp), %rsi
callq 0x420380
movq %rax, %rsi
leaq -0xc8(%rbp), %rdi
callq 0x41cce0
movq -0xf0(%rbp), %rdi
addq $0xa0, %rdi
movq -0x50(%rbp), %rsi
callq 0x4216a0
movq %rax, %rsi
leaq -0xd0(%rbp), %rdi
callq 0x41d8d0
jmp 0x41bc2e
testb $0x1, -0x78(%rbp)
je 0x41bcae
leaq -0xd0(%rbp), %rdi
callq 0x4216c0
movq %rax, -0x110(%rbp)
jmp 0x41bc49
movq -0x110(%rbp), %rdi
callq 0x4a2c50
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movq %rax, -0x8(%rbp)
movl $0x1, -0xd4(%rbp)
jmp 0x41bcdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4a2730
jmp 0x41bd12
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x41bcf7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x41c930
jmp 0x41bcf7
leaq -0xd0(%rbp), %rdi
callq 0x421720
movq %rax, -0x118(%rbp)
jmp 0x41bcc3
movq -0x118(%rbp), %rdi
callq 0x40ed20
movq %rax, -0x8(%rbp)
movl $0x1, -0xd4(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x41c930
leaq -0xc8(%rbp), %rdi
callq 0x41c6a0
jmp 0x41bd05
leaq -0xc8(%rbp), %rdi
callq 0x41c6a0
jmp 0x41bd12
movq -0x8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4d0770
nopl (%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/../argparse/argparse.hpp
// Function: ArgumentParser::Argument::Argument(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, char)
Argument(const String& _short_name, const String& _name, bool _optional, char nargs)
                : short_name(_short_name), name(_name), optional(_optional) {
            if (nargs == '+' || nargs == '*') {
                variable_nargs = nargs;
                fixed = false;
            } else {
                fixed_nargs = nargs;
                fixed = true;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %cl
movb %cl, -0x19(%rbp)
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
callq 0x4a4ec0
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
callq 0x4a4ec0
jmp 0x41c41b
movq -0x40(%rbp), %rax
movb -0x19(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x40(%rax)
movsbl -0x1a(%rbp), %eax
cmpl $0x2b, %eax
je 0x41c43a
movsbl -0x1a(%rbp), %eax
cmpl $0x2a, %eax
jne 0x41c461
movq -0x40(%rbp), %rax
movb -0x1a(%rbp), %cl
movb %cl, 0x48(%rax)
movb $0x0, 0x50(%rax)
jmp 0x41c472
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x4a2730
jmp 0x41c478
movq -0x40(%rbp), %rax
movsbq -0x1a(%rbp), %rcx
movq %rcx, 0x48(%rax)
movb $0x1, 0x50(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x4d0770
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/../argparse/argparse.hpp
// Function: ArgumentParser::insertArgument(ArgumentParser::Argument const&)
void insertArgument(const Argument& arg) {
        size_t N = arguments_.size();
        arguments_.push_back(arg);
        if (arg.fixed && arg.fixed_nargs <= 1) {
            variables_.push_back(String());
        } else {
            variables_.push_back(StringVector());
        }
        if (!arg.short_name.empty()) index_[arg.short_name] = N;
        if (!arg.name.empty()) index_[arg.name] = N;
        if (!arg.optional) required_++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x88, %rdi
callq 0x41c7f0
movq -0x78(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x88, %rdi
movq -0x10(%rbp), %rsi
callq 0x41c820
movq -0x10(%rbp), %rax
testb $0x1, 0x50(%rax)
je 0x41c573
movq -0x10(%rbp), %rax
cmpq $0x1, 0x48(%rax)
ja 0x41c573
movq -0x78(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4a2620
movq -0x80(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x41c8c0
jmp 0x41c519
movq -0x88(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x41c890
jmp 0x41c52b
leaq -0x20(%rbp), %rdi
callq 0x41c930
leaq -0x40(%rbp), %rdi
callq 0x4a2730
jmp 0x41c60c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x41c565
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x41c930
leaq -0x40(%rbp), %rdi
callq 0x4a2730
jmp 0x41c695
movq -0x78(%rbp), %rax
addq $0xa0, %rax
movq %rax, -0x98(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x40ebb0
movq -0x90(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x41c960
jmp 0x41c5b5
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x41c890
jmp 0x41c5c7
leaq -0x58(%rbp), %rdi
callq 0x41c930
leaq -0x70(%rbp), %rdi
callq 0x40ebd0
jmp 0x41c60c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x41c5fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x41c930
leaq -0x70(%rbp), %rdi
callq 0x40ebd0
jmp 0x41c695
movq -0x10(%rbp), %rdi
callq 0x4a2c50
testb $0x1, %al
jne 0x41c63b
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x41c9d0
movq -0xa0(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x4a2c50
testb $0x1, %al
jne 0x41c672
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
callq 0x41c9d0
movq -0xa8(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x40(%rax)
jne 0x41c68c
movq -0x78(%rbp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4d0770
nop
// File: MPSLab-ASU[P]DiRAC/./src/../argparse/argparse.hpp
// Function: ArgumentParser::argumentError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void argumentError(const std::string& msg, bool show_usage = false) {
        if (use_exceptions_) throw std::invalid_argument(msg);
        std::cerr << "ArgumentParser error: " << msg << std::endl;
        if (show_usage) std::cerr << usage() << std::endl;
        exit(-5);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0x39(%rax)
je 0x41c745
movl $0x10, %edi
callq 0x424b90
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rsi
callq 0x457160
jmp 0x41c714
movq -0x58(%rbp), %rdi
movq $0x6151e8, %rsi         # imm = 0x6151E8
movq $0x42f0b0, %rdx         # imm = 0x42F0B0
callq 0x425be0
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x424bf0
jmp 0x41c7de
movq $0x61f7e0, %rdi         # imm = 0x61F7E0
leaq 0x187a1e(%rip), %rsi    # 0x5a4171
callq 0x492450
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x4a5160
movq %rax, %rdi
movq $0x491d30, %rsi         # imm = 0x491D30
callq 0x490f40
testb $0x1, -0x11(%rbp)
je 0x41c7d4
movq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x41b000
movq -0x68(%rbp), %rsi
movq $0x61f7e0, %rdi         # imm = 0x61F7E0
callq 0x4a5160
movq %rax, -0x60(%rbp)
jmp 0x41c7a0
movq -0x60(%rbp), %rdi
movq $0x491d30, %rsi         # imm = 0x491D30
callq 0x490f40
jmp 0x41c7b2
leaq -0x48(%rbp), %rdi
callq 0x4a2730
jmp 0x41c7d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x4a2730
jmp 0x41c7de
movl $0xfffffffb, %edi       # imm = 0xFFFFFFFB
callq 0x4ec1e0
movq -0x20(%rbp), %rdi
callq 0x4d0770
nopw (%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/../argparse/argparse.hpp
// Function: ArgumentParser::strip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static String strip(const String& name) {
        size_t begin = 0;
        begin += name.size() > 0 ? name[0] == '-' : 0;
        begin += name.size() > 3 ? name[1] == '-' : 0;
        return name.substr(begin);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4a2950
cmpq $0x0, %rax
jbe 0x4204c2
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4a2c60
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4204c9
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x4204c9
movl -0x2c(%rbp), %eax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4a2950
cmpq $0x3, %rax
jbe 0x420506
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x4a2c60
movsbl (%rax), %eax
cmpl $0x2d, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x30(%rbp)
jmp 0x42050d
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x42050d
movq -0x28(%rbp), %rdi
movl -0x30(%rbp), %eax
cltq
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq $-0x1, %rcx
callq 0x4a50e0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: MPSLab-ASU[P]DiRAC/./src/pe.cc
// Function: PE::setup(unsigned short, unsigned short)
void PE::setup(uint16_t _row, uint16_t _col) {
  row = _row;
  col = _col;
  PE_State = idle;

  // ToDo: Configure dynamically
  // count_trigger_PE_exec += row*col + col;
  // count_trigger_write_back += row*col + col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %dx, %ax
movw %si, %cx
movq %rdi, -0x8(%rbp)
movw %cx, -0xa(%rbp)
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movw -0xa(%rbp), %cx
movw %cx, 0x10(%rax)
movw -0xc(%rbp), %cx
movw %cx, 0x12(%rax)
movl $0x0, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)