// File: /workspace/github_cpp_makefile_star2_O1/jeffchan[P]blockchain-parser/BlockChain.cpp
// Function: BitcoinTransactionFactory::gatherStatistics(unsigned int, unsigned int, bool)
void gatherStatistics(uint32_t stime,uint32_t zombieDate,bool recordAddresses)
	{
		gatherAddresses();

		assert( mStatCount < MAX_STAT_COUNT );
		StatRow &row = mStatistics[mStatCount];
		row.mTime = stime;

		time_t currentTime;
		time(&currentTime); // get the current time.

		for (uint32_t i=0; i<mAddresses.size(); i++) // print one in every 10,000 addresses (just for testing right now)
		{
			BitcoinAddress *ba = mAddresses.getKey(i);
			uint64_t balance = ba->mTotalReceived-ba->mTotalSent;
			StatSize s = getStatSize(balance);
			row.mCount++;
			row.mValue+=balance;

			row.mStats[s].mCount++;
			row.mStats[s].mValue+=balance;

			uint32_t lastUsed = ba->mLastInputTime; // the last time we sent money (not received because anyone can send us money).
			if ( ba->mLastInputTime == 0 ) // if it has never had a spend.. then we use the time of first receive..
			{
				lastUsed = ba->mFirstOutputTime;
			}

			if ( lastUsed < zombieDate )
			{
				row.mZombieTotal+=balance;
				row.mZombieCount++;
			}

		}

		if ( recordAddresses )
		{
			// First compute how many bitcoin addresses have a balance over a minimum bitcoin size (we will start with just one)
			uint32_t plotCount = 0;

			for (uint32_t i=0; i<mAddresses.size(); i++) 
			{
				BitcoinAddress *ba = mAddresses.getKey(i);
				uint64_t balance = ba->mTotalReceived-ba->mTotalSent;
				if ( balance >= ONE_BTC )
				{
					plotCount++;
				}
			}

			printf("Gathering Address Delta's for %s addresses containing more than one bitcoin\r\n", formatNumber(plotCount) );

			if ( plotCount )
			{
				BitcoinAddress **sortPointers = new BitcoinAddress*[plotCount];
				uint32_t plotCount = 0;
				for (uint32_t i=0; i<mAddresses.size(); i++) // print one in every 10,000 addresses (just for testing right now)
				{
					BitcoinAddress *ba = mAddresses.getKey(i);
					uint64_t balance = ba->mTotalReceived-ba->mTotalSent;
					if ( balance >= ONE_BTC )
					{
						sortPointers[plotCount] = ba;
						plotCount++;
					}
				}

				uint32_t reportCount = plotCount;

				row.mAddresses = new StatAddress[reportCount];
				row.mAddressCount = reportCount;

				SortByBalance sb(sortPointers,plotCount);

				for (uint32_t i=0; i<reportCount; i++)
				{
					BitcoinAddress *ba = sortPointers[i];
					StatAddress &sa = row.mAddresses[i];
					sa.mAddress = mAddresses.getIndex(ba)+1;
					sa.mLastTime = ba->getLastUsedTime();
					sa.mFirstTime = ba->mFirstOutputTime;
					sa.mTotalReceived = (uint32_t)(ba->mTotalReceived/ONE_MBTC);
					sa.mTotalSent = (uint32_t)(ba->mTotalSent/ONE_MBTC);
					sa.mTransactionCount = (uint8_t) (ba->mTransactionCount > 255 ? 255 : ba->mTransactionCount);
					uint32_t inputCount = ba->getInputCount();
					uint32_t outputCount = ba->getOutputCount();
					sa.mInputCount = (uint8_t) (inputCount > 255 ? 255 : inputCount);
					sa.mOutputCount = (uint8_t) (outputCount > 255 ? 255 : outputCount);
				}

				if ( mStatCount >= 1 )
				{
					// build the delta!
					StatRow &previousRow = mStatistics[mStatCount-1];
					//
					uint32_t *addressIndex = new uint32_t[mAddresses.size()];	// convert from master address list to used by statistics address list table

					memset(addressIndex,0,sizeof(uint32_t)*mAddresses.size());

					for (uint32_t i=0; i<previousRow.mAddressCount; i++)
					{
						StatAddress &sa = previousRow.mAddresses[i];
						addressIndex[sa.mAddress-1] = i+1; // make this address as being used by the previous row
					}

					uint32_t changeCount=0;
					uint32_t newCount=0;
					uint32_t deleteCount=0;
					uint32_t sameCount=0;
					uint32_t riseFromTheDeadCount=0;
					uint32_t riseFromTheDeadAmount=0;

					for (uint32_t i=0; i<row.mAddressCount; i++)
					{
						StatAddress &na = row.mAddresses[i];	// get the current row address
						uint32_t aindex = na.mAddress-1; // get the array index for this address

						if ( addressIndex[aindex] ) // did the previous row use this address?
						{
							uint32_t pindex = addressIndex[aindex]-1; // get the array index in the previous row so we can do a compare.

							addressIndex[aindex] = 0xFFFFFFFF; // make it as processed.

							StatAddress &oa = previousRow.mAddresses[pindex];

							if ( na == oa )
							{
								sameCount++; // no changes...
							}
							else
							{
								// ok.. if it previously existed but there has been a change, was it a zombie change?
								if ( oa.mLastTime < zombieDate && na.mLastTime >= zombieDate )
								{
									riseFromTheDeadCount++;
									riseFromTheDeadAmount+=oa.getBalance(); // how much bitcoin rose from the dead.
								}
								changeCount++;
							}
						}
						else
						{
							newCount++;
						}
					}

					for (uint32_t i=0; i<mAddresses.size(); i++)
					{
						if ( addressIndex[i] && addressIndex[i] != 0xFFFFFFFF )
						{
							deleteCount++;
						}
					}

					row.mNewAddressCount = newCount;
					row.mDeleteAddressCount = deleteCount;
					row.mChangeAddressCount = changeCount;
					row.mSameAddressCount = sameCount;
					row.mRiseFromDeadAmount = riseFromTheDeadAmount;
					row.mRiseFromDeadCount = riseFromTheDeadCount;


					if ( newCount )
					{
						row.mNewAddresses = new StatAddress[newCount];
					}

					if ( changeCount )
					{
						row.mChangedAddresses = new StatAddress[changeCount];
					}
					// Assign an array index to each address used by the previous row
					memset(addressIndex,0,sizeof(uint32_t)*mAddresses.size());
					for (uint32_t i=0; i<previousRow.mAddressCount; i++)
					{
						StatAddress &sa = previousRow.mAddresses[i];
						addressIndex[sa.mAddress-1] = i+1;
					}

					newCount = 0;
					changeCount = 0;
					sameCount = 0;

					for (uint32_t i=0; i<row.mAddressCount; i++)
					{
						StatAddress &na = row.mAddresses[i];
						uint32_t aindex = na.mAddress-1;

						if ( addressIndex[aindex] ) // did the previous row have this address.
						{
							uint32_t pindex = addressIndex[aindex]-1;
							addressIndex[aindex] = 0xFFFFFFFF; // make it as processed.
							StatAddress &oa = previousRow.mAddresses[pindex];
							if ( na == oa )
							{
								sameCount++;
							}
							else
							{
								row.mChangedAddresses[changeCount] = na;
								changeCount++;
							}
						}
						else
						{
							row.mNewAddresses[newCount] = na;
							newCount++;
						}
					}

					if ( deleteCount ) 
					{
						row.mDeletedAddresses = new uint32_t[deleteCount];
						deleteCount = 0;
						for (uint32_t i=0; i<mAddresses.size(); i++)
						{
							if ( addressIndex[i] && addressIndex[i] != 0xFFFFFFFF )
							{
								row.mDeletedAddresses[deleteCount] = i+1;
								deleteCount++;
							}
						}
					}

					delete []addressIndex;

					printf("Found %s new addresses, %s changed addresses, and %s deleted addresses\r\n",
						formatNumber(newCount),
						formatNumber(changeCount),
						formatNumber(deleteCount));

					if ( mStatCount >= 2 )
					{
						StatRow &oldRow = mStatistics[mStatCount-2];
						delete []oldRow.mAddresses;
						oldRow.mAddresses = NULL;
						oldRow.mAddressCount = 0;
					}
				}
				delete []sortPointers;
			}
		}
		mStatCount++;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
callq 0xd328
movl 0x2000050(%rbx), %eax
cmpq $0x88e, %rax            # imm = 0x88E
jae 0xddc8
imulq $0x190, %rax, %rax      # imm = 0x190
leaq (%rbx,%rax), %r13
addq $0x2000058, %r13        # imm = 0x2000058
movl %r12d, 0xc(%r13)
leaq -0x80(%rbp), %rdi
callq 0x2120
movl 0x2000000(%rbx), %eax
testq %rax, %rax
je 0xd6fe
movq 0x2000008(%rbx), %rdx
leaq 0x20(%r13), %rsi
movl 0x10(%r13), %ecx
movq 0x18(%r13), %rdi
xorl %r8d, %r8d
leaq (%r8,%r8,4), %r10
shlq $0x4, %r10
movq 0x28(%rdx,%r10), %r9
subq 0x20(%rdx,%r10), %r9
jne 0xd69b
xorl %r11d, %r11d
jmp 0xd6bf
xorl %r11d, %r11d
cmpq %r9, 0x20d5ed8(%rbx,%r11,8)
ja 0xd6b9
incq %r11
cmpq $0x11, %r11
jne 0xd69e
movl $0x12, %r11d
jmp 0xd6bc
incq %r11
movl %r11d, %r11d
addq %r9, %rdi
movq %rdi, 0x18(%r13)
shlq $0x4, %r11
incl (%rsi,%r11)
addq %r9, 0x8(%rsi,%r11)
addq %rdx, %r10
movl 0x14(%r10), %r11d
testl %r11d, %r11d
jne 0xd6e3
movl 0x1c(%r10), %r11d
cmpl %r15d, %r11d
jae 0xd6f0
addq %r9, (%r13)
incl 0x8(%r13)
incq %r8
cmpq %rax, %r8
jne 0xd682
addl %eax, %ecx
movl %ecx, 0x10(%r13)
testb %r14b, %r14b
je 0xdd94
testq %rax, %rax
je 0xd740
movq 0x2000008(%rbx), %rcx
shlq $0x4, %rax
leaq (%rax,%rax,4), %rax
xorl %edx, %edx
xorl %r14d, %r14d
movq 0x28(%rcx,%rdx), %rsi
subq 0x20(%rcx,%rdx), %rsi
cmpq $0x5f5e100, %rsi        # imm = 0x5F5E100
sbbl $-0x1, %r14d
addq $0x50, %rdx
cmpq %rdx, %rax
jne 0xd720
jmp 0xd743
xorl %r14d, %r14d
movl %r14d, %edi
callq 0xb5d3
leaq 0xabb9(%rip), %rdi      # 0x1830b
xorl %r12d, %r12d
movq %rax, %rsi
xorl %eax, %eax
callq 0x2050
testl %r14d, %r14d
je 0xdd94
movl %r15d, -0x5c(%rbp)
movl %r14d, %edi
shlq $0x3, %rdi
callq 0x2040
movq %rax, %r15
movl 0x2000000(%rbx), %eax
testq %rax, %rax
je 0xd7b4
movq 0x2000008(%rbx), %rcx
xorl %r12d, %r12d
movq 0x28(%rcx), %rdx
subq 0x20(%rcx), %rdx
cmpq $0x5f5e100, %rdx        # imm = 0x5F5E100
jb 0xd7ab
movl %r12d, %edx
movq %rcx, (%r15,%rdx,8)
incl %r12d
addq $0x50, %rcx
decq %rax
jne 0xd790
movl %r12d, %r14d
leaq (,%r14,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x2040
testl %r12d, %r12d
je 0xd7f3
leaq (%r14,%r14,2), %rcx
leaq (%rax,%rcx,8), %rcx
xorl %edx, %edx
movq %rax, %rsi
movq $0x0, (%rsi)
movl %edx, 0x8(%rsi)
movl %edx, 0x10(%rsi)
movl %edx, 0x13(%rsi)
addq $0x18, %rsi
cmpq %rcx, %rsi
jne 0xd7da
movq %rax, 0x158(%r13)
movl %r12d, 0x150(%r13)
leaq 0x113d8(%rip), %rax     # 0x1ebe0
leaq -0x78(%rbp), %rdi
movq %rax, (%rdi)
movq %r15, %rsi
movl %r12d, %edx
callq 0xb372
testl %r12d, %r12d
je 0xd8ea
movq 0x2000008(%rbx), %rcx
movl $0x16, %esi
xorl %edi, %edi
movabsq $0xa7c5ac471b47843, %r8 # imm = 0xA7C5AC471B47843
movl $0xff, %r9d
movq (%r15,%rdi,8), %r11
testq %r11, %r11
je 0xdda9
movq 0x158(%r13), %r10
movq %r11, %rax
subq %rcx, %rax
shrq $0x4, %rax
imull $0xcccccccd, %eax, %eax # imm = 0xCCCCCCCD
incl %eax
movl %eax, -0x16(%r10,%rsi)
movl 0x14(%r11), %eax
movl 0x1c(%r11), %edx
testl %eax, %eax
cmovel %edx, %eax
movl %eax, -0x6(%r10,%rsi)
movl %edx, -0xa(%r10,%rsi)
movq 0x28(%r11), %rax
shrq $0x5, %rax
mulq %r8
shrq $0x7, %rdx
movl %edx, -0xe(%r10,%rsi)
movq 0x20(%r11), %rax
shrq $0x5, %rax
mulq %r8
shrq $0x7, %rdx
movl %edx, -0x12(%r10,%rsi)
movl 0x3c(%r11), %eax
cmpl %r9d, %eax
cmovael %r9d, %eax
movb %al, -0x2(%r10,%rsi)
movl 0x30(%r11), %eax
movl 0x34(%r11), %edx
cmpl %r9d, %eax
cmovael %r9d, %eax
movb %al, -0x1(%r10,%rsi)
cmpl %r9d, %edx
cmovael %r9d, %edx
movb %dl, (%r10,%rsi)
incq %rdi
addq $0x18, %rsi
cmpl %edi, %r14d
jne 0xd841
movl 0x2000050(%rbx), %eax
testl %eax, %eax
je 0xdd8c
movq %r15, -0x68(%rbp)
leaq 0x2000058(%rbx), %r12
decl %eax
imulq $0x190, %rax, %rax      # imm = 0x190
movq %rax, -0x38(%rbp)
addq %r12, %rax
movq %rax, -0x58(%rbp)
movl 0x2000000(%rbx), %r14d
shlq $0x2, %r14
movq %r14, %rdi
callq 0x2040
movq %rax, %r15
movl $0x0, -0x3c(%rbp)
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x20b0
movq %r15, %r8
movq %r12, -0x70(%rbp)
movq -0x38(%rbp), %rax
movl 0x150(%r12,%rax), %ecx
testq %rcx, %rcx
je 0xd987
movq -0x58(%rbp), %rax
movq 0x158(%rax), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
movl $0x1, %edx
xorl %esi, %esi
movl (%rax,%rsi), %edi
decl %edi
movl %edx, (%r8,%rdi,4)
addq $0x18, %rsi
incl %edx
cmpq %rsi, %rcx
jne 0xd973
cmpl $0x0, 0x150(%r13)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x40(%rbp)
movl $0x0, %edx
movl $0x0, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
je 0xda94
xorl %r15d, %r15d
xorl %r12d, %r12d
movl $0x0, -0x2c(%rbp)
xorl %edx, %edx
movl $0x0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x3c(%rbp)
movq %r13, -0x50(%rbp)
movq 0x158(%r13), %r13
movl (%r13,%r15), %eax
decl %eax
movl (%r8,%rax,4), %ecx
testl %ecx, %ecx
je 0xda31
movl %edx, -0x30(%rbp)
leaq (%r15,%r13), %rdi
decl %ecx
movl $0xffffffff, (%r8,%rax,4) # imm = 0xFFFFFFFF
leaq (%rcx,%rcx,2), %r14
shlq $0x3, %r14
movq -0x58(%rbp), %rax
addq 0x158(%rax), %r14
movq %r14, %rsi
callq 0xdde8
testb %al, %al
je 0xda39
incl -0x3c(%rbp)
movq -0x50(%rbp), %r13
movq -0x38(%rbp), %r8
movl -0x30(%rbp), %edx
jmp 0xda7d
incl %edx
movq -0x50(%rbp), %r13
jmp 0xda7d
movl -0x5c(%rbp), %eax
cmpl %eax, 0x10(%r14)
jae 0xda6a
cmpl %eax, 0x10(%r13,%r15)
movq -0x38(%rbp), %r8
movl -0x30(%rbp), %edx
jb 0xda61
incl -0x44(%rbp)
movl -0x40(%rbp), %eax
addl 0x8(%r14), %eax
subl 0x4(%r14), %eax
movl %eax, -0x40(%rbp)
movq -0x50(%rbp), %r13
movl -0x2c(%rbp), %eax
jmp 0xda78
movq -0x50(%rbp), %r13
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %eax
movl -0x30(%rbp), %edx
incl %eax
movl %eax, -0x2c(%rbp)
incq %r12
movl 0x150(%r13), %eax
addq $0x18, %r15
cmpq %rax, %r12
jb 0xd9db
movl 0x2000000(%rbx), %r15d
testq %r15, %r15
je 0xdabd
xorl %eax, %eax
xorl %r12d, %r12d
movl (%r8,%rax,4), %ecx
incl %ecx
cmpl $0x2, %ecx
jb 0xdab3
incl %r12d
incq %rax
cmpq %rax, %r15
jne 0xdaa5
jmp 0xdac0
xorl %r12d, %r12d
movl %edx, 0x160(%r13)
movl %r12d, 0x164(%r13)
movl -0x2c(%rbp), %eax
movl %eax, 0x168(%r13)
movl -0x3c(%rbp), %ecx
movl %ecx, 0x16c(%r13)
movl -0x40(%rbp), %ecx
movl %ecx, 0x174(%r13)
movl -0x44(%rbp), %ecx
movl %ecx, 0x170(%r13)
testl %edx, %edx
je 0xdb3e
movl %edx, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r14
movq %r14, %rdi
callq 0x2040
movq %rax, %rcx
addq %r14, %rcx
xorl %edx, %edx
movq %rax, %rsi
movq $0x0, (%rsi)
movl %edx, 0x8(%rsi)
movl %edx, 0x10(%rsi)
movl %edx, 0x13(%rsi)
addq $0x18, %rsi
cmpq %rcx, %rsi
jne 0xdb17
movq %rax, 0x178(%r13)
movq -0x38(%rbp), %r8
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0xdb83
movl %eax, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %r14
movq %r14, %rdi
callq 0x2040
movq %rax, %rcx
addq %r14, %rcx
xorl %edx, %edx
movq %rax, %rsi
movq $0x0, (%rsi)
movl %edx, 0x8(%rsi)
movl %edx, 0x10(%rsi)
movl %edx, 0x13(%rsi)
addq $0x18, %rsi
cmpq %rcx, %rsi
jne 0xdb5f
movq %rax, 0x180(%r13)
movq -0x38(%rbp), %r8
movl %r12d, -0x3c(%rbp)
shlq $0x2, %r15
movl $0x0, -0x30(%rbp)
movq %r8, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20b0
movq -0x38(%rbp), %rdi
movq -0x58(%rbp), %rax
movl 0x150(%rax), %ecx
testq %rcx, %rcx
je 0xdbe2
movq -0x58(%rbp), %rax
movq 0x158(%rax), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rcx
movl $0x1, %edx
xorl %esi, %esi
movl (%rax,%rsi), %r8d
decl %r8d
movl %edx, (%rdi,%r8,4)
addq $0x18, %rsi
incl %edx
cmpq %rsi, %rcx
jne 0xdbcc
cmpl $0x0, 0x150(%r13)
movl $0x0, -0x2c(%rbp)
je 0xdcb3
xorl %r12d, %r12d
xorl %r15d, %r15d
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq 0x158(%r13), %r14
movl (%r14,%r12), %eax
addq %r12, %r14
decl %eax
movl (%rdi,%rax,4), %ecx
testl %ecx, %ecx
je 0xdc76
decl %ecx
movl $0xffffffff, (%rdi,%rax,4) # imm = 0xFFFFFFFF
leaq (%rcx,%rcx,2), %rsi
shlq $0x3, %rsi
movq -0x58(%rbp), %rax
addq 0x158(%rax), %rsi
movq %r14, %rdi
callq 0xdde8
testb %al, %al
jne 0xdc70
movq 0x180(%r13), %rax
movl -0x2c(%rbp), %esi
movl %esi, %ecx
leaq (%rcx,%rcx,2), %rcx
movq 0xf(%r14), %rdx
movq %rdx, 0xf(%rax,%rcx,8)
movups (%r14), %xmm0
movups %xmm0, (%rax,%rcx,8)
incl %esi
movl %esi, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
jmp 0xdc9c
movq 0x178(%r13), %rax
movl -0x30(%rbp), %esi
movl %esi, %ecx
leaq (%rcx,%rcx,2), %rcx
movq 0xf(%r14), %rdx
movq %rdx, 0xf(%rax,%rcx,8)
movups (%r14), %xmm0
movups %xmm0, (%rax,%rcx,8)
incl %esi
movl %esi, -0x30(%rbp)
incq %r15
movl 0x150(%r13), %eax
addq $0x18, %r12
cmpq %rax, %r15
jb 0xdc0b
xorl %r14d, %r14d
movl -0x3c(%rbp), %eax
testl %eax, %eax
je 0xdd09
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2040
movq -0x38(%rbp), %rdi
movq %rax, 0x188(%r13)
movl 0x2000000(%rbx), %ecx
testq %rcx, %rcx
movq -0x68(%rbp), %r15
je 0xdd0d
xorl %edx, %edx
xorl %r14d, %r14d
movl (%rdi,%rdx,4), %esi
incl %esi
cmpl $0x2, %esi
jb 0xdcff
movl %r14d, %esi
leal 0x1(%rdx), %r8d
movl %r8d, (%rax,%rsi,4)
incl %r14d
incq %rdx
cmpq %rdx, %rcx
jne 0xdce7
jmp 0xdd0d
movq -0x68(%rbp), %r15
callq 0x21f0
movl -0x30(%rbp), %edi
callq 0xb5d3
movq %rax, %r13
movl -0x2c(%rbp), %edi
callq 0xb5d3
movq %rax, %r12
movl %r14d, %edi
callq 0xb5d3
leaq 0xa622(%rip), %rdi      # 0x18359
movq %r13, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x2050
movl 0x2000050(%rbx), %eax
cmpl $0x2, %eax
jb 0xdd8c
addl $-0x2, %eax
imulq $0x190, %rax, %rax      # imm = 0x190
movq -0x70(%rbp), %rcx
leaq (%rcx,%rax), %r14
movq 0x158(%rcx,%rax), %rdi
testq %rdi, %rdi
je 0xdd76
callq 0x21f0
movq $0x0, 0x158(%r14)
movl $0x0, 0x150(%r14)
movq %r15, %rdi
callq 0x21f0
incl 0x2000050(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc427(%rip), %rdi      # 0x1a1d7
leaq 0x9a39(%rip), %rsi      # 0x177f0
leaq 0xa319(%rip), %rcx      # 0x180d7
movl $0x13b, %edx            # imm = 0x13B
callq 0x20c0
leaq 0xa4d5(%rip), %rdi      # 0x182a4
leaq 0x9a1a(%rip), %rsi      # 0x177f0
leaq 0xa4e3(%rip), %rcx      # 0x182c0
movl $0xe56, %edx            # imm = 0xE56
callq 0x20c0
nop