LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ef-gy[P]libefgy/include/ef.gy/json.h
// Function: efgy::json::value<long double>::clear()
void clear(void) {
    if (payload) {
      switch (type) {
        case object:
          delete ((objectType *)payload);
          break;
        case array:
          delete ((arrayType *)payload);
          break;
        case string:
          delete ((stringType *)payload);
          break;
        case number:
          delete ((numberType *)payload);
          break;
        case yes:
        case no:
        case null:
        case comma:
        case colon:
        case error:
        case endObject:
        case endArray:
          break;
      }
      payload = 0;
    }
    type = null;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x2ebb8
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x18(%rbp)
subq $0xb, %rax
ja 0x2ebac
movq -0x18(%rbp), %rax
leaq 0xe8c2(%rip), %rcx      # 0x3d3c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x2eb30
movq -0x20(%rbp), %rdi
callq 0xb670
movq -0x20(%rbp), %rdi
movl $0x30, %esi
callq 0x53d0
jmp 0x2ebac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2eb5b
movq -0x28(%rbp), %rdi
callq 0xb5f0
movq -0x28(%rbp), %rdi
movl $0x18, %esi
callq 0x53d0
jmp 0x2ebac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2eb86
movq -0x30(%rbp), %rdi
callq 0x5270
movq -0x30(%rbp), %rdi
movl $0x20, %esi
callq 0x53d0
jmp 0x2ebac
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x2eba8
movq -0x38(%rbp), %rdi
movl $0x10, %esi
callq 0x53d0
jmp 0x2ebac
jmp 0x2ebac
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x6, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/json.h
// Function: efgy::json::value<long double>::operator=(efgy::json::value<long double> const&)
value &operator=(const value &b) {
    clear();
    switch (b.type) {
      case object:
        toObject() = b.asObject();
        break;
      case array:
        toArray() = b.asArray();
        break;
      case string:
        toString() = b.asString();
        break;
      case number:
        toNumber() = b.asNumber();
        break;
      case yes:
      case no:
      case null:
      case comma:
      case colon:
      case error:
      case endObject:
      case endArray:
        type = b.type;
        break;
    }
    return *this;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2eac0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x90(%rbp)
subq $0xb, %rax
ja 0x2ed6f
movq -0x90(%rbp), %rax
leaq 0xe7d8(%rip), %rcx      # 0x3d3f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2f160
movq -0x98(%rbp), %rdi
callq 0x2ed90
movq %rax, -0xa0(%rbp)
jmp 0x2ec43
movq -0xa0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2f1d0
jmp 0x2ec55
leaq -0x40(%rbp), %rdi
callq 0xb670
jmp 0x2ed6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xb670
jmp 0x2ed7f
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x2f200
movq -0x98(%rbp), %rdi
callq 0x2ee00
movq %rax, -0xa8(%rbp)
jmp 0x2ec9f
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2f270
jmp 0x2ecb1
leaq -0x68(%rbp), %rdi
callq 0xb5f0
jmp 0x2ed6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xb5f0
jmp 0x2ed7f
movq -0x10(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x2ef30
movq -0x98(%rbp), %rdi
callq 0x2ee70
movq %rax, -0xb0(%rbp)
jmp 0x2ecfe
movq -0xb0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x5070
jmp 0x2ed13
leaq -0x88(%rbp), %rdi
callq 0x5270
jmp 0x2ed6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x5270
jmp 0x2ed7f
movq -0x10(%rbp), %rdi
callq 0x2f4c0
movq -0x98(%rbp), %rdi
fstpt -0xbc(%rbp)
callq 0x2eed0
fldt -0xbc(%rbp)
fstpt (%rax)
jmp 0x2ed6f
movq -0x98(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x5660
nopl (%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/json.h
// Function: efgy::json::value<long double>::toObject[abi:cxx11]()
objectType &toObject(void) {
    if (!isObject()) {
      clear();
      type = object;
      payload = new objectType();
    }
    return *((objectType *)payload);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x2f500
testb $0x1, %al
jne 0x2edf2
movq -0x10(%rbp), %rdi
callq 0x2eac0
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x30, %edi
callq 0x53c0
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x30, %edx
callq 0x51f0
movq -0x18(%rbp), %rdi
callq 0x2f520
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: ef-gy[P]libefgy/include/ef.gy/json.h
// Function: efgy::json::value<long double>::toArray()
arrayType &toArray(void) {
    if (!isArray()) {
      clear();
      type = array;
      payload = new arrayType();
    }
    return *((arrayType *)payload);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x304d0
testb $0x1, %al
jne 0x2ee62
movq -0x10(%rbp), %rdi
callq 0x2eac0
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movl $0x18, %edi
callq 0x53c0
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x51f0
movq -0x18(%rbp), %rdi
callq 0x304f0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: ef-gy[P]libefgy/include/ef.gy/json.h
// Function: efgy::json::value<long double>::toString[abi:cxx11]()
stringType &toString(void) {
    if (!isString()) {
      clear();
      type = string;
      payload = new stringType();
    }
    return *((stringType *)payload);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x31650
testb $0x1, %al
jne 0x2eec2
movq -0x10(%rbp), %rdi
callq 0x2eac0
movq -0x10(%rbp), %rax
movl $0x2, (%rax)
movl $0x20, %edi
callq 0x53c0
movq %rax, %rdi
movq %rdi, -0x18(%rbp)
callq 0x5540
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: ef-gy[P]libefgy/include/ef.gy/json.h
// Function: efgy::json::value<long double>::toNumber()
numberType &toNumber(void) {
    if (!isNumber()) {
      clear();
      type = number;
      payload = new numberType();
    }
    return *((numberType *)payload);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x31630
testb $0x1, %al
jne 0x2ef1c
movq -0x10(%rbp), %rdi
callq 0x2eac0
movq -0x10(%rbp), %rax
movl $0x3, (%rax)
movl $0x10, %edi
callq 0x53c0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq %rdx, %rcx
fldz
fstpt (%rdx)
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: JainamS1996[P]Btree_DataStructure/final.cpp
// Function: go(Node*)
void go(Node *curNode) {
    if (!curNode->isleaf) {
        go(curNode->children.at(0));
    }
    else {
        while (curNode!=NULL) {
            for (int i = 0; i<curNode->record.size();i++)
                cout << get<0>(curNode->record.at(i))<<endl;
            curNode = curNode->next;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x88(%rax)
jne 0x34d7
movq -0x8(%rbp), %rdi
addq $0x70, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5550
movq (%rax), %rdi
callq 0x34a0
jmp 0x355b
jmp 0x34d9
cmpq $0x0, -0x8(%rbp)
je 0x3559
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
callq 0x4f20
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x354b
movq -0x8(%rbp), %rdi
addq $0x40, %rdi
movslq -0xc(%rbp), %rsi
callq 0x4fc0
movq %rax, %rdi
callq 0x5250
movsd (%rax), %xmm0
movq 0xfaac(%rip), %rdi      # 0x12fd8
callq 0x2330
movq %rax, %rdi
movq 0xfa85(%rip), %rsi      # 0x12fc0
callq 0x21e0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x34e7
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x34d9
jmp 0x355b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: JainamS1996[P]Btree_DataStructure/final.cpp
// Function: Node::Node(bool)
Node(bool leaf = true){
            nNodes = 0;
            parentNode = NULL;
            next = NULL;
            prev = NULL;
            greeting = "alive";
            isleaf = leaf ;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x2260
movq -0x28(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x40(%rbp)
callq 0x58a0
movq -0x28(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x38(%rbp)
callq 0x58c0
movq -0x28(%rbp), %rdi
addq $0x70, %rdi
movq %rdi, -0x30(%rbp)
callq 0x58e0
movq -0x28(%rbp), %rdi
movl $0x0, 0x20(%rdi)
movq $0x0, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
leaq 0x81ff(%rip), %rsi      # 0xd024
callq 0x2240
jmp 0x4e2c
movq -0x48(%rbp), %rax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x88(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5900
movq -0x38(%rbp), %rdi
callq 0x5960
movq -0x40(%rbp), %rdi
callq 0x59c0
movq -0x28(%rbp), %rdi
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x2300
nopl (%rax,%rax)
// File: estwings57[P]CasHMC/sources/BankState.cpp
// Function: CasHMC::BankState::BankState(unsigned int)
BankState::BankState(unsigned id):
	bankID(id)
{
	currentBankState = IDLE;
	openRowAddress = 0;
	nextActivate = 0;
	nextRead = 0;
	nextWrite = 0;
	nextPrecharge = 0;
	nextPowerUp = 0;
	lastCommand = PRECHARGE;
	stateChangeCountdown = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movl $0x7, 0x38(%rax)
movl $0x0, 0x3c(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/BankState.cpp
// Function: CasHMC::operator<<(std::ostream&, CasHMC::BankState const&)
ostream &operator<<(ostream &out, const BankState &bs)
{
	switch(bs.currentBankState) {
		case IDLE:
			out<<"Idle";
			break;
		case ROW_ACTIVE:
			out<<"Actv";
			break;
		case PRECHARGING:
			out<<"Prch";
			break;
		case REFRESHING:
			out<<"Refr";
			break;
		case POWERDOWN:
			out<<"Pwdw";
			break;
		case AWAKING:
			out<<"Awak";
			break;
		default:
			ERROR(" (BS) == Error - Trying to print unknown kind of bank state");
			ERROR("         Type : "<<bs.currentBankState);
			exit(0);
	}
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x7387
movq -0x18(%rbp), %rax
leaq 0x49d04(%rip), %rcx     # 0x51004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
leaq 0x49d08(%rip), %rsi     # 0x5101c
callq 0x4380
jmp 0x7473
movq -0x8(%rbp), %rdi
leaq 0x49cf8(%rip), %rsi     # 0x51021
callq 0x4380
jmp 0x7473
movq -0x8(%rbp), %rdi
leaq 0x49ce8(%rip), %rsi     # 0x51026
callq 0x4380
jmp 0x7473
movq -0x8(%rbp), %rdi
leaq 0x49cd8(%rip), %rsi     # 0x5102b
callq 0x4380
jmp 0x7473
movq -0x8(%rbp), %rdi
leaq 0x49cc8(%rip), %rsi     # 0x51030
callq 0x4380
jmp 0x7473
movq -0x8(%rbp), %rdi
leaq 0x49cb8(%rip), %rsi     # 0x51035
callq 0x4380
jmp 0x7473
movq 0x5ec62(%rip), %rdi     # 0x65ff0
leaq 0x49ca5(%rip), %rsi     # 0x5103a
callq 0x4380
movq %rax, %rdi
leaq 0x49c9f(%rip), %rsi     # 0x51043
callq 0x4380
movq %rax, %rdi
leaq 0x4a482(%rip), %rsi     # 0x51835
callq 0x4380
movq %rax, %rdi
movl $0x3d, %esi
callq 0x4610
movq %rax, %rdi
leaq 0x49c8a(%rip), %rsi     # 0x51059
callq 0x4380
movq %rax, %rdi
leaq 0x49c80(%rip), %rsi     # 0x5105e
callq 0x4380
movq %rax, %rdi
movq 0x5ebc3(%rip), %rsi     # 0x65fb0
callq 0x43c0
movq 0x5ebf7(%rip), %rdi     # 0x65ff0
leaq 0x49c3a(%rip), %rsi     # 0x5103a
callq 0x4380
movq %rax, %rdi
leaq 0x49c34(%rip), %rsi     # 0x51043
callq 0x4380
movq %rax, %rdi
leaq 0x4a417(%rip), %rsi     # 0x51835
callq 0x4380
movq %rax, %rdi
movl $0x3e, %esi
callq 0x4610
movq %rax, %rdi
leaq 0x49c1f(%rip), %rsi     # 0x51059
callq 0x4380
movq %rax, %rdi
leaq 0x49c51(%rip), %rsi     # 0x5109a
callq 0x4380
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x4610
movq %rax, %rdi
movq 0x5eb49(%rip), %rsi     # 0x65fb0
callq 0x43c0
xorl %edi, %edi
callq 0x4460
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/CasHMCWrapper.cpp
// Function: CasHMC::CasHMCWrapper::ReceiveTran(CasHMC::TransactionType, unsigned long, unsigned int)
bool CasHMCWrapper::ReceiveTran(TransactionType tranType, uint64_t addr, unsigned size)
{
	Transaction *newTran = new Transaction(tranType, addr, size, this);

	if(hmcCont->ReceiveDown(newTran)) {
		DE_CR(ALI(18)<<" (BUS)"<<ALI(15)<<*newTran<<"Down) SENDING transaction to HMC controller (HC)");
		return true;
	}
	else {
		newTran->ReductGlobalID();
		delete newTran->trace;
		delete newTran;
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movl $0x30, %edi
callq 0x4390
movq -0x60(%rbp), %r8
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movl -0x24(%rbp), %ecx
callq 0x4a2a0
jmp 0x149ca
movq -0x60(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x330(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x17aa0
testb $0x1, %al
jne 0x149ef
jmp 0x14ad1
leaq 0x51b32(%rip), %rax     # 0x66528
testb $0x1, (%rax)
je 0x14acb
movl $0x12, %edi
callq 0x177b0
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %esi
movq 0x515ba(%rip), %rdi     # 0x65fd0
callq 0x4440
movq %rax, -0x78(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x78(%rbp), %rdi
movb %al, -0x41(%rbp)
movzbl -0x41(%rbp), %esi
callq 0x4550
movq %rax, %rdi
leaq 0x3ce53(%rip), %rsi     # 0x51896
callq 0x4380
movq %rax, -0x70(%rbp)
movl $0xf, %edi
callq 0x177b0
movq -0x70(%rbp), %rdi
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %esi
callq 0x4440
movq %rax, -0x68(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x68(%rbp), %rdi
movb %al, -0x49(%rbp)
movzbl -0x49(%rbp), %esi
callq 0x4550
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x4a3b0
movq %rax, %rdi
leaq 0x3ce04(%rip), %rsi     # 0x5189d
callq 0x4380
movq %rax, %rdi
movq 0x51508(%rip), %rsi     # 0x65fb0
callq 0x43c0
jmp 0x14acb
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x30, %esi
callq 0x43a0
jmp 0x14b33
movb $0x1, -0x1(%rbp)
jmp 0x14b25
movq -0x30(%rbp), %rdi
callq 0x4a390
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, %rax
je 0x14b03
movq -0x80(%rbp), %rdi
callq 0x17b80
movq -0x80(%rbp), %rdi
movl $0x20, %esi
callq 0x43a0
movq -0x30(%rbp), %rax
movq %rax, -0x88(%rbp)
cmpq $0x0, %rax
je 0x14b21
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4630
nopl (%rax)
// File: estwings57[P]CasHMC/sources/CasHMCWrapper.cpp
// Function: CasHMC::CasHMCWrapper::ReceiveTran(CasHMC::Transaction*)
bool CasHMCWrapper::ReceiveTran(Transaction *tran)
{
	if(hmcCont->ReceiveDown(tran)) {
		DE_CR(ALI(18)<<" (BUS)"<<ALI(15)<<*tran<<"Down) SENDING transaction to HMC controller (HC)");
		return true;
	}
	else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x330(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x17aa0
testb $0x1, %al
jne 0x14b6d
jmp 0x14c31
leaq 0x519b4(%rip), %rax     # 0x66528
testb $0x1, (%rax)
je 0x14c2b
movl $0x12, %edi
callq 0x177b0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
movq 0x5143c(%rip), %rdi     # 0x65fd0
callq 0x4440
movq %rax, -0x40(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x40(%rbp), %rdi
movb %al, -0x1d(%rbp)
movzbl -0x1d(%rbp), %esi
callq 0x4550
movq %rax, %rdi
leaq 0x3ccd5(%rip), %rsi     # 0x51896
callq 0x4380
movq %rax, -0x38(%rbp)
movl $0xf, %edi
callq 0x177b0
movq -0x38(%rbp), %rdi
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
callq 0x4440
movq %rax, -0x30(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x30(%rbp), %rdi
movb %al, -0x25(%rbp)
movzbl -0x25(%rbp), %esi
callq 0x4550
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x4a3b0
movq %rax, %rdi
leaq 0x3cc86(%rip), %rsi     # 0x5189d
callq 0x4380
movq %rax, %rdi
movq 0x5138a(%rip), %rsi     # 0x65fb0
callq 0x43c0
movb $0x1, -0x1(%rbp)
jmp 0x14c35
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: estwings57[P]CasHMC/sources/DualVectorObject.h
// Function: CasHMC::DualVectorObject<CasHMC::Packet, CasHMC::Packet>::ReceiveDown(CasHMC::Packet*)
bool ReceiveDown(DownT *downEle) {
		if(downBuffers.size() + downEle->LNG <= downBufferMax) {
			if(downBuffers.size() == 0) {
				bufPopDelay = (bufPopDelay>0) ? bufPopDelay : 1;
			}
			downBuffers.push_back(downEle);
			//If receiving packet is packet, add virtual tail packet in Buffers as long as packet length
			if(sizeof(*downEle) == sizeof(Packet)) {
				for(int i=1; i<downEle->LNG; i++) {
					downBuffers.push_back(NULL);
				}
			}
			CallbackReceiveDown(downEle, true);
			return true;
		}
		else {
			CallbackReceiveDown(downEle, false);
			return false;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x22d60
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl 0x430(%rdx), %edx
addq %rdx, %rax
movslq 0x1c8(%rcx), %rcx
cmpq %rcx, %rax
ja 0x29e58
movq -0x30(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
callq 0x22d60
cmpq $0x0, %rax
jne 0x29dee
movq -0x30(%rbp), %rax
cmpl $0x0, 0x200(%rax)
jle 0x29dd7
movq -0x30(%rbp), %rax
movl 0x200(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x29de1
movl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x29de1
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, 0x200(%rax)
movq -0x30(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
leaq -0x18(%rbp), %rsi
callq 0x29ef0
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x430(%rcx), %eax
jae 0x29e3f
movq -0x30(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x2ca20
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x29e09
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x18(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x29e6c
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
xorl %edx, %edx
callq *0x18(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/TranTrace.h
// Function: CasHMC::TranTrace::~TranTrace()
~TranTrace() {
		if(tranFullLat==0 || linkFullLat==0 || vaultFullLat==0) {
			ERROR(" (Trace) == Error - Full latency is '0'  (tranFullLat : "<<tranFullLat
					<<", linkFullLat : "<<linkFullLat<<", vaultFullLat : "<<vaultFullLat<<")");
			exit(0);
		}
		else {
			statis->UpdateStatis(tranFullLat, linkFullLat, vaultFullLat);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x0, 0xc(%rax)
je 0x17bb2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x17bb2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x17cd4
movq 0x4e437(%rip), %rdi     # 0x65ff0
leaq 0x3947a(%rip), %rsi     # 0x5103a
callq 0x4380
movq %rax, -0x18(%rbp)
jmp 0x17bcb
movq -0x18(%rbp), %rdi
leaq 0x3ac90(%rip), %rsi     # 0x52866
callq 0x4380
movq %rax, -0x20(%rbp)
jmp 0x17be1
movq -0x20(%rbp), %rdi
leaq 0x39c49(%rip), %rsi     # 0x51835
callq 0x4380
movq %rax, -0x28(%rbp)
jmp 0x17bf7
movq -0x28(%rbp), %rdi
movl $0x28, %esi
callq 0x4610
movq %rax, -0x30(%rbp)
jmp 0x17c0b
movq -0x30(%rbp), %rdi
leaq 0x39443(%rip), %rsi     # 0x51059
callq 0x4380
movq %rax, -0x38(%rbp)
jmp 0x17c21
movq -0x38(%rbp), %rdi
leaq 0x3ac4e(%rip), %rsi     # 0x5287a
callq 0x4380
movq %rax, -0x40(%rbp)
jmp 0x17c37
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x44c0
movq %rax, -0x48(%rbp)
jmp 0x17c4d
movq -0x48(%rbp), %rdi
leaq 0x3a419(%rip), %rsi     # 0x52071
callq 0x4380
movq %rax, -0x50(%rbp)
jmp 0x17c63
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x14(%rax), %esi
callq 0x44c0
movq %rax, -0x58(%rbp)
jmp 0x17c79
movq -0x58(%rbp), %rdi
leaq 0x3a3fe(%rip), %rsi     # 0x52082
callq 0x4380
movq %rax, -0x60(%rbp)
jmp 0x17c8f
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x44c0
movq %rax, -0x68(%rbp)
jmp 0x17ca5
movq -0x68(%rbp), %rdi
leaq 0x3c6c9(%rip), %rsi     # 0x54379
callq 0x4380
movq %rax, -0x70(%rbp)
jmp 0x17cbb
movq -0x70(%rbp), %rdi
movq 0x4e2ea(%rip), %rsi     # 0x65fb0
callq 0x43c0
jmp 0x17ccd
xorl %edi, %edi
callq 0x4460
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl 0xc(%rax), %esi
movl 0x14(%rax), %edx
movl 0x1c(%rax), %ecx
callq 0x19e50
jmp 0x17ceb
jmp 0x17ced
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x17a70
nopl (%rax,%rax)
// File: estwings57[P]CasHMC/sources/TranStatistic.h
// Function: CasHMC::TranStatistic::~TranStatistic()
virtual ~TranStatistic() {
		tranFullLat.clear();
		linkFullLat.clear();
		vaultFullLat.clear();
		errorRetryLat.clear();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x4d74d(%rip), %rax     # 0x65948
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x17f80
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x17f80
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x17f80
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x17f80
movq -0x10(%rbp), %rdi
addq $0x318, %rdi            # imm = 0x318
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x300, %rdi            # imm = 0x300
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x2d0, %rdi            # imm = 0x2D0
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x270, %rdi            # imm = 0x270
callq 0x18160
movq -0x10(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x228, %rdi            # imm = 0x228
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x210, %rdi            # imm = 0x210
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x178, %rdi            # imm = 0x178
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x110, %rdi            # imm = 0x110
callq 0x18160
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0x18160
movq -0x10(%rbp), %rdi
addq $0xe0, %rdi
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0xc8, %rdi
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0xb0, %rdi
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x80, %rdi
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x178f0
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x18160
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x18160
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x18160
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x18160
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/TranStatistic.h
// Function: CasHMC::TranStatistic::UpdateStatis(unsigned int, unsigned int, unsigned int)
void UpdateStatis(unsigned tranFull, unsigned linkFull, unsigned vaultFull) {
		tranFullLat.push_back(tranFull);
		linkFullLat.push_back(linkFull);
		vaultFullLat.push_back(vaultFull);
		
		tranFullSum += tranFull;
		linkFullSum += linkFull;
		vaultFullSum += vaultFull;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x8, %rdi
leaq -0xc(%rbp), %rsi
callq 0x19ee0
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x19ee0
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
leaq -0x14(%rbp), %rsi
callq 0x19ee0
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
addq 0x190(%rax), %rcx
movq %rcx, 0x190(%rax)
movl -0x10(%rbp), %ecx
addq 0x198(%rax), %rcx
movq %rcx, 0x198(%rax)
movl -0x14(%rbp), %ecx
addq 0x1a0(%rax), %rcx
movq %rcx, 0x1a0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/CommandQueue.cpp
// Function: CasHMC::CommandQueue::~CommandQueue()
CommandQueue::~CommandQueue()
{
	for(int b=0; b<NUM_BANKS; b++) {
		ACCESSQUE(b).clear();
		if(!QUE_PER_BANK)	break;
	}
	atomicLock.clear();
	atomicLockTag.clear();
	bufPopDelayPerBank.clear();
	queue.clear();
	tFAWCountdown.clear();
	rowAccessCounter.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x48ded(%rip), %rcx     # 0x65968
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x49a8d(%rip), %rcx     # 0x66620
cmpl (%rcx), %eax
jge 0x1cc00
leaq 0x49a92(%rip), %rax     # 0x66630
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1cbc4
movq -0x18(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
movslq -0xc(%rbp), %rsi
callq 0x22650
movq %rax, -0x20(%rbp)
jmp 0x1cbdc
movq -0x18(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
xorl %eax, %eax
movl %eax, %esi
callq 0x22650
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x22770
leaq 0x49a44(%rip), %rax     # 0x66630
testb $0x1, (%rax)
jne 0x1cbf3
jmp 0x1cc00
jmp 0x1cbf5
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1cb89
movq -0x18(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x22790
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x17f80
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x227e0
movq -0x18(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0x22800
movq -0x18(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x17f80
movq -0x18(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0x17f80
movq -0x18(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0x18160
movq -0x18(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x18160
movq -0x18(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
callq 0x22570
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x22400
movq -0x18(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x18160
movq -0x18(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x221f0
movq -0x18(%rbp), %rdi
callq 0x22e30
addq $0x20, %rsp
popq %rbp
retq
nop
// File: estwings57[P]CasHMC/sources/CommandQueue.cpp
// Function: CasHMC::CommandQueue::AvailableSpace(unsigned int, unsigned int)
bool CommandQueue::AvailableSpace(unsigned bank, unsigned cmdN)
{
	if(atomicLock[bank]) {
		cmdN += 1;
	}
		
	if(ACCESSQUE(bank).size()+cmdN <= MAX_CMD_QUE) {
		return true;
	}
	else {
/*		if(QUE_PER_BANK) {
			classID.str( string() );	classID.clear();
			classID << bank;
			DEBUG(ALI(39)<<(header+"-"+classID.str()+")")<<"Down) Command queue FULL");
		}
		else {
			DEBUG(ALI(39)<<(header+")")<<"Down) Command queue FULL");
		}*/
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x1e0, %rdi            # imm = 0x1E0
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x22820
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x22880
testb $0x1, %al
jne 0x1cd42
jmp 0x1cd4b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
leaq 0x498de(%rip), %rax     # 0x66630
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1cd79
movq -0x30(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x22650
movq %rax, -0x38(%rbp)
jmp 0x1cd91
movq -0x30(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
xorl %eax, %eax
movl %eax, %esi
callq 0x22650
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x228b0
movl -0x18(%rbp), %ecx
addq %rcx, %rax
leaq 0x497c1(%rip), %rcx     # 0x66568
movslq (%rcx), %rcx
cmpq %rcx, %rax
ja 0x1cdb5
movb $0x1, -0x1(%rbp)
jmp 0x1cdb9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: estwings57[P]CasHMC/sources/CommandQueue.cpp
// Function: CasHMC::CommandQueue::isEmpty()
bool CommandQueue::isEmpty()
{
	for(int b=0; b<NUM_BANKS; b++) {
		if(!ACCESSQUE(b).empty()) {
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
leaq 0x44e3b(%rip), %rcx     # 0x66620
cmpl (%rcx), %eax
jge 0x2184e
leaq 0x44e40(%rip), %rax     # 0x66630
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x21816
movq -0x20(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
movslq -0x14(%rbp), %rsi
callq 0x22650
movq %rax, -0x28(%rbp)
jmp 0x2182e
movq -0x20(%rbp), %rdi
addq $0x238, %rdi            # imm = 0x238
xorl %eax, %eax
movl %eax, %esi
callq 0x22650
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x22d80
testb $0x1, %al
jne 0x21841
movb $0x0, -0x1(%rbp)
jmp 0x21852
jmp 0x21843
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x217db
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/CommandQueue.cpp
// Function: CasHMC::CommandQueue::Update()
void CommandQueue::Update()
{
	for(int b=0; b<NUM_BANKS; b++){
		POPCYCLE(b) = (POPCYCLE(b)>0) ? POPCYCLE(b)-1 : 0;
		if(!QUE_PER_BANK)	break;	
	}

	Step();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x44d9b(%rip), %rcx     # 0x66620
cmpl (%rcx), %eax
jge 0x219a7
leaq 0x44d9c(%rip), %rax     # 0x66630
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x218bb
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
movslq -0xc(%rbp), %rsi
callq 0x229a0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x218d4
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
xorl %eax, %eax
movl %eax, %esi
callq 0x229a0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl $0x0, %eax
jle 0x2192e
leaq 0x44d4d(%rip), %rax     # 0x66630
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2190a
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
movslq -0xc(%rbp), %rsi
callq 0x229a0
movl (%rax), %eax
movl %eax, -0x20(%rbp)
jmp 0x21923
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
xorl %eax, %eax
movl %eax, %esi
callq 0x229a0
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x21935
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x21935
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
leaq 0x44cee(%rip), %rax     # 0x66630
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x21968
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
movslq -0xc(%rbp), %rsi
callq 0x229a0
movq %rax, -0x30(%rbp)
jmp 0x21980
movq -0x18(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
xorl %eax, %eax
movl %eax, %esi
callq 0x229a0
movq %rax, -0x30(%rbp)
movl -0x28(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
leaq 0x44ca0(%rip), %rax     # 0x66630
testb $0x1, (%rax)
jne 0x21997
jmp 0x219a7
jmp 0x21999
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2187b
movq -0x18(%rbp), %rdi
callq 0x22dc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: estwings57[P]CasHMC/sources/CrossbarSwitch.cpp
// Function: CasHMC::CrossbarSwitch::CrossbarSwitch(std::basic_ofstream<char, std::char_traits<char>>&, std::basic_ofstream<char, std::char_traits<char>>&)
CrossbarSwitch::CrossbarSwitch(ofstream &debugOut_, ofstream &stateOut_):
	DualVectorObject<Packet, Packet>(debugOut_, stateOut_, MAX_CROSS_BUF, MAX_CROSS_BUF)
{
	header = "        (CS)";
	
	inServiceLink = -1;

	downBufferDest = vector<DualVectorObject<Packet, Packet> *>(NUM_VAULTS, NULL);
	upBufferDest = vector<LinkMaster *>(NUM_LINKS, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x3f1c6(%rip), %rax     # 0x66564
movl (%rax), %r8d
movl %r8d, %ecx
callq 0x29490
movq -0x80(%rbp), %rdi
leaq 0x3e63c(%rip), %rax     # 0x659f0
movq %rax, (%rdi)
addq $0x208, %rdi            # imm = 0x208
movq %rdi, -0xa0(%rbp)
callq 0x29580
movq -0x80(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
movq %rdi, -0x98(%rbp)
callq 0x295a0
movq -0x80(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
movq %rdi, -0x90(%rbp)
callq 0x18070
movq -0x80(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
movq %rdi, -0x88(%rbp)
callq 0x295c0
movq -0x80(%rbp), %rdi
addq $0x20, %rdi
leaq 0x2b9ab(%rip), %rsi     # 0x52dc9
callq 0x44e0
jmp 0x27425
movq -0x80(%rbp), %rax
movl $0xffffffff, 0x238(%rax) # imm = 0xFFFFFFFF
leaq 0x3f1e2(%rip), %rax     # 0x6661c
movslq (%rax), %rax
movq %rax, -0xb0(%rbp)
movq $0x0, -0x48(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x295e0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rcx
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rdx
callq 0x29600
jmp 0x27479
movq -0x80(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
leaq -0x40(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
callq 0x29680
movq -0xc8(%rbp), %rdi
callq 0x296b0
leaq -0x49(%rbp), %rdi
callq 0x29710
leaq 0x3f098(%rip), %rax     # 0x66548
movslq (%rax), %rax
movq %rax, -0xc0(%rbp)
movq $0x0, -0x70(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x29730
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rcx
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x29750
jmp 0x274ef
movq -0x80(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
leaq -0x68(%rbp), %rsi
callq 0x297d0
leaq -0x68(%rbp), %rdi
callq 0x29800
leaq -0x71(%rbp), %rdi
callq 0x29860
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x27558
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x29710
jmp 0x27558
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x71(%rbp), %rdi
callq 0x29860
movq -0x88(%rbp), %rdi
callq 0x29880
movq -0x90(%rbp), %rdi
callq 0x18160
movq -0x98(%rbp), %rdi
callq 0x29800
movq -0xa0(%rbp), %rdi
callq 0x296b0
movq -0x80(%rbp), %rdi
callq 0x2a2f0
movq -0x20(%rbp), %rdi
callq 0x4630
nopw (%rax,%rax)
// File: estwings57[P]CasHMC/sources/CrossbarSwitch.cpp
// Function: CasHMC::CrossbarSwitch::~CrossbarSwitch()
CrossbarSwitch::~CrossbarSwitch()
{	
	downBufferDest.clear();
	upBufferDest.clear();
	pendingSegTag.clear(); 
	pendingSegPacket.clear(); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
leaq 0x3e425(%rip), %rax     # 0x659e0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x208, %rdi            # imm = 0x208
callq 0x298e0
movq -0x10(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x29900
movq -0x10(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x17f80
movq -0x10(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0x29920
movq -0x10(%rbp), %rdi
addq $0x258, %rdi            # imm = 0x258
callq 0x29880
movq -0x10(%rbp), %rdi
addq $0x240, %rdi            # imm = 0x240
callq 0x18160
movq -0x10(%rbp), %rdi
addq $0x220, %rdi            # imm = 0x220
callq 0x29800
movq -0x10(%rbp), %rdi
addq $0x208, %rdi            # imm = 0x208
callq 0x296b0
movq -0x10(%rbp), %rdi
callq 0x2a2f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/ConfigValue.h
// Function: CasHMC::_log2(unsigned int)
unsigned inline _log2(unsigned value)
{
	unsigned logbase2 = 0;
	unsigned orig = value;
	value >>= 1;
	while(value > 0)
	{
		value >>= 1;
		logbase2++;
	}
	if(1<<logbase2 < orig)	logbase2++;
	return logbase2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jbe 0x29d15
movl -0x4(%rbp), %eax
shrl %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x29cfc
movl -0x8(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
cmpl -0xc(%rbp), %eax
jae 0x29d2d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: estwings57[P]CasHMC/sources/SingleVectorObject.h
// Function: CasHMC::SingleVectorObject<CasHMC::Packet>::Receive(CasHMC::Packet*)
bool Receive(BufT *ele) {
		if(Buffers.size() + ele->LNG <= bufferMax) {
			Buffers.push_back(ele);
			//If receiving packet is packet, add virtual tail packet in Buffers as long as packet length
			if(sizeof(*ele) == sizeof(Packet)) {
				for(int i=1; i<ele->LNG; i++) {
					Buffers.push_back(NULL);
				}
			}
			CallbackReceive(ele, true);
			return true;
		}
		else {
			CallbackReceive(ele, 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 $0x1d0, %rdi            # imm = 0x1D0
callq 0x22d60
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl 0x430(%rdx), %edx
addq %rdx, %rax
movslq 0x1c8(%rcx), %rcx
cmpq %rcx, %rax
ja 0x2a00b
movq -0x30(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
leaq -0x18(%rbp), %rsi
callq 0x29ef0
movl $0x1, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x430(%rcx), %eax
jae 0x29ff2
movq -0x30(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x2ca20
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x29fbc
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
movl $0x1, %edx
callq *0x18(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2a01f
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
xorl %edx, %edx
callq *0x18(%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/DRAM.cpp
// Function: CasHMC::DRAM::~DRAM()
DRAM::~DRAM()
{
	for(int i=0; i<readReturnDATA.size(); i++) {
		delete readReturnDATA[i];
	}
	readReturnDATA.clear();
	readReturnCountdown.clear();
	
	for(int b=0; b<NUM_BANKS; b++) {
		delete bankStates[b];
	}
	bankStates.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x38ad5(%rip), %rcx     # 0x65a80
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x218, %rdi            # imm = 0x218
callq 0x228b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x2d015
movq -0x18(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
movslq -0xc(%rbp), %rsi
callq 0x22ae0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2d008
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2d00a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2cfb9
movq -0x18(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
callq 0x22770
movq -0x18(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0x17f80
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
leaq 0x395da(%rip), %rcx     # 0x66620
cmpl (%rcx), %eax
jge 0x2d086
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0x10(%rbp), %rsi
callq 0x22c30
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2d079
movq -0x30(%rbp), %rdi
movl $0x40, %esi
callq 0x43a0
jmp 0x2d07b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2d03c
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x2f940
movq -0x18(%rbp), %rdi
addq $0x230, %rdi            # imm = 0x230
callq 0x18160
movq -0x18(%rbp), %rdi
addq $0x218, %rdi            # imm = 0x218
callq 0x225f0
movq -0x18(%rbp), %rdi
addq $0x1f0, %rdi            # imm = 0x1F0
callq 0x2f860
movq -0x18(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x2f8e0
movq -0x18(%rbp), %rdi
callq 0x22e30
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: estwings57[P]CasHMC/sources/DRAM.cpp
// Function: CasHMC::DRAM::powerDown()
bool DRAM::powerDown()
{
	//check to make sure all banks are idle
	bool allIdle = true;
	for(int b=0; b<NUM_BANKS; b++) {
		if(bankStates[b]->currentBankState != IDLE) {
			allIdle = false;
			break;
		}
	}
	if(allIdle) {
		for(int b=0; b<NUM_BANKS; b++) {
			bankStates[b]->currentBankState = POWERDOWN;
			bankStates[b]->nextPowerUp = currentClockCycle + tCKE;
		}
		return true;
	}
	else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x1, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
leaq 0x377e7(%rip), %rcx     # 0x66620
cmpl (%rcx), %eax
jge 0x2ee6d
movq -0x28(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0x18(%rbp), %rsi
callq 0x22c30
movq (%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x2ee60
movb $0x0, -0x11(%rbp)
jmp 0x2ee6d
jmp 0x2ee62
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2ee2f
testb $0x1, -0x11(%rbp)
je 0x2eeea
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
leaq 0x3779c(%rip), %rcx     # 0x66620
cmpl (%rcx), %eax
jge 0x2eee4
movq -0x28(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0x1c(%rbp), %rsi
callq 0x22c30
movq -0x28(%rbp), %rdi
movq (%rax), %rax
movl $0x4, 0x4(%rax)
movq 0x8(%rdi), %rax
leaq 0x377cf(%rip), %rcx     # 0x66684
movl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0x1c(%rbp), %rsi
callq 0x22c30
movq -0x30(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x30(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2ee7a
movb $0x1, -0x1(%rbp)
jmp 0x2eeee
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: estwings57[P]CasHMC/sources/DRAM.cpp
// Function: CasHMC::DRAM::powerUp()
void DRAM::powerUp()
{
	for(int b=0; b<NUM_BANKS; b++) {
		bankStates[b]->lastCommand = POWERDOWN_EXIT;
		bankStates[b]->currentBankState = AWAKING;
		bankStates[b]->stateChangeCountdown = tXP;
		bankStates[b]->nextActivate = currentClockCycle + tXP;
	}
	DEBUG(ALI(39)<<header<<"AWAKE DRAM power down mode   nextActivate time : "<<bankStates[0]->nextActivate);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
leaq 0x376fb(%rip), %rcx     # 0x66620
cmpl (%rcx), %eax
jge 0x2efd3
movq -0x20(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movl $0xa, 0x38(%rax)
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movl $0x5, 0x4(%rax)
leaq 0x37714(%rip), %rax     # 0x66688
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movl %ecx, 0x3c(%rax)
movq 0x8(%rdi), %rax
leaq 0x376e7(%rip), %rcx     # 0x66688
movl (%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
addq $0x1d8, %rdi            # imm = 0x1D8
movslq -0xc(%rbp), %rsi
callq 0x22c30
movq -0x28(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ef1b
leaq 0x3754e(%rip), %rax     # 0x66528
testb $0x1, (%rax)
je 0x2f083
leaq 0x3753f(%rip), %rax     # 0x66529
testb $0x1, (%rax)
jne 0x2f083
movl $0x27, %edi
callq 0x177b0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %esi
movq 0x36fc6(%rip), %rdi     # 0x65fd0
callq 0x4440
movq %rax, -0x40(%rbp)
movl $0x20, %edi
callq 0x177d0
movq -0x40(%rbp), %rdi
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %esi
callq 0x4550
movq -0x20(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x4320
movq %rax, %rdi
leaq 0x24067(%rip), %rsi     # 0x530ae
callq 0x4380
movq -0x20(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x1d8, %rdi            # imm = 0x1D8
xorl %eax, %eax
movl %eax, %esi
callq 0x22c30
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq 0x10(%rax), %rsi
callq 0x40f0
movq %rax, %rdi
movq 0x36f32(%rip), %rsi     # 0x65fb0
callq 0x43c0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)