LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::calculateCRC32(unsigned char const*, unsigned short)
uint32_t RscpProtocol::calculateCRC32(const uint8_t *data, uint16_t length) {
    static const uint32_t crc_table[] = {
      0x4DBDF21C, 0x500AE278, 0x76D3D2D4, 0x6B64C2B0,
      0x3B61B38C, 0x26D6A3E8, 0x000F9344, 0x1DB88320,
      0xA005713C, 0xBDB26158, 0x9B6B51F4, 0x86DC4190,
      0xD6D930AC, 0xCB6E20C8, 0xEDB71064, 0xF0000000
    };
	uint32_t crc = 0;
    for(uint32_t n = 0; n < length; n++) {
        crc = (crc >> 4) ^ crc_table[(crc ^ (data[n] >> 0)) & 0x0F];  /* lower nibble */
        crc = (crc >> 4) ^ crc_table[(crc ^ (data[n] >> 4)) & 0x0F];  /* upper nibble */
	}
	return crc;
}

// Assembly:
movw %dx, %ax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movw %ax, -0x12(%rsp)
movl $0x0, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movzwl -0x12(%rsp), %ecx
cmpl %ecx, %eax
jae 0x79b0
movl -0x18(%rsp), %eax
shrl $0x4, %eax
movl -0x18(%rsp), %ecx
movq -0x10(%rsp), %rdx
movl -0x1c(%rsp), %esi
movzbl (%rdx,%rsi), %edx
sarl $0x0, %edx
xorl %edx, %ecx
andl $0xf, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x18fb6(%rip), %rcx     # 0x20920
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
shrl $0x4, %eax
movl -0x18(%rsp), %ecx
movq -0x10(%rsp), %rdx
movl -0x1c(%rsp), %esi
movzbl (%rdx,%rsi), %edx
sarl $0x4, %edx
xorl %edx, %ecx
andl $0xf, %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x18f84(%rip), %rcx     # 0x20920
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x7932
movl -0x18(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::getFrameLength(unsigned char const*, unsigned int const&)
int32_t RscpProtocol::getFrameLength(const uint8_t * data, const uint32_t & length) {
	// validate input
	if(data == NULL) {
		return RSCP::ERR_INVALID_INPUT;
	}
	// first the length must at least be of the header size
	if(length < sizeof(SRscpFrameHeader)) {
		return RSCP::ERR_INVALID_FRAME_LENGTH;
	}
	// check the header information for length
	SRscpFrameHeader *header = reinterpret_cast<SRscpFrameHeader *> ((uint8_t*)data);

	if(header->magic != RSCP::MAGIC) {
		return RSCP::ERR_INVALID_MAGIC;
	}
	// check the frame version number
	if(header->ctrl.bits.version != RSCP::VERSION) {
		return RSCP::ERR_PROT_VERSION_MISMATCH;
	}
	// calculate the expected frame length
	int32_t frameLength = sizeof(SRscpFrameHeader) + header->dataLength + ((header->ctrl.bits.crc != 0) ? sizeof(uint32_t) : 0);
	return frameLength;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x79e4
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x7a82
movq -0x20(%rsp), %rax
movl (%rax), %eax
cmpq $0x12, %rax
jae 0x79fe
movl $0xfffffffb, -0x4(%rsp) # imm = 0xFFFFFFFB
jmp 0x7a82
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movzwl (%rax), %eax
cmpl $0xdce3, %eax           # imm = 0xDCE3
je 0x7a21
movl $0xfffffffd, -0x4(%rsp) # imm = 0xFFFFFFFD
jmp 0x7a82
movq -0x28(%rsp), %rax
movw 0x2(%rax), %ax
shrw $0x8, %ax
andw $0xf, %ax
movzbl %al, %eax
cmpl $0x1, %eax
je 0x7a44
movl $0xfffffffc, -0x4(%rsp) # imm = 0xFFFFFFFC
jmp 0x7a82
movq -0x28(%rsp), %rax
movzwl 0x10(%rax), %eax
addq $0x12, %rax
movq -0x28(%rsp), %rcx
movw 0x2(%rcx), %cx
shrw $0xc, %cx
andw $0x1, %cx
movzbl %cl, %esi
xorl %ecx, %ecx
movl $0x4, %edx
cmpl $0x0, %esi
cmovneq %rdx, %rcx
addq %rcx, %rax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::createFrame(SRscpFrame*, std::vector<SRscpValue, std::allocator<SRscpValue>> const&, bool)
int32_t RscpProtocol::createFrame(SRscpFrame* frame, const std::vector<SRscpValue> & data, bool calcCRC) {
	if(frame == NULL) {
		return RSCP::ERR_INVALID_INPUT;
	}

	// set frame edge values
	memset(&frame->header, 0, sizeof(frame->header));
	frame->header.magic = RSCP::MAGIC;
	frame->header.ctrl.bits.crc = calcCRC;
	frame->header.ctrl.bits.version = RSCP::VERSION;
	setHeaderTimestamp(frame);
	frame->data = data;

	// calculate the data length
	for(size_t i = 0; i < data.size(); ++i) {
		frame->header.dataLength += sizeof(SRscpValue) - sizeof(data[i].data) + data[i].length;
	}

	// in case the CRC has to be calculated we need to generate a new frame buffer which then calculates the CRC
	if(calcCRC) {
		SRscpFrameBuffer frameBuffer;
		int32_t iResult = createFrameAsBuffer(&frameBuffer, *frame, calcCRC);
		if(iResult != RSCP::OK) {
			return iResult;
		}
		// get the CRC from the frame buffer
		memcpy(&frame->CRC, &frameBuffer.data + frameBuffer.dataLength - sizeof(frame->CRC), sizeof(frame->CRC));
		// free the buffer data again
		destroyFrameData(frameBuffer);
	}
	return RSCP::OK;
}

// Assembly:
subq $0x58, %rsp
movb %cl, %al
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x848a
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x85c9
movq 0x40(%rsp), %rdi
xorl %esi, %esi
movl $0x12, %edx
callq 0x20e0
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rax
movw $0xdce3, (%rax)         # imm = 0xDCE3
movb 0x37(%rsp), %cl
andb $0x1, %cl
movq 0x40(%rsp), %rax
movzbl %cl, %ecx
movw %cx, %dx
movw 0x2(%rax), %cx
andw $0x1, %dx
shlw $0xc, %dx
andw $0xefff, %cx            # imm = 0xEFFF
orw %dx, %cx
movw %cx, 0x2(%rax)
movq 0x40(%rsp), %rax
movw 0x2(%rax), %cx
andw $0xf0ff, %cx            # imm = 0xF0FF
orw $0x100, %cx             # imm = 0x100
movw %cx, 0x2(%rax)
movq 0x40(%rsp), %rsi
callq 0x78a0
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
callq 0x95f0
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
callq 0x5e80
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x8569
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x95d0
movzwl 0x5(%rax), %eax
movl %eax, %edx
addq $0x7, %rdx
movq 0x40(%rsp), %rax
movzwl 0x10(%rax), %ecx
addq %rdx, %rcx
movw %cx, 0x10(%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x8511
testb $0x1, 0x37(%rsp)
je 0x85c1
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rdx
movb 0x37(%rsp), %al
leaq 0x18(%rsp), %rsi
andb $0x1, %al
movzbl %al, %ecx
callq 0x8090
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x85a2
movl 0x14(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x85c9
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rax
movl 0x20(%rsp), %ecx
movl -0x8(%rsp,%rcx,8), %ecx
movl %ecx, 0x30(%rax)
leaq 0x18(%rsp), %rsi
callq 0x98b0
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::allocateMemory(SRscpValue*, unsigned long)
bool RscpProtocol::allocateMemory(SRscpValue* value, size_t size)  {
	// sanity check
	if(value == NULL) {
		return false;
	}
	// if no data is allocated yet -> allocate full size
	if(value->data == NULL) {
		if(size == 0) {
			return true;
		}
		value->data = (uint8_t *) malloc(size);
		return (value->data != NULL);
	}
	else {
		// if data is already allocated -> reallocate to the correct size
		uint8_t *ucTmp = (uint8_t *) realloc(value->data, size);
		if(ucTmp != NULL) {
			value->data = ucTmp;
			return true;
		}
	}
	return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x8602
movb $0x0, 0x27(%rsp)
jmp 0x8681
movq 0x10(%rsp), %rax
cmpq $0x0, 0x7(%rax)
jne 0x8648
cmpq $0x0, 0x8(%rsp)
jne 0x861d
movb $0x1, 0x27(%rsp)
jmp 0x8681
movq 0x8(%rsp), %rdi
callq 0x21d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x7(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x7(%rax)
setne %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x8681
movq 0x10(%rsp), %rax
movq 0x7(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x2280
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x867a
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x7(%rax)
movb $0x1, 0x27(%rsp)
jmp 0x8681
jmp 0x867c
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::parseData(unsigned char const*, unsigned int const&, std::vector<SRscpValue, std::allocator<SRscpValue>>&)
int32_t RscpProtocol::parseData(const uint8_t* data, const uint32_t & length, std::vector<SRscpValue> & vecValues) {
	// sanity check
	if(data == NULL) {
		return RSCP::ERR_INVALID_INPUT;
	}
	// start parsing
	uint32_t uiPos = 0;
	SRscpValue * value = reinterpret_cast<SRscpValue *>(((uint8_t*)data) + uiPos);

	// check the boundaries of the buffer
	while((uiPos < length) && ((uiPos + value->length) <= length)) {
		// parse the data
		SRscpValue newVal;
		newVal.tag = value->tag;
		newVal.dataType = value->dataType;
		newVal.length = value->length;
		if(value->length > 0) {
			// allocate data memory for each value separately
			newVal.data = (uint8_t *) malloc(value->length);
			if(newVal.data == NULL) {
				// not enough memory, return only what parsed until now
				destroyValueData(vecValues);
				return RSCP::ERR_NO_MEMORY;
			}
			memcpy(newVal.data, &value->data, value->length);
		}
		else {
			// set NULL pointer as no data is in this tag
			newVal.data = NULL;
		}
		//push new value to the return vector
		vecValues.push_back(newVal);
		// increment value pointer
		uiPos += sizeof(SRscpValue) - sizeof(newVal.data) + value->length;
		value =  reinterpret_cast<SRscpValue *>(((uint8_t*)data) + uiPos);
	}

	// return all collected values
	return uiPos;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x88e7
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x8a16
movl $0x0, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movl 0x2c(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movl 0x2c(%rsp), %ecx
movq 0x38(%rsp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
jae 0x8930
movl 0x2c(%rsp), %eax
movq 0x20(%rsp), %rcx
movzwl 0x5(%rcx), %ecx
addl %ecx, %eax
movq 0x38(%rsp), %rcx
cmpl (%rcx), %eax
setbe %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x893d
jmp 0x8a0e
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x11(%rsp)
movq 0x20(%rsp), %rax
movb 0x4(%rax), %al
movb %al, 0x15(%rsp)
movq 0x20(%rsp), %rax
movw 0x5(%rax), %ax
movw %ax, 0x16(%rsp)
movq 0x20(%rsp), %rax
movzwl 0x5(%rax), %eax
cmpl $0x0, %eax
jle 0x89c6
movq 0x20(%rsp), %rax
movzwl 0x5(%rax), %eax
movl %eax, %edi
callq 0x21d0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x89a6
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x8a20
movl $0xfffffffe, 0x54(%rsp) # imm = 0xFFFFFFFE
jmp 0x8a16
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x7, %rsi
movq 0x20(%rsp), %rax
movzwl 0x5(%rax), %eax
movl %eax, %edx
callq 0x2130
jmp 0x89cf
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x11(%rsp), %rsi
callq 0x98e0
movq 0x20(%rsp), %rax
movzwl 0x5(%rax), %eax
movl %eax, %ecx
addq $0x7, %rcx
movl 0x2c(%rsp), %eax
addq %rcx, %rax
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rax
movl 0x2c(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x8900
movl 0x2c(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nop
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::destroyValueData(std::vector<SRscpValue, std::allocator<SRscpValue>>&)
int32_t RscpProtocol::destroyValueData(std::vector<SRscpValue> & value) {
	for(size_t i = 0; i < value.size(); ++i) {
		destroyValueData(value[i]);
	}
	value.clear();
	return RSCP::OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x5e80
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x8a8c
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x5ea0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x5cc0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x8a41
movq 0x18(%rsp), %rdi
callq 0x9950
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::getValueAsString[abi:cxx11](SRscpValue const*)
std::string RscpProtocol::getValueAsString(const SRscpValue* value) {
	// sanity check
	std::string strValue;
	if((value == NULL) || (value->data == NULL)) {
		return strValue;
	}
	// extract only the bytes that are defined by the length
	strValue.assign((char*)value->data, value->length);
	return strValue;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
callq 0x2200
cmpq $0x0, 0x30(%rsp)
je 0x8ade
movq 0x30(%rsp), %rax
cmpq $0x0, 0x7(%rax)
jne 0x8aed
movb $0x1, 0x2f(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0x8b31
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x7(%rax), %rsi
movzwl 0x5(%rax), %eax
movl %eax, %edx
callq 0x21e0
jmp 0x8b08
movb $0x1, 0x2f(%rsp)
movl $0x1, 0x28(%rsp)
jmp 0x8b31
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x20f0
jmp 0x8b4c
testb $0x1, 0x2f(%rsp)
jne 0x8b42
movq 0x8(%rsp), %rdi
callq 0x20f0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::createValue(SRscpValue*, unsigned int const&, unsigned char const*, unsigned short const&, unsigned char const&)
int32_t RscpProtocol::createValue(SRscpValue* response, const SRscpTag & tag, const uint8_t * data, const uint16_t & dataLength, const uint8_t &dataType) {
	// sanity check
	if(response == NULL) {
		return RSCP::ERR_INVALID_INPUT;
	}
	// reset the memory of the response value to zero
	memset(response, 0, sizeof(SRscpValue));
	// calculate the new tag size
	uint16_t newTagLength = dataLength;
	// check boundaries
	if(newTagLength > 0xFFF8) {
		return RSCP::ERR_DATA_LIMIT_EXCEEDED;
	}
	// re-allocate the structure memory
	if(allocateMemory(response, newTagLength) == false) {
		return RSCP::ERR_NO_MEMORY;
	}
	// copy data
	response->tag = tag;
	response->dataType = dataType;
	response->length = dataLength;
	// copy into the position of the data pointer
	if(response->length > 0) {
		memcpy(response->data, data, dataLength);
	}
	return RSCP::OK;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq %r9, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x8ba0
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x8c61
movq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0xf, %edx
callq 0x20e0
movq 0x18(%rsp), %rax
movw (%rax), %ax
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
cmpl $0xfff8, %eax           # imm = 0xFFF8
jle 0x8bd7
movl $0xfffffff9, 0x44(%rsp) # imm = 0xFFFFFFF9
jmp 0x8c61
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
movzwl 0xe(%rsp), %eax
movl %eax, %edx
callq 0x85e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8c00
movl $0xfffffffe, 0x44(%rsp) # imm = 0xFFFFFFFE
jmp 0x8c61
movq 0x28(%rsp), %rax
movl (%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movb (%rax), %cl
movq 0x30(%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x18(%rsp), %rax
movw (%rax), %cx
movq 0x30(%rsp), %rax
movw %cx, 0x5(%rax)
movq 0x30(%rsp), %rax
movzwl 0x5(%rax), %eax
cmpl $0x0, %eax
jle 0x8c59
movq 0x30(%rsp), %rax
movq 0x7(%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movzwl (%rax), %eax
movl %eax, %edx
callq 0x2130
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::appendValue(SRscpValue*, unsigned int const&, unsigned char const*, unsigned short const&, unsigned char const&)
int32_t RscpProtocol::appendValue(SRscpValue* response, const SRscpTag & tag, const uint8_t * data, const uint16_t & dataLength, const uint8_t &dataType) {
	// sanity check
	if(response == NULL) {
		return RSCP::ERR_INVALID_INPUT;
	}
	// calculate the new tag size
	uint16_t newTagLength = sizeof(SRscpValue) - sizeof(response->data) + dataLength;
	// check boundaries
	if(response->length + newTagLength > 0xFFF8) {
		return RSCP::ERR_DATA_LIMIT_EXCEEDED;
	}
	// re-allocate the structure memory
	if(allocateMemory(response, response->length + newTagLength) == false) {
		return RSCP::ERR_NO_MEMORY;
	}
	// copy data
	SRscpValue *newData = reinterpret_cast<SRscpValue *>(response->data + response->length);
	newData->tag = tag;
	newData->dataType = dataType;
	newData->length = dataLength;
	// copy into the position of the data pointer and not into the data pointer itself as the data is appended
	if(newData->length > 0) {
		memcpy(&newData->data, data, dataLength);
	}
	// increment the total length by the new tag
	response->length += newTagLength;
	return RSCP::OK;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x40(%rsp)
jne 0x8ef1
movl $0xffffffff, 0x54(%rsp) # imm = 0xFFFFFFFF
jmp 0x8ff1
movq 0x28(%rsp), %rax
movzwl (%rax), %eax
addq $0x7, %rax
movw %ax, 0x1e(%rsp)
movq 0x40(%rsp), %rax
movzwl 0x5(%rax), %eax
movzwl 0x1e(%rsp), %ecx
addl %ecx, %eax
cmpl $0xfff8, %eax           # imm = 0xFFF8
jle 0x8f26
movl $0xfffffff9, 0x54(%rsp) # imm = 0xFFFFFFF9
jmp 0x8ff1
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x40(%rsp), %rax
movzwl 0x5(%rax), %eax
movzwl 0x1e(%rsp), %ecx
addl %ecx, %eax
movslq %eax, %rdx
callq 0x85e0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8f5f
movl $0xfffffffe, 0x54(%rsp) # imm = 0xFFFFFFFE
jmp 0x8ff1
movq 0x40(%rsp), %rax
movq 0x7(%rax), %rax
movq 0x40(%rsp), %rcx
movzwl 0x5(%rcx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movb (%rax), %cl
movq 0x10(%rsp), %rax
movb %cl, 0x4(%rax)
movq 0x28(%rsp), %rax
movw (%rax), %cx
movq 0x10(%rsp), %rax
movw %cx, 0x5(%rax)
movq 0x10(%rsp), %rax
movzwl 0x5(%rax), %eax
cmpl $0x0, %eax
jle 0x8fd5
movq 0x10(%rsp), %rdi
addq $0x7, %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rax
movzwl (%rax), %eax
movl %eax, %edx
callq 0x2130
movzwl 0x1e(%rsp), %edx
movq 0x40(%rsp), %rax
movzwl 0x5(%rax), %ecx
addl %edx, %ecx
movw %cx, 0x5(%rax)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::destroyValueData(SRscpValue*)
int32_t RscpProtocol::destroyValueData(SRscpValue * value) {
	if(value == NULL) {
		return RSCP::ERR_INVALID_INPUT;
	}
	if(value->data != NULL) {
		free(value->data);
		value->data = NULL;
	}
	return RSCP::OK;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x94ee
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x951a
movq (%rsp), %rax
cmpq $0x0, 0x7(%rax)
je 0x9512
movq (%rsp), %rax
movq 0x7(%rax), %rdi
callq 0x21c0
movq (%rsp), %rax
movq $0x0, 0x7(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: rellla[P]E3DC-Rscp/RscpProtocol.cpp
// Function: RscpProtocol::destroyFrameData(SRscpFrameBuffer*)
int32_t RscpProtocol::destroyFrameData(SRscpFrameBuffer * frameBuffer) {
	if(frameBuffer == NULL) {
		return RSCP::ERR_INVALID_INPUT;
	}
	if(frameBuffer->data != NULL) {
		free(frameBuffer->data);
		frameBuffer->data = NULL;
	}
	return RSCP::OK;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x959e
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x95c7
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x95bf
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x21c0
movq (%rsp), %rax
movq $0x0, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: (anonymous namespace)::SubByte(unsigned long)
unsigned long SubByte(unsigned long data)
	{ // does the SBox on this 4 byte data
	unsigned result = 0;
	result = byte_sub[data>>24];
	result <<= 8;
	result |= byte_sub[(data>>16)&255];
	result <<= 8;
	result |= byte_sub[(data>>8)&255];
	result <<= 8;
	result |= byte_sub[data&255];
	return result;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rcx
shrq $0x18, %rcx
leaq 0x21e43(%rip), %rax     # 0x2c900
movzbl (%rax,%rcx), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
shll $0x8, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rcx
shrq $0x10, %rcx
andq $0xff, %rcx
leaq 0x21e19(%rip), %rax     # 0x2c900
movzbl (%rax,%rcx), %eax
orl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
shll $0x8, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rcx
shrq $0x8, %rcx
andq $0xff, %rcx
leaq 0x21deb(%rip), %rax     # 0x2c900
movzbl (%rax,%rcx), %eax
orl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
shll $0x8, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rcx
andq $0xff, %rcx
leaq 0x21dc1(%rip), %rax     # 0x2c900
movzbl (%rax,%rcx), %eax
orl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: AES::SetParameters(int, int)
void AES::SetParameters(int keylength, int blocklength)
	{
	Nk = Nr = Nb = 0; // default values

	if ((keylength != 128) && (keylength != 192) && (keylength != 256))
		return; // nothing - todo - throw error?
	if ((blocklength != 128) && (blocklength != 192) && (blocklength != 256))
		return; // nothing - todo - throw error?

	static int const parameters[] = {
//Nk*32 128     192     256
		10, 	12,  	14,  // Nb*32 = 128
		12, 	12,  	14,  // Nb*32 = 192
		14, 	14,  	14,  // Nb*32 = 256
		};

	// legal parameters, so fire it up
	Nk = keylength  /32;
	Nb = blocklength/32;
	Nr = parameters[((Nk-4)/2 + 3*(Nb-4)/2)];
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movl $0x0, (%rax)
movl $0x0, 0x8(%rax)
movl $0x0, 0x4(%rax)
cmpl $0x80, -0xc(%rsp)
je 0xab9e
cmpl $0xc0, -0xc(%rsp)
je 0xab9e
cmpl $0x100, -0xc(%rsp)      # imm = 0x100
je 0xab9e
jmp 0xac27
cmpl $0x80, -0x10(%rsp)
je 0xabbe
cmpl $0xc0, -0x10(%rsp)
je 0xabbe
cmpl $0x100, -0x10(%rsp)     # imm = 0x100
je 0xabbe
jmp 0xac27
movl -0xc(%rsp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
movl -0x10(%rsp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0x4(%rax), %eax
subl $0x4, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x18(%rsp), %rax
movl (%rax), %eax
subl $0x4, %eax
imull $0x3, %eax, %eax
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %edx
movq -0x18(%rsp), %rax
addl %edx, %ecx
movslq %ecx, %rdx
leaq 0x15d6f(%rip), %rcx     # 0x20990
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x8(%rax)
retq
nopl (%rax,%rax)
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: AES::Encrypt(unsigned char const*, unsigned char*, unsigned long, AES::BlockMode)
void AES::Encrypt(const unsigned char * datain, unsigned char * dataout, unsigned long numBlocks, BlockMode mode)
	{
	if (0 == numBlocks)
		return;
	unsigned int blocksize = Nb*4;
	switch (mode)
		{
		case ECB :
			while (numBlocks)
				{
				EncryptBlock(datain,dataout);
				datain   += blocksize;
				dataout  += blocksize;
				--numBlocks;
				}
			break;
		case CBC :
			{
			unsigned char buffer[32]; // max blocksize
			memcpy(buffer,iv,blocksize); // clear out - todo - allow setting the Initialization Vector - needed for security
			while (numBlocks)
				{
				for (unsigned int pos = 0; pos < blocksize; ++pos)
					buffer[pos] ^= *datain++;
				EncryptBlock(buffer,dataout);
				memcpy(buffer,dataout,blocksize);
				dataout  += blocksize;
				--numBlocks;
				}
			}
			break;
		default :
			break;
		}
	}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movl %r8d, 0x44(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq 0x48(%rsp), %rax
jne 0x14535
jmp 0x14675
movq 0x10(%rsp), %rax
movl (%rax), %eax
shll $0x2, %eax
movl %eax, 0x40(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x1455f
jmp 0x14551
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0x145b8
jmp 0x14673
jmp 0x14561
cmpq $0x0, 0x48(%rsp)
je 0x145b3
movq 0x10(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0xace0
movl 0x40(%rsp), %ecx
movq 0x58(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x58(%rsp)
movl 0x40(%rsp), %ecx
movq 0x50(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x14561
jmp 0x14675
movq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdi
addq $0x1ec, %rsi            # imm = 0x1EC
movl 0x40(%rsp), %eax
movl %eax, %edx
callq 0x2130
cmpq $0x0, 0x48(%rsp)
je 0x14671
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x40(%rsp), %eax
jae 0x14622
movq 0x58(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x58(%rsp)
movzbl (%rax), %edx
movl 0x1c(%rsp), %eax
movzbl 0x20(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x20(%rsp,%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x145e8
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0xace0
leaq 0x20(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x40(%rsp), %eax
movl %eax, %edx
callq 0x2130
movl 0x40(%rsp), %ecx
movq 0x50(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x48(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x145d4
jmp 0x14675
jmp 0x14675
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: (anonymous namespace)::GF2_8_mult(unsigned char, unsigned char)
inline unsigned char GF2_8_mult(unsigned char a, unsigned char b)
	{ // todo - make 4x4 table for nibbles, use lookup
	unsigned char result = 0;

	// should give 0x57 . 0x13 = 0xFE with poly 0x11B
	//

	int count = 8;
	while (count--)
		{
		if (b&1)
			result ^= a;
		if (a&128)
			{
			a <<= 1;
			a ^= (0x1B);
			}
		else
			a <<= 1;
		b >>= 1;
		}
	return result;
	}

// Assembly:
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rsp)
movb %al, -0x2(%rsp)
movb $0x0, -0x3(%rsp)
movl $0x8, -0x8(%rsp)
movl -0x8(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rsp)
cmpl $0x0, %eax
je 0x14aca
movzbl -0x2(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x14a8a
movzbl -0x1(%rsp), %ecx
movzbl -0x3(%rsp), %eax
xorl %ecx, %eax
movb %al, -0x3(%rsp)
movzbl -0x1(%rsp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x14ab2
movzbl -0x1(%rsp), %eax
shll %eax
movb %al, -0x1(%rsp)
movzbl -0x1(%rsp), %eax
xorl $0x1b, %eax
movb %al, -0x1(%rsp)
jmp 0x14abd
movzbl -0x1(%rsp), %eax
shll %eax
movb %al, -0x1(%rsp)
movzbl -0x2(%rsp), %eax
sarl %eax
movb %al, -0x2(%rsp)
jmp 0x14a5b
movb -0x3(%rsp), %al
retq
nop
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: (anonymous namespace)::CreateAESTables(bool)
bool CreateAESTables(bool create)
	{
	bool retval = true;
	if (CheckInverses(create) == false)
		retval = false;
	if (CheckByteSub(create) == false)
		retval = false;
	if (CheckInvByteSub(create) == false)
		retval = false;
	if (CheckRcon(create) == false)
		return false;
	if (CheckLargeTables(create) == false)
		return false;
	return retval;
	}

// Assembly:
pushq %rax
movb %dil, %al
andb $0x1, %al
movb %al, 0x6(%rsp)
movb $0x1, 0x5(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x1e660
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1e5cc
movb $0x0, 0x5(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x1e750
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1e5e9
movb $0x0, 0x5(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x1e930
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1e606
movb $0x0, 0x5(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x1ea30
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1e625
movb $0x0, 0x7(%rsp)
jmp 0x1e64e
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x1eb00
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1e644
movb $0x0, 0x7(%rsp)
jmp 0x1e64e
movb 0x5(%rsp), %al
andb $0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: (anonymous namespace)::CheckInverses(bool)
bool CheckInverses(bool create)
	{
	unsigned int a,b; // need int here to prevent wraps in loop
	if (create == true)
		gf2_8_inv[0] = 0;
	else if (gf2_8_inv[0] != 0)
		return false;
	for (a = 1; a <= 255; a++)
		{
		b = 1;
		while (GF2_8_mult(a,b) != 1)
			b++;

		if (create == true)
			gf2_8_inv[a] = b;
		else if (gf2_8_inv[a] != b)
			return false;
		}
	return true;
	}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x16(%rsp)
movb 0x16(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1e684
movb $0x0, 0xe37e(%rip)      # 0x2ca00
jmp 0x1e69c
movzbl 0xe375(%rip), %eax      # 0x2ca00
cmpl $0x0, %eax
je 0x1e69a
movb $0x0, 0x17(%rsp)
jmp 0x1e741
jmp 0x1e69c
movl $0x1, 0x10(%rsp)
cmpl $0xff, 0x10(%rsp)
ja 0x1e73c
movl $0x1, 0xc(%rsp)
movl 0x10(%rsp), %eax
movb %al, %cl
movl 0xc(%rsp), %eax
movzbl %cl, %edi
movzbl %al, %esi
callq 0x14a40
movzbl %al, %eax
cmpl $0x1, %eax
je 0x1e6e4
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1e6ba
movb 0x16(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1e70a
movl 0xc(%rsp), %eax
movb %al, %dl
movl 0x10(%rsp), %eax
movl %eax, %ecx
leaq 0xe2fb(%rip), %rax      # 0x2ca00
movb %dl, (%rax,%rcx)
jmp 0x1e72a
movl 0x10(%rsp), %eax
movl %eax, %ecx
leaq 0xe2e9(%rip), %rax      # 0x2ca00
movzbl (%rax,%rcx), %eax
cmpl 0xc(%rsp), %eax
je 0x1e728
movb $0x0, 0x17(%rsp)
jmp 0x1e741
jmp 0x1e72a
jmp 0x1e72c
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1e6a4
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: (anonymous namespace)::CheckByteSub(bool)
bool CheckByteSub(bool create)
	{
	if (CheckInverses(create) == false)
		return false; // we cannot do this without inverses

	unsigned int x,y; // need ints here to prevent wrap in loop
	for (x = 0; x <= 255; x++)
		{
		y = gf2_8_inv[x]; // inverse to start with

		// affine transform
		y = BitSum(y&0xF1) | (BitSum(y&0xE3)<<1) | (BitSum(y&0xC7)<<2) | (BitSum(y&0x8F)<<3) |
			(BitSum(y&0x1F)<<4) | (BitSum(y&0x3E)<<5) | (BitSum(y&0x7C)<<6) | (BitSum(y&0xF8)<<7);
		y = y ^ 0x63;
		if (create == true)
			byte_sub[x] = y;
		else if (byte_sub[x] != y)
			return false;
		}
	return true;
	}

// Assembly:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x26(%rsp)
movb 0x26(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x1e660
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1e77f
movb $0x0, 0x27(%rsp)
jmp 0x1e916
movl $0x0, 0x20(%rsp)
cmpl $0xff, 0x20(%rsp)
ja 0x1e911
movl 0x20(%rsp), %eax
movl %eax, %ecx
leaq 0xe25e(%rip), %rax      # 0x2ca00
movzbl (%rax,%rcx), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
andl $0xf1, %eax
movzbl %al, %edi
callq 0x1f440
movzbl %al, %eax
movl %eax, (%rsp)
movl 0x1c(%rsp), %eax
andl $0xe3, %eax
movzbl %al, %edi
callq 0x1f440
movb %al, %cl
movl (%rsp), %eax
movzbl %cl, %ecx
shll %ecx
orl %ecx, %eax
movl %eax, 0x4(%rsp)
movl 0x1c(%rsp), %eax
andl $0xc7, %eax
movzbl %al, %edi
callq 0x1f440
movb %al, %cl
movl 0x4(%rsp), %eax
movzbl %cl, %ecx
shll $0x2, %ecx
orl %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
andl $0x8f, %eax
movzbl %al, %edi
callq 0x1f440
movb %al, %cl
movl 0x8(%rsp), %eax
movzbl %cl, %ecx
shll $0x3, %ecx
orl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %eax
andl $0x1f, %eax
movzbl %al, %edi
callq 0x1f440
movb %al, %cl
movl 0xc(%rsp), %eax
movzbl %cl, %ecx
shll $0x4, %ecx
orl %ecx, %eax
movl %eax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
andl $0x3e, %eax
movzbl %al, %edi
callq 0x1f440
movb %al, %cl
movl 0x10(%rsp), %eax
movzbl %cl, %ecx
shll $0x5, %ecx
orl %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x1c(%rsp), %eax
andl $0x7c, %eax
movzbl %al, %edi
callq 0x1f440
movb %al, %cl
movl 0x14(%rsp), %eax
movzbl %cl, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movl %eax, 0x18(%rsp)
movl 0x1c(%rsp), %eax
andl $0xf8, %eax
movzbl %al, %edi
callq 0x1f440
movb %al, %cl
movl 0x18(%rsp), %eax
movzbl %cl, %ecx
shll $0x7, %ecx
orl %ecx, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
xorl $0x63, %eax
movl %eax, 0x1c(%rsp)
movb 0x26(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1e8df
movl 0x1c(%rsp), %eax
movb %al, %dl
movl 0x20(%rsp), %eax
movl %eax, %ecx
leaq 0xe026(%rip), %rax      # 0x2c900
movb %dl, (%rax,%rcx)
jmp 0x1e8ff
movl 0x20(%rsp), %eax
movl %eax, %ecx
leaq 0xe014(%rip), %rax      # 0x2c900
movzbl (%rax,%rcx), %eax
cmpl 0x1c(%rsp), %eax
je 0x1e8fd
movb $0x0, 0x27(%rsp)
jmp 0x1e916
jmp 0x1e8ff
jmp 0x1e901
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x1e787
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: (anonymous namespace)::CheckInvByteSub(bool)
bool CheckInvByteSub(bool create)
	{
	if (CheckInverses(create) == false)
		return false; // we cannot do this without inverses
	if (CheckByteSub(create) == false)
		return false; // we cannot do this without byte_sub

	unsigned int x,y; // need ints here to prevent wrap in loop
	for (x = 0; x <= 255; x++)
		{
		// we brute force it...
		y = 0;
		while (byte_sub[y] != x)
			y++;
		if (create == true)
			inv_byte_sub[x] = y;
		else if (inv_byte_sub[x] != y)
			return false;
		}
	return true;
	}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x16(%rsp)
movb 0x16(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x1e660
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1e95f
movb $0x0, 0x17(%rsp)
jmp 0x1ea20
movb 0x16(%rsp), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x1e750
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1e981
movb $0x0, 0x17(%rsp)
jmp 0x1ea20
movl $0x0, 0x10(%rsp)
cmpl $0xff, 0x10(%rsp)
ja 0x1ea1b
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, %ecx
leaq 0xdf54(%rip), %rax      # 0x2c900
movzbl (%rax,%rcx), %eax
cmpl 0x10(%rsp), %eax
je 0x1e9c3
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1e99f
movb 0x16(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1e9e9
movl 0xc(%rsp), %eax
movb %al, %dl
movl 0x10(%rsp), %eax
movl %eax, %ecx
leaq 0xe11c(%rip), %rax      # 0x2cb00
movb %dl, (%rax,%rcx)
jmp 0x1ea09
movl 0x10(%rsp), %eax
movl %eax, %ecx
leaq 0xe10a(%rip), %rax      # 0x2cb00
movzbl (%rax,%rcx), %eax
cmpl 0xc(%rsp), %eax
je 0x1ea07
movb $0x0, 0x17(%rsp)
jmp 0x1ea20
jmp 0x1ea09
jmp 0x1ea0b
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1e989
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: (anonymous namespace)::CheckRcon(bool)
bool CheckRcon(bool create)
	{
	unsigned char Ri = 1; // start here

	if (create == true)
		Rcon[0] = 0;
	else if (Rcon[0] != 0)
		return false; // todo - this is unused still check?
	for (unsigned int i = 1; i < sizeof(Rcon)/sizeof(Rcon[0])-1; i++)
		{
		if (create == true)
			Rcon[i] = Ri;
		else if (Rcon[i] != Ri)
			return false;
		Ri = GF2_8_mult(Ri,0x02); // multiply by x - todo replace with xmult
		}
	return true;
	}

// Assembly:
pushq %rax
movb %dil, %al
andb $0x1, %al
movb %al, 0x6(%rsp)
movb $0x1, 0x5(%rsp)
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1ea5a
movq $0x0, 0x5cb8(%rip) # 0x24710
jmp 0x1ea6d
cmpq $0x0, 0x5cae(%rip)      # 0x24710
je 0x1ea6b
movb $0x0, 0x7(%rsp)
jmp 0x1eaea
jmp 0x1ea6d
movl $0x1, (%rsp)
movl (%rsp), %eax
cmpq $0x3b, %rax
jae 0x1eae5
movb 0x6(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x1eaa4
movzbl 0x5(%rsp), %eax
movl %eax, %edx
movl (%rsp), %eax
movl %eax, %ecx
leaq 0x5c72(%rip), %rax      # 0x24710
movq %rdx, (%rax,%rcx,8)
jmp 0x1eac7
movl (%rsp), %eax
movl %eax, %ecx
leaq 0x5c60(%rip), %rax      # 0x24710
movq (%rax,%rcx,8), %rax
movzbl 0x5(%rsp), %ecx
cmpq %rcx, %rax
je 0x1eac5
movb $0x0, 0x7(%rsp)
jmp 0x1eaea
jmp 0x1eac7
movl $0x2, %esi
movzbl 0x5(%rsp), %edi
callq 0x14a40
movb %al, 0x5(%rsp)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x1ea74
movb $0x1, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: rellla[P]E3DC-Rscp/AES.cpp
// Function: (anonymous namespace)::BitSum(unsigned char)
unsigned char BitSum(unsigned char byte)
	{ // return the sum of bits mod 2
	byte = (byte>>4)^(byte&15);
	byte = (byte>>2)^(byte&3);
	return (byte>>1)^(byte&1);
	}

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movzbl -0x1(%rsp), %eax
sarl $0x4, %eax
movzbl -0x1(%rsp), %ecx
andl $0xf, %ecx
xorl %ecx, %eax
movb %al, -0x1(%rsp)
movzbl -0x1(%rsp), %eax
sarl $0x2, %eax
movzbl -0x1(%rsp), %ecx
andl $0x3, %ecx
xorl %ecx, %eax
movb %al, -0x1(%rsp)
movzbl -0x1(%rsp), %eax
sarl %eax
movzbl -0x1(%rsp), %ecx
andl $0x1, %ecx
xorl %ecx, %eax
retq
nopw %cs:(%rax,%rax)
nop
// File: rellla[P]E3DC-Rscp/SocketConnection.cpp
// Function: SocketSendData(int, unsigned char const*, int)
int SocketSendData(int iSocket, const unsigned char * ucBuffer, int iLength)
{
    // sanity check
    if(iSocket < 0) {
        return iSocket;
    }

    int iSentBytes = 0;
    while(iLength)
    {
        int result = send(iSocket, ucBuffer, iLength, 0);
        if(result <= 0) {
            return -1;
        }
        iSentBytes += result;
        ucBuffer += result;
        iLength -= result;
    }
    return iSentBytes;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
cmpl $0x0, 0x20(%rsp)
jge 0x1f6d2
movl 0x20(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x1f743
movl $0x0, 0x10(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0x1f73b
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
xorl %ecx, %ecx
callq 0x20c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jg 0x1f70b
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1f743
movl 0xc(%rsp), %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movl 0xc(%rsp), %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
jmp 0x1f6da
movl 0x10(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: saeefahmad[P]MIPS-pipeline-simulator/pipeline.cpp
// Function: finalize()
void finalize() {
  int i;
  for (i = 0; i < IMEMSIZE; i++)
    if (imem[i] != NULL)
      delete imem[i];
  delete[] imem;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0x100, -0x4(%rbp)      # imm = 0x100
jge 0x5d89
movq 0x7441(%rip), %rax      # 0xd180
movslq -0x4(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5d7c
movq 0x742f(%rip), %rax      # 0xd180
movslq -0x4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5d7a
movq -0x10(%rbp), %rdi
callq 0x87e0
movq -0x10(%rbp), %rdi
movl $0x5c, %esi
callq 0x2120
jmp 0x5d7c
jmp 0x5d7e
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x5d2f
movq 0x73f0(%rip), %rax      # 0xd180
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x5da3
movq -0x18(%rbp), %rdi
callq 0x21a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: saeefahmad[P]MIPS-pipeline-simulator/pipeline.cpp
// Function: incStatistics(_StatisticsType)
void incStatistics(StatisticsType type) {
  switch(type) {
    case STALLCYCLE:
      stallCycle++;
      break;
    case FETCHEDINS:
      fetchedIns++;
      break;
    case FINISHEDINS:
      finishedIns++;
      break;
    default:
      assert(0);
      break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
testl %eax, %eax
je 0x62cb
jmp 0x62b7
movl -0x8(%rbp), %eax
subl $0x1, %eax
je 0x62dc
jmp 0x62c1
movl -0x8(%rbp), %eax
subl $0x2, %eax
je 0x62ed
jmp 0x62fe
movl 0x72c7(%rip), %eax      # 0xd598
addl $0x1, %eax
movl %eax, 0x72be(%rip)      # 0xd598
jmp 0x631d
movl 0x72ba(%rip), %eax      # 0xd59c
addl $0x1, %eax
movl %eax, 0x72b1(%rip)      # 0xd59c
jmp 0x631d
movl 0x72ad(%rip), %eax      # 0xd5a0
addl $0x1, %eax
movl %eax, 0x72a4(%rip)      # 0xd5a0
jmp 0x631d
leaq 0x2d18(%rip), %rdi      # 0x901d
leaq 0x2dc2(%rip), %rsi      # 0x90ce
movl $0x1dd, %edx            # imm = 0x1DD
leaq 0x2e13(%rip), %rcx      # 0x912b
callq 0x2090
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: saeefahmad[P]MIPS-pipeline-simulator/pipeline.cpp
// Function: hasNextIns()
bool hasNextIns() {
  Instruction* ins = imem[pc>>2];
  if(ins != NULL)
	  return true;
  else
	  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x6e45(%rip), %rax      # 0xd180
movl 0x6e13(%rip), %ecx      # 0xd154
sarl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x635c
movb $0x1, -0x1(%rbp)
jmp 0x6360
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: saeefahmad[P]MIPS-pipeline-simulator/stage.cpp
// Function: AbstractStage::createStage(_StageType, AbstractStage*)
AbstractStage* AbstractStage::createStage(StageType _type, AbstractStage *_prevStage) {
  // Create a new stage of type _type and set the previous stage to _prevStage
  // Return the newly created stage

	AbstractStage* temp;
	switch (_type) {
	case 0:
		temp = new FetchStage(_type, _prevStage);
		break;
	case 1:
		temp = new DecodeStage(_type, _prevStage);
		break;
	case 2:
		temp = new ExecuteStage(_type, _prevStage);
		break;
	case 3:
		temp = new MemaccessStage(_type, _prevStage);
		break;
	case 4:
		temp = new WritebackStage(_type, _prevStage);
		break;
	}
	return temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x4, %rax
ja 0x6c8e
movq -0x30(%rbp), %rax
leaq 0x266d(%rip), %rcx      # 0x9178
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x80, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x6dd0
jmp 0x6b36
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6c8e
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x80, %esi
callq 0x2120
jmp 0x6c98
movl $0x80, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x7010
jmp 0x6b84
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6c8e
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x80, %esi
callq 0x2120
jmp 0x6c98
movl $0x80, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x7620
jmp 0x6bd2
movq -0x48(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6c8e
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x80, %esi
callq 0x2120
jmp 0x6c98
movl $0x80, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x7ca0
jmp 0x6c20
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6c8e
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x80, %esi
callq 0x2120
jmp 0x6c98
movl $0x80, %edi
callq 0x2110
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movl -0x4(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x8060
jmp 0x6c68
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x6c8e
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x80, %esi
callq 0x2120
jmp 0x6c98
movq -0x18(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2200
nopw %cs:(%rax,%rax)
// File: saeefahmad[P]MIPS-pipeline-simulator/fetch.cpp
// Function: FetchStage::process()
void FetchStage::process() {
  // process for this step
  if(getPc()/4 < getInstrCount()){
	  Instruction instr;
	  instr = this->getNextIns();
	  this->nextStage->setInstruction(instr);
	  this->incStatistics((StatisticsType) 1);
	  setPc(this->getPc()+4);
  } else {
	  Instruction instr;
	  instr = this->ins;
	  this->nextStage->setInstruction(instr);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq 0x68d7(%rip), %rax      # 0xd738
callq *(%rax)
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, -0xd4(%rbp)
leaq 0x68d0(%rip), %rax      # 0xd748
callq *(%rax)
movl %eax, %ecx
movl -0xd4(%rbp), %eax
cmpl %ecx, %eax
jge 0x6f41
leaq -0x64(%rbp), %rdi
callq 0x8480
leaq 0x68c6(%rip), %rax      # 0xd760
movq (%rax), %rax
callq *%rax
movq %rax, -0xe8(%rbp)
jmp 0x6ea8
movq -0xe8(%rbp), %rsi
leaq -0x64(%rbp), %rdi
callq 0x86a0
jmp 0x6eba
movq -0xe0(%rbp), %rax
movq 0x78(%rax), %rdi
leaq -0x64(%rbp), %rsi
callq 0x6d40
jmp 0x6ed0
leaq 0x68c9(%rip), %rax      # 0xd7a0
movq (%rax), %rax
movl $0x1, %edi
callq *%rax
jmp 0x6ee3
leaq 0x6856(%rip), %rax      # 0xd740
movq (%rax), %rax
movq %rax, -0xf8(%rbp)
leaq 0x683d(%rip), %rax      # 0xd738
movq (%rax), %rax
callq *%rax
movl %eax, -0xec(%rbp)
jmp 0x6f08
movq -0xf8(%rbp), %rax
movl -0xec(%rbp), %edi
addl $0x4, %edi
callq *%rax
jmp 0x6f1c
leaq -0x64(%rbp), %rdi
callq 0x87e0
jmp 0x6fae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x64(%rbp), %rdi
callq 0x87e0
jmp 0x6fb7
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x8480
movq -0xe0(%rbp), %rsi
movq -0x100(%rbp), %rdi
addq $0x8, %rsi
callq 0x86a0
jmp 0x6f6d
movq -0xe0(%rbp), %rax
movq 0x78(%rax), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x6d40
jmp 0x6f86
leaq -0xd0(%rbp), %rdi
callq 0x87e0
jmp 0x6fae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x87e0
jmp 0x6fb7
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x2200
// File: saeefahmad[P]MIPS-pipeline-simulator/instruction.cpp
// Function: Instruction::init(_InstructionType, _RegisterType, _RegisterType, _RegisterType, int, int)
void Instruction::init(InstructionType _type, RegisterType _arg1, RegisterType _arg2, RegisterType _arg3, 
                       int _immidiate, int _address) {
  type = _type;
  arg1 = _arg1;
  arg2 = _arg2;
  arg3 = _arg3;
  immidiate = _immidiate;
  address = _address;
  A = B = 0;
  aluOut = 0;
  loadMemData = 0;
  fetchedAtCycle = 0;
  srcCycle1 = 0;
  srcCycle2 = 0;
  cond = false;
  decodeCycle = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl %r9d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0xc(%rax)
movl -0x1c(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl 0x10(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl $0x0, 0x1c(%rax)
movl $0x0, 0x18(%rax)
movl $0x0, 0x20(%rax)
movl $0x0, 0x24(%rax)
movl $0x0, 0x28(%rax)
movl $0x0, 0x2c(%rax)
movl $0x0, 0x30(%rax)
movb $0x0, 0x34(%rax)
movl $0x0, 0x38(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)