LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/BlockChain.cpp
// Function: BitcoinTransactionFactory::printAddress(BitcoinAddress*)
void printAddress(BitcoinAddress *ba)
	{
		uint32_t i = mAddresses.getIndex(ba);
		printf("========================================\r\n");
		printf("PublicKey: %s[%d] has %s transactions associated with it.\r\n", getKey(i+1),i+1, formatNumber(ba->mTransactionCount) );
		printf("Balance: %0.4f : TotalReceived: %0.4f TotalSpent: %0.4f\r\n", (float) (ba->mTotalReceived-ba->mTotalSent)/ONE_BTC, (float)ba->mTotalReceived / ONE_BTC, (float) ba->mTotalSent / ONE_BTC );
		if ( ba->mLastInputTime )
		{
			printf("Last Input Time: %s\r\n", getTimeString(ba->mLastInputTime) );
		}
		if ( ba->mLastOutputTime )
		{
			printf("Last Output Time: %s\r\n", getTimeString(ba->mLastOutputTime) );
		}
		for (uint32_t j=0; j<ba->mTransactionCount; j++)
		{
			printTransaction(j,ba->mTransactions[j],i+1);
		}
		printf("========================================\r\n");
		printf("\r\n");
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0xe020
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rax
subq 0x2000008(%rdi), %rax
shrq $0x4, %rax
imull $0xcccccccd, %eax, %r15d # imm = 0xCCCCCCCD
leaq 0xba81(%rip), %rdi      # 0x19949
callq 0x2260
incl %r15d
movq %r14, %rdi
movl %r15d, %esi
callq 0xe040
movq %rax, %r12
movl 0x3c(%rbx), %edi
callq 0xb5d3
leaq 0xa4b5(%rip), %rdi      # 0x183a2
movq %r12, %rsi
movl %r15d, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2050
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
js 0xdf14
cvtsi2ss %rdx, %xmm0
jmp 0xdf29
movq %rdx, %rsi
shrq %rsi
andl $0x1, %edx
orq %rsi, %rdx
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
movss 0x97df(%rip), %xmm2     # 0x17710
divss %xmm2, %xmm0
testq %rcx, %rcx
js 0xdf41
cvtsi2ss %rcx, %xmm1
jmp 0xdf56
movq %rcx, %rdx
shrq %rdx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm1
addss %xmm1, %xmm1
cvtss2sd %xmm0, %xmm0
divss %xmm2, %xmm1
cvtss2sd %xmm1, %xmm1
testq %rax, %rax
js 0xdf6e
cvtsi2ss %rax, %xmm3
jmp 0xdf83
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm3
addss %xmm3, %xmm3
divss %xmm2, %xmm3
xorps %xmm2, %xmm2
cvtss2sd %xmm3, %xmm2
leaq 0xa449(%rip), %rdi      # 0x183de
movb $0x3, %al
callq 0x2050
movl 0x14(%rbx), %edi
testl %edi, %edi
je 0xdfb9
callq 0xb6b4
leaq 0xa469(%rip), %rdi      # 0x18418
movq %rax, %rsi
xorl %eax, %eax
callq 0x2050
movl 0x18(%rbx), %edi
testl %edi, %edi
je 0xdfd6
callq 0xb6b4
leaq 0xa462(%rip), %rdi      # 0x1842e
movq %rax, %rsi
xorl %eax, %eax
callq 0x2050
cmpl $0x0, 0x3c(%rbx)
je 0xe000
xorl %r12d, %r12d
movq 0x40(%rbx), %rax
movq (%rax,%r12,8), %rdx
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %ecx
callq 0xe0c4
incq %r12
movl 0x3c(%rbx), %eax
cmpq %rax, %r12
jb 0xdfdf
leaq 0xb942(%rip), %rdi      # 0x19949
callq 0x2260
leaq 0xba5b(%rip), %rdi      # 0x19a6e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2260
leaq 0xc1b0(%rip), %rdi      # 0x1a1d7
leaq 0x97c2(%rip), %rsi      # 0x177f0
leaq 0xa0a2(%rip), %rcx      # 0x180d7
movl $0x13b, %edx            # imm = 0x13B
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/BlockChain.cpp
// Function: BitcoinTransactionFactory::getKey(unsigned int) const
const char *getKey(uint32_t a) const
	{
		static char scratch[256];
		const char *ret = "UNKNOWN ADDRESS";
		if ( a )
		{
			BitcoinAddress *ba = mAddresses.getKey(a-1);
			uint8_t address1[25];
			BLOCKCHAIN_BITCOIN_ADDRESS::bitcoinRIPEMD160ToAddress((const uint8_t *)ba,address1);
			BLOCKCHAIN_BITCOIN_ADDRESS::bitcoinAddressToAscii(address1,scratch,256);
			ret = scratch;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testl %esi, %esi
je 0xe092
decl %esi
cmpl %esi, 0x2000000(%rdi)
jbe 0xe0a5
movl %esi, %eax
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
addq 0x2000008(%rdi), %rax
leaq -0x30(%rbp), %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0xb26b
leaq 0x11790(%rip), %rbx     # 0x1f810
movq %r14, %rdi
movq %rbx, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0xb2d1
jmp 0xe099
leaq 0xa3ac(%rip), %rbx      # 0x18445
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xa14c(%rip), %rdi      # 0x181f8
leaq 0x973d(%rip), %rsi      # 0x177f0
leaq 0xa152(%rip), %rcx      # 0x1820c
movl $0x143, %edx            # imm = 0x143
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/BlockChain.cpp
// Function: BitcoinTransactionFactory::printTransactions(unsigned int)
void printTransactions(uint32_t blockIndex)
	{
		uint32_t tcount;
		Transaction *t = getBlock(blockIndex,tcount);
		if ( t )
		{
			printf("===================================================\r\n");
			printf("Block #%s has %s transactions.\r\n", formatNumber(blockIndex), formatNumber(tcount) );
			for (uint32_t j=0; j<tcount; j++)
			{
				printTransaction(j,t,0);
				t++;
			}
			printf("===================================================\r\n");
			printf("\r\n");
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r15d
movq %rdi, %rbx
leaq -0x24(%rbp), %rdx
callq 0xe43e
testq %rax, %rax
je 0xe431
movq %rax, %r14
leaq 0xb577(%rip), %rdi      # 0x1993e
callq 0x2260
movl %r15d, %edi
callq 0xb5d3
movq %rax, %r12
movl -0x24(%rbp), %edi
callq 0xb5d3
leaq 0xa178(%rip), %rdi      # 0x1855e
xorl %r15d, %r15d
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2050
cmpl $0x0, -0x24(%rbp)
je 0xe419
movq %rbx, %rdi
movl %r15d, %esi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0xe0c4
addq $0x20, %r14
incl %r15d
cmpl -0x24(%rbp), %r15d
jb 0xe3fc
leaq 0xb51e(%rip), %rdi      # 0x1993e
callq 0x2260
leaq 0xb642(%rip), %rdi      # 0x19a6e
callq 0x2260
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/BlockChain.cpp
// Function: BitcoinTransactionFactory::getBlock(unsigned int, unsigned int&) const
Transaction * getBlock(uint32_t index,uint32_t &tcount) const
	{
		Transaction *ret = NULL;
		assert( index < mBlockCount );
		if ( index < mBlockCount )
		{
			ret = mBlocks[index];
			if ( (index+1) == mBlockCount )
			{
				tcount = (uint32_t)(&mTransactions[mTransactionCount] - ret);
			}
			else
			{
				tcount = (uint32_t)(mBlocks[index+1] - ret);
			}
		}
		return ret;
	}

// Assembly:
movl 0x2000038(%rdi), %r8d
cmpl %esi, %r8d
jbe 0xe488
movq 0x2000040(%rdi), %rcx
movl %esi, %eax
movq (%rcx,%rax,8), %rax
incl %esi
cmpl %r8d, %esi
jne 0xe478
movl 0x2000010(%rdi), %ecx
shlq $0x5, %rcx
addq 0x2000020(%rdi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
jmp 0xe485
movl %esi, %esi
movq (%rcx,%rsi,8), %rcx
subq %rax, %rcx
shrq $0x5, %rcx
movl %ecx, (%rdx)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xa0ec(%rip), %rdi      # 0x1857f
leaq 0x9356(%rip), %rsi      # 0x177f0
leaq 0xa0f2(%rip), %rcx      # 0x18593
movl $0xb9a, %edx            # imm = 0xB9A
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/BlockChain.cpp
// Function: BitcoinAddress::getDaysSinceLastUsed() const
uint32_t getDaysSinceLastUsed(void) const
	{
		time_t currentTime;
		time(&currentTime); // get the current time.
		uint32_t lastUsed = mLastInputTime; // the last time we sent money (not received because anyone can send us money).
		if ( mLastInputTime == 0 ) // if it has never had a spend.. then we use the time of first receive..
		{
			lastUsed = mFirstOutputTime;
		}
		double seconds = difftime(currentTime,time_t(lastUsed));
		double minutes = seconds/60;
		double hours = minutes/60;
		uint32_t days = (uint32_t) (hours/24);
		return days;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0x2120
movl 0x14(%rbx), %esi
testl %esi, %esi
cmovel 0x1c(%rbx), %esi
movq (%r14), %rdi
callq 0x20a0
movsd 0x77ab(%rip), %xmm1     # 0x177e0
divsd %xmm1, %xmm0
divsd %xmm1, %xmm0
divsd 0x77a3(%rip), %xmm0     # 0x177e8
cvttsd2si %xmm0, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/BlockChain.cpp
// Function: SortByAge::compare(void**, void**)
virtual int32_t compare(void **p1,void **p2) 
	{
		BitcoinAddress **ba1 = (BitcoinAddress **)p1;
		BitcoinAddress **ba2 = (BitcoinAddress **)p2;
		BitcoinAddress *a1 = *ba1;
		BitcoinAddress *a2 = *ba2;
		uint32_t age1 = a1->getDaysSinceLastUsed();
		uint32_t age2 = a2->getDaysSinceLastUsed();
		if ( age1 == age2 ) return 0;
		return age1 > age2 ? -1 : 1;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rsi), %rdi
movq (%rdx), %rbx
callq 0x10002
movl %eax, %r14d
movq %rbx, %rdi
callq 0x10002
xorl %ecx, %ecx
xorl %edx, %edx
cmpl %eax, %r14d
setbe %dl
leal -0x1(%rdx,%rdx), %eax
cmovel %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/BlockChain.cpp
// Function: BitcoinTransactionFactory::printAddress(char const*)
void printAddress(const char *adr)
	{
		BitcoinAddress ba;
		uint8_t output[25];
		if ( BLOCKCHAIN_BITCOIN_ADDRESS::bitcoinAsciiToAddress(adr,output) )
		{
			memcpy(&ba.mWord0,&output[1],20);
			BitcoinAddress *found = mAddresses.find(ba);
			if ( found )
			{
				printAddress(found);
			}
			else
			{
				printf("Failed to locate address: %s\r\n", adr );
			}
		}
		else
		{
			printf("Failed to decode address: %s\r\n", adr );
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0xb1f6
testb %al, %al
je 0x10a1b
movq -0x2f(%rbp), %rax
movq -0x27(%rbp), %rcx
movl -0x1f(%rbp), %edx
movq %rcx, %rsi
xorq %rax, %rsi
shrq $0x20, %rsi
movl %ecx, %edi
xorl %eax, %edi
xorl %edx, %edi
xorl %esi, %edi
andl $0x3fffff, %edi         # imm = 0x3FFFFF
movq (%r14,%rdi,8), %rsi
testq %rsi, %rsi
je 0x10a24
cmpq %rax, (%rsi)
jne 0x10a15
cmpq %rcx, 0x8(%rsi)
jne 0x10a15
cmpl %edx, 0x10(%rsi)
je 0x10a26
movq 0x48(%rsi), %rsi
jmp 0x10a00
leaq 0x8763(%rip), %rdi      # 0x19185
jmp 0x10a42
xorl %esi, %esi
testq %rsi, %rsi
je 0x10a3b
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xde92
leaq 0x8724(%rip), %rdi      # 0x19166
movq %rbx, %rsi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/BlockChain.cpp
// Function: BlockImpl::readInput(BlockChain::BlockInput&)
bool readInput(BlockChain::BlockInput &input)
	{
		bool ret = true;

		input.transactionHash = readHash();	// read the transaction hash
		input.transactionIndex = readU32();	// read the transaction index
		input.responseScriptLength = readVariableLengthInteger();	// read the length of the script
		assert( input.responseScriptLength < MAX_REASONABLE_SCRIPT_LENGTH );
		if ( input.responseScriptLength < MAX_REASONABLE_SCRIPT_LENGTH )
		{
			input.responseScript = input.responseScriptLength ? getReadBufferAdvance(input.responseScriptLength) : NULL;	// get the script buffer pointer; and advance the read location
			input.sequenceNumber = readU32();
		}
		else
		{
			ret = false;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x80(%rdi), %rcx
movq 0x88(%rdi), %rax
leaq 0x20(%rcx), %rdx
cmpq %rax, %rdx
ja 0x119e5
movq %rdx, 0x80(%rdi)
movq %rcx, (%rsi)
leaq 0x24(%rcx), %rdx
cmpq %rax, %rdx
ja 0x119c6
movl 0x20(%rcx), %r8d
movq %rdx, 0x80(%rdi)
movl %r8d, 0x8(%rsi)
leaq 0x25(%rcx), %r9
cmpq %rax, %r9
ja 0x11a04
movzbl (%rdx), %edx
movq %r9, 0x80(%rdi)
cmpl $0xfc, %edx
jbe 0x11956
leaq 0x27(%rcx), %r8
cmpq %rax, %r8
ja 0x11a42
movzwl (%r9), %edx
movq %r8, 0x80(%rdi)
cmpl $0xffff, %edx           # imm = 0xFFFF
jne 0x11956
addq $0x2b, %rcx
cmpq %rax, %rcx
ja 0x119c6
movl (%r8), %edx
movq %rcx, 0x80(%rdi)
cmpl $-0x1, %edx
je 0x11a61
movl %edx, 0xc(%rsi)
cmpl $0x2000, %edx           # imm = 0x2000
jae 0x11a23
testl %edx, %edx
je 0x119a0
movq 0x80(%rdi), %rcx
movl %edx, %edx
addq %rcx, %rdx
movq %rdx, 0x80(%rdi)
cmpq %rax, %rdx
jbe 0x119a2
leaq 0x7ce1(%rip), %rdi      # 0x19669
leaq 0x5e61(%rip), %rsi      # 0x177f0
leaq 0x7ceb(%rip), %rcx      # 0x19681
movl $0x82f, %edx            # imm = 0x82F
callq 0x20c0
xorl %ecx, %ecx
movq %rcx, 0x10(%rsi)
movq 0x80(%rdi), %rcx
leaq 0x4(%rcx), %rdx
cmpq %rax, %rdx
ja 0x119c6
movl (%rcx), %eax
movq %rdx, 0x80(%rdi)
movl %eax, 0x18(%rsi)
movb $0x1, %al
popq %rbp
retq
leaq 0x798b(%rip), %rdi      # 0x19358
leaq 0x5e1c(%rip), %rsi      # 0x177f0
leaq 0x79a8(%rip), %rcx      # 0x19383
movl $0x7ee, %edx            # imm = 0x7EE
callq 0x20c0
leaq 0x79b5(%rip), %rdi      # 0x193a1
leaq 0x5dfd(%rip), %rsi      # 0x177f0
leaq 0x79c4(%rip), %rcx      # 0x193be
movl $0x801, %edx            # imm = 0x801
callq 0x20c0
leaq 0x7a08(%rip), %rdi      # 0x19413
leaq 0x5dde(%rip), %rsi      # 0x177f0
leaq 0x7a24(%rip), %rcx      # 0x1943d
movl $0x7dc, %edx            # imm = 0x7DC
callq 0x20c0
leaq 0x7bd1(%rip), %rdi      # 0x195fb
leaq 0x5dbf(%rip), %rsi      # 0x177f0
leaq 0x7bfd(%rip), %rcx      # 0x19635
movl $0x83b, %edx            # imm = 0x83B
callq 0x20c0
leaq 0x7a10(%rip), %rdi      # 0x19459
leaq 0x5da0(%rip), %rsi      # 0x177f0
leaq 0x7a2d(%rip), %rcx      # 0x19484
movl $0x7e5, %edx            # imm = 0x7E5
callq 0x20c0
leaq 0x6308(%rip), %rdi      # 0x17d70
leaq 0x5d81(%rip), %rsi      # 0x177f0
leaq 0x796d(%rip), %rcx      # 0x193e3
movl $0x821, %edx            # imm = 0x821
callq 0x20c0
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/SHA256.cpp
// Function: sha256_update(sha256_ctx_t*, void const*, unsigned int)
void sha256_update(sha256_ctx_t * sc, const void *data, uint32_t len)
{
	uint32_t bufferBytesLeft;
	uint32_t bytesToCopy;
	int needBurn = 0;

	if (sc->bufferLength) 
	{
		bufferBytesLeft = 64L - sc->bufferLength;
		bytesToCopy = bufferBytesLeft;
		if (bytesToCopy > len)
		{
			bytesToCopy = len;
		}
		memcpy(&sc->buffer.bytes[sc->bufferLength], data, bytesToCopy);
		sc->totalLength += bytesToCopy * 8L;
		sc->bufferLength += bytesToCopy;
		data = ((uint8_t *) data) + bytesToCopy;
		len -= bytesToCopy;
		if (sc->bufferLength == 64L) 
		{
			SHA256Guts(sc, sc->buffer.words);
			needBurn = 1;
			sc->bufferLength = 0L;
		}
	}

	while (len > 63L) 
	{
		sc->totalLength += 512L;

		SHA256Guts(sc, (const uint32_t *)data);
		needBurn = 1;

		data = ((uint8_t *) data) + 64L;
		len -= 64L;
	}

	if (len) 
	{
		memcpy(&sc->buffer.bytes[sc->bufferLength], data, len);
		sc->totalLength += len * 8L;
		sc->bufferLength += len;
	}

	if (needBurn)
	{
		burnStack(sizeof(uint32_t[74]) + sizeof(uint32_t *[6]) +  sizeof(int));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl 0x28(%rdi), %eax
testq %rax, %rax
je 0x13891
movl $0x40, %r12d
subl %eax, %r12d
cmpl %ebx, %r12d
cmovael %ebx, %r12d
leaq (%r14,%rax), %rdi
addq $0x2c, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x20f0
leaq (,%r12,8), %rax
addq %rax, (%r14)
movl %r12d, %eax
addl 0x28(%r14), %eax
subl %r12d, %ebx
movl %eax, 0x28(%r14)
addq %r12, %r15
cmpl $0x40, %eax
jne 0x13891
leaq 0x2c(%r14), %rsi
movq %r14, %rdi
callq 0x138e6
movl $0x0, 0x28(%r14)
cmpl $0x40, %ebx
jb 0x138b4
addq $0x200, (%r14)          # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq 0x138e6
addq $0x40, %r15
addl $-0x40, %ebx
cmpl $0x3f, %ebx
ja 0x13896
testl %ebx, %ebx
je 0x138dd
movl %ebx, %r12d
movl 0x28(%r14), %eax
leaq (%r14,%rax), %rdi
addq $0x2c, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x20f0
shlq $0x3, %r12
addq %r12, (%r14)
addl %ebx, 0x28(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/SHA256.cpp
// Function: computeSHA256(void const*, unsigned int, unsigned char*)
void computeSHA256(const void *input,uint32_t size,uint8_t destHash[32])
{
	sha256_ctx_t sc;
	sha256_init(&sc);
	sha256_update(&sc,input,size);
	sha256_finalize(&sc,destHash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %rsi
leaq -0x80(%rbp), %r14
movq $0x0, (%r14)
movaps 0x1d50(%rip), %xmm0     # 0x17160
movups %xmm0, 0x8(%r14)
movaps 0x1d54(%rip), %xmm0     # 0x17170
movups %xmm0, 0x18(%r14)
movl $0x0, 0x28(%r14)
movq %r14, %rdi
callq 0x1381e
movq %r14, %rdi
movq %rbx, %rsi
callq 0x15376
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/keyboard.cpp
// Function: kbhit()
static int kbhit(void)
{
	struct timeval timeout;
	fd_set read_handles;
	int status;

	raw();
/* check stdin (fd 0) for activity */
	FD_ZERO(&read_handles);
	FD_SET(0, &read_handles);
	timeout.tv_sec = timeout.tv_usec = 0;
	status = select(0 + 1, &read_handles, NULL, NULL, &timeout);
	if(status < 0)
	{
		printf("select() failed in kbhit()\n");
		exit(1);
	}
	return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
callq 0x156c6
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x70(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movq $0x1, (%rsi)
leaq -0x10(%rbp), %r8
movaps %xmm0, (%r8)
movl $0x1, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2140
testl %eax, %eax
js 0x154bb
addq $0x90, %rsp
popq %rbp
retq
leaq 0x492e(%rip), %rdi      # 0x19df0
callq 0x2260
movl $0x1, %edi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/keyboard.cpp
// Function: getKey()
int  getKey(void) 	  // returns a key
{
	int ret = getch();
	if ( ret == 0 )
	{
		ret = getch()+256;
	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x156c6
xorl %r14d, %r14d
leaq -0x11(%rbp), %rbx
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2240
cmpq $0x1, %rax
movzbl (%rbx), %eax
cmovnel %r14d, %eax
testl %eax, %eax
jne 0x15532
callq 0x156c6
leaq -0x12(%rbp), %rbx
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2240
movq %rax, %rcx
movzbl (%rbx), %eax
movl $0x100, %edx            # imm = 0x100
orl %edx, %eax
cmpq $0x1, %rcx
cmovnel %edx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/keyboard.cpp
// Function: raw()
static void raw(void)
{
	static char init;
/**/
	struct termios new_kbd_mode;

	if(init)
		return;
/* put keyboard (stdin, actually) in raw, unbuffered mode */
	tcgetattr(0, &g_old_kbd_mode);
	memcpy(&new_kbd_mode, &g_old_kbd_mode, sizeof(struct termios));

	//new_kbd_mode.c_lflag &= ~(ICANON | ECHO);
	new_kbd_mode.c_lflag &= ~(ICANON | ECHO);
	new_kbd_mode.c_lflag|=ECHO;

	new_kbd_mode.c_cc[VTIME] = 0;
	new_kbd_mode.c_cc[VMIN] = 1;
	tcsetattr(0, TCSANOW, &new_kbd_mode);
/* when we exit, go back to normal, "cooked" mode */
	atexit(cooked);

	init = 1;
}

// Assembly:
cmpb $0x0, 0xa453(%rip)      # 0x1fb20
jne 0x15747
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0xa446(%rip), %rsi      # 0x1fb24
xorl %edi, %edi
callq 0x2190
movups 0xa438(%rip), %xmm0     # 0x1fb24
leaq -0x40(%rbp), %rdx
movaps %xmm0, (%rdx)
movups 0xa43a(%rip), %xmm0     # 0x1fb34
movaps %xmm0, 0x10(%rdx)
movups 0xa43f(%rip), %xmm0     # 0x1fb44
movaps %xmm0, 0x20(%rdx)
movups 0xa440(%rip), %xmm0     # 0x1fb50
movups %xmm0, 0x2c(%rdx)
movl 0xc(%rdx), %eax
andl $-0xb, %eax
orl $0x8, %eax
movl %eax, 0xc(%rdx)
movw $0x100, 0x16(%rdx)      # imm = 0x100
xorl %edi, %edi
xorl %esi, %esi
callq 0x21e0
leaq 0x12(%rip), %rdi        # 0x15748
callq 0x16260
movb $0x1, 0xa3de(%rip)      # 0x1fb20
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/main.cpp
// Function: main
int main(int argc,const char **argv)
{
	const char *dataPath = ".";
	if ( argc < 2 )
	{
		printf("Using local test FILE.\r\n");
	}
	else
	{
		dataPath = argv[1];
	}

	BlockChainCommand bc(dataPath);

	while ( bc.process() );


	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
cmpl $0x1, %edi
jg 0x15783
leaq 0x4b56(%rip), %rdi      # 0x1a2cb
callq 0x2260
leaq 0x1f08(%rip), %rsi      # 0x17689
jmp 0x15787
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x157c6
movq %rbx, %rdi
callq 0x1587e
testb %al, %al
jne 0x15793
leaq -0x50(%rbp), %rdi
callq 0x160ca
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x160ca
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/main.cpp
// Function: BlockChainCommand::BlockChainCommand(char const*)
BlockChainCommand(const char *dataPath)
	{
		mBlockChain = createBlockChain(dataPath);	// Create the block-chain parser using this root path
		mStatResolution = SR_YEAR;
		mMaxBlock = 500000;
		printf("Welcome to the BlockChain command parser.  Written by John W. Ratcliff on January 4, 2014 : TipJar: 1BT66EoaGySkbY9J6MugvQRhMMXDwPxPya\r\n");
		printf("Registered DataDirectory: %s to scan for the blockchain.\r\n", dataPath );
		printf("\r\n");
		mProcessTransactions = false;
		mProcessBlock = 0;
		mLastBlockScan = 0;
		mLastBlockPrint = 0;
		mFinishedScanning = false;
		mCurrentBlock = NULL;
		mLastTime = 0;
		mSatoshiTime = 0;
		mMinBalance = 1;
		mRecordAddresses = false;
		mAddresses = NULL;
		mMode = CM_NONE;

		if ( mBlockChain )
		{
			help();
		}
		else
		{
			printf("Failed to open file: blk00000.dat in directory: %s\r\n", dataPath );
			mMode = CM_EXIT;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb579
movq %rax, 0x28(%rbx)
movl $0x2, 0x8(%rbx)
movl $0x7a120, 0x10(%rbx)    # imm = 0x7A120
leaq 0x4aec(%rip), %rdi      # 0x1a2e3
callq 0x2260
leaq 0x4608(%rip), %rdi      # 0x19e0b
xorl %r15d, %r15d
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
leaq 0x4257(%rip), %rdi      # 0x19a6e
callq 0x2260
movb $0x0, 0x6(%rbx)
movl %r15d, 0xc(%rbx)
movq %r15, 0x14(%rbx)
movq %r15, 0x20(%rbx)
movq %r15, 0x30(%rbx)
movl $0x1, 0x38(%rbx)
movw $0x0, 0x4(%rbx)
movq %r15, 0x40(%rbx)
movl %r15d, (%rbx)
cmpq %r15, 0x28(%rbx)
je 0x1585c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16104
leaq 0x45e3(%rip), %rdi      # 0x19e46
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
movl $0x3, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/main.cpp
// Function: BlockChainCommand::~BlockChainCommand()
~BlockChainCommand(void)
	{
		if ( mAddresses )
		{
			mAddresses->release();
		}
		if ( mBlockChain )
		{
			mBlockChain->release();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x160e2
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x160f4
movq (%rdi), %rax
callq *0x98(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x775d
nop
// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/main.cpp
// Function: BlockChainCommand::stopScanning()
void stopScanning(void)
	{
		mFinishedScanning = true;
		mMode = CM_NONE; // done scanning.
		mLastBlockScan = mBlockChain->buildBlockChain();
		mCurrentBlock = mBlockChain->readBlock(0);
		printf("Stopped scanning block headers early. Built block-chain with %d blocks found..\r\n", mLastBlockScan);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x5(%rdi)
movl $0x0, (%rdi)
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movl %eax, 0x14(%rbx)
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x20(%rax)
movq %rax, 0x20(%rbx)
movl 0x14(%rbx), %esi
leaq 0x4028(%rip), %rdi      # 0x1a27a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2050
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/unorderedWordCount.cc
// Function: main
int main()
{
	// count occurrences, but the words won't be in alphabetical order
	unordered_map<string, size_t> word_count;
	string word;
	while (cin >> word)
		++word_count[word]; // fetch and increment the counter for word

	for (const auto& w : word_count) // for each element in the map
		// print the results
		cout <<  w.first << " occurs " << w.second
			 << ((w.second > 1) ? " times" : " time") << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq -0x50(%rbp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2bf7(%rip), %rbx      # 0x4fe0
leaq -0x48(%rbp), %r14
leaq -0x80(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2150
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x241a
movq %r15, %rdi
movq %r14, %rsi
callq 0x2998
incq (%rax)
jmp 0x23f1
movq -0x70(%rbp), %r13
testq %r13, %r13
je 0x24c3
leaq 0xbd6(%rip), %r14       # 0x3004
leaq 0xbd8(%rip), %r12       # 0x300d
leaq 0xbd8(%rip), %rbx       # 0x3014
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
movq 0x2b85(%rip), %rdi      # 0x4fd0
callq 0x2140
movq %rax, %r15
movl $0x8, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
movq 0x28(%r13), %rsi
movq %r15, %rdi
callq 0x2090
movq %rax, %r15
cmpq $0x2, 0x28(%r13)
movq %rbx, %rsi
cmovaeq %r12, %rsi
movl $0x5, %edx
sbbq $-0x1, %rdx
movq %rax, %rdi
callq 0x2140
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2100
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20a0
movq (%r13), %r13
testq %r13, %r13
jne 0x243c
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x24dc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2120
leaq -0x80(%rbp), %rdi
callq 0x26ca
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24f8
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x2514
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2120
leaq -0x80(%rbp), %rdi
callq 0x26ca
movq %rbx, %rdi
callq 0x21a0
// File: /workspace/github_cpp_makefile_star2_O1/qinguoyi[P]TinyWebServer/webserver.cpp
// Function: WebServer::sql_pool()
void WebServer::sql_pool()
{
    //初始化数据库连接池
    m_connPool = connection_pool::GetInstance();
    m_connPool->init("localhost", m_user, m_passWord, m_databaseName, 3306, m_sql_num, m_close_log);

    //初始化数据库读取表
    users->initmysql_result(m_connPool);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
callq 0x6bf0
movq %rax, %r14
movq %rax, 0x30(%rbx)
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1fb7(%rip), %rsi      # 0x9485
leaq 0x1fb9(%rip), %rdx      # 0x948e
leaq 0x68(%rsp), %rdi
callq 0x3d66
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x3cd6
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x58(%rbx), %rsi
movq 0x60(%rbx), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3cd6
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3cd6
movl 0x14(%rbx), %eax
movl 0x98(%rbx), %r10d
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %r14, %rdi
movl $0xcea, %r9d            # imm = 0xCEA
pushq %rax
pushq %r10
callq 0x6c60
addq $0x10, %rsp
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7587
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x759e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x75b5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x75cc
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x422c
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x760a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x33a0
jmp 0x760a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x7626
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x33a0
jmp 0x7626
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x7642
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x33a0
jmp 0x7642
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x7659
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x33a0
movq %rbx, %rdi
callq 0x35e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/qinguoyi[P]TinyWebServer/webserver.cpp
// Function: WebServer::adjust_timer(util_timer*)
void WebServer::adjust_timer(util_timer *timer)
{
    time_t cur = time(NULL);
    timer->expire = cur + 3 * TIMESLOT;
    utils.m_timer_lst.adjust_timer(timer);

    LOG_INFO("%s", "adjust timer once");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edi, %edi
callq 0x3360
addq $0xf, %rax
movq %rax, (%rbx)
leaq 0x1d588(%r14), %rdi
movq %rbx, %rsi
callq 0x3ebc
cmpl $0x0, 0x14(%r14)
je 0x7b9a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x58ea
leaq 0x1712(%rip), %rdx      # 0x92b8
leaq 0x1941(%rip), %rcx      # 0x94ee
movq %rax, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x6440
callq 0x58ea
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6866
// File: /workspace/github_cpp_makefile_star2_O1/qinguoyi[P]TinyWebServer/webserver.cpp
// Function: WebServer::deal_timer(util_timer*, int)
void WebServer::deal_timer(util_timer *timer, int sockfd)
{
    timer->cb_func(&users_timer[sockfd]);
    if (timer)
    {
        utils.m_timer_lst.del_timer(timer);
    }

    LOG_INFO("close fd %d", users_timer[sockfd].sockfd);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %r15
shlq $0x5, %r15
movq 0x1d580(%rdi), %rdi
addq %r15, %rdi
callq *0x8(%rsi)
testq %r14, %r14
je 0x7c03
leaq 0x1d588(%rbx), %rdi
movq %r14, %rsi
callq 0x3f6a
cmpl $0x0, 0x14(%rbx)
je 0x7c0f
popq %rbx
popq %r14
popq %r15
retq
callq 0x58ea
movq 0x1d580(%rbx), %rcx
movl 0x10(%rcx,%r15), %ecx
leaq 0x18d9(%rip), %rdx      # 0x9500
movq %rax, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x6440
callq 0x58ea
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6866
// File: /workspace/github_cpp_makefile_star2_O1/TNanukem[P]chip8-emulator/chip8.cpp
// Function: chip8::initialize()
void chip8::initialize(){

	// Clears the memory of the system
	for(int i = 0; i < 4096; i++){
		memory[i] = 0;
	}

	// Clears all registers and the stack
	for(int i = 0; i < 16; i++){
		v[i] = 0;
		stack[i] = 0;
        keyboard[i] = 0;
	}

	// Clears the display
	for(int i = 0; i < 2048; i++){
		display[i] = 0;
	}

	// Uploads the fontset to the Memory
	for(int i = 0; i < 80; i++){
		memory[i] = chip8_fontset[i];
	}

	opcode = 0;
	pc = 0x200;
	sp = 0;
	I = 0;

	soundTimer = 0;
	delayTimer = 0;

	drawFlag = 1;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2(%rdi), %r14
xorl %r15d, %r15d
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rdi
xorl %esi, %esi
callq 0x2110
xorps %xmm0, %xmm0
movups %xmm0, 0x1002(%rbx)
movups %xmm0, 0x301a(%rbx)
movups %xmm0, 0x302a(%rbx)
movups %xmm0, 0x303c(%rbx)
leaq 0x1018(%rbx), %rdi
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x2110
leaq 0x3c88(%rip), %rsi      # 0x61b0
movl $0x50, %edx
movq %r14, %rdi
callq 0x2180
movw %r15w, (%rbx)
movw %r15w, 0x303a(%rbx)
movl $0x2000000, 0x1012(%rbx) # imm = 0x2000000
movw %r15w, 0x3018(%rbx)
movb $0x1, 0x304c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/TNanukem[P]chip8-emulator/chip8.cpp
// Function: chip8::loadGame(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool chip8::loadGame(std::string game){
    //printf("Loading the game....\n");
	FILE *gameP = fopen(game.c_str(), "rb");
	if(gameP == NULL){
        //printf("ERROR! Game file not found!\n");
		return false;
	}

	// Finds the size of the game
	fseek(gameP, 0, SEEK_END);
	long int gameSize = ftell(gameP);
	fseek(gameP, 0, SEEK_SET);

	// Reads the data from the game into the buffer
	char *buffer = (char*) malloc(sizeof(char)*gameSize);
	if(buffer == NULL){
		return false;
	}
	fread(buffer, 1, gameSize, gameP);

	// Writes the data on the memory
	for(int i = 0; i < gameSize; i++){
		memory[i + 512] = buffer[i];
        //printf("Memory[%d] = %d\n", i+512,memory[i+512]);
	}

	fclose(gameP);
	free(buffer);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x1b02(%rip), %rsi      # 0x4080
callq 0x2210
testq %rax, %rax
je 0x2605
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21d0
movq %r14, %rdi
callq 0x2030
movq %rax, %r15
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
movq %r15, %rdi
callq 0x2260
movq %rax, %r12
testq %rax, %rax
setne %al
je 0x2607
movl $0x1, %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2280
testq %r15, %r15
jle 0x25f1
addq $0x202, %rbx            # imm = 0x202
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x2180
movq %r14, %rdi
callq 0x21b0
movq %r12, %rdi
callq 0x2220
movb $0x1, %al
jmp 0x2607
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/TNanukem[P]chip8-emulator/display.cpp
// Function: display::displayInit()
void display::displayInit(){

    if(SDL_Init(SDL_INIT_EVERYTHING) < 0)
		printf("Error! Unable to initialize the SDL!\n");

	// Creates the screen
	screen = SDL_CreateWindow("CHIP-8 Emulator", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 1024, 512, SDL_WINDOW_SHOWN);
	if(screen == NULL)
		printf("Error! Unable to create the screen!\n");

	// Creates the render
	render = SDL_CreateRenderer(screen, -1, SDL_RENDERER_ACCELERATED);
	if(render == NULL)
		printf("Error! Unable to create the render!\n");

	SDL_SetRenderDrawColor(render, 0xFF, 0xFF, 0xFF, 0xFF);

	// Creates the Texture
	texture = SDL_CreateTexture(render, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STATIC, 64, 32);
	if(texture == NULL)
		printf("Error! Unable to create the texture!\n");

	// Delay to see possible errors
	SDL_Delay(1000);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xf231, %edi           # imm = 0xF231
callq 0x21a0
testl %eax, %eax
jns 0x2d17
leaq 0x1381(%rip), %rdi      # 0x4093
callq 0x22a0
leaq 0x1365(%rip), %rdi      # 0x4083
movl $0x1fff0000, %esi       # imm = 0x1FFF0000
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
movl $0x400, %ecx            # imm = 0x400
movl $0x200, %r8d            # imm = 0x200
movl $0x4, %r9d
callq 0x2080
movq %rax, (%rbx)
testq %rax, %rax
jne 0x2d52
leaq 0x136b(%rip), %rdi      # 0x40b8
callq 0x22a0
movq (%rbx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x2050
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x2d79
leaq 0x1368(%rip), %rdi      # 0x40dc
callq 0x22a0
movq 0x8(%rbx), %rdi
movl $0xff, %esi
movl $0xff, %edx
movl $0xff, %ecx
movl $0xff, %r8d
callq 0x2270
movq 0x8(%rbx), %rdi
movl $0x16362004, %esi       # imm = 0x16362004
xorl %edx, %edx
movl $0x40, %ecx
movl $0x20, %r8d
callq 0x22f0
movq %rax, 0x10(%rbx)
testq %rax, %rax
jne 0x2dc7
leaq 0x133e(%rip), %rdi      # 0x4100
callq 0x22a0
movl $0x3e8, %edi            # imm = 0x3E8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O1/TNanukem[P]chip8-emulator/display.cpp
// Function: display::displayDraw(unsigned int*)
void display::displayDraw(uint32_t *disp){
    // Saves the display pixels on the buffer
	uint32_t pixel;
    uint32_t pixels[32*64];

    for(int i = 0; i < 2048; i++){
        pixel = disp[i];
        pixels[i] = (0x00FFFFFF * pixel) | 0xFF000000;
    }

    // Updates the screen
    SDL_UpdateTexture(texture, NULL, pixels, 64 * sizeof(uint32_t));
    SDL_RenderCopy(render, texture, NULL, NULL);
    SDL_RenderPresent(render);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x2008, %rsp           # imm = 0x2008
movq %rdi, %rbx
xorl %eax, %eax
xorl %ecx, %ecx
subl (%rsi,%rax,4), %ecx
orl $0xff000000, %ecx       # imm = 0xFF000000
movl %ecx, -0x2010(%rbp,%rax,4)
incq %rax
cmpq $0x800, %rax            # imm = 0x800
jne 0x2df7
movq 0x10(%rbx), %rdi
leaq -0x2010(%rbp), %rdx
xorl %esi, %esi
movl $0x100, %ecx            # imm = 0x100
callq 0x2170
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x21e0
movq 0x8(%rbx), %rdi
callq 0x20a0
addq $0x2008, %rsp           # imm = 0x2008
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/TNanukem[P]chip8-emulator/display.cpp
// Function: display::displayDestroy()
void display::displayDestroy(){
    SDL_DestroyTexture(texture);
    SDL_DestroyRenderer(render);
    SDL_DestroyWindow(screen);
    SDL_Quit();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x2150
movq 0x8(%rbx), %rdi
callq 0x20f0
movq (%rbx), %rdi
callq 0x2040
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2090
nop
// File: /workspace/github_cpp_makefile_star2_O1/jp-myk[P]WAVUtil/src/wav_trim.cpp
// Function: main
int main(int argc, char *argv[]){
  if(argc<5){
    std::cout << argv[0] << " WAVFILE OUTWAVFLE START_TIME[sec] END_TIME[sec]" << std::endl;
    exit(0);
  }
  const char* wavFName=argv[1];
  const char* output_wavFName=argv[2];
  float start= 0.0;
  float end  = 1.0;
  start= atof(argv[3]);
  end  = atof(argv[4]);
  WAV wav,outwav;
  int res=0;
  res=wav.Read(wavFName);
  std::cout << "trim!" << std::endl;
  res=SimpleWAV::trim_wav(start, end, wav, outwav); // extra 0.0 - 1.00[sec]
  res=outwav.Write(output_wavFName);
  if(res==0) std::cout << "sucess" << std::endl;

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r15
cmpl $0x4, %edi
jle 0x3c0b
movq 0x8(%r15), %r14
movq 0x10(%r15), %rbx
movq 0x18(%r15), %rdi
callq 0x21c0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%r15), %rdi
callq 0x21c0
movsd %xmm0, (%rsp)
xorl %eax, %eax
leaq 0x68(%rsp), %rdi
movl %eax, 0x4(%rdi)
movabsq $0x2000100000010, %rcx  # imm = 0x2000100000010
movq %rcx, 0x10(%rdi)
movabsq $0x7d000000ac44, %rdx   # imm = 0x7D000000AC44
movq %rdx, 0x18(%rdi)
movl $0x100002, %esi         # imm = 0x100002
movl %esi, 0x20(%rdi)
movl %eax, 0x28(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
movl %eax, 0x14(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movl %esi, 0x30(%rsp)
movl %eax, 0x38(%rsp)
movups %xmm0, 0x40(%rsp)
movups %xmm0, 0x50(%rsp)
movq %rax, 0x60(%rsp)
movq %r14, %rsi
callq 0x2a90
movq 0x249b(%rip), %r14      # 0x5fd0
leaq 0x7fe(%rip), %rsi       # 0x433a
movl $0x5, %edx
movq %r14, %rdi
callq 0x2190
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq 0x2469(%rip), %rdi      # 0x5fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorps %xmm0, %xmm0
cvtsd2ss 0x8(%rsp), %xmm0
cvtsd2ss (%rsp), %xmm1
leaq 0x68(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3114
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x27e8
testl %eax, %eax
jne 0x3be8
movq 0x2427(%rip), %rbx      # 0x5fd0
leaq 0x790(%rip), %rsi       # 0x4340
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %esi
movq 0x23f5(%rip), %rdi      # 0x5fd0
callq 0x2030
movq %rax, %rdi
callq 0x2100
leaq 0x10(%rsp), %rdi
callq 0x273e
leaq 0x68(%rsp), %rdi
callq 0x273e
xorl %eax, %eax
addq $0xc0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%r15), %rsi
movq 0x23bb(%rip), %rdi      # 0x5fd0
callq 0x2160
leaq 0x6e8(%rip), %rsi       # 0x4309
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
jmp 0x3c5d
jmp 0x3c5d
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x273e
leaq 0x68(%rsp), %rdi
callq 0x273e
movq %rbx, %rdi
callq 0x2280
jmp 0x3c5d
movq %rax, %rdi
callq 0x379f
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_load_file(unsigned char**, unsigned long*, char const*)
unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename) {
  unsigned error;
  FILE* file = fopen(filename, "rb");
  if(!file) return 78;
  error = lodepng_load_file_(out, outsize, file);
  fclose(file);
  return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x7211c(%rip), %rsi     # 0x7474d
movq %rdx, %rdi
callq 0x2280
testq %rax, %rax
je 0x2696
movq %rax, %rbx
movq %rax, %rdi
callq 0xd8f9
testq %rax, %rax
js 0x269d
movq %rax, %r12
movq %rax, (%r14)
movq %rax, %rdi
callq 0x22a0
movq %rax, (%r15)
testq %rax, %rax
sete %cl
testq %r12, %r12
setne %dl
movl $0x53, %ebp
testb %cl, %dl
jne 0x26a2
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x22d0
xorl %ecx, %ecx
cmpq (%r14), %rax
movl $0x4e, %ebp
cmovel %ecx, %ebp
jmp 0x26a2
movl $0x4e, %ebp
jmp 0x26aa
movl $0x4e, %ebp
movq %rbx, %rdi
callq 0x2220
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_inflate(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
unsigned lodepng_inflate(unsigned char** out, size_t* outsize,
                         const unsigned char* in, size_t insize,
                         const LodePNGDecompressSettings* settings) {
  ucvector v = ucvector_init(*out, *outsize);
  unsigned error = lodepng_inflatev(&v, in, insize, settings);
  *out = v.data;
  *outsize = v.size;
  return error;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq (%rsi), %rsi
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %rsi, 0x8(%r15)
movq %rsi, 0x10(%r15)
movq %r15, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x2d52
movq (%r15), %rcx
movq %rcx, (%r14)
movq 0x8(%r15), %rcx
movq %rcx, (%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_zlib_decompressv(ucvector*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*)
static unsigned lodepng_zlib_decompressv(ucvector* out,
                                         const unsigned char* in, size_t insize,
                                         const LodePNGDecompressSettings* settings) {
  unsigned error = 0;
  unsigned CM, CINFO, FDICT;

  if(insize < 2) return 53; /*error, size of zlib data too small*/
  /*read information from zlib header*/
  if((in[0] * 256 + in[1]) % 31 != 0) {
    /*error: 256 * in[0] + in[1] must be a multiple of 31, the FCHECK value is supposed to be made that way*/
    return 24;
  }

  CM = in[0] & 15;
  CINFO = (in[0] >> 4) & 15;
  /*FCHECK = in[1] & 31;*/ /*FCHECK is already tested above*/
  FDICT = (in[1] >> 5) & 1;
  /*FLEVEL = (in[1] >> 6) & 3;*/ /*FLEVEL is not used here*/

  if(CM != 8 || CINFO > 7) {
    /*error: only compression method 8: inflate with sliding window of 32k is supported by the PNG spec*/
    return 25;
  }
  if(FDICT != 0) {
    /*error: the specification of PNG says about the zlib stream:
      "The additional flags shall not specify a preset dictionary."*/
    return 26;
  }

  error = inflatev(out, in + 2, insize - 2, settings);
  if(error) return error;

  if(!settings->ignore_adler32) {
    unsigned ADLER32 = lodepng_read32bitInt(&in[insize - 4]);
    unsigned checksum = adler32(out->data, (unsigned)(out->size));
    if(checksum != ADLER32) return 58; /*error, adler checksum not correct, data must be corrupted*/
  }

  return 0; /*no error*/
}

// Assembly:
movl $0x35, %eax
cmpq $0x2, %rdx
jb 0x4b3c
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movzbl (%rsi), %edx
movl %edx, %eax
shll $0x8, %eax
movzbl 0x1(%rsi), %ecx
orl %ecx, %eax
imull $0xbdef7bdf, %eax, %esi # imm = 0xBDEF7BDF
movl $0x18, %eax
cmpl $0x8421084, %esi        # imm = 0x8421084
ja 0x4b34
movl %edx, %eax
andl $0xf, %eax
cmpl $0x8, %eax
setne %al
testb %dl, %dl
sets %dl
orb %al, %dl
movl $0x19, %eax
jne 0x4b34
movl $0x1a, %eax
testb $0x20, %cl
jne 0x4b34
movq %rdi, %rbx
leaq 0x2(%r15), %rdx
leaq -0x2(%r14), %rcx
movq 0x18(%r12), %rax
testq %rax, %rax
je 0x4aee
leaq 0x8(%rbx), %rsi
movq %rbx, %rdi
movq %r12, %r8
callq *%rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x10(%rbx)
testl %eax, %eax
je 0x4b01
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x4b05
cmpq %rcx, %rax
movl $0x6e, %eax
sbbl $0x0, %eax
jmp 0x4b0a
movq %rbx, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r12, %rcx
callq 0x2d52
jmp 0x4b0a
xorl %eax, %eax
jmp 0x4b0a
movl $0x6e, %eax
testl %eax, %eax
jne 0x4b34
cmpl $0x0, (%r12)
jne 0x4b32
movl -0x4(%r15,%r14), %ebp
bswapl %ebp
movq (%rbx), %rdi
movl 0x8(%rbx), %esi
callq 0x4caa
movl %eax, %ecx
movl $0x3a, %eax
cmpl %ebp, %ecx
jne 0x4b34
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_crc32(unsigned char const*, unsigned long)
unsigned lodepng_crc32(const unsigned char* data, size_t length) {
  /*Using the Slicing by Eight algorithm*/
  unsigned r = 0xffffffffu;
  while(length >= 8) {
    r = lodepng_crc32_table7[(data[0] ^ (r & 0xffu))] ^
        lodepng_crc32_table6[(data[1] ^ ((r >> 8) & 0xffu))] ^
        lodepng_crc32_table5[(data[2] ^ ((r >> 16) & 0xffu))] ^
        lodepng_crc32_table4[(data[3] ^ ((r >> 24) & 0xffu))] ^
        lodepng_crc32_table3[data[4]] ^
        lodepng_crc32_table2[data[5]] ^
        lodepng_crc32_table1[data[6]] ^
        lodepng_crc32_table0[data[7]];
    data += 8;
    length -= 8;
  }
  while(length--) {
    r = lodepng_crc32_table0[(r ^ *data++) & 0xffu] ^ (r >> 8);
  }
  return r ^ 0xffffffffu;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $0x8, %rsi
jb 0x4e4f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xff, %ecx
leaq 0x6d4cd(%rip), %rdx     # 0x72270
leaq 0x6d8c6(%rip), %r8      # 0x72670
leaq 0x6dcbf(%rip), %r9      # 0x72a70
leaq 0x6e0b8(%rip), %r10     # 0x72e70
leaq 0x6e4b1(%rip), %r11     # 0x73270
leaq 0x6e8aa(%rip), %rbx     # 0x73670
leaq 0x6eca3(%rip), %r14     # 0x73a70
leaq 0x6f09c(%rip), %r15     # 0x73e70
movzbl (%rdi), %eax
movl %r12d, %r13d
andl %ecx, %r13d
xorl %eax, %r13d
movzbl 0x1(%rdi), %eax
movl %r12d, %ebp
shrl $0x8, %ebp
andl %ecx, %ebp
xorl %eax, %ebp
movl (%r8,%rbp,4), %eax
xorl (%rdx,%r13,4), %eax
movzbl 0x2(%rdi), %ebp
movl %r12d, %r13d
shrl $0x10, %r13d
andl %ecx, %r13d
xorl %ebp, %r13d
xorl (%r9,%r13,4), %eax
movzbl 0x3(%rdi), %ebp
shrl $0x18, %r12d
xorl %ebp, %r12d
xorl (%r10,%r12,4), %eax
movzbl 0x4(%rdi), %r12d
xorl (%r11,%r12,4), %eax
movzbl 0x5(%rdi), %r12d
xorl (%rbx,%r12,4), %eax
movzbl 0x6(%rdi), %r12d
xorl (%r14,%r12,4), %eax
movzbl 0x7(%rdi), %r12d
xorl (%r15,%r12,4), %eax
addq $0x8, %rdi
addq $-0x8, %rsi
movl %eax, %r12d
cmpq $0x7, %rsi
ja 0x4dd4
testq %rsi, %rsi
je 0x4e77
xorl %ecx, %ecx
leaq 0x6f013(%rip), %rdx     # 0x73e70
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x4e5d
notl %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq