LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: estwings57[P]CasHMC/sources/DRAM.cpp
// Function: CasHMC::DRAM::Update()
void DRAM::Update()
{
	//update bank states
	for(int b=0; b<NUM_BANKS; b++) {
		if(bankStates[b]->stateChangeCountdown>0) {
			//decrement counters
			bankStates[b]->stateChangeCountdown--;

			//if counter has reached 0, change state
			if(bankStates[b]->stateChangeCountdown == 0) {
				switch(bankStates[b]->lastCommand) {
					//only these commands have an implicit state change
					case WRITE_P:
					case READ_P:
						bankStates[b]->currentBankState = PRECHARGING;
						bankStates[b]->lastCommand = PRECHARGE;
						bankStates[b]->stateChangeCountdown = tRP;
						break;
					case REFRESH:
					case PRECHARGE:
					case POWERDOWN_EXIT:
						bankStates[b]->currentBankState = IDLE;
						break;
					default:
						break;
				}
			}
		}
	}
	
	UpdateState();
	Step();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x3756b(%rip), %rcx     # 0x66620
cmpl (%rcx), %eax
jge 0x2f204
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq (%rax), %rax
cmpl $0x0, 0x3c(%rax)
jbe 0x2f1f4
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movl 0x3c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3c(%rax)
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq (%rax), %rax
cmpl $0x0, 0x3c(%rax)
jne 0x2f1f2
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq (%rax), %rax
movl 0x38(%rax), %eax
movl %eax, -0x1c(%rbp)
subl $0x2, %eax
je 0x2f167
jmp 0x2f143
movl -0x1c(%rbp), %eax
subl $0x4, %eax
je 0x2f167
jmp 0x2f14d
movl -0x1c(%rbp), %eax
addl $-0x7, %eax
subl $0x2, %eax
jb 0x2f1ce
jmp 0x2f15a
movl -0x1c(%rbp), %eax
subl $0xa, %eax
je 0x2f1ce
jmp 0x2f1ee
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movl $0x2, 0x4(%rax)
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq -0x18(%rbp), %rdi
movq (%rax), %rax
movl $0x7, 0x38(%rax)
leaq 0x374b6(%rip), %rax     # 0x66664
movl (%rax), %eax
movl %eax, -0x20(%rbp)
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movl -0x20(%rbp), %ecx
movq (%rax), %rax
movl %ecx, 0x3c(%rax)
jmp 0x2f1f0
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq (%rax), %rax
movl $0x0, 0x4(%rax)
jmp 0x2f1f0
jmp 0x2f1f0
jmp 0x2f1f2
jmp 0x2f1f4
jmp 0x2f1f6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f0ab
movq -0x18(%rbp), %rdi
callq 0x2f220
movq -0x18(%rbp), %rdi
callq 0x22dc0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/DRAM.cpp
// Function: CasHMC::DRAM::UpdateState()
void DRAM::UpdateState()
{
	if(readData != NULL) {
		dataCyclesLeft--;
		if(dataCyclesLeft == 0) {
			vaultContP->ReturnCommand(readData);
			readData = NULL;
		}
	}

	//Send back return command to vault controller
	if(readReturnCountdown.size() > 0 && readReturnCountdown[0] == 0) {
		readData = readReturnDATA[0];
		dataCyclesLeft = BL;
		readReturnDATA.erase(readReturnDATA.begin());
		readReturnCountdown.erase(readReturnCountdown.begin());
	}
	
	for(int i=0; i<readReturnCountdown.size(); i++) {
		readReturnCountdown[i]--;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, 0x208(%rax)
je 0x2f282
movq -0x48(%rbp), %rax
movl 0x210(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x210(%rax)
cmpl $0x0, 0x210(%rax)
jne 0x2f280
movq -0x48(%rbp), %rax
movq 0x1d0(%rax), %rdi
movq 0x208(%rax), %rsi
callq 0x4c5d0
movq -0x48(%rbp), %rax
movq $0x0, 0x208(%rax)
jmp 0x2f282
movq -0x48(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0x17eb0
cmpq $0x0, %rax
jbe 0x2f367
movq -0x48(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
xorl %eax, %eax
movl %eax, %esi
callq 0x17e90
cmpl $0x0, (%rax)
jne 0x2f367
movq -0x48(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
xorl %eax, %eax
movl %eax, %esi
callq 0x22ae0
movq -0x48(%rbp), %rdi
movq (%rax), %rax
movq %rax, 0x208(%rdi)
leaq 0x3734a(%rip), %rax     # 0x6662c
movl (%rax), %eax
shrl $0x5, %eax
movl %eax, 0x210(%rdi)
movq %rdi, %rax
addq $0x218, %rax            # imm = 0x218
movq %rax, -0x58(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x22bc0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x22bf0
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22b50
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdi, %rax
addq $0x230, %rax            # imm = 0x230
movq %rax, -0x50(%rbp)
addq $0x230, %rdi            # imm = 0x230
callq 0x19bc0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x22aa0
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x22a30
movq %rax, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq -0x48(%rbp), %rdi
movslq -0x3c(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x230, %rdi            # imm = 0x230
callq 0x17eb0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f3b8
movq -0x48(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
movslq -0x3c(%rbp), %rsi
callq 0x17e90
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x2f36e
addq $0x60, %rsp
popq %rbp
retq
nop
// File: estwings57[P]CasHMC/sources/DRAMCommand.cpp
// Function: CasHMC::DRAMCommand::DRAMCommand(CasHMC::DRAMCommand const&)
DRAMCommand::DRAMCommand(const DRAMCommand &dc)
{
	trace = dc.trace;
	commandType = dc.commandType;
	packetTAG = dc.packetTAG;
	bank = dc.bank;
	column = dc.column;
	row = dc.row;
	dataSize = dc.dataSize;
	posted = dc.posted;
	lastCMD = dc.lastCMD;
	packetCMD = dc.packetCMD;
	atomic = dc.atomic;
	segment = dc.segment;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
leaq 0x34c49(%rip), %rcx     # 0x65ac0
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x14(%rcx), %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x24(%rax)
movq -0x10(%rbp), %rcx
movb 0x28(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x28(%rax)
movq -0x10(%rbp), %rcx
movb 0x29(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x29(%rax)
movq -0x10(%rbp), %rcx
movl 0x2c(%rcx), %ecx
movl %ecx, 0x2c(%rax)
movq -0x10(%rbp), %rcx
movb 0x30(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x30(%rax)
movq -0x10(%rbp), %rcx
movb 0x31(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x31(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: estwings57[P]CasHMC/sources/HMC.cpp
// Function: CasHMC::HMC::~HMC()
HMC::~HMC()
{
	for(int l=0; l<NUM_LINKS; l++) {
		delete downLinkSlaves[l];
		delete upLinkMasters[l];
	}
	downLinkSlaves.clear();
	upLinkMasters.clear();

	delete crossbarSwitch;
	crossbarSwitch = NULL;

	for(int v=0; v<NUM_VAULTS; v++) {
		delete vaultControllers[v];
		delete drams[v];
	}
	vaultControllers.clear();
	drams.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x33a95(%rip), %rcx     # 0x65af0
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x344d5(%rip), %rcx     # 0x66548
cmpl (%rcx), %eax
jge 0x320da
movq -0x18(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x17790
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x320a2
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movslq -0xc(%rbp), %rsi
callq 0x17770
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x320cd
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x320cf
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x32069
movq -0x18(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x32b20
movq -0x18(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x29900
movq -0x18(%rbp), %rax
movq 0x200(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x32119
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x200(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0x344e3(%rip), %rcx     # 0x6661c
cmpl (%rcx), %eax
jge 0x321a0
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movslq -0x10(%rbp), %rsi
callq 0x329c0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x32168
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
movslq -0x10(%rbp), %rsi
callq 0x329e0
movq (%rax), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0x32193
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x32195
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3212f
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x32b40
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x32b60
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x32a00
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x32a60
movq -0x18(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x29800
movq -0x18(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x32ac0
movq -0x18(%rbp), %rdi
callq 0x22e30
addq $0x40, %rsp
popq %rbp
retq
nop
// File: estwings57[P]CasHMC/sources/HMC.cpp
// Function: CasHMC::HMC::Update()
void HMC::Update()
{	
	for(int l=0; l<NUM_LINKS; l++) {
		downLinkSlaves[l]->Update();
	}
	crossbarSwitch->Update();
	for(int v=0; v<NUM_VAULTS; v++) {
		vaultControllers[v]->Update();
	}
	for(int v=0; v<NUM_VAULTS; v++) {
		drams[v]->Update();
	}
	for(int l=0; l<NUM_LINKS; l++) {
		upLinkMasters[l]->Update();
	}
	clockTuner++;
	Step();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x342e3(%rip), %rcx     # 0x66548
cmpl (%rcx), %eax
jge 0x32291
movq -0x20(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x17790
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3225b
movq -0x20(%rbp), %rax
movq 0x200(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0x34369(%rip), %rcx     # 0x6661c
cmpl (%rcx), %eax
jge 0x322df
movq -0x20(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movslq -0x10(%rbp), %rsi
callq 0x329c0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x322a9
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x3432c(%rip), %rcx     # 0x6661c
cmpl (%rcx), %eax
jge 0x3231c
movq -0x20(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
movslq -0x14(%rbp), %rsi
callq 0x329e0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x322e6
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0x3421b(%rip), %rcx     # 0x66548
cmpl (%rcx), %eax
jge 0x32359
movq -0x20(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movslq -0x18(%rbp), %rsi
callq 0x17770
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x32323
movq -0x20(%rbp), %rdi
movq 0x1c8(%rdi), %rax
addq $0x1, %rax
movq %rax, 0x1c8(%rdi)
callq 0x22dc0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/HMC.cpp
// Function: CasHMC::HMC::PrintState()
void HMC::PrintState()
{
	for(int l=0; l<NUM_LINKS; l++) {
		downLinkSlaves[l]->PrintState();
	}
	crossbarSwitch->PrintState();
	for(int v=0; v<NUM_VAULTS; v++) {
		vaultControllers[v]->PrintState();
	}
	for(int v=0; v<NUM_VAULTS; v++) {
		drams[v]->PrintState();
	}
	for(int l=0; l<NUM_LINKS; l++) {
		upLinkMasters[l]->PrintState();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x341a3(%rip), %rcx     # 0x66548
cmpl (%rcx), %eax
jge 0x323d0
movq -0x20(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x17790
movq (%rax), %rdi
callq 0x434e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3239b
movq -0x20(%rbp), %rax
movq 0x200(%rax), %rdi
callq 0x28f90
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0x3422b(%rip), %rcx     # 0x6661c
cmpl (%rcx), %eax
jge 0x3241c
movq -0x20(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movslq -0x10(%rbp), %rsi
callq 0x329c0
movq (%rax), %rdi
callq 0x4f840
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x323e7
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x341ef(%rip), %rcx     # 0x6661c
cmpl (%rcx), %eax
jge 0x32458
movq -0x20(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
movslq -0x14(%rbp), %rsi
callq 0x329e0
movq (%rax), %rdi
callq 0x2f3c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x32423
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0x340df(%rip), %rcx     # 0x66548
cmpl (%rcx), %eax
jge 0x32494
movq -0x20(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movslq -0x18(%rbp), %rsi
callq 0x17770
movq (%rax), %rdi
callq 0x3fa30
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3245f
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/HMCController.cpp
// Function: CasHMC::HMCController::~HMCController()
HMCController::~HMCController()
{
	for(int l=0; l<NUM_LINKS; l++) {
		delete downLinkMasters[l];
		delete upLinkSlaves[l];
	}
	downLinkMasters.clear();
	upLinkSlaves.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x2ff55(%rip), %rcx     # 0x65b30
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x30955(%rip), %rcx     # 0x66548
cmpl (%rcx), %eax
jge 0x35c5a
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movslq -0xc(%rbp), %rsi
callq 0x17770
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x35c22
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
movslq -0xc(%rbp), %rsi
callq 0x17790
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x35c4d
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x35c4f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x35be9
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x29900
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x32b20
movq -0x18(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
callq 0x178f0
movq -0x18(%rbp), %rdi
addq $0x320, %rdi            # imm = 0x320
callq 0x178f0
movq -0x18(%rbp), %rdi
addq $0x2f8, %rdi            # imm = 0x2F8
callq 0x221f0
movq -0x18(%rbp), %rdi
addq $0x2d0, %rdi            # imm = 0x2D0
callq 0x221f0
movq -0x18(%rbp), %rdi
addq $0x2b8, %rdi            # imm = 0x2B8
callq 0x178f0
movq -0x18(%rbp), %rdi
addq $0x2a0, %rdi            # imm = 0x2A0
callq 0x178f0
movq -0x18(%rbp), %rdi
addq $0x288, %rdi            # imm = 0x288
callq 0x178f0
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x32ac0
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x29800
movq -0x18(%rbp), %rdi
callq 0x3aa30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/HMCController.cpp
// Function: CasHMC::HMCController::CallbackReceiveDown(CasHMC::Transaction*, bool)
void HMCController::CallbackReceiveDown(Transaction *downEle, bool chkReceive)
{
	if(chkReceive) {
		//Check transaction address
		downEle->address &= ((uint64_t)NUM_VAULTS*NUM_BANKS*NUM_COLS*NUM_ROWS - 1);
		downEle->trace->tranTransmitTime = currentClockCycle;
		if(downEle->transactionType == DATA_WRITE)	downEle->trace->statis->hmcTransmitSize += downEle->dataSize;
		//DEBUG(ALI(18)<<header<<ALI(15)<<*downEle<<"Down) RECEIVING transaction");
	}
	else {
		//DEBUG(ALI(18)<<header<<ALI(15)<<*downEle<<"Down) Transaction buffer FULL");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x35e2c
movq -0x20(%rbp), %rax
leaq 0x3086c(%rip), %rcx     # 0x6661c
movslq (%rcx), %rdx
leaq 0x30866(%rip), %rcx     # 0x66620
movslq (%rcx), %rcx
imulq %rcx, %rdx
leaq 0x30860(%rip), %rcx     # 0x66628
movslq (%rcx), %rcx
imulq %rcx, %rdx
leaq 0x3084e(%rip), %rcx     # 0x66624
movslq (%rcx), %rcx
imulq %rcx, %rdx
subq $0x1, %rdx
movq -0x10(%rbp), %rcx
andq 0x18(%rcx), %rdx
movq %rdx, 0x18(%rcx)
movq 0x8(%rax), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x35e2a
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
addq 0x128(%rax), %rcx
movq %rcx, 0x128(%rax)
jmp 0x35e2e
jmp 0x35e2e
popq %rbp
retq
// File: estwings57[P]CasHMC/sources/HMCController.cpp
// Function: CasHMC::HMCController::LinkStatistic()
void HMCController::LinkStatistic()
{
	for(int l=0; l<NUM_LINKS; l++) {
		if(downLinkMasters[l]->currentState == SLEEP) {
			linkSleepTime[l]++;
		}
		else if(downLinkMasters[l]->currentState == DOWN) {
			linkDownTime[l]++;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x2c353(%rip), %rcx     # 0x66548
cmpl (%rcx), %eax
jge 0x3a28d
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movslq -0xc(%rbp), %rsi
callq 0x17770
movq (%rax), %rax
cmpl $0x1, 0x200(%rax)
jne 0x3a23d
movq -0x18(%rbp), %rdi
addq $0x320, %rdi            # imm = 0x320
movslq -0xc(%rbp), %rsi
callq 0x17df0
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3a27d
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
movslq -0xc(%rbp), %rsi
callq 0x17770
movq (%rax), %rax
cmpl $0x2, 0x200(%rax)
jne 0x3a27b
movq -0x18(%rbp), %rdi
addq $0x338, %rdi            # imm = 0x338
movslq -0xc(%rbp), %rsi
callq 0x17df0
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3a27d
jmp 0x3a27f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3a1eb
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: estwings57[P]CasHMC/sources/Link.cpp
// Function: CasHMC::Link::NoisePacket(CasHMC::Packet*)
void Link::NoisePacket(Packet *packet)
{
	for(int i=0; i<packet->LNG; i++) {
		unsigned ranNum1 = rand();
		unsigned ranNum2 = rand();	
		if(ranNum1%errorProba == 0 && ranNum2%errorProba == 0) {
			DE_CR(ALI(18)<<header<<ALI(15)<<*packet<<(downstream ? "Down) " : "Up)   ")<<"====> Link ERROR is occurred <====");
			packet->CRC = ~packet->CRC;
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x430(%rcx), %eax
jae 0x3c0f5
callq 0x4120
movl %eax, -0x18(%rbp)
callq 0x4120
movq -0x38(%rbp), %rcx
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
xorl %edx, %edx
divl 0x1d0(%rcx)
cmpl $0x0, %edx
jne 0x3c0e5
movq -0x38(%rbp), %rcx
movl -0x1c(%rbp), %eax
xorl %edx, %edx
divl 0x1d0(%rcx)
cmpl $0x0, %edx
jne 0x3c0e5
leaq 0x2a54f(%rip), %rax     # 0x66528
testb $0x1, (%rax)
je 0x3c0cc
movl $0x12, %edi
callq 0x177b0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
movq 0x29fd7(%rip), %rdi     # 0x65fd0
callq 0x4440
movq %rax, -0x58(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x58(%rbp), %rdi
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %esi
callq 0x4550
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x4320
movq %rax, -0x50(%rbp)
movl $0xf, %edi
callq 0x177b0
movq -0x50(%rbp), %rdi
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
callq 0x4440
movq %rax, -0x48(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x48(%rbp), %rdi
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %esi
callq 0x4550
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x44960
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, -0x40(%rbp)
testb $0x1, 0x1cc(%rax)
je 0x3c094
leaq 0x175ba(%rip), %rax     # 0x53648
movq %rax, -0x60(%rbp)
jmp 0x3c0a1
leaq 0x175b4(%rip), %rax     # 0x5364f
movq %rax, -0x60(%rbp)
jmp 0x3c0a1
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x4380
movq %rax, %rdi
leaq 0x17621(%rip), %rsi     # 0x536d9
callq 0x4380
movq %rax, %rdi
movq 0x29ee9(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq -0x10(%rbp), %rax
movl 0x438(%rax), %ecx
xorl $-0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x438(%rax)
jmp 0x3c0f5
jmp 0x3c0e7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3bf7f
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: estwings57[P]CasHMC/sources/Link.cpp
// Function: CasHMC::Link::PrintState()
void Link::PrintState()
{
	if(inFlightPacket != NULL) {
		STATEN(ALI(17)<<header);
		STATEN((downstream ? "Down " : " Up  "));
		STATEN(*inFlightPacket);
		STATE("*"<<inFlightPacket->LNG);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, 0x1f0(%rax)
je 0x3c227
leaq 0x2a401(%rip), %rax     # 0x6652a
testb $0x1, (%rax)
je 0x3c178
movl $0x11, %edi
callq 0x177b0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq 0x29e8b(%rip), %rdi     # 0x65fd0
callq 0x4440
movq %rax, -0x20(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x20(%rbp), %rdi
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %esi
callq 0x4550
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x4320
leaq 0x2a3ab(%rip), %rax     # 0x6652a
testb $0x1, (%rax)
je 0x3c1bb
movq -0x18(%rbp), %rax
testb $0x1, 0x1cc(%rax)
je 0x3c19e
leaq 0x16d85(%rip), %rax     # 0x52f1d
movq %rax, -0x28(%rbp)
jmp 0x3c1ab
leaq 0x16d7e(%rip), %rax     # 0x52f23
movq %rax, -0x28(%rbp)
jmp 0x3c1ab
movq -0x28(%rbp), %rsi
movq 0x29e1a(%rip), %rdi     # 0x65fd0
callq 0x4380
leaq 0x2a368(%rip), %rax     # 0x6652a
testb $0x1, (%rax)
je 0x3c1de
movq -0x18(%rbp), %rax
movq 0x1f0(%rax), %rsi
movq 0x29df7(%rip), %rdi     # 0x65fd0
callq 0x44960
leaq 0x2a345(%rip), %rax     # 0x6652a
testb $0x1, (%rax)
je 0x3c225
movq 0x29ddf(%rip), %rdi     # 0x65fd0
leaq 0x150ef(%rip), %rsi     # 0x512e7
callq 0x4380
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x1f0(%rax), %rax
movl 0x430(%rax), %esi
callq 0x44c0
movq %rax, %rdi
movq 0x29d90(%rip), %rsi     # 0x65fb0
callq 0x43c0
jmp 0x3c227
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/LinkMaster.cpp
// Function: CasHMC::LinkMaster::FinishRetry()
void LinkMaster::FinishRetry()
{
	DEBUG(ALI(33)<<header<<(downstream ? "Down) " : "Up)   ")<<"RETRY sequence is finished");
	currentState = ACTIVE;
	header.erase(header.find(")"));
	header += ")";
	delete retryStartPacket;
	retryStartPacket = NULL;
	retryAttempts = 1;
	startRetryTimer = false;
	uint64_t retryTime;
	if(downstream) {
		retryTime = retryTimer;
	}
	else {
		retryTime = ceil(retryTimer * (double)tCK/CPU_CLK_PERIOD);
	}
	linkP->statis->errorRetryLat.push_back(retryTime);
	retryTimer = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x2839d(%rip), %rax     # 0x66528
testb $0x1, (%rax)
je 0x3e247
leaq 0x2838e(%rip), %rax     # 0x66529
testb $0x1, (%rax)
jne 0x3e247
movl $0x21, %edi
callq 0x177b0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
movq 0x27e15(%rip), %rdi     # 0x65fd0
callq 0x4440
movq %rax, -0x38(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x38(%rbp), %rdi
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %esi
callq 0x4550
movq -0x28(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x4320
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x30(%rbp)
testb $0x1, 0x1cc(%rax)
je 0x3e20f
leaq 0x1543f(%rip), %rax     # 0x53648
movq %rax, -0x40(%rbp)
jmp 0x3e21c
leaq 0x15439(%rip), %rax     # 0x5364f
movq %rax, -0x40(%rbp)
jmp 0x3e21c
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x4380
movq %rax, %rdi
leaq 0x15775(%rip), %rsi     # 0x539a8
callq 0x4380
movq %rax, %rdi
movq 0x27d6e(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq -0x28(%rbp), %rdi
movl $0x0, 0x200(%rdi)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
leaq 0x1610e(%rip), %rsi     # 0x54379
xorl %eax, %eax
movl %eax, %edx
callq 0x46d0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
movq $-0x1, %rdx
callq 0x40e0
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
leaq 0x160e3(%rip), %rsi     # 0x54379
callq 0x4350
movq -0x28(%rbp), %rax
movq 0x248(%rax), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x3e2ba
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x248(%rax)
movl $0x1, 0x258(%rax)
movb $0x0, 0x251(%rax)
testb $0x1, 0x1cc(%rax)
je 0x3e2f3
movq -0x28(%rbp), %rax
movl 0x254(%rax), %eax
movq %rax, -0x18(%rbp)
jmp 0x3e34f
movq -0x28(%rbp), %rax
movl 0x254(%rax), %eax
cvtsi2sd %rax, %xmm0
leaq 0x28337(%rip), %rax     # 0x66640
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
leaq 0x28220(%rip), %rax     # 0x66538
movsd (%rax), %xmm1
divsd %xmm1, %xmm0
callq 0x40a0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x14ebc(%rip), %xmm1    # 0x531f8
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq 0x210(%rax), %rax
movq 0x1e0(%rax), %rdi
addq $0x50, %rdi
movq -0x18(%rbp), %rax
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rsi
callq 0x18ef0
movq -0x28(%rbp), %rax
movl $0x0, 0x254(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/LinkMaster.cpp
// Function: CasHMC::LinkMaster::QuitePacket()
void LinkMaster::QuitePacket()
{
	//packet, cmd, addr, cub, lng, *lat
	Packet *packetQUIET = new Packet(FLOW, QUIET, 0, 0, 1, NULL);
	packetQUIET->RRP = lastestRRP;
	DEBUG(ALI(18)<<header<<ALI(15)<<*packetQUIET<<(downstream ? "Down) " : "Up)   ")<<"sending QUITE packet");
	linkRxTx.push_back(packetQUIET);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x468, %edi            # imm = 0x468
callq 0x4390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rsp, %rax
movq $0x0, (%rax)
xorl %r8d, %r8d
movl %r8d, %ecx
movl $0x2, %esi
movl $0x4, %edx
movl $0x1, %r9d
callq 0x43a90
jmp 0x3f6df
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x10(%rbp)
movl 0x20c(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x44c(%rax)
leaq 0x26e26(%rip), %rax     # 0x66528
testb $0x1, (%rax)
je 0x3f823
leaq 0x26e17(%rip), %rax     # 0x66529
testb $0x1, (%rax)
jne 0x3f823
movl $0x12, %edi
callq 0x177b0
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
movq 0x2689e(%rip), %rdi     # 0x65fd0
callq 0x4440
movq %rax, -0x60(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x60(%rbp), %rdi
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %esi
callq 0x4550
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x4320
movq %rax, -0x58(%rbp)
movl $0xf, %edi
callq 0x177b0
movq -0x58(%rbp), %rdi
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
callq 0x4440
movq %rax, -0x50(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x50(%rbp), %rdi
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %esi
callq 0x4550
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x44960
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x48(%rbp)
testb $0x1, 0x1cc(%rax)
je 0x3f7cd
leaq 0x13e81(%rip), %rax     # 0x53648
movq %rax, -0x68(%rbp)
jmp 0x3f7da
leaq 0x13e7b(%rip), %rax     # 0x5364f
movq %rax, -0x68(%rbp)
jmp 0x3f7da
movq -0x48(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x4380
movq %rax, %rdi
leaq 0x1433f(%rip), %rsi     # 0x53b30
callq 0x4380
movq %rax, %rdi
movq 0x267b0(%rip), %rsi     # 0x65fb0
callq 0x43c0
jmp 0x3f823
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x468, %esi            # imm = 0x468
callq 0x43a0
jmp 0x3f83d
movq -0x40(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
leaq -0x10(%rbp), %rsi
callq 0x29ef0
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4630
nopw %cs:(%rax,%rax)
// File: estwings57[P]CasHMC/sources/LinkMaster.cpp
// Function: CasHMC::LinkMaster::FinishRetrain()
void LinkMaster::FinishRetrain()
{
	currentState = ACTIVE;
	//The requester must send a minimum of 32 NULL FLITs before sending the first nonNULL flow packet
	Packet *packetNULL = NULL;
	for(int i=0; i<32; i++) {
		packetNULL = new Packet(FLOW, NULL_, 0, 0, 1, NULL);
		linkRxTx.push_back(packetNULL);
	}
	DEBUG(ALI(18)<<header<<ALI(15)<<*packetNULL<<(downstream ? "Down) " : "Up)   ")
			<<"sending a minimum of 32 NULL FLITs before entering ACTIVE mode");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, 0x200(%rax)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x20, -0x14(%rbp)
jge 0x3f905
movl $0x468, %edi            # imm = 0x468
callq 0x4390
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rsp, %rax
movq $0x0, (%rax)
xorl %r8d, %r8d
movl %r8d, %ecx
movl $0x2, %esi
movl $0x1, %r9d
movl %r8d, %edx
callq 0x43a90
jmp 0x3f8bf
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
addq $0x1e8, %rdi            # imm = 0x1E8
leaq -0x10(%rbp), %rsi
callq 0x29ef0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3f880
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x468, %esi            # imm = 0x468
callq 0x43a0
jmp 0x3fa18
leaq 0x26c1c(%rip), %rax     # 0x66528
testb $0x1, (%rax)
je 0x3fa0f
leaq 0x26c0d(%rip), %rax     # 0x66529
testb $0x1, (%rax)
jne 0x3fa0f
movl $0x12, %edi
callq 0x177b0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
movq 0x26694(%rip), %rdi     # 0x65fd0
callq 0x4440
movq %rax, -0x68(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x68(%rbp), %rdi
movb %al, -0x29(%rbp)
movzbl -0x29(%rbp), %esi
callq 0x4550
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x4320
movq %rax, -0x60(%rbp)
movl $0xf, %edi
callq 0x177b0
movq -0x60(%rbp), %rdi
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %esi
callq 0x4440
movq %rax, -0x58(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x58(%rbp), %rdi
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %esi
callq 0x4550
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x44960
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x50(%rbp)
testb $0x1, 0x1cc(%rax)
je 0x3f9d7
leaq 0x13c77(%rip), %rax     # 0x53648
movq %rax, -0x70(%rbp)
jmp 0x3f9e4
leaq 0x13c71(%rip), %rax     # 0x5364f
movq %rax, -0x70(%rbp)
jmp 0x3f9e4
movq -0x50(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x4380
movq %rax, %rdi
leaq 0x1414a(%rip), %rsi     # 0x53b45
callq 0x4380
movq %rax, %rdi
movq 0x265a6(%rip), %rsi     # 0x65fb0
callq 0x43c0
addq $0x80, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x4630
nopw %cs:(%rax,%rax)
// File: estwings57[P]CasHMC/sources/SingleVectorObject.h
// Function: CasHMC::SingleVectorObject<CasHMC::Packet>::Step()
void Step() {
		currentClockCycle++;
		for(int i=0; i<Buffers.size(); i++) {
			if(Buffers[i] != NULL) {
				Buffers[i]->bufPopDelay = (Buffers[i]->bufPopDelay>0) ? Buffers[i]->bufPopDelay-1 : 0;
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x22d60
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x406d2
movq -0x18(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x29940
cmpq $0x0, (%rax)
je 0x406c2
movq -0x18(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x29940
movq (%rax), %rax
cmpl $0x0, 0x14(%rax)
jle 0x40698
movq -0x18(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x29940
movq (%rax), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4069f
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x4069f
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x29940
movl -0x28(%rbp), %ecx
movq (%rax), %rax
movl %ecx, 0x14(%rax)
jmp 0x406c4
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x40617
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: estwings57[P]CasHMC/sources/LinkSlave.cpp
// Function: CasHMC::LinkSlave::LinkSlave(std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&, unsigned int, bool)
LinkSlave::LinkSlave(ofstream &debugOut_, ofstream &stateOut_, unsigned id, bool down):
	SingleVectorObject<Packet>(debugOut_, stateOut_, MAX_LINK_BUF, down),
	linkSlaveID(id)
{
	classID << linkSlaveID;
	header = "   (LS_";
	header += downstream ? "D" : "U";
	header += classID.str() + ")";
	
	slaveSEQ = 0;
	countdownCRC = 0;
	startCRC = false;
	downBufferDest = NULL;
	upBufferDest = NULL;
	localLinkMaster = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x257cf(%rip), %rax     # 0x66558
movl (%rax), %ecx
movzbl -0x1d(%rbp), %r8d
andl $0x1, %r8d
callq 0x40430
movq -0x78(%rbp), %rax
leaq 0x24f0c(%rip), %rcx     # 0x65cb0
movq %rcx, (%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x204(%rax)
movq %rax, %rdi
addq $0x50, %rdi
movl 0x204(%rax), %esi
callq 0x44c0
jmp 0x40dc4
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
leaq 0x13069(%rip), %rsi     # 0x53e3c
callq 0x44e0
jmp 0x40dda
movq -0x78(%rbp), %rax
testb $0x1, 0x1cc(%rax)
je 0x40df4
leaq 0x136bf(%rip), %rax     # 0x544ad
movq %rax, -0x80(%rbp)
jmp 0x40e01
leaq 0x12120(%rip), %rax     # 0x52f1b
movq %rax, -0x80(%rbp)
jmp 0x40e01
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
addq $0x20, %rdi
callq 0x4350
jmp 0x40e14
movq -0x78(%rbp), %rsi
addq $0x40, %rsi
leaq -0x70(%rbp), %rdi
callq 0x4370
jmp 0x40e27
leaq 0x1354b(%rip), %rdx     # 0x54379
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x18020
jmp 0x40e3d
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
leaq -0x50(%rbp), %rsi
callq 0x44a0
jmp 0x40e50
leaq -0x50(%rbp), %rdi
callq 0x46e8
leaq -0x70(%rbp), %rdi
callq 0x46e8
movq -0x78(%rbp), %rax
movl $0x0, 0x220(%rax)
movl $0x0, 0x224(%rax)
movb $0x0, 0x228(%rax)
movq $0x0, 0x208(%rax)
movq $0x0, 0x210(%rax)
movq $0x0, 0x218(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x40ee5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x40edc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x46e8
leaq -0x70(%rbp), %rdi
callq 0x46e8
movq -0x78(%rbp), %rdi
callq 0x406e0
movq -0x28(%rbp), %rdi
callq 0x4630
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/LinkSlave.cpp
// Function: CasHMC::LinkSlave::CallbackReceive(CasHMC::Packet*, bool)
void LinkSlave::CallbackReceive(Packet *packet, bool chkReceive)
{
/*	if(chkReceive) {
		DEBUG(ALI(18)<<header<<ALI(15)<<*packet<<(downstream ? "Down) " : "Up)   ")<<"RECEIVING packet");
	}
	else {
		DEBUG(ALI(18)<<header<<ALI(15)<<*packet<<(downstream ? "Down) " : "Up)   ")<<"packet buffer FULL");
	}*/
	
	if(packet->packetType == FLOW) {
		ERROR(header<<"  == Error - flow packet "<<*packet<<" is not meant to be here");
		exit(0);
	}
	else {
		if(!chkReceive) {
			ERROR(header<<"  == Error - packet "<<*packet<<" is missed, because link slave buffer is FULL (CurrentClock : "<<currentClockCycle<<")");
			exit(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, 0x10(%rax)
jne 0x4103a
movq 0x2504c(%rip), %rdi     # 0x65ff0
leaq 0x1008f(%rip), %rsi     # 0x5103a
callq 0x4380
movq %rax, %rdi
leaq 0x12c21(%rip), %rsi     # 0x53bdb
callq 0x4380
movq %rax, %rdi
leaq 0x1086c(%rip), %rsi     # 0x51835
callq 0x4380
movq %rax, %rdi
movl $0x35, %esi
callq 0x4610
movq %rax, %rdi
leaq 0x10074(%rip), %rsi     # 0x51059
callq 0x4380
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x4320
movq %rax, %rdi
leaq 0x12bed(%rip), %rsi     # 0x53bf1
callq 0x4380
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x44960
movq %rax, %rdi
leaq 0x12bec(%rip), %rsi     # 0x53c0b
callq 0x4380
movq %rax, %rdi
movq 0x24f82(%rip), %rsi     # 0x65fb0
callq 0x43c0
xorl %edi, %edi
callq 0x4460
testb $0x1, -0x11(%rbp)
jne 0x41100
movq 0x24fa5(%rip), %rdi     # 0x65ff0
leaq 0xffe8(%rip), %rsi      # 0x5103a
callq 0x4380
movq %rax, %rdi
leaq 0x12b7a(%rip), %rsi     # 0x53bdb
callq 0x4380
movq %rax, %rdi
leaq 0x107c5(%rip), %rsi     # 0x51835
callq 0x4380
movq %rax, %rdi
movl $0x3a, %esi
callq 0x4610
movq %rax, %rdi
leaq 0xffcd(%rip), %rsi      # 0x51059
callq 0x4380
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x4320
movq %rax, %rdi
leaq 0x12b79(%rip), %rsi     # 0x53c24
callq 0x4380
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x44960
movq %rax, %rdi
leaq 0x12b73(%rip), %rsi     # 0x53c39
callq 0x4380
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x40f0
movq %rax, %rdi
leaq 0x13294(%rip), %rsi     # 0x54379
callq 0x4380
movq %rax, %rdi
movq 0x24ebc(%rip), %rsi     # 0x65fb0
callq 0x43c0
xorl %edi, %edi
callq 0x4460
jmp 0x41102
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: estwings57[P]CasHMC/sources/DualVectorObject.h
// Function: CasHMC::DualVectorObject<CasHMC::Transaction, CasHMC::Packet>::ReceiveUp(CasHMC::Packet*)
bool ReceiveUp(UpT *upEle) {
		if(upBuffers.size() + upEle->LNG <= upBufferMax) {
			//Upstream buffer does not need upBufPopCycle (one cycle to pop one buffer data), 
			//	because upBufferDest (upstream buffer destination) is updated before buffer class.
			upBuffers.push_back(upEle);
			//If receiving packet is packet, add virtual tail packet in Buffers as long as packet length
			if(sizeof(*upEle) == sizeof(Packet)) {
				for(int i=1; i<upEle->LNG; i++) {
					upBuffers.push_back(NULL);
				}
			}
			CallbackReceiveUp(upEle, true);
			return true;
		}
		else {
			CallbackReceiveUp(upEle, false);
			return false;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x22d60
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl 0x430(%rdx), %edx
addq %rdx, %rax
movslq 0x1cc(%rcx), %rcx
cmpq %rcx, %rax
ja 0x4394b
movq -0x30(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
leaq -0x18(%rbp), %rsi
callq 0x29ef0
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x430(%rcx), %eax
jae 0x43932
movq -0x30(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x2ca20
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x438fc
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x20(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x4395f
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
xorl %edx, %edx
callq *0x20(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/Packet.cpp
// Function: CasHMC::Packet::MakeCRCtable(unsigned int*, unsigned int)
void Packet::MakeCRCtable(uint32_t *table, uint32_t id) 
{
	uint32_t k;
	for(int i=0; i<256; ++i){
		k = i;
		for(int j=0; j<8; ++j){
			if(k&1)	k = (k >> 1) ^ id;
			else	k >>= 1;
		}
		table[i] = k;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
jge 0x43d68
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x8, -0x20(%rbp)
jge 0x43d4f
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x43d3a
movl -0x18(%rbp), %eax
shrl %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x43d42
movl -0x18(%rbp), %eax
shrl %eax
movl %eax, -0x18(%rbp)
jmp 0x43d44
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x43d1c
movl -0x18(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x43d06
popq %rbp
retq
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/Packet.cpp
// Function: CasHMC::Packet::Packet(CasHMC::PacketType, CasHMC::PacketCommandType, unsigned int, unsigned int, CasHMC::TranTrace*)
Packet::Packet(PacketType packet, PacketCommandType cmd, unsigned tag, unsigned lng, TranTrace *lat):
	trace(lat),
	packetType(packet),
	TAG(tag),
	LNG(lng),
	CMD(cmd)
{
	bufPopDelay=1;
	CRCtable[256]=0;	
	CUB=0; Pb=0;
	CRC=0; RTC=0; SLID=0;
	SEQ=0; FRP=0; RRP=0;
	AF=0; ERRSTAT=0; DINV=0;
	chkCRC = false;
	chkRRP = false;
	segment = false;
	reqDataSize=16;	//The minimum size is 16-Byte
	
	if(CRC_CHECK) {
		if(LNG>1) {
			DATA = new uint64_t[(LNG-1)*2];
			uint64_t tempData;
			for(int i=0; i<(LNG-1)*2; i++) {
				tempData = rand();
				tempData = (tempData<<32)|rand();
				DATA[i] = tempData;
			}
		}
		else {
			DATA = NULL;
		}
		MakeCRCtable(CRCtable, 0xEB31D82E);
	}
	else {
		DATA = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x21f4c(%rip), %rcx     # 0x65ce8
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x42c(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x430(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x434(%rax)
movl $0x1, 0x14(%rax)
movl $0x0, 0x420(%rax)
movl $0x0, 0x428(%rax)
movl $0x0, 0x458(%rax)
movl $0x0, 0x438(%rax)
movl $0x0, 0x43c(%rax)
movl $0x0, 0x440(%rax)
movl $0x0, 0x444(%rax)
movl $0x0, 0x448(%rax)
movl $0x0, 0x44c(%rax)
movl $0x0, 0x45c(%rax)
movl $0x0, 0x460(%rax)
movl $0x0, 0x464(%rax)
movb $0x0, 0x420(%rax)
movb $0x0, 0x421(%rax)
movb $0x0, 0x422(%rax)
movl $0x10, 0x424(%rax)
leaq 0x226fb(%rip), %rax     # 0x6656c
testb $0x1, (%rax)
je 0x43f55
movq -0x38(%rbp), %rax
cmpl $0x1, 0x430(%rax)
jbe 0x43f32
movq -0x38(%rbp), %rax
movl 0x430(%rax), %eax
subl $0x1, %eax
shll %eax
movl %eax, %eax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x4030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl 0x430(%rcx), %ecx
subl $0x1, %ecx
shll %ecx
cmpl %ecx, %eax
jae 0x43f30
callq 0x4120
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x40(%rbp)
callq 0x4120
movq -0x40(%rbp), %rcx
movl %eax, %edx
movq -0x38(%rbp), %rax
movslq %edx, %rdx
orq %rdx, %rcx
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x43ecf
jmp 0x43f3e
movq -0x38(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x38(%rbp), %rdi
movq %rdi, %rsi
addq $0x20, %rsi
movl $0xeb31d82e, %edx       # imm = 0xEB31D82E
callq 0x43cf0
jmp 0x43f61
movq -0x38(%rbp), %rax
movq $0x0, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/Packet.cpp
// Function: CasHMC::Packet::CalcCRC(unsigned char const*, int, unsigned int, unsigned int*)
uint32_t Packet::CalcCRC(const unsigned char *mem, signed int size, uint32_t crc, uint32_t *table)
{
	crc = ~crc;
	while(size--){
		crc = table[(crc ^ *(mem++)) & 0xFF] ^ (crc >> 8);
	}
	return ~crc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl -0x18(%rbp), %eax
xorl $-0x1, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x44932
movq -0x20(%rbp), %rax
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rdx
movq %rdx, %rsi
addq $0x1, %rsi
movq %rsi, -0x10(%rbp)
movzbl (%rdx), %edx
xorl %edx, %ecx
andl $0xff, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x18(%rbp), %ecx
shrl $0x8, %ecx
xorl %ecx, %eax
movl %eax, -0x18(%rbp)
jmp 0x448ef
movl -0x18(%rbp), %eax
xorl $-0x1, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/RunSim.cpp
// Function: Help()
void Help()
{
	cout<<endl<<"-c (--cycle)   : The number of CPU cycles to be simulated"<<endl;
	cout<<"-t (--trace)   : Trace type ('random' or 'file')"<<endl;
	cout<<"-u (--util)    : Requests frequency (0 = no requests, 1 = as fast as possible) [Default 0.1]"<<endl;
	cout<<"-r (--rwratio) : (%) The percentage of reads in request stream [Default 80]"<<endl;
	cout<<"-f (--file)    : Trace file name"<<endl;
	cout<<"-h (--help)    : Simulation option help"<<endl<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x1dd05(%rip), %rdi     # 0x65fd0
movq 0x1dcde(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq %rax, %rdi
leaq 0xc02f(%rip), %rsi      # 0x54310
callq 0x4380
movq %rax, %rdi
movq 0x1dcc0(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq 0x1dcd4(%rip), %rdi     # 0x65fd0
leaq 0xc047(%rip), %rsi      # 0x5434a
callq 0x4380
movq %rax, %rdi
movq 0x1dc9e(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq 0x1dcb2(%rip), %rdi     # 0x65fd0
leaq 0xc056(%rip), %rsi      # 0x5437b
callq 0x4380
movq %rax, %rdi
movq 0x1dc7c(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq 0x1dc90(%rip), %rdi     # 0x65fd0
leaq 0xc091(%rip), %rsi      # 0x543d8
callq 0x4380
movq %rax, %rdi
movq 0x1dc5a(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq 0x1dc6e(%rip), %rdi     # 0x65fd0
leaq 0xc0bb(%rip), %rsi      # 0x54424
callq 0x4380
movq %rax, %rdi
movq 0x1dc38(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq 0x1dc4c(%rip), %rdi     # 0x65fd0
leaq 0xc0ba(%rip), %rsi      # 0x54445
callq 0x4380
movq %rax, %rdi
movq 0x1dc16(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq %rax, %rdi
movq 0x1dc07(%rip), %rsi     # 0x65fb0
callq 0x43c0
popq %rbp
retq