LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::read_golden_outputs()
void baseAccelSim::read_golden_outputs()
{
	for(uint8_t op=input_operands; op < total_operands; op++)
	{
		string fileName = dir_data + "golden_op" + std::to_string(int(op)+1) + ".txt";
		ifstream inFile(fileName.c_str());

		if(!inFile)
		{
			cout << "Cannot open and read file: " << fileName.c_str() << endl;
			exit (EXIT_FAILURE);
		}

		for(int i=0; i < size_tensors[op]; i++) {
			inFile >> golden_outputs[op-input_operands][i];
		}
		inFile.close();
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp            # imm = 0x268
movzbl 0x20129c(%rip), %ebp    # 0x608558
leaq 0x40(%rsp), %r12
leaq 0x20(%rsp), %r15
leaq 0x60(%rsp), %r13
movq %rsp, %rbx
movzbl 0x201281(%rip), %eax    # 0x608556
cmpq %rax, %rbp
jae 0x4073c3
movq %r12, %rdi
leaq 0x201478(%rip), %rsi    # 0x608760
leaq 0x189d70(%rip), %rdx    # 0x59105f
callq 0x40a546
leal 0x1(%rbp), %esi
movq %r15, %rdi
callq 0x40a42c
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x40a4df
movq %rbx, %rdi
movq %r13, %rsi
leaq 0x18af22(%rip), %rdx    # 0x59223c
callq 0x40a4c0
movq %r13, %rdi
callq 0x490a30
movq %r15, %rdi
callq 0x490a30
movq %r12, %rdi
callq 0x490a30
movq (%rsp), %rsi
movq %r13, %rdi
pushq $0x8
popq %rdx
callq 0x45cbc0
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x80(%rsp,%rax)
jne 0x4073d5
movq %rbx, %r15
xorl %r14d, %r14d
xorl %ebx, %ebx
movq 0x201208(%rip), %rax    # 0x608570
cmpq %rbx, (%rax,%rbp,8)
jbe 0x40739b
movq 0x2011f3(%rip), %rax    # 0x608568
movzbl 0x2011dc(%rip), %ecx    # 0x608558
movl %ebp, %edx
subl %ecx, %edx
movslq %edx, %rcx
movq (%rax,%rcx,8), %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x4665c0
incq %rbx
addq $0x2, %r14
jmp 0x407361
movq %r13, %rdi
callq 0x45d170
movq %r13, %rdi
callq 0x45d520
movq %r15, %rbx
movq %r15, %rdi
callq 0x490a30
incq %rbp
leaq 0x20(%rsp), %r15
jmp 0x4072ce
addq $0x268, %rsp            # imm = 0x268
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x609900, %rdi         # imm = 0x609900
leaq 0x188c3d(%rip), %rsi    # 0x590020
callq 0x480750
movq (%rsp), %rsi
movq %rax, %rdi
callq 0x480750
movq %rax, %rdi
callq 0x480030
pushq $0x1
popq %rdi
callq 0x4da4e0
jmp 0x407435
jmp 0x407435
movq %rax, %rbx
jmp 0x407442
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x490a30
jmp 0x40741f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x490a30
jmp 0x40742e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0x407445
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x45d520
movq %rsp, %rdi
callq 0x490a30
movq %rbx, %rdi
callq 0x4bea70
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::compare_golden_outputs()
void baseAccelSim::compare_golden_outputs()
{
	if(compare_golden)
	{
		read_golden_outputs();

		for(uint8_t op=(total_operands-output_operands); op < total_operands; op++)
		{
			for(int i=0; i < size_tensors[op]; i++)
			{
				if(golden_outputs[op-input_operands][i] - tensor_operands[op][i] > 0.001)
				{
					printf("Operand %d: Golden output does not match with generated output.\n", op);
					exit (EXIT_FAILURE);
				}
			}
		}
		cout << "Generated output operands consist of expected values.\n";
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x1, 0x201522(%rip)    # 0x608980
jne 0x4074d7
callq 0x4072a4
movzbl 0x2010ea(%rip), %eax    # 0x608556
movb 0x2010e5(%rip), %cl     # 0x608557
movl %eax, %esi
subb %cl, %sil
movq 0x2010f2(%rip), %rcx    # 0x608570
movq 0x2010e3(%rip), %rdx    # 0x608568
movzbl 0x2010cc(%rip), %edi    # 0x608558
movq 0x2010cd(%rip), %r8     # 0x608560
movzbl %sil, %esi
cmpq %rax, %rsi
jae 0x4074dd
movq (%rcx,%rsi,8), %r9
movl %esi, %r10d
subl %edi, %r10d
movslq %r10d, %r10
shlq $0x3, %r10
xorl %r11d, %r11d
cmpq %r11, %r9
je 0x4074d2
movq (%rdx,%r10), %rbx
movzwl (%rbx,%r11,2), %ebx
movq (%r8,%rsi,8), %r14
leaq 0x1(%r11), %r15
cmpw (%r14,%r11,2), %bx
movq %r15, %r11
jbe 0x4074b0
jmp 0x4074f5
incq %rsi
jmp 0x407497
popq %rbx
popq %r14
popq %r15
retq
movq $0x609900, %rdi         # imm = 0x609900
leaq 0x189bbf(%rip), %rsi    # 0x5910aa
popq %rbx
popq %r14
popq %r15
jmp 0x480750
leaq 0x189b6d(%rip), %rdi    # 0x591069
xorl %eax, %eax
callq 0x4e57b0
pushq $0x1
popq %rdi
callq 0x4da4e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq (%rsi), %rsi
leaq 0x28(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x45cbc0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
jne 0x408f15
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rbx
leaq 0x8(%rsp), %r14
pushq $0xa
popq %rbp
leaq 0x1ff77a(%rip), %r15    # 0x608628
movq %rsp, %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x493470
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x408ee7
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq 0x40a5b8
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x40b71c
jmp 0x408eb1
leaq 0x28(%rsp), %rdi
callq 0x45d170
leaq 0x8(%rsp), %rdi
callq 0x490a30
leaq 0x28(%rsp), %rdi
callq 0x45d520
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq $0x609900, %rdi         # imm = 0x609900
leaq 0x1870fd(%rip), %rsi    # 0x590020
callq 0x480750
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x480750
movq %rax, %rdi
callq 0x480030
pushq $0x1
popq %rdi
callq 0x4da4e0
movq %rax, %rbx
jmp 0x408f59
jmp 0x408f4c
jmp 0x408f4c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x490a30
leaq 0x28(%rsp), %rdi
callq 0x45d520
movq %rbx, %rdi
callq 0x4bea70
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::read_accel_configurations()
void baseAccelSim::read_accel_configurations()
{
	read_file_instns(instnsFileName);
	define_vars_SPM_management();
	read_file_SPM_config(spmConfigFileName);
	read_file_DMAC_prefetch_management(dmacPrefetchManageFileName);
	read_file_DMAC_WB_management(dmacWBManageFileName);
	read_file_network_info(networkInfoFileName);
	read_file_config_interconnect(interconnectConfigFileName);
	read_file_input_network_packets(inputNetworkPacketsFileName);
	read_file_output_network_packets(outputNetworkPacketsFileName);
	define_vars_network_comm_management();
	read_file_SPM_read_management(spmReadManageFileName);
	read_file_SPM_write_management(spmWriteManageFileName);
	read_file_config_trigger_PEs(configTriggerPEsFileName);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
leaq 0x1ff185(%rip), %rsi    # 0x608820
leaq 0x148(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x408e52
leaq 0x148(%rsp), %rdi
callq 0x490a30
callq 0x406044
leaq 0x1ff174(%rip), %rsi    # 0x608840
leaq 0x128(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x406346
leaq 0x128(%rsp), %rdi
callq 0x490a30
leaq 0x1ff168(%rip), %rsi    # 0x608860
leaq 0x108(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x406604
leaq 0x108(%rsp), %rdi
callq 0x490a30
leaq 0x1ff15c(%rip), %rsi    # 0x608880
leaq 0xe8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x406a48
leaq 0xe8(%rsp), %rdi
callq 0x490a30
leaq 0x1ff150(%rip), %rsi    # 0x6088a0
leaq 0xc8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x40750c
leaq 0xc8(%rsp), %rdi
callq 0x490a30
leaq 0x1ff144(%rip), %rsi    # 0x6088c0
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x40774c
leaq 0xa8(%rsp), %rdi
callq 0x490a30
leaq 0x1ff138(%rip), %rsi    # 0x6088e0
leaq 0x88(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x407b48
leaq 0x88(%rsp), %rdi
callq 0x490a30
leaq 0x1ff12c(%rip), %rsi    # 0x608900
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x407e4a
leaq 0x68(%rsp), %rdi
callq 0x490a30
callq 0x408170
leaq 0x1ff121(%rip), %rsi    # 0x608920
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x40846c
leaq 0x48(%rsp), %rdi
callq 0x490a30
leaq 0x1ff11b(%rip), %rsi    # 0x608940
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x408956
leaq 0x28(%rsp), %rdi
callq 0x490a30
leaq 0x1ff115(%rip), %rsi    # 0x608960
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x408f6c
leaq 0x8(%rsp), %rdi
callq 0x490a30
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r14
retq
jmp 0x409889
jmp 0x409889
jmp 0x409889
jmp 0x409889
jmp 0x409889
jmp 0x409889
jmp 0x409889
jmp 0x409889
jmp 0x409889
jmp 0x409889
movq %rax, %r14
movq %rbx, %rdi
callq 0x490a30
movq %r14, %rdi
callq 0x4bea70
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x130, %rsp            # imm = 0x130
callq 0x40ed88
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x404b8e
movq %rbx, %rdi
callq 0x406e98
callq 0x40968a
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x40b898
movq 0x1fe343(%rip), %rsi    # 0x608560
movq %rbx, %rdi
callq 0x40c4e4
movq 0x1fe3ec(%rip), %rsi    # 0x608618
leaq 0x187776(%rip), %rdi    # 0x5919a9
xorl %eax, %eax
callq 0x4e57b0
leaq 0x8(%rsp), %rdi
callq 0x4070ae
callq 0x407452
callq 0x40989c
leaq 0x10(%rsp), %rdi
callq 0x40c0d4
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x40c0d4
movq %rbx, %rdi
callq 0x4bea70
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::controller()
controller::controller()
{
  setup_PEs();
  setup_interconnect();
  setup_DMAC();
  setup_scratchpad();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1f3035(%rip), %rax    # 0x5fe8d8
movq %rax, (%rdi)
andw $0x0, 0xa0(%rdi)
xorl %eax, %eax
movb %al, 0xb8(%rdi)
movb $0x1, 0xc8(%rdi)
movb %al, 0xcd(%rdi)
andl $0x0, 0xc9(%rdi)
movw $0x101, 0xce(%rdi)      # imm = 0x101
andl $0x0, 0xd0(%rdi)
andl $0x0, 0xf8(%rdi)
callq 0x40b900
movq %rbx, %rdi
callq 0x40bc06
movq %rbx, %rdi
callq 0x40c032
movq %rbx, %rdi
popq %rbx
jmp 0x40c094
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq $0x6085ac, %r15         # imm = 0x6085AC
movq $0x6085ae, %r12         # imm = 0x6085AE
movzwl (%r15), %eax
cmpq %rax, %r14
jae 0x40c4be
xorl %r13d, %r13d
xorl %ebp, %ebp
movzwl (%r12), %eax
cmpq %rax, %rbp
jae 0x40c4b9
movq 0x8(%rbx), %rax
movq (%rax,%r14,8), %rdi
addq %r13, %rdi
callq 0x4128ac
incq %rbp
addq $0x148, %r13            # imm = 0x148
jmp 0x40c493
incq %r14
jmp 0x40c485
movq $0x60873a, %rax         # imm = 0x60873A
andw $0x0, (%rax)
movq $0x608738, %rax         # imm = 0x608738
andw $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x40c466
movq $0x6085e4, %rbp         # imm = 0x6085E4
movq $0x6085ae, %r12         # imm = 0x6085AE
movq $0x606151, %r13         # imm = 0x606151
cmpb $0x0, 0xa0(%rbx)
jne 0x40c5d3
movq %rbx, %rdi
callq 0x40c5e2
xorl %r14d, %r14d
xorl %r15d, %r15d
movzbl (%rbp), %eax
cmpq %rax, %r15
jae 0x40c548
movq 0x88(%rbx), %rdi
addq %r14, %rdi
callq 0x40ec7c
incq %r15
addq $0x10, %r14
jmp 0x40c527
xorl %ebp, %ebp
movq $0x6085ac, %rax         # imm = 0x6085AC
movzwl (%rax), %eax
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %rax, %rbp
jb 0x40c57b
jmp 0x40c58a
movq 0x8(%rbx), %rax
movq (%rax,%rbp,8), %rdi
addq %r14, %rdi
callq 0x41213e
incq %r15
addq $0x148, %r14            # imm = 0x148
movzwl (%r12), %eax
cmpq %rax, %r15
jb 0x40c561
incq %rbp
jmp 0x40c54a
movq $0x6085e4, %rbp         # imm = 0x6085E4
movzbl (%r13), %eax
cmpq %rax, %r15
jae 0x40c5b0
movq 0x50(%rbx), %rdi
addq %r14, %rdi
callq 0x40dc74
incq %r15
addq $0x10, %r14
jmp 0x40c591
movq 0xa8(%rbx), %rdi
callq 0x40d8ca
movq %rbx, %rdi
callq 0x40c65c
movq $0x608618, %rax         # imm = 0x608618
incq (%rax)
jmp 0x40c50c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0xb8(%rdi)
movq 0xc0(%rdi), %rax
movzbl 0xc9(%rdi), %ecx
xorl %r14d, %r14d
cmpb $0x0, (%rax)
cmovnel %r14d, %ecx
movb %cl, 0xc9(%rdi)
movq $0x6085e4, %r15         # imm = 0x6085E4
xorl %r12d, %r12d
movzbl (%r15), %eax
cmpq %rax, %r12
jae 0x40c64f
movq 0x118(%rbx), %rdx
addq %r14, %rdx
movzbl %r12b, %esi
movq %rbx, %rdi
callq 0x40cf18
movq 0x110(%rbx), %rcx
movb %al, (%rcx,%r12)
incq %r12
addq $0x2, %r14
jmp 0x40c61c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq $0x608620, %rax         # imm = 0x608620
movl (%rax), %eax
cmpq $0x3, %rax
ja 0x40c711
movq %rdi, %rbx
leaq 0x185482(%rip), %rcx    # 0x591afc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
jmp 0x40cc78
movq %rbx, %rdi
callq 0x40c728
movq %rbx, %rdi
popq %rbx
jmp 0x40cdfc
movq $0x6085ac, %rax         # imm = 0x6085AC
movzwl (%rax), %eax
movq $0x6085ae, %rcx         # imm = 0x6085AE
movzwl (%rcx), %ecx
xorl %edx, %edx
cmpq %rax, %rdx
je 0x40c6d6
movq 0x10(%rbx), %rsi
xorl %edi, %edi
cmpq %rdi, %rcx
je 0x40c6d1
movq (%rsi,%rdx,8), %r8
movb $0x0, (%r8,%rdi)
incq %rdi
jmp 0x40c6be
incq %rdx
jmp 0x40c6b3
movq 0x58(%rbx), %rax
movq 0x60(%rbx), %rcx
movq 0x68(%rbx), %rdx
xorl %esi, %esi
movq $0x606151, %rdi         # imm = 0x606151
xorl %r8d, %r8d
movzbl (%rdi), %r9d
cmpq %r9, %r8
jae 0x40c70a
movb %sil, (%rax,%r8)
movb %sil, (%rcx,%r8)
andw $0x0, (%rdx,%r8,2)
incq %r8
jmp 0x40c6ee
movb $0x1, 0xa0(%rbx)
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x40cd08
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq 0x80(%rdi), %rax
xorl %ecx, %ecx
movq $0x606153, %rdx         # imm = 0x606153
movzbl (%rdx), %esi
cmpq %rsi, %rcx
jae 0x40cc9b
andw $0x0, (%rax,%rcx,2)
incq %rcx
jmp 0x40cc89
movq $0x608620, %rax         # imm = 0x608620
movl $0x1, (%rax)
xorl %eax, %eax
movq $0x608556, %rcx         # imm = 0x608556
movq $0x608718, %rdx         # imm = 0x608718
movb $0x1, %sil
movq $0x608720, %r8          # imm = 0x608720
movq $0x608728, %r9          # imm = 0x608728
movq $0x608730, %r10         # imm = 0x608730
xorl %r11d, %r11d
movzbl (%rcx), %ebx
cmpq %rbx, %r11
jae 0x40ccfc
movq (%rdx), %rbx
movb %sil, (%rbx,%r11)
movq (%r8), %rbx
movb %sil, (%rbx,%r11)
movq (%r9), %rbx
movb %al, (%rbx,%r11)
movq (%r10), %rbx
movb %al, (%rbx,%r11)
incq %r11
jmp 0x40ccd3
movw $0x101, 0xce(%rdi)      # imm = 0x101
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::configure_interconnect()
void controller::configure_interconnect()
{
  for(uint8_t i=0; i < totalNetworks; i++)
  {
    configNetwork[i] = 1;
    // 4 is total elements in configArr packet
    uint32_t idxRow = cnt_data_distribution[i] / network_controller_config_params;
    uint16_t idxCol = cnt_data_distribution[i] % network_controller_config_params;
    if(cnt_data_distribution[i] >= nRows_PE_Array*network_controller_config_params)
      forwardDataToNetwork[i] = 1;
    else
      forwardDataToNetwork[i] = 0;

    rowTagDataToNetwork[i] = configArr[i][idxRow][idxCol].getRowTag();
    colTagDataToNetwork[i] = configArr[i][idxRow][idxCol].getColTag();
    dataOutToNetwork[i]    = configArr[i][idxRow][idxCol].getData();

    cnt_data_distribution[i]++;

    // all networks are configured simultanously
    // so controller does not need to sync-up or wait for a specific network
    if(cnt_data_distribution[i] == total_MC*network_controller_config_params)
    {
      cnt_data_distribution[i] = 0;
      acc_controller_state = exec_kernel;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorl %eax, %eax
movq $0x606153, %rcx         # imm = 0x606153
movq $0x6085ac, %rdx         # imm = 0x6085AC
movq $0x608600, %rsi         # imm = 0x608600
movq $0x608610, %r8          # imm = 0x608610
movq $0x608620, %r9          # imm = 0x608620
movzbl (%rcx), %r10d
cmpq %r10, %rax
jae 0x40cdf6
movq 0x58(%rdi), %r10
movb $0x1, (%r10,%rax)
movq 0x60(%rdi), %r10
movq 0x80(%rdi), %r11
movzwl (%r11,%rax,2), %r11d
movl %r11d, %ebx
andl $0x3, %ebx
movzwl (%rdx), %ebp
shll $0x2, %ebp
cmpl %r11d, %ebp
setbe (%r10,%rax)
movq (%rsi), %r10
movq (%r10,%rax,8), %r10
addl %r11d, %r11d
andl $-0x8, %r11d
movq (%r10,%r11), %r10
shll $0x2, %ebx
movb (%r10,%rbx), %r10b
movq 0x70(%rdi), %r14
movb %r10b, (%r14,%rax)
movq (%rsi), %r10
movq (%r10,%rax,8), %r10
movq (%r10,%r11), %r10
movb 0x1(%r10,%rbx), %r10b
movq 0x78(%rdi), %r14
movb %r10b, (%r14,%rax)
movq (%rsi), %r10
movq (%r10,%rax,8), %r10
movq (%r10,%r11), %r10
movzwl 0x2(%r10,%rbx), %r10d
movq 0x68(%rdi), %r11
movw %r10w, (%r11,%rax,2)
movq 0x80(%rdi), %r10
movzwl (%r10,%rax,2), %r11d
incl %r11d
movw %r11w, (%r10,%rax,2)
movzwl %r11w, %r11d
movl (%r8), %ebx
shll $0x2, %ebx
cmpl %r11d, %ebx
jne 0x40cdee
andw $0x0, (%r10,%rax,2)
movl $0x2, (%r9)
incq %rax
jmp 0x40cd31
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/controller.cc
// Function: controller::execute_RF_pass()
void controller::execute_RF_pass()
{
  // DMA prefetches data in 0th SPM pass.
  // Networks and PEs are already configured.
  // No need to configure networks further or communicate data.
  if(current_SPM_pass == 0)
  {
    for(uint8_t i=0; i < inNetworks; i++)
    {
      configNetwork[i] = 0;
      forwardDataToNetwork[i] = 0;
    }
  }

  if(current_SPM_pass > 0 && current_SPM_pass < SPM_passes + 1)
  {
    trigger_PEs();
    if ((current_RF_pass >= RF_passes) && (current_RF_pass < RF_passes + WB_delay_RF_pass))
    {
      // don't process read operands. need to process write operands
      if(PE_writeback_RF_incomplete)
        write_back_controller(current_RF_pass);
      else
        inc_RF_pass();
    }
    else if (current_RF_pass < WB_delay_RF_pass)
    {
      // don't process write operands. need to process read operands
      if(PE_prefetch_RF_incomplete)
        prefetch_to_PE(current_RF_pass);
      else
        inc_RF_pass();
    }
    else if((current_RF_pass >= WB_delay_RF_pass) && (current_RF_pass < RF_passes))
    {
      // process both read operands and write operands
      if(PE_prefetch_RF_incomplete)
        prefetch_to_PE(current_RF_pass);
      if (PE_writeback_RF_incomplete)
        write_back_controller(current_RF_pass);

      if ((PE_prefetch_RF_incomplete == 0) && (PE_writeback_RF_incomplete == 0))
        inc_RF_pass();
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x60873a, %rax         # imm = 0x60873A
movzwl (%rax), %eax
testw %ax, %ax
je 0x40ce7b
movq $0x608554, %rcx         # imm = 0x608554
decl %eax
cmpw (%rcx), %ax
jae 0x40cf10
movq %rbx, %rdi
callq 0x40cf6c
movq $0x608738, %r14         # imm = 0x608738
movzwl (%r14), %eax
movq $0x608552, %rcx         # imm = 0x608552
movzwl (%rcx), %ecx
cmpw %cx, %ax
setae %dl
movzwl %cx, %edi
movzwl %ax, %esi
addl $0x2, %edi
cmpl %esi, %edi
seta %dil
andb %dl, %dil
cmpb $0x1, %dil
jne 0x40cea9
cmpb $0x1, 0xcf(%rbx)
jne 0x40cf01
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40d234
movq 0x58(%rbx), %rcx
movq 0x60(%rbx), %rdx
xorl %esi, %esi
movq $0x606151, %rdi         # imm = 0x606151
xorl %r8d, %r8d
movzbl (%rdi), %r9d
cmpq %r9, %r8
jae 0x40ce12
movb %sil, (%rcx,%r8)
movb %sil, (%rdx,%r8)
incq %r8
jmp 0x40ce8f
cmpw $0x1, %ax
ja 0x40cec7
cmpb $0x1, 0xce(%rbx)
jne 0x40cf01
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40d47e
cmpw %cx, %ax
jae 0x40cf10
cmpb $0x1, 0xce(%rbx)
jne 0x40cedd
movq %rbx, %rdi
callq 0x40d47e
movb 0xcf(%rbx), %al
cmpb $0x1, %al
jne 0x40cef9
movzwl (%r14), %esi
movq %rbx, %rdi
callq 0x40d234
movb 0xcf(%rbx), %al
orb 0xce(%rbx), %al
jne 0x40cf10
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x40d434
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq $0x6085ac, %rax         # imm = 0x6085AC
movzwl (%rax), %ecx
movq 0x90(%rdi), %r8
movq 0x98(%rdi), %rdi
movl %esi, %esi
xorl %r9d, %r9d
shll $0x3, %esi
xorl %eax, %eax
xorl %r10d, %r10d
cmpq %r9, %rcx
je 0x40cf60
movq (%rdi,%rsi), %r11
movq (%r11,%r9,8), %r11
andb $0x1, %al
orb (%r11), %al
movq (%r8,%rsi), %r11
movq (%r11,%r9,8), %r11
orw (%r11), %r10w
incq %r9
jmp 0x40cf3d
testb $0x1, %al
je 0x40cf68
movw %r10w, (%rdx)
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq $0x608738, %rax         # imm = 0x608738
incw (%rax)
movw $0x101, 0xce(%rdi)      # imm = 0x101
andl $0x0, 0xd0(%rdi)
andl $0x0, 0xf8(%rdi)
movq 0x58(%rdi), %rax
movq 0x60(%rdi), %rcx
xorl %edx, %edx
movq $0x606151, %rsi         # imm = 0x606151
xorl %edi, %edi
movzbl (%rsi), %r8d
cmpq %r8, %rdi
jae 0x40d47c
movb %dl, (%rax,%rdi)
movb %dl, (%rcx,%rdi)
incq %rdi
jmp 0x40d468
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq $0x6085e8, %rax         # imm = 0x6085E8
movq (%rax), %r9
movl %esi, %eax
cmpw %cx, (%r9,%rax,2)
jbe 0x40d717
movq 0x58(%rdi), %rsi
movzbl %dl, %edx
movb $0x0, (%rsi,%rdx)
movq 0x60(%rdi), %rsi
movb $0x1, (%rsi,%rdx)
movq $0x6085f8, %rsi         # imm = 0x6085F8
movq (%rsi), %r9
shll $0x3, %eax
movq (%r9,%rax), %r9
movzwl %cx, %ecx
shll $0x2, %ecx
movb 0x1(%r9,%rcx), %r9b
movq 0x70(%rdi), %r10
movb %r9b, (%r10,%rdx)
movq (%rsi), %rsi
movq (%rsi,%rax), %rax
movb (%rax,%rcx), %al
movq 0x78(%rdi), %rcx
movb %al, (%rcx,%rdx)
movq 0x68(%rdi), %rax
movw %r8w, (%rax,%rdx,2)
retq
pushq %rax
leaq 0x1845ca(%rip), %rdi    # 0x591ce9
leaq 0x184444(%rip), %rsi    # 0x591b6a
leaq 0x1845e1(%rip), %rcx    # 0x591d0e
movl $0x25e, %edx            # imm = 0x25E
callq 0x4d36d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
cmpb $0x0, (%rax)
je 0x40d77a
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
jne 0x40d793
cmpb $0x0, 0x12(%rbx)
jne 0x40d7ac
movl %ecx, %ebp
movl %ecx, %eax
movq %rdx, %rdi
movq %rax, %rdx
callq 0x401070
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40d892
movl %eax, 0x1c(%rbx)
movb $0x1, 0x11(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1846d0(%rip), %rdi    # 0x591e51
leaq 0x184722(%rip), %rsi    # 0x591eaa
leaq 0x18472c(%rip), %rcx    # 0x591ebb
pushq $0x14
jmp 0x40d7c3
leaq 0x184766(%rip), %rdi    # 0x591f00
leaq 0x184709(%rip), %rsi    # 0x591eaa
leaq 0x184713(%rip), %rcx    # 0x591ebb
pushq $0x15
jmp 0x40d7c3
leaq 0x1847a4(%rip), %rdi    # 0x591f57
leaq 0x1846f0(%rip), %rsi    # 0x591eaa
leaq 0x1846fa(%rip), %rcx    # 0x591ebb
pushq $0x16
popq %rdx
callq 0x4d36d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
cmpb $0x0, (%rax)
je 0x40d80c
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
jne 0x40d825
cmpb $0x0, 0x12(%rbx)
jne 0x40d83e
movl %ecx, %ebp
movl %ecx, %eax
movq %rdx, %rdi
movq %rax, %rdx
callq 0x401070
movq %rbx, %rdi
movl %ebp, %esi
callq 0x40d892
movl %eax, 0x20(%rbx)
movb $0x1, 0x12(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x18463e(%rip), %rdi    # 0x591e51
leaq 0x184690(%rip), %rsi    # 0x591eaa
leaq 0x184790(%rip), %rcx    # 0x591fb1
pushq $0x23
jmp 0x40d855
leaq 0x1847cc(%rip), %rdi    # 0x591ff8
leaq 0x184677(%rip), %rsi    # 0x591eaa
leaq 0x184777(%rip), %rcx    # 0x591fb1
pushq $0x24
jmp 0x40d855
leaq 0x184712(%rip), %rdi    # 0x591f57
leaq 0x18465e(%rip), %rsi    # 0x591eaa
leaq 0x18475e(%rip), %rcx    # 0x591fb1
pushq $0x25
popq %rdx
callq 0x4d36d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/network.cc
// Function: MultiCastNetwork_Input::MultiCastNetwork_Input()
MultiCastNetwork_Input::MultiCastNetwork_Input()
{
  rowWiseMC = new MultiCastController_InputNetwork[nRows_PE_Array];
  colWiseMC = new MultiCastController_InputNetwork*[nRows_PE_Array];
  for(uint16_t i=0; i < nRows_PE_Array; i++) {
    colWiseMC[i] = new MultiCastController_InputNetwork[nCols_PE_Array];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x6085ac, %rax         # imm = 0x6085AC
movzwl (%rax), %r15d
movl %r15d, %edi
shll $0x6, %edi
orq $0x8, %rdi
callq 0x414190
leaq 0x8(%rax), %rcx
movq %r15, (%rax)
testl %r15d, %r15d
je 0x40d986
addq $0x20, %rax
movl %r15d, %edx
shll $0x6, %edx
xorl %esi, %esi
andl $0x0, (%rax,%rsi)
andw $0x0, 0x24(%rax,%rsi)
andq $0x0, 0x18(%rax,%rsi)
andl $0x0, 0x1f(%rax,%rsi)
addq $0x40, %rsi
cmpq %rsi, %rdx
jne 0x40d968
movq %rcx, (%rbx)
leal (,%r15,8), %edi
callq 0x414190
movq %rax, 0x8(%rbx)
movq $0x6085ae, %rax         # imm = 0x6085AE
movzwl (%rax), %r12d
movl %r12d, %r13d
shll $0x6, %r13d
leaq 0x8(%r13), %r14
xorl %ebp, %ebp
cmpq %r15, %rbp
je 0x40d9fc
movq %r14, %rdi
callq 0x414190
movq %r12, (%rax)
testq %r12, %r12
je 0x40d9eb
leaq 0x20(%rax), %rcx
xorl %edx, %edx
andl $0x0, (%rcx,%rdx)
andw $0x0, 0x24(%rcx,%rdx)
andq $0x0, 0x18(%rcx,%rdx)
andl $0x0, 0x1f(%rcx,%rdx)
addq $0x40, %rdx
cmpq %rdx, %r13
jne 0x40d9cd
addq $0x8, %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
jmp 0x40d9b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq $0x6085ac, %r14         # imm = 0x6085AC
movzwl (%r14), %eax
xorl %r15d, %r15d
movzwl %ax, %ecx
movq 0x8(%rbx), %rdi
cmpq %rcx, %r15
jae 0x40da55
movq (%rdi,%r15,8), %rdi
testq %rdi, %rdi
je 0x40da50
movq -0x8(%rdi), %rsi
addq $-0x8, %rdi
shlq $0x6, %rsi
orq $0x8, %rsi
callq 0x412c70
movzwl (%r14), %eax
incq %r15
jmp 0x40da22
testq %rdi, %rdi
je 0x40da5f
callq 0x412c60
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x40da81
movq -0x8(%rdi), %rsi
addq $-0x8, %rdi
shlq $0x6, %rsi
orq $0x8, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x412c70
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq $0x6085ac, %r14         # imm = 0x6085AC
movq $0x6085ae, %r12         # imm = 0x6085AE
movzwl (%r14), %eax
cmpq %rax, %r15
jae 0x40dcc9
xorl %r13d, %r13d
xorl %ebp, %ebp
movzwl (%r12), %eax
cmpq %rax, %rbp
jae 0x40dcc4
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r13, %rdi
callq 0x40dcfe
incq %rbp
addq $0x40, %r13
jmp 0x40dca1
incq %r15
jmp 0x40dc93
xorl %r15d, %r15d
xorl %r12d, %r12d
movzwl %ax, %eax
cmpq %rax, %r12
jae 0x40dcef
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x40dcfe
incq %r12
movzwl (%r14), %eax
addq $0x40, %r15
jmp 0x40dccf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x6085ac, %rax         # imm = 0x6085AC
movzwl (%rax), %eax
xorl %r12d, %r12d
movzwl %ax, %ecx
movq 0x8(%rbx), %rdi
cmpq %rcx, %r12
jae 0x40ea23
movq (%rdi,%r12,8), %r14
testq %r14, %r14
je 0x40ea1e
movq -0x8(%r14), %r13
testq %r13, %r13
je 0x40ea00
leaq -0x18(%r14), %rbp
imulq $0x18, %r13, %r15
leaq (%r15,%rbp), %rdi
callq 0x40ed64
addq $-0x18, %r15
jne 0x40e9f1
addq $-0x8, %r14
imulq $0x18, %r13, %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x412c70
movq $0x6085ac, %rax         # imm = 0x6085AC
movzwl (%rax), %eax
incq %r12
jmp 0x40e9cb
testq %rdi, %rdi
je 0x40ea2d
callq 0x412c60
movq (%rbx), %r14
testq %r14, %r14
je 0x40ea77
leaq -0x8(%r14), %rbx
movq -0x8(%r14), %r15
testq %r15, %r15
je 0x40ea59
addq $-0x18, %r14
imulq $0x18, %r15, %r12
leaq (%r14,%r12), %rdi
callq 0x40ed64
addq $-0x18, %r12
jne 0x40ea4a
imulq $0x18, %r15, %rsi
addq $0x8, %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x412c70
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r15d, %r15d
movq $0x6085ac, %r14         # imm = 0x6085AC
xorl %r12d, %r12d
movzwl (%r14), %eax
cmpq %rax, %r12
jae 0x40ecb8
movq (%rbx), %rdi
addq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40ed0e
incq %r12
addq $0x18, %r15
jmp 0x40ec97
xorl %r15d, %r15d
movq $0x6085ae, %r12         # imm = 0x6085AE
movzwl %ax, %eax
cmpq %rax, %r15
jae 0x40ecff
xorl %r13d, %r13d
xorl %ebp, %ebp
movzwl (%r12), %eax
cmpq %rax, %rbp
jae 0x40ecf6
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x40ed0e
incq %rbp
addq $0x18, %r13
jmp 0x40eccf
incq %r15
movzwl (%r14), %eax
jmp 0x40ecc2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq $0x6085ae, %rax         # imm = 0x6085AE
movzwl (%rax), %edx
cmpb $0x0, 0x14(%rdi)
movq (%rdi), %rax
pushq $0x1
popq %rcx
cmovneq %rdx, %rcx
movq 0x8(%rdi), %rdx
xorl %esi, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpq %rsi, %rcx
je 0x40ed4f
movq (%rdx,%rsi,8), %r10
orw (%r10), %r9w
movq (%rax,%rsi,8), %r10
andb $0x1, %r8b
orb (%r10), %r8b
incq %rsi
jmp 0x40ed32
movw %r9w, 0x12(%rdi)
andb $0x1, %r8b
movb %r8b, 0x10(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x411762
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4115a6
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x490a30
testq %r15, %r15
je 0x40f946
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x411762
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4117d6
movq (%rax), %r14
leaq 0x8(%rsp), %rdi
callq 0x490a30
imulq $0x58, %r14, %rsi
addq 0x88(%rbx), %rsi
leaq 0x8(%rsp), %rdi
callq 0x40ffc6
movq 0xa0(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x40f94a
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x40f94c
xorl %ebx, %ebx
jmp 0x40f997
xorl %eax, %eax
movq %rax, (%rsp)
cmpb $0x1, 0x58(%rsp)
jne 0x40f96b
movq %rsp, %rdi
callq 0x4114e6
xorl %ebx, %ebx
cmpq $0x0, 0x8(%rax)
setne %bl
jmp 0x40f97e
movq %rsp, %rdi
callq 0x41152a
movq 0x8(%rax), %rbx
subq (%rax), %rbx
sarq $0x5, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x40f98d
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x40fd26
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x40f9bb
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x40f9bb
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
callq 0x40fd26
jmp 0x40f9d6
jmp 0x40f9c9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x490a30
movq %rbx, %rdi
callq 0x4bea70
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/../argparse/argparse.hpp
// Function: ArgumentParser::verify(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
String verify(const String& name) {
        if (name.empty()) argumentError("argument names must be non-empty");
        if ((name.size() == 2 && name[0] != '-') || name.size() == 3)
            argumentError(String("invalid argument '")
                              .append(name)
                              .append("'. Short names must begin with '-'"));
        if (name.size() > 3 && (name[0] != '-' || name[1] != '-'))
            argumentError(String("invalid argument '")
                              .append(name)
                              .append("'. Multi-character names must begin with '--'"));
        return name;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdx), %rax
testq %rax, %rax
jne 0x40fa64
leaq 0x1828ff(%rip), %rsi    # 0x592337
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x40a3b4
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x40fd3c
leaq 0x10(%rsp), %rdi
callq 0x490a30
movq 0x8(%r14), %rax
cmpq $0x3, %rax
je 0x40fa7c
cmpq $0x2, %rax
jne 0x40fac9
movq (%r14), %rax
cmpb $0x2d, (%rax)
je 0x40fb26
leaq 0x1828d5(%rip), %rsi    # 0x592358
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x40a3b4
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x492140
leaq 0x1828c5(%rip), %rsi    # 0x59236b
movq %rax, %rdi
callq 0x4921e0
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x40fd3c
leaq 0x10(%rsp), %rdi
callq 0x490a30
movq 0x8(%r14), %rax
cmpq $0x4, %rax
jb 0x40fb26
movq (%r14), %rax
cmpb $0x2d, (%rax)
jne 0x40fadd
cmpb $0x2d, 0x1(%rax)
je 0x40fb26
leaq 0x182874(%rip), %rsi    # 0x592358
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x40a3b4
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x492140
leaq 0x182887(%rip), %rsi    # 0x59238e
movq %rax, %rdi
callq 0x4921e0
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x40fd3c
leaq 0x10(%rsp), %rdi
callq 0x490a30
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4931c0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x40fb44
jmp 0x40fb4b
jmp 0x40fb44
movq %rax, %rbx
jmp 0x40fb58
jmp 0x40fb4b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x490a30
movq %rbx, %rdi
callq 0x4bea70
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
callq 0x4931c0
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x4931c0
movb %r14b, 0x40(%rbx)
movl %ebp, %eax
andb $-0x2, %al
cmpb $0x2a, %al
jne 0x40fb98
movb %bpl, 0x48(%rbx)
xorl %eax, %eax
jmp 0x40fba2
movsbq %bpl, %rax
movq %rax, 0x48(%rbx)
movb $0x1, %al
movb %al, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x490a30
movq %r14, %rdi
callq 0x4bea70
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x88, %rdi
movq 0x90(%rbx), %rax
subq 0x88(%rbx), %rax
pushq $0x58
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
callq 0x40fe06
cmpb $0x1, 0x50(%r14)
jne 0x40fc53
cmpq $0x1, 0x48(%r14)
ja 0x40fc53
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x40fe32
leaq 0xa0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x410166
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x40fc47
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x490a30
jmp 0x40fc98
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x40fe72
leaq 0xa0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x410166
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x40fc8e
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x40a278
cmpq $0x0, 0x8(%r14)
je 0x40fcad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x410620
movq %r15, (%rax)
cmpq $0x0, 0x28(%r14)
je 0x40fcc3
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x410620
movq %r15, (%rax)
cmpb $0x0, 0x40(%r14)
jne 0x40fcce
incq 0x40(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x40fd05
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x40fd05
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x40fd14
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x40fd14
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x490a30
jmp 0x40fd1e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x40a278
movq %rbx, %rdi
callq 0x4bea70
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
cmpb $0x1, 0x39(%rdi)
jne 0x40fd7b
pushq $0x10
popq %rdi
callq 0x412f50
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x445460
movq $0x5ff1e8, %rsi         # imm = 0x5FF1E8
movq $0x41d3b0, %rdx         # imm = 0x41D3B0
movq %r15, %rdi
callq 0x413fa0
movl %edx, %ebp
movq %rdi, %rbx
movq $0x6097e0, %rdi         # imm = 0x6097E0
leaq 0x18262e(%rip), %rsi    # 0x5923bc
callq 0x480750
movq %rax, %rdi
movq %r14, %rsi
callq 0x493460
movq %rax, %rdi
callq 0x480030
testb %bpl, %bpl
je 0x40fddc
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x40f3ca
movq $0x6097e0, %rdi         # imm = 0x6097E0
movq %r14, %rsi
callq 0x493460
movq %rax, %rdi
callq 0x480030
leaq 0x8(%rsp), %rdi
callq 0x490a30
pushq $-0x5
popq %rdi
callq 0x4da4e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x490a30
jmp 0x40fdfe
movq %rax, %rbx
movq %r15, %rdi
callq 0x412fb0
movq %rbx, %rdi
callq 0x4bea70
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x8(%rsi), %rcx
testq %rcx, %rcx
je 0x410e29
movq (%rsi), %rdx
cmpb $0x2d, (%rdx)
sete %al
cmpq $0x4, %rcx
jb 0x410e2b
xorl %ecx, %ecx
cmpb $0x2d, 0x1(%rdx)
sete %cl
jmp 0x410e2d
xorl %eax, %eax
xorl %ecx, %ecx
movzbl %al, %edx
addq %rcx, %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rdi
callq 0x4933e0
movq %rbx, %rax
popq %rbx
retq
nop