LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/seqio.cc
// Function: FastqRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<SeqRecord, std::allocator<SeqRecord>>&)
void FastqRead(string fname, vector<SeqRecord>& recs)
{
	int N = CountReads(fname);
	RecordGenerator rec_gen(fname);
	for (int i=0; i<N; i++) {
		recs.push_back(rec_gen.next());
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x310, %rsp            # imm = 0x310
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3d94
movq %r15, %rdi
callq 0x72a7
movl %eax, %ebp
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x71bd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3d94
leaq 0xc0(%rsp), %rdi
movq %r14, %rsi
callq 0x6ac2
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7201
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
testl %ebp, %ebp
jle 0x7234
leaq 0x40(%rsp), %r14
leaq 0xc0(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x6bae
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7404
movq %r14, %rdi
callq 0x65d2
decl %ebp
jne 0x7212
leaq 0xc0(%rsp), %rdi
callq 0x6b64
addq $0x310, %rsp            # imm = 0x310
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x729f
movq 0x10(%rsp), %rsi
jmp 0x7276
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x729f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x729f
movq %rax, %rbx
jmp 0x7292
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x65d2
leaq 0xc0(%rsp), %rdi
callq 0x6b64
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/seqio.cc
// Function: CountReads(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int CountReads(string fname)
{
	int num_reads = 0;
	int indice_riga = 0;
	string line="";
	
	ifstream ifs(fname.c_str());
	
	//Skip rows until first "@" character
	while (ifs.good() && (!line.length() || line[0] != '@')) {
		getline(ifs, line);
	}
	
	while (ifs.good()) {
		indice_riga = (indice_riga+1) % 4;
		if (indice_riga % 4 == 0) num_reads++;	//Couno 1 read every 4 row
		getline(ifs, line);
	}
	
	return num_reads;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x17fa(%rip), %rdx      # 0x8ac6
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x3e24
movq (%rbx), %rsi
leaq 0x20(%rsp), %rdi
movl $0x8, %edx
callq 0x2360
leaq 0x20(%rsp), %rbx
movq %rsp, %r14
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x40(%rsp,%rax)
jne 0x7334
cmpq $0x0, 0x8(%rsp)
je 0x7312
movq (%rsp), %rcx
cmpb $0x40, (%rcx)
je 0x7334
leaq (%rsp,%rax), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x21e0
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2370
jmp 0x72f1
xorl %ebx, %ebx
leaq 0x20(%rsp), %r14
movq %rsp, %r15
xorl %r13d, %r13d
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x40(%rsp,%rax)
jne 0x7392
leaq (%rsp,%rax), %rdi
addq $0x20, %rdi
movl $0xa, %esi
callq 0x21e0
leal 0x1(%r13), %ebp
addl $0x4, %r13d
testl %ebp, %ebp
cmovnsl %ebp, %r13d
andl $-0x4, %r13d
xorl %ecx, %ecx
subl %r13d, %ebp
sete %cl
addl %ecx, %ebx
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2370
movl %ebp, %r13d
jmp 0x7341
leaq 0x20(%rsp), %rdi
callq 0x2090
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x73b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x73da
jmp 0x73cd
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2090
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x73f0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::read_data_operand(unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void baseAccelSim::read_data_operand(uint8_t op, string fileName) {
	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 >> tensor_operands[op][i];
	}
	inFile.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %rbx
movl %esi, %ebp
movq (%rdx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x460c10
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x408d38
movzbl %bpl, %r14d
movq 0x202898(%rip), %rax    # 0x60b570
cmpq $0x0, (%rax,%r14,8)
je 0x408d14
xorl %r15d, %r15d
leaq 0x8(%rsp), %rbx
xorl %r12d, %r12d
movq 0x20286f(%rip), %rax    # 0x60b560
movq (%rax,%r14,8), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x46a610
incq %r12
movq 0x202866(%rip), %rax    # 0x60b570
addq $0x2, %r15
cmpq %r12, (%rax,%r14,8)
ja 0x408cea
leaq 0x8(%rsp), %rdi
callq 0x4611c0
leaq 0x8(%rsp), %rdi
callq 0x461570
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq $0x60c900, %rdi         # imm = 0x60C900
leaq 0x18b2da(%rip), %rsi    # 0x594020
movl $0x1b, %edx
callq 0x484270
movq (%rbx), %rsi
movq $0x60c900, %rdi         # imm = 0x60C900
callq 0x4847a0
movq %rax, %rdi
callq 0x484080
movl $0x1, %edi
callq 0x4de3d0
jmp 0x408d73
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x461570
movq %rbx, %rdi
callq 0x4c2960
// File: /workspace/github_cpp_makefile_star2_O1/MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::write_data_operand(unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void baseAccelSim::write_data_operand(uint8_t op, string fileName)
{
	std::ofstream outFile;
  outFile.open (fileName.c_str(), std::ofstream::out | std::ofstream::trunc);

	for(uint64_t idx = 0; idx < size_tensors[op]; idx++)
    outFile << tensor_operands[op][idx] << "\n";

	outFile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %r14
movl %esi, %ebx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x45f880
movq (%r14), %rsi
movq %r15, %rdi
movl $0x30, %edx
callq 0x4601a0
movzbl %bl, %r15d
movq 0x202443(%rip), %rax    # 0x60b570
cmpq $0x0, (%rax,%r15,8)
je 0x40917b
xorl %r12d, %r12d
leaq 0x8(%rsp), %rbx
leaq 0x194c87(%rip), %r14    # 0x59ddca
movq 0x202416(%rip), %rax    # 0x60b560
movq (%rax,%r15,8), %rax
movzwl (%rax,%r12,2), %esi
movq %rbx, %rdi
callq 0x484b70
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x484270
incq %r12
movq 0x2023fb(%rip), %rax    # 0x60b570
cmpq (%rax,%r15,8), %r12
jb 0x409143
leaq 0x8(%rsp), %rdi
callq 0x461200
movq $0x604c08, %rax         # imm = 0x604C08
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x10(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x8(%rsp,%rcx)
callq 0x45f490
leaq 0x100(%rsp), %rdi
callq 0x4667e0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4091c8
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x461430
movq %rbx, %rdi
callq 0x4c2960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
cmpb $0x1, 0x2023d8(%rip)    # 0x60b980
jne 0x40963e
callq 0x4091de
movzbl 0x201f9c(%rip), %eax    # 0x60b556
movl %eax, %esi
subb 0x201f94(%rip), %sil    # 0x60b557
cmpb %al, %sil
jae 0x409620
movq 0x201fa1(%rip), %rcx    # 0x60b570
movq 0x201f92(%rip), %rdx    # 0x60b568
movzbl 0x201f7b(%rip), %edi    # 0x60b558
movq 0x201f7c(%rip), %r8     # 0x60b560
movzbl %sil, %esi
movq (%rcx,%rsi,8), %r9
testq %r9, %r9
je 0x409618
movl %esi, %r10d
subl %edi, %r10d
movslq %r10d, %r10
movq (%rdx,%r10,8), %r10
movq (%r8,%rsi,8), %r11
xorl %ebx, %ebx
movzwl (%r10,%rbx,2), %ebp
cmpw (%r11,%rbx,2), %bp
ja 0x409645
incq %rbx
cmpq %rbx, %r9
jne 0x409604
incq %rsi
cmpq %rax, %rsi
jne 0x4095e8
movq $0x60c900, %rdi         # imm = 0x60C900
leaq 0x18ba7c(%rip), %rsi    # 0x5950aa
movl $0x36, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x484270
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x18ba1d(%rip), %rdi    # 0x595069
xorl %eax, %eax
callq 0x4e96a0
movl $0x1, %edi
callq 0x4de3d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %r14
movq (%rsi), %rsi
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x460c10
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x50(%rsp,%rax)
jne 0x40c373
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %r14
leaq 0x28(%rsp), %r15
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4653c0
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x419ec0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x40c31a
movq (%rsp), %r12
callq 0x4c7aa0
movq %rax, %rbp
movl (%rax), %r13d
movl $0x0, (%rax)
movq %r12, %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x4de720
cmpq %r12, 0x28(%rsp)
je 0x40c35b
movl (%rbp), %ecx
testl %ecx, %ecx
je 0x40c2d8
cmpl $0x22, %ecx
jne 0x40c2dc
jmp 0x40c367
movl %r13d, (%rbp)
movq %rax, 0x20(%rsp)
movq 0x1ff348(%rip), %rsi    # 0x60b630
cmpq 0x1ff349(%rip), %rsi    # 0x60b638
je 0x40c304
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x1ff331(%rip)    # 0x60b630
jmp 0x40c261
leaq 0x1ff31d(%rip), %rdi    # 0x60b628
leaq 0x20(%rsp), %rdx
callq 0x40ee3c
jmp 0x40c261
leaq 0x30(%rsp), %rdi
callq 0x4611c0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x40c33f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x416ca0
leaq 0x30(%rsp), %rdi
callq 0x461570
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18966f(%rip), %rdi    # 0x5959d1
callq 0x402b8d
leaq 0x189663(%rip), %rdi    # 0x5959d1
callq 0x402c3d
movq $0x60c900, %rdi         # imm = 0x60C900
leaq 0x187c9f(%rip), %rsi    # 0x594020
movl $0x1b, %edx
callq 0x484270
movq (%r14), %rsi
movq $0x60c900, %rdi         # imm = 0x60C900
callq 0x4847a0
movq %rax, %rdi
callq 0x484080
movl $0x1, %edi
callq 0x4de3d0
movq %rax, %rbx
jmp 0x40c3e2
jmp 0x40c3c4
jmp 0x40c3c4
movq %rax, %rbx
cmpl $0x0, (%rbp)
jne 0x40c3c7
movl %r13d, (%rbp)
jmp 0x40c3c7
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x40c3e2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x416ca0
leaq 0x30(%rsp), %rdi
callq 0x461570
movq %rbx, %rdi
callq 0x4c2960
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x1f39ec(%rip), %rax    # 0x6018a8
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
callq 0x411c94
movq %rbx, %rdi
callq 0x404c70
movq %rbx, %rdi
callq 0x408922
callq 0x40cff6
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x40ef78
movq 0x1fd66e(%rip), %rsi    # 0x60b560
movq %rbx, %rdi
callq 0x40fc0a
movq 0x1fd717(%rip), %rsi    # 0x60b618
leaq 0x187aa1(%rip), %rdi    # 0x5959a9
xorl %eax, %eax
callq 0x4e96a0
leaq 0x8(%rsp), %rdi
callq 0x408d88
callq 0x40959e
callq 0x40d404
leaq 0x10(%rsp), %rdi
callq 0x40f7ce
xorl %eax, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x40f7ce
movq %rbx, %rdi
callq 0x4c2960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f2955(%rip), %rax    # 0x6018d8
movq %rax, (%rdi)
movw $0x0, 0xa0(%rdi)
xorl %eax, %eax
movb %al, 0xb8(%rdi)
movb $0x1, 0xc8(%rdi)
movl %eax, 0xc9(%rdi)
movb %al, 0xcd(%rdi)
movw $0x101, 0xce(%rdi)      # imm = 0x101
movl %eax, 0xd0(%rdi)
movl %eax, 0xf8(%rdi)
callq 0x40efde
movq %rbx, %rdi
callq 0x40f2de
movq %rbx, %rdi
callq 0x40f724
movq %rbx, %rdi
popq %rbx
jmp 0x40f78a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x60b5ac, %r14         # imm = 0x60B5AC
cmpw $0x0, (%r14)
je 0x40fbe5
movq %rdi, %rbx
xorl %r15d, %r15d
movq $0x60b5ae, %r12         # imm = 0x60B5AE
cmpw $0x0, (%r12)
je 0x40fbd9
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r13, %rdi
callq 0x416916
incq %rbp
movzwl (%r12), %eax
addq $0x148, %r13            # imm = 0x148
cmpq %rax, %rbp
jb 0x40fbb5
incq %r15
movzwl (%r14), %eax
cmpq %rax, %r15
jb 0x40fba8
movq $0x60b73a, %rax         # imm = 0x60B73A
xorl %ecx, %ecx
movw %cx, (%rax)
movq $0x60b738, %rax         # imm = 0x60B738
movw %cx, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40fb82
cmpb $0x0, 0xa0(%rbx)
jne 0x40fd22
movq $0x60b5e4, %r13         # imm = 0x60B5E4
movq $0x609151, %r12         # imm = 0x609151
movq $0x60b5ae, %rbp         # imm = 0x60B5AE
movq %rbx, %rdi
callq 0x40fd32
cmpb $0x0, (%r13)
je 0x40fc74
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x88(%rbx), %rdi
addq %r14, %rdi
callq 0x411b7a
incq %r15
movzbl (%r13), %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x40fc54
movq $0x60b5ac, %rax         # imm = 0x60B5AC
cmpw $0x0, (%rax)
je 0x40fcc6
xorl %r13d, %r13d
cmpw $0x0, (%rbp)
je 0x40fcb4
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r13,8), %rdi
addq %r14, %rdi
callq 0x415fee
incq %r15
movzwl (%rbp), %eax
addq $0x148, %r14            # imm = 0x148
cmpq %rax, %r15
jb 0x40fc91
incq %r13
movq $0x60b5ac, %rax         # imm = 0x60B5AC
movzwl (%rax), %eax
cmpq %rax, %r13
jb 0x40fc84
cmpb $0x0, (%r12)
je 0x40fcf0
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x50(%rbx), %rdi
addq %r14, %rdi
callq 0x41150c
incq %r15
movzbl (%r12), %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0x40fcd3
movq 0xa8(%rbx), %rdi
callq 0x411132
movq %rbx, %rdi
callq 0x40fdb0
movq $0x60b618, %rax         # imm = 0x60B618
incq (%rax)
cmpb $0x0, 0xa0(%rbx)
movq $0x60b5e4, %r13         # imm = 0x60B5E4
je 0x40fc3f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movb $0x0, 0xb8(%rdi)
movq 0xc0(%rdi), %rax
movzbl 0xc9(%rdi), %ecx
xorl %edx, %edx
cmpb $0x0, (%rax)
cmovel %ecx, %edx
movb %dl, 0xc9(%rdi)
movq $0x60b5e4, %r14         # imm = 0x60B5E4
cmpb $0x0, (%r14)
je 0x40fda4
movq %rdi, %rbx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x118(%rbx), %rdx
addq %r15, %rdx
movzbl %r12b, %esi
movq %rbx, %rdi
callq 0x41069e
movq 0x110(%rbx), %rcx
movb %al, (%rcx,%r12)
incq %r12
movzbl (%r14), %eax
addq $0x2, %r15
cmpq %rax, %r12
jb 0x40fd73
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq $0x60b620, %rax         # imm = 0x60B620
movl (%rax), %eax
cmpq $0x3, %rax
ja 0x40fe85
movq %rdi, %rbx
leaq 0x185d26(%rip), %rcx    # 0x595afc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x4103fa
movq %rbx, %rdi
callq 0x40feac
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x410588
movq $0x60b5ac, %rax         # imm = 0x60B5AC
movzwl (%rax), %r15d
testq %r15, %r15
je 0x40fe46
movq $0x60b5ae, %rax         # imm = 0x60B5AE
movzwl (%rax), %r14d
movq 0x10(%rbx), %r12
xorl %r13d, %r13d
testq %r14, %r14
je 0x40fe3e
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x401088
incq %r13
cmpq %r13, %r15
jne 0x40fe2b
movq $0x609151, %rax         # imm = 0x609151
cmpb $0x0, (%rax)
je 0x40fe7e
movq 0x58(%rbx), %rcx
movq 0x60(%rbx), %rdx
movq 0x68(%rbx), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movb %dil, (%rcx,%r8)
movb %dil, (%rdx,%r8)
movw $0x0, (%rsi,%r8,2)
incq %r8
movzbl (%rax), %r9d
cmpq %r9, %r8
jb 0x40fe63
movb $0x1, 0xa0(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x410490
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x609153, %rax         # imm = 0x609153
cmpb $0x0, (%rax)
je 0x410421
movq 0x80(%rdi), %rcx
xorl %edx, %edx
movw $0x0, (%rcx,%rdx,2)
incq %rdx
movzbl (%rax), %esi
cmpq %rsi, %rdx
jb 0x410410
movq $0x60b620, %rax         # imm = 0x60B620
movl $0x1, (%rax)
movq $0x60b556, %rax         # imm = 0x60B556
cmpb $0x0, (%rax)
je 0x410485
xorl %ecx, %ecx
movq $0x60b718, %rdx         # imm = 0x60B718
movb $0x1, %sil
movq $0x60b720, %r8          # imm = 0x60B720
movq $0x60b728, %r9          # imm = 0x60B728
movq $0x60b730, %r10         # imm = 0x60B730
xorl %r11d, %r11d
movq (%rdx), %rbx
movb %sil, (%rbx,%r11)
movq (%r8), %rbx
movb %sil, (%rbx,%r11)
movq (%r9), %rbx
movb %cl, (%rbx,%r11)
movq (%r10), %rbx
movb %cl, (%rbx,%r11)
incq %r11
movzbl (%rax), %ebx
cmpq %rbx, %r11
jb 0x41045e
movw $0x101, 0xce(%rdi)      # imm = 0x101
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x609153, %rax         # imm = 0x609153
cmpb $0x0, (%rax)
je 0x410583
xorl %ecx, %ecx
movq $0x60b5ac, %rdx         # imm = 0x60B5AC
movq $0x60b600, %rsi         # imm = 0x60B600
movq $0x60b610, %r8          # imm = 0x60B610
movq $0x60b620, %r9          # imm = 0x60B620
movq 0x58(%rdi), %r10
movb $0x1, (%r10,%rcx)
movq 0x60(%rdi), %r10
movq 0x80(%rdi), %r11
movzwl (%r11,%rcx,2), %r11d
movl %r11d, %ebx
andl $0x3, %ebx
movzwl (%rdx), %ebp
shll $0x2, %ebp
cmpl %r11d, %ebp
setbe (%r10,%rcx)
movq (%rsi), %r10
movq (%r10,%rcx,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,%rcx)
movq (%rsi), %r10
movq (%r10,%rcx,8), %r10
movq (%r10,%r11), %r10
movb 0x1(%r10,%rbx), %r10b
movq 0x78(%rdi), %r14
movb %r10b, (%r14,%rcx)
movq (%rsi), %r10
movq (%r10,%rcx,8), %r10
movq (%r10,%r11), %r10
movzwl 0x2(%r10,%rbx), %r10d
movq 0x68(%rdi), %r11
movw %r10w, (%r11,%rcx,2)
movq 0x80(%rdi), %r10
movzwl (%r10,%rcx,2), %r11d
incl %r11d
movw %r11w, (%r10,%rcx,2)
movzwl %r11w, %r11d
movl (%r8), %ebx
shll $0x2, %ebx
cmpl %r11d, %ebx
jne 0x410573
movw $0x0, (%r10,%rcx,2)
movl $0x2, (%r9)
incq %rcx
movzbl (%rax), %r10d
cmpq %r10, %rcx
jb 0x4104c2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x60b73a, %rax         # imm = 0x60B73A
movzwl (%rax), %eax
testw %ax, %ax
jne 0x4105cb
movq $0x609151, %rcx         # imm = 0x609151
cmpb $0x0, (%rcx)
je 0x4105cb
movq 0x58(%rbx), %rdx
movq 0x60(%rbx), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
movb %dil, (%rdx,%r8)
movb %dil, (%rsi,%r8)
incq %r8
movzbl (%rcx), %r9d
cmpq %r9, %r8
jb 0x4105b7
movq $0x60b554, %rcx         # imm = 0x60B554
decl %eax
cmpw (%rcx), %ax
jae 0x410696
movq %rbx, %rdi
callq 0x4106f8
movq $0x60b738, %r14         # imm = 0x60B738
movzwl (%r14), %eax
movq $0x60b552, %rcx         # imm = 0x60B552
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 0x410630
cmpb $0x1, 0xcf(%rbx)
jne 0x410687
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x410a5e
cmpw $0x1, %ax
ja 0x41064e
cmpb $0x1, 0xce(%rbx)
jne 0x410687
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x410cba
cmpw %cx, %ax
jae 0x410696
cmpb $0x1, 0xce(%rbx)
jne 0x410664
movq %rbx, %rdi
callq 0x410cba
cmpb $0x1, 0xcf(%rbx)
jne 0x410679
movzwl (%r14), %esi
movq %rbx, %rdi
callq 0x410a5e
movb 0xcf(%rbx), %al
orb 0xce(%rbx), %al
jne 0x410696
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x410c6c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x60b5ac, %rax         # imm = 0x60B5AC
movzwl (%rax), %ecx
testq %rcx, %rcx
je 0x4106ec
movq 0x90(%rdi), %rax
movq 0x98(%rdi), %rdi
movzbl %sil, %esi
shll $0x3, %esi
movq (%rdi,%rsi), %rdi
movq (%rax,%rsi), %r8
xorl %r9d, %r9d
xorl %esi, %esi
xorl %eax, %eax
movq (%rdi,%r9,8), %r10
andb $0x1, %al
orb (%r10), %al
movq (%r8,%r9,8), %r10
orw (%r10), %si
incq %r9
cmpq %r9, %rcx
jne 0x4106d1
jmp 0x4106f0
xorl %eax, %eax
xorl %esi, %esi
testb %al, %al
je 0x4106f7
movw %si, (%rdx)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x60b738, %rax         # imm = 0x60B738
incw (%rax)
movw $0x101, 0xce(%rdi)      # imm = 0x101
xorl %eax, %eax
movl %eax, 0xd0(%rdi)
movl %eax, 0xf8(%rdi)
movq $0x609151, %rax         # imm = 0x609151
cmpb $0x0, (%rax)
je 0x410cb9
movq 0x58(%rdi), %rcx
movq 0x60(%rdi), %rdx
xorl %esi, %esi
xorl %edi, %edi
movb %sil, (%rcx,%rdi)
movb %sil, (%rdx,%rdi)
incq %rdi
movzbl (%rax), %r8d
cmpq %r8, %rdi
jb 0x410ca5
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x60b5e8, %rax         # imm = 0x60B5E8
movq (%rax), %r9
movl %esi, %eax
cmpw %cx, (%r9,%rax,2)
jbe 0x410f5f
movq 0x58(%rdi), %rsi
movzbl %dl, %edx
movb $0x0, (%rsi,%rdx)
movq 0x60(%rdi), %rsi
movb $0x1, (%rsi,%rdx)
movq $0x60b5f8, %rsi         # imm = 0x60B5F8
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 0x184d82(%rip), %rdi    # 0x595ce9
leaq 0x184bfc(%rip), %rsi    # 0x595b6a
leaq 0x184d99(%rip), %rcx    # 0x595d0e
movl $0x25e, %edx            # imm = 0x25E
callq 0x4d75c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x410fc2
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
jne 0x410fe1
cmpb $0x0, 0x12(%rbx)
jne 0x411000
movl %ecx, %ebp
movl %ecx, %eax
movq %rdx, %rdi
movq %rax, %rdx
callq 0x401070
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4110fa
movl %eax, 0x1c(%rbx)
movb $0x1, 0x11(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x184e88(%rip), %rdi    # 0x595e51
leaq 0x184eda(%rip), %rsi    # 0x595eaa
leaq 0x184ee4(%rip), %rcx    # 0x595ebb
movl $0x14, %edx
callq 0x4d75c0
leaq 0x184f18(%rip), %rdi    # 0x595f00
leaq 0x184ebb(%rip), %rsi    # 0x595eaa
leaq 0x184ec5(%rip), %rcx    # 0x595ebb
movl $0x15, %edx
callq 0x4d75c0
leaq 0x184f50(%rip), %rdi    # 0x595f57
leaq 0x184e9c(%rip), %rsi    # 0x595eaa
leaq 0x184ea6(%rip), %rcx    # 0x595ebb
movl $0x16, %edx
callq 0x4d75c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x411062
movq %rdi, %rbx
cmpb $0x0, 0x11(%rdi)
jne 0x411081
cmpb $0x0, 0x12(%rbx)
jne 0x4110a0
movl %ecx, %ebp
movl %ecx, %eax
movq %rdx, %rdi
movq %rax, %rdx
callq 0x401070
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4110fa
movl %eax, 0x20(%rbx)
movb $0x1, 0x12(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x184de8(%rip), %rdi    # 0x595e51
leaq 0x184e3a(%rip), %rsi    # 0x595eaa
leaq 0x184f3a(%rip), %rcx    # 0x595fb1
movl $0x23, %edx
callq 0x4d75c0
leaq 0x184f70(%rip), %rdi    # 0x595ff8
leaq 0x184e1b(%rip), %rsi    # 0x595eaa
leaq 0x184f1b(%rip), %rcx    # 0x595fb1
movl $0x24, %edx
callq 0x4d75c0
leaq 0x184eb0(%rip), %rdi    # 0x595f57
leaq 0x184dfc(%rip), %rsi    # 0x595eaa
leaq 0x184efc(%rip), %rcx    # 0x595fb1
movl $0x25, %edx
callq 0x4d75c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, (%rsp)
movq $0x60b5ac, %rax         # imm = 0x60B5AC
movzwl (%rax), %r15d
movl %r15d, %edi
shll $0x6, %edi
orq $0x8, %rdi
callq 0x4181e0
leaq 0x8(%rax), %rcx
movq %r15, (%rax)
testl %r15d, %r15d
je 0x4111fb
addq $0x20, %rax
movl %r15d, %edx
shll $0x6, %edx
xorl %esi, %esi
xorl %edi, %edi
movl %esi, (%rax,%rdi)
movw $0x0, 0x24(%rax,%rdi)
movl %esi, 0x1f(%rax,%rdi)
movq $0x0, 0x18(%rax,%rdi)
addq $0x40, %rdi
cmpq %rdi, %rdx
jne 0x4111db
movq (%rsp), %rbx
movq %rcx, (%rbx)
leal (,%r15,8), %edi
callq 0x4181e0
movq %rax, 0x8(%rbx)
testq %r15, %r15
je 0x411280
movq $0x60b5ae, %rax         # imm = 0x60B5AE
movzwl (%rax), %r12d
movl %r12d, %r13d
shll $0x6, %r13d
leaq 0x8(%r13), %r14
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x4181e0
movq %r12, (%rax)
testq %r12, %r12
je 0x411268
leaq 0x20(%rax), %rcx
xorl %edx, %edx
movl %ebp, (%rcx,%rdx)
movw $0x0, 0x24(%rcx,%rdx)
movl %ebp, 0x1f(%rcx,%rdx)
movq $0x0, 0x18(%rcx,%rdx)
addq $0x40, %rdx
cmpq %rdx, %r13
jne 0x411248
addq $0x8, %rax
movq (%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, (%rcx,%rbx,8)
incq %rbx
cmpq %r15, %rbx
jne 0x411232
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x60b5ac, %r14         # imm = 0x60B5AC
cmpw $0x0, (%r14)
je 0x4112d7
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x4112cb
movq -0x8(%rdi), %rsi
addq $-0x8, %rdi
shlq $0x6, %rsi
orq $0x8, %rsi
callq 0x416cc0
incq %r15
movzwl (%r14), %eax
cmpq %rax, %r15
jb 0x4112a9
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4112e5
callq 0x416cb0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x411307
movq -0x8(%rdi), %rsi
addq $-0x8, %rdi
shlq $0x6, %rsi
orq $0x8, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x416cc0
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x60b5ac, %r14         # imm = 0x60B5AC
cmpw $0x0, (%r14)
je 0x41156c
xorl %r15d, %r15d
movq $0x60b5ae, %r12         # imm = 0x60B5AE
cmpw $0x0, (%r12)
je 0x411560
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r13, %rdi
callq 0x4115a4
incq %rbp
movzwl (%r12), %eax
addq $0x40, %r13
cmpq %rax, %rbp
jb 0x41153f
incq %r15
movzwl (%r14), %eax
cmpq %rax, %r15
jb 0x411532
cmpw $0x0, (%r14)
je 0x411594
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rdi
addq %r15, %rdi
callq 0x4115a4
incq %r12
movzwl (%r14), %eax
addq $0x40, %r15
cmpq %rax, %r12
jb 0x411579
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/MPSLab-ASU[P]DiRAC/./src/network.cc
// Function: MultiCastNetwork_Output::MultiCastNetwork_Output()
MultiCastNetwork_Output::MultiCastNetwork_Output()
{
  rowWiseMC = new MultiCastController_OutputNetwork[nRows_PE_Array];
  colWiseMC = new MultiCastController_OutputNetwork*[nRows_PE_Array];
  for(uint16_t i=0; i < nRows_PE_Array; i++) {
    colWiseMC[i] = new MultiCastController_OutputNetwork[nCols_PE_Array];
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x60b5ac, %rax         # imm = 0x60B5AC
movzwl (%rax), %r15d
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rdi
callq 0x4181e0
leaq 0x8(%rax), %rcx
movq %r15, (%rax)
testq %r15, %r15
je 0x41179c
leal (,%r15,8), %edx
leaq (%rdx,%rdx,2), %rdx
xorl %esi, %esi
movb $0x0, 0x1c(%rax,%rsi)
addq $0x18, %rsi
cmpq %rsi, %rdx
jne 0x41178e
movq %rcx, (%rbx)
leal (,%r15,8), %edi
callq 0x4181e0
movq %rax, 0x8(%rbx)
testq %r15, %r15
je 0x41180a
movq $0x60b5ae, %rax         # imm = 0x60B5AE
movzwl (%rax), %r12d
leal (,%r12,8), %eax
leaq (%rax,%rax,2), %r13
leaq (%rax,%rax,2), %r14
addq $0x8, %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x4181e0
movq %r12, (%rax)
testq %r12, %r12
je 0x4117f6
xorl %ecx, %ecx
movb $0x0, 0x1c(%rax,%rcx)
addq $0x18, %rcx
cmpq %rcx, %r13
jne 0x4117e8
addq $0x8, %rax
movq 0x8(%rbx), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
cmpq %r15, %rbp
jne 0x4117d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x60b5ac, %rax         # imm = 0x60B5AC
cmpw $0x0, (%rax)
je 0x41189e
xorl %r12d, %r12d
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %r14
testq %r14, %r14
je 0x41188c
movq -0x8(%r14), %r13
testq %r13, %r13
je 0x41186d
leaq -0x18(%r14), %rbp
leaq (,%r13,8), %rax
leaq (%rax,%rax,2), %r15
leaq (%r15,%rbp), %rdi
callq 0x411c72
addq $-0x18, %r15
jne 0x41185e
addq $-0x8, %r14
leaq (,%r13,2), %rax
addq %r13, %rax
leaq 0x8(,%rax,8), %rsi
movq %r14, %rdi
callq 0x416cc0
incq %r12
movq $0x60b5ac, %rax         # imm = 0x60B5AC
movzwl (%rax), %eax
cmpq %rax, %r12
jb 0x411838
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x4118ac
callq 0x416cb0
movq (%rbx), %r14
testq %r14, %r14
je 0x411902
leaq -0x8(%r14), %rbx
movq -0x8(%r14), %r15
testq %r15, %r15
je 0x4118e0
addq $-0x18, %r14
leaq (,%r15,8), %rax
leaq (%rax,%rax,2), %r12
leaq (%r14,%r12), %rdi
callq 0x411c72
addq $-0x18, %r12
jne 0x4118d1
leaq (%r15,%r15,2), %rax
leaq 0x8(,%rax,8), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x416cc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq $0x60b5ac, %r14         # imm = 0x60B5AC
cmpw $0x0, (%r14)
je 0x411bbb
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rdi
addq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x411c1a
incq %r12
movzwl (%r14), %eax
addq $0x18, %r15
cmpq %rax, %r12
jb 0x411b9c
cmpw $0x0, (%r14)
je 0x411c0a
xorl %r15d, %r15d
movq $0x60b5ae, %r12         # imm = 0x60B5AE
cmpw $0x0, (%r12)
je 0x411bfe
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
addq %r13, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x411c1a
incq %rbp
movzwl (%r12), %eax
addq $0x18, %r13
cmpq %rax, %rbp
jb 0x411bd9
incq %r15
movzwl (%r14), %eax
cmpq %rax, %r15
jb 0x411bcc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x60b5ae, %rax         # imm = 0x60B5AE
movzwl (%rax), %ecx
cmpb $0x0, 0x14(%rdi)
movl $0x1, %eax
cmovnel %ecx, %eax
testl %eax, %eax
je 0x411c60
movq (%rdi), %rdx
movq 0x8(%rdi), %rsi
movl %eax, %r8d
xorl %r9d, %r9d
xorl %ecx, %ecx
xorl %eax, %eax
movq (%rsi,%r9,8), %r10
orw (%r10), %cx
movq (%rdx,%r9,8), %r10
andb $0x1, %al
orb (%r10), %al
incq %r9
cmpq %r9, %r8
jne 0x411c45
jmp 0x411c64
xorl %eax, %eax
xorl %ecx, %ecx
movw %cx, 0x12(%rdi)
movb %al, 0x10(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x40e204
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x40e204
movb %r14b, 0x40(%rbx)
movl %ebp, %eax
andb $-0x2, %al
cmpb $0x2a, %al
jne 0x4133be
movb %bpl, 0x48(%rbx)
xorl %eax, %eax
jmp 0x4133c8
movsbq %bpl, %rax
movq %rax, 0x48(%rbx)
movb $0x1, %al
movb %al, 0x50(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4133eb
movq (%r12), %rsi
incq %rsi
callq 0x416ca0
movq %r14, %rdi
callq 0x4c2960
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x88, %rdi
movq 0x90(%rbx), %r15
subq 0x88(%rbx), %r15
callq 0x413700
cmpb $0x1, 0x50(%r14)
jne 0x41348e
cmpq $0x1, 0x48(%r14)
ja 0x41348e
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x41372a
leaq 0xa0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x413b4a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x413475
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x4134d6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x416ca0
jmp 0x4134d6
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x8(%rsp), %rdi
callq 0x413788
leaq 0xa0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x413b4a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4134cc
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x40df4e
sarq $0x3, %r15
movabsq $0x2e8ba2e8ba2e8ba3, %r12 # imm = 0x2E8BA2E8BA2E8BA3
imulq %r15, %r12
cmpq $0x0, 0x8(%r14)
je 0x4134fd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x414084
movq %r12, (%rax)
cmpq $0x0, 0x28(%r14)
je 0x413513
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x414084
movq %r12, (%rax)
cmpb $0x0, 0x40(%r14)
jne 0x41351e
incq 0x40(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x413557
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x413557
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x413573
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x413573
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x41357d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x416ca0
jmp 0x41357d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x40df4e
movq %rbx, %rdi
callq 0x4c2960
nop