LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0xff6c
movl %eax, %r14d
movq %rbx, %rdi
callq 0xff6c
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_O3/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 0xb158
testb %al, %al
je 0x1093d
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 0x10946
cmpq %rax, (%rsi)
jne 0x10937
cmpq %rcx, 0x8(%rsi)
jne 0x10937
cmpl %edx, 0x10(%rsi)
je 0x1095f
movq 0x48(%rsi), %rsi
jmp 0x10922
leaq 0x8841(%rip), %rdi      # 0x19185
jmp 0x1094d
leaq 0x8819(%rip), %rdi      # 0x19166
movq %rbx, %rsi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2050
movq %r14, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xde54
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x118d4
movq %rdx, 0x80(%rdi)
movq %rcx, (%rsi)
leaq 0x24(%rcx), %r8
cmpq %rax, %r8
ja 0x118b5
movl 0x20(%rcx), %edx
movq %r8, 0x80(%rdi)
movl %edx, 0x8(%rsi)
leaq 0x25(%rcx), %rdx
cmpq %rax, %rdx
ja 0x118f3
movzbl (%r8), %r8d
movq %rdx, 0x80(%rdi)
cmpl $0xfc, %r8d
ja 0x11802
movl %r8d, 0xc(%rsi)
jmp 0x1185d
leaq 0x27(%rcx), %r9
cmpq %rax, %r9
ja 0x11912
movzwl (%rdx), %r8d
movq %r9, 0x80(%rdi)
cmpl $0xffff, %r8d           # imm = 0xFFFF
je 0x11828
movq %r9, %rcx
jmp 0x11849
addq $0x2b, %rcx
cmpq %rax, %rcx
ja 0x118b5
movl (%r9), %r8d
movq %rcx, 0x80(%rdi)
cmpl $-0x1, %r8d
je 0x11950
movl %r8d, 0xc(%rsi)
movq %rcx, %rdx
cmpl $0x2000, %r8d           # imm = 0x2000
jae 0x11931
testl %r8d, %r8d
je 0x11893
movl %r8d, %ecx
addq %rdx, %rcx
movq %rcx, 0x80(%rdi)
cmpq %rax, %rcx
jbe 0x11898
leaq 0x7dee(%rip), %rdi      # 0x19669
leaq 0x5f6e(%rip), %rsi      # 0x177f0
leaq 0x7df8(%rip), %rcx      # 0x19681
movl $0x82f, %edx            # imm = 0x82F
callq 0x20c0
movq %rdx, %rcx
xorl %edx, %edx
movq %rdx, 0x10(%rsi)
leaq 0x4(%rcx), %rdx
cmpq %rax, %rdx
ja 0x118b5
movl (%rcx), %eax
movq %rdx, 0x80(%rdi)
movl %eax, 0x18(%rsi)
movb $0x1, %al
popq %rbp
retq
leaq 0x7a9c(%rip), %rdi      # 0x19358
leaq 0x5f2d(%rip), %rsi      # 0x177f0
leaq 0x7ab9(%rip), %rcx      # 0x19383
movl $0x7ee, %edx            # imm = 0x7EE
callq 0x20c0
leaq 0x7ac6(%rip), %rdi      # 0x193a1
leaq 0x5f0e(%rip), %rsi      # 0x177f0
leaq 0x7ad5(%rip), %rcx      # 0x193be
movl $0x801, %edx            # imm = 0x801
callq 0x20c0
leaq 0x7b19(%rip), %rdi      # 0x19413
leaq 0x5eef(%rip), %rsi      # 0x177f0
leaq 0x7b35(%rip), %rcx      # 0x1943d
movl $0x7dc, %edx            # imm = 0x7DC
callq 0x20c0
leaq 0x7b40(%rip), %rdi      # 0x19459
leaq 0x5ed0(%rip), %rsi      # 0x177f0
leaq 0x7b5d(%rip), %rcx      # 0x19484
movl $0x7e5, %edx            # imm = 0x7E5
callq 0x20c0
leaq 0x7cc3(%rip), %rdi      # 0x195fb
leaq 0x5eb1(%rip), %rsi      # 0x177f0
leaq 0x7cef(%rip), %rcx      # 0x19635
movl $0x83b, %edx            # imm = 0x83B
callq 0x20c0
leaq 0x6419(%rip), %rdi      # 0x17d70
leaq 0x5e92(%rip), %rsi      # 0x177f0
leaq 0x7a7e(%rip), %rcx      # 0x193e3
movl $0x821, %edx            # imm = 0x821
callq 0x20c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x137b9
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 0x2100
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 0x137b9
leaq 0x2c(%r14), %rsi
movq %r14, %rdi
callq 0x1380e
movl $0x0, 0x28(%r14)
cmpl $0x40, %ebx
jb 0x137dc
addq $0x200, (%r14)          # imm = 0x200
movq %r14, %rdi
movq %r15, %rsi
callq 0x1380e
addq $0x40, %r15
addl $-0x40, %ebx
cmpl $0x3f, %ebx
ja 0x137be
testl %ebx, %ebx
je 0x13805
movl %ebx, %r12d
movl 0x28(%r14), %eax
leaq (%r14,%rax), %rdi
addq $0x2c, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2100
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_O3/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 0x1e28(%rip), %xmm0     # 0x17160
movups %xmm0, 0x8(%r14)
movaps 0x1e2c(%rip), %xmm0     # 0x17170
movups %xmm0, 0x18(%r14)
movl $0x0, 0x28(%r14)
movq %r14, %rdi
callq 0x13746
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1529e
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/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 0x15604
xorps %xmm0, %xmm0
leaq -0x90(%rbp), %rsi
movups %xmm0, 0x68(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x48(%rsi)
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x28(%rsi)
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x8(%rsi)
movq $0x0, 0x78(%rsi)
movq $0x1, (%rsi)
leaq -0x10(%rbp), %r8
movaps %xmm0, (%r8)
movl $0x1, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2150
testl %eax, %eax
js 0x153e8
addq $0x90, %rsp
popq %rbp
retq
leaq 0x4a01(%rip), %rdi      # 0x19df0
callq 0x2260
movl $0x1, %edi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
callq 0x15604
leaq -0x9(%rbp), %rbx
movl $0x1, %edx
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2240
cmpq $0x1, %rax
setne %cl
movb (%rbx), %al
testb %al, %al
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1545f
callq 0x15604
leaq -0xa(%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
jmp 0x15462
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xa515(%rip)      # 0x1fb20
jne 0x15685
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0xa508(%rip), %rsi      # 0x1fb24
xorl %edi, %edi
callq 0x21a0
movups 0xa4fa(%rip), %xmm0     # 0x1fb24
leaq -0x40(%rbp), %rdx
movaps %xmm0, (%rdx)
movups 0xa4fc(%rip), %xmm0     # 0x1fb34
movaps %xmm0, 0x10(%rdx)
movups 0xa501(%rip), %xmm0     # 0x1fb44
movaps %xmm0, 0x20(%rdx)
movups 0xa502(%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 0x21f0
leaq 0x12(%rip), %rdi        # 0x15686
callq 0x161b0
movb $0x1, 0xa4a0(%rip)      # 0x1fb20
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x156bf
leaq 0x4c1a(%rip), %rdi      # 0x1a2cb
callq 0x2260
leaq 0x1fcc(%rip), %rsi      # 0x17689
jmp 0x156c3
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x15702
movq %rbx, %rdi
callq 0x157ba
testb %al, %al
jne 0x156cf
leaq -0x50(%rbp), %rdi
callq 0x1600c
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x1600c
movq %rbx, %rdi
callq 0x22a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb4db
movq %rax, 0x28(%rbx)
movl $0x2, 0x8(%rbx)
movl $0x7a120, 0x10(%rbx)    # imm = 0x7A120
leaq 0x4bb0(%rip), %rdi      # 0x1a2e3
callq 0x2260
leaq 0x46cc(%rip), %rdi      # 0x19e0b
xorl %r15d, %r15d
movq %r14, %rsi
xorl %eax, %eax
callq 0x2050
leaq 0x431b(%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 0x15798
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16046
leaq 0x46a7(%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_O3/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 0x16024
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x16036
movq (%rdi), %rax
callq *0x98(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x76ed
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40e6(%rip), %rdi      # 0x1a27a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2050
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_cpp_makefile_star2_O3/AutomataLab[P]JSONSki/example/example1.cpp
// Function: main
int main() {
    char* file_path = "../dataset/twitter_sample_large_record.json";
    Record* rec = RecordLoader::loadSingleRecord(file_path);
    if (rec == NULL) {
        cout<<"record loading fails."<<endl;
        return -1;
    }

    QueryProcessor processor("$[*].entities.urls[*].url");
    string output = processor.runQuery(rec);
    cout<<"matches are: "<<output<<endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
andq $-0x20, %rsp
subq $0xef80, %rsp           # imm = 0xEF80
leaq 0x9f245(%rip), %rdi     # 0xc51c0
callq 0x25a50
testq %rax, %rax
je 0x26054
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x9f266(%rip), %rsi     # 0xc5202
leaq 0x9f278(%rip), %rdx     # 0xc521b
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x260e8
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x165d8
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x25fcc
callq 0x26180
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
movq %rbx, %rdx
callq 0x25772
leaq 0xd949d(%rip), %rdi     # 0xff480
leaq 0x9f232(%rip), %rsi     # 0xc521c
movl $0xd, %edx
callq 0x8ec40
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0xd947c(%rip), %rdi     # 0xff480
callq 0x8ec40
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6fd90
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8e740
movq %rax, %rdi
callq 0x8dd10
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26046
callq 0x26180
leaq 0x40(%rsp), %rdi
callq 0x16972
xorl %eax, %eax
jmp 0x2609b
leaq 0xd9425(%rip), %rbx     # 0xff480
leaq 0x9f18a(%rip), %rsi     # 0xc51ec
movl $0x15, %edx
movq %rbx, %rdi
callq 0x8ec40
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x6fd90
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8e740
movq %rax, %rdi
callq 0x8dd10
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x260d5
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x260df
callq 0x26180
jmp 0x260df
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x260d5
callq 0x26180
leaq 0x40(%rsp), %rdi
callq 0x16972
movq %rbx, %rdi
callq 0x13720
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6b98
movq %rax, %r14
movq %rax, 0x30(%rbx)
leaq 0x78(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ff8(%rip), %rsi      # 0x948e
leaq 0x1ffa(%rip), %rdx      # 0x9497
leaq 0x68(%rsp), %rdi
callq 0x3d6c
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 0x6c08
addq $0x10, %rsp
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x754f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x7566
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x757d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x7594
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x33a0
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x4210
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 0x75d2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x33a0
jmp 0x75d2
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x75ee
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x33a0
jmp 0x75ee
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x760a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x33a0
jmp 0x760a
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x7621
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x33a0
movq %rbx, %rdi
callq 0x35e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3ec8
cmpl $0x0, 0x14(%r14)
je 0x7b64
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5896
leaq 0x1724(%rip), %rdx      # 0x9294
leaq 0x1980(%rip), %rcx      # 0x94f7
movq %rax, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x63ec
callq 0x5896
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6832
// File: /workspace/github_cpp_makefile_star2_O3/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)
leaq 0x1d588(%rbx), %rdi
movq %r14, %rsi
callq 0x3f76
cmpl $0x0, 0x14(%rbx)
je 0x7bd4
popq %rbx
popq %r14
popq %r15
retq
callq 0x5896
movq 0x1d580(%rbx), %rcx
movl 0x10(%rcx,%r15), %ecx
leaq 0x191d(%rip), %rdx      # 0x9509
movq %rax, %rdi
movl $0x1, %esi
xorl %eax, %eax
callq 0x63ec
callq 0x5896
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x6832
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
xorps %xmm0, %xmm0
movups %xmm0, 0x302a(%rdi)
movups %xmm0, 0x301a(%rdi)
movups %xmm0, 0x303c(%rdi)
addq $0x1018, %rdi           # imm = 0x1018
xorl %r15d, %r15d
movl $0x2000, %edx           # imm = 0x2000
xorl %esi, %esi
callq 0x2110
leaq 0x52(%rbx), %rdi
movl $0xfc0, %edx            # imm = 0xFC0
xorl %esi, %esi
callq 0x2110
leaq 0x4c8e(%rip), %rsi      # 0x71b0
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_O3/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x2b05(%rip), %rsi      # 0x5080
callq 0x2210
testq %rax, %rax
je 0x2603
movq %rax, %r14
xorl %r15d, %r15d
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21d0
movq %r14, %rdi
callq 0x2030
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21d0
movq %r12, %rdi
callq 0x2260
testq %rax, %rax
je 0x2606
movq %rax, %r13
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x2280
testq %r12, %r12
jle 0x25ee
addq $0x202, %rbx            # imm = 0x202
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x2180
movq %r14, %rdi
callq 0x21b0
movq %r13, %rdi
callq 0x2220
movb $0x1, %r15b
jmp 0x2606
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d2f
leaq 0x2369(%rip), %rdi      # 0x5093
callq 0x22a0
leaq 0x234d(%rip), %rdi      # 0x5083
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 0x2d6d
leaq 0x2353(%rip), %rdi      # 0x50b8
callq 0x22a0
movq (%rbx), %rax
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x2050
movq %rax, 0x8(%rbx)
testq %rax, %rax
jne 0x2d98
leaq 0x234d(%rip), %rdi      # 0x50dc
callq 0x22a0
movq 0x8(%rbx), %rax
movq %rax, %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 0x2de5
leaq 0x2320(%rip), %rdi      # 0x5100
callq 0x22a0
movl $0x3e8, %edi            # imm = 0x3E8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2160
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3c1f
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 0x2487(%rip), %r14      # 0x5fd0
leaq 0x7ea(%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 0x2455(%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 0x3bfc
movq 0x2413(%rip), %rbx      # 0x5fd0
leaq 0x77c(%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 0x23e1(%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 0x23a7(%rip), %rdi      # 0x5fd0
callq 0x2160
leaq 0x6d4(%rip), %rsi       # 0x4309
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20d0
xorl %edi, %edi
callq 0x21b0
jmp 0x3c71
jmp 0x3c71
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x273e
leaq 0x68(%rsp), %rdi
callq 0x273e
movq %rbx, %rdi
callq 0x2280
jmp 0x3c71
movq %rax, %rdi
callq 0x379f
// File: /workspace/github_cpp_makefile_star2_O3/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 0x72230(%rip), %rsi     # 0x74871
movq %rdx, %rdi
callq 0x2290
testq %rax, %rax
je 0x26a6
movq %rax, %rbx
movq %rax, %rdi
callq 0xdb12
testq %rax, %rax
js 0x26ad
movq %rax, %r12
movq %rax, (%r14)
movq %rax, %rdi
callq 0x22b0
movq %rax, (%r15)
testq %rax, %rax
sete %cl
testq %r12, %r12
setne %dl
movl $0x53, %ebp
testb %cl, %dl
jne 0x26b2
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x22e0
xorl %ecx, %ecx
cmpq (%r14), %rax
movl $0x4e, %ebp
cmovel %ecx, %ebp
jmp 0x26b2
movl $0x4e, %ebp
jmp 0x26ba
movl $0x4e, %ebp
movq %rbx, %rdi
callq 0x2230
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5414
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xff, %ecx
leaq 0x6d028(%rip), %rdx     # 0x72390
leaq 0x6d421(%rip), %r8      # 0x72790
leaq 0x6d81a(%rip), %r9      # 0x72b90
leaq 0x6dc13(%rip), %r10     # 0x72f90
leaq 0x6e00c(%rip), %r11     # 0x73390
leaq 0x6e405(%rip), %rbx     # 0x73790
leaq 0x6e7fe(%rip), %r14     # 0x73b90
leaq 0x6ebf7(%rip), %r15     # 0x73f90
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 0x5399
testq %rsi, %rsi
je 0x543c
xorl %ecx, %ecx
leaq 0x6eb6e(%rip), %rdx     # 0x73f90
movb (%rdi,%rcx), %r8b
xorb %al, %r8b
movzbl %r8b, %r8d
shrl $0x8, %eax
xorl (%rdx,%r8,4), %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x5422
notl %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_chunk_next(unsigned char*, unsigned char*)
unsigned char* lodepng_chunk_next(unsigned char* chunk, unsigned char* end) {
  size_t available_size = (size_t)(end - chunk);
  if(chunk >= end || available_size < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    if(total_chunk_length > available_size) return end; /*outside of range*/
    return chunk + total_chunk_length;
  }
}

// Assembly:
movq %rsi, %rax
movq %rsi, %rcx
subq %rdi, %rcx
setbe %dl
cmpq $0xc, %rcx
setb %sil
orb %dl, %sil
jne 0x55b1
movzbl (%rdi), %edx
movl %edx, %r8d
xorb $-0x77, %r8b
movb 0x1(%rdi), %sil
movl %esi, %r9d
xorb $0x50, %r9b
orb %r8b, %r9b
jne 0x5581
movb $0x50, %sil
cmpb $0x4e, 0x2(%rdi)
jne 0x5581
cmpb $0x47, 0x3(%rdi)
jne 0x5581
cmpb $0xd, 0x4(%rdi)
jne 0x5581
cmpb $0xa, 0x5(%rdi)
jne 0x5581
cmpb $0x1a, 0x6(%rdi)
jne 0x5581
cmpb $0xa, 0x7(%rdi)
jne 0x5581
addq $0x8, %rdi
movq %rdi, %rax
retq
shll $0x18, %edx
movzbl %sil, %esi
shll $0x10, %esi
orl %edx, %esi
movzbl 0x2(%rdi), %edx
shll $0x8, %edx
orl %esi, %edx
movzbl 0x3(%rdi), %esi
leaq (%rdx,%rsi), %r8
addq %rsi, %rdx
addq $0xc, %rdx
cmpq %rcx, %rdx
leaq 0xc(%rdi,%r8), %rcx
cmovbeq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_chunk_next_const(unsigned char const*, unsigned char const*)
const unsigned char* lodepng_chunk_next_const(const unsigned char* chunk, const unsigned char* end) {
  size_t available_size = (size_t)(end - chunk);
  if(chunk >= end || available_size < 12) return end; /*too small to contain a chunk*/
  if(chunk[0] == 0x89 && chunk[1] == 0x50 && chunk[2] == 0x4e && chunk[3] == 0x47
    && chunk[4] == 0x0d && chunk[5] == 0x0a && chunk[6] == 0x1a && chunk[7] == 0x0a) {
    /* Is PNG magic header at start of PNG file. Jump to first actual chunk. */
    return chunk + 8;
  } else {
    size_t total_chunk_length;
    if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return end;
    if(total_chunk_length > available_size) return end; /*outside of range*/
    return chunk + total_chunk_length;
  }
}

// Assembly:
movq %rsi, %rax
movq %rsi, %rcx
subq %rdi, %rcx
setbe %dl
cmpq $0xc, %rcx
setb %sil
orb %dl, %sil
jne 0x5644
movzbl (%rdi), %edx
movl %edx, %r8d
xorb $-0x77, %r8b
movb 0x1(%rdi), %sil
movl %esi, %r9d
xorb $0x50, %r9b
orb %r8b, %r9b
jne 0x5614
movb $0x50, %sil
cmpb $0x4e, 0x2(%rdi)
jne 0x5614
cmpb $0x47, 0x3(%rdi)
jne 0x5614
cmpb $0xd, 0x4(%rdi)
jne 0x5614
cmpb $0xa, 0x5(%rdi)
jne 0x5614
cmpb $0x1a, 0x6(%rdi)
jne 0x5614
cmpb $0xa, 0x7(%rdi)
jne 0x5614
addq $0x8, %rdi
movq %rdi, %rax
retq
shll $0x18, %edx
movzbl %sil, %esi
shll $0x10, %esi
orl %edx, %esi
movzbl 0x2(%rdi), %edx
shll $0x8, %edx
orl %esi, %edx
movzbl 0x3(%rdi), %esi
leaq (%rdx,%rsi), %r8
addq %rsi, %rdx
addq $0xc, %rdx
cmpq %rcx, %rdx
leaq 0xc(%rdi,%r8), %rcx
cmovbeq %rcx, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_chunk_append(unsigned char**, unsigned long*, unsigned char const*)
unsigned lodepng_chunk_append(unsigned char** out, size_t* outsize, const unsigned char* chunk) {
  unsigned i;
  size_t total_chunk_length, new_length;
  unsigned char *chunk_start, *new_buffer;

  if(!lodepng_chunk_type_name_valid(chunk)) {
    return 121; /* invalid chunk type name */
  }
  if(lodepng_chunk_reserved(chunk)) {
    return 122; /* invalid third lowercase character */
  }

  if(lodepng_addofl(lodepng_chunk_length(chunk), 12, &total_chunk_length)) return 77;
  if(lodepng_addofl(*outsize, total_chunk_length, &new_length)) return 77;

  new_buffer = (unsigned char*)lodepng_realloc(*out, new_length);
  if(!new_buffer) return 83; /*alloc fail*/
  (*out) = new_buffer;
  (*outsize) = new_length;
  chunk_start = &(*out)[new_length - total_chunk_length];

  for(i = 0; i != total_chunk_length; ++i) chunk_start[i] = chunk[i];

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x4, %eax
movb (%rbx,%rax), %cl
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jae 0x57a8
incq %rax
cmpq $0x8, %rax
jne 0x5736
movl $0x7a, %eax
testb $0x20, 0x6(%rbx)
jne 0x57ad
movl (%rbx), %r13d
bswapl %r13d
addq $0xc, %r13
movq (%r14), %rbp
movq %r13, %r12
movl $0x4d, %eax
addq %rbp, %r12
jb 0x57ad
movq (%r15), %rdi
movq %r12, %rsi
callq 0x2360
testq %rax, %rax
je 0x57bc
movq %rax, (%r15)
movq %r12, (%r14)
addq %rax, %rbp
movl $0x1, %ecx
xorl %eax, %eax
xorl %edx, %edx
movb (%rbx,%rdx), %sil
movb %sil, (%rbp,%rdx)
movl %ecx, %edx
incl %ecx
cmpq %rdx, %r13
jne 0x5794
jmp 0x57ad
movl $0x79, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x53, %eax
jmp 0x57ad
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_chunk_createv(ucvector*, unsigned long, char const*, unsigned char const*)
static unsigned lodepng_chunk_createv(ucvector* out,
                                      size_t length, const char* type, const unsigned char* data) {
  unsigned char* chunk;
  CERROR_TRY_RETURN(lodepng_chunk_init(&chunk, out, length, type));

  /*3: the data*/
  lodepng_memcpy(chunk + 8, data, length);

  /*4: CRC (of the chunkname characters and the data)*/
  lodepng_chunk_generate_crc(chunk);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rcx
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0xebd0
movl %eax, %ebp
testl %eax, %eax
jne 0x5854
movq (%rsp), %r15
testq %r14, %r14
je 0x584c
leaq 0x8(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x21e0
movq %r15, %rdi
callq 0x54f4
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_color_mode_copy(LodePNGColorMode*, LodePNGColorMode const*)
unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source) {
  lodepng_color_mode_cleanup(dest);
  lodepng_memcpy(dest, source, sizeof(LodePNGColorMode));
  if(source->palette) {
    dest->palette = (unsigned char*)lodepng_malloc(1024);
    if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
    lodepng_memcpy(dest->palette, source->palette, source->palettesize * 4);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x58d5
callq 0x22a0
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x20(%rbx), %rax
movq %rax, 0x20(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm1, 0x10(%r14)
movups %xmm0, (%r14)
xorl %ebp, %ebp
cmpq $0x0, 0x8(%rbx)
je 0x5937
movl $0x400, %edi            # imm = 0x400
callq 0x22b0
movq %rax, (%r15)
movq 0x10(%rbx), %rdx
testq %rax, %rax
je 0x592a
shlq $0x2, %rdx
testq %rdx, %rdx
je 0x5937
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x21e0
jmp 0x5937
xorl %eax, %eax
testq %rdx, %rdx
movl $0x53, %ebp
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_color_mode_alloc_palette(LodePNGColorMode*)
static void lodepng_color_mode_alloc_palette(LodePNGColorMode* info) {
  size_t i;
  /*if the palette is already allocated, it will have size 1024 so no reallocation needed in that case*/
  /*the palette must have room for up to 256 colors with 4 bytes each.*/
  if(!info->palette) info->palette = (unsigned char*)lodepng_malloc(1024);
  if(!info->palette) return; /*alloc fail*/
  for(i = 0; i != 256; ++i) {
    /*Initialize all unused colors with black, the value used for invalid palette indices.
    This is an error according to the PNG spec, but common PNG decoders make it black instead.
    That makes color conversion slightly faster due to no error handling needed.*/
    info->palette[i * 4 + 0] = 0;
    info->palette[i * 4 + 1] = 0;
    info->palette[i * 4 + 2] = 0;
    info->palette[i * 4 + 3] = 255;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x59f8
movl $0x400, %edi            # imm = 0x400
callq 0x22b0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x5a28
xorl %eax, %eax
xorl %ecx, %ecx
movq 0x8(%rbx), %rdx
movb %al, (%rdx,%rcx,4)
movq 0x8(%rbx), %rdx
movb %al, 0x1(%rdx,%rcx,4)
movq 0x8(%rbx), %rdx
movb %al, 0x2(%rdx,%rcx,4)
movq 0x8(%rbx), %rdx
movb $-0x1, 0x3(%rdx,%rcx,4)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x59fc
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_add_text_sized(LodePNGInfo*, char const*, char const*, unsigned long)
static unsigned lodepng_add_text_sized(LodePNGInfo* info, const char* key, const char* str, size_t size) {
  char** new_keys = (char**)(lodepng_realloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
  char** new_strings = (char**)(lodepng_realloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));

  if(new_keys) info->text_keys = new_keys;
  if(new_strings) info->text_strings = new_strings;

  if(!new_keys || !new_strings) return 83; /*alloc fail*/

  ++info->text_num;
  info->text_keys[info->text_num - 1] = alloc_string(key);
  info->text_strings[info->text_num - 1] = alloc_string_sized(str, size);
  if(!info->text_keys[info->text_num - 1] || !info->text_strings[info->text_num - 1]) return 83; /*alloc fail*/

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2360
movq %rax, %r13
movq 0x48(%rbx), %rax
movq 0x58(%rbx), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2360
testq %r13, %r13
je 0x5c0c
movq %r13, 0x50(%rbx)
movl $0x53, %ebp
testq %rax, %rax
je 0x5c1a
movq %rax, 0x58(%rbx)
incq 0x48(%rbx)
movq %r12, %rdi
callq 0x5fb2
movq 0x48(%rbx), %r13
movq 0x50(%rbx), %rcx
movq %rax, -0x8(%rcx,%r13,8)
leaq 0x1(%r14), %rdi
callq 0x22b0
movq %rax, %r12
testq %rax, %rax
je 0x5be1
testq %r14, %r14
je 0x5bdc
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x21e0
movb $0x0, (%r12,%r14)
movq 0x58(%rbx), %rax
movq %r12, -0x8(%rax,%r13,8)
movq 0x50(%rbx), %rax
cmpq $0x0, -0x8(%rax,%r13,8)
je 0x5c1a
movq 0x58(%rbx), %rax
xorl %ecx, %ecx
cmpq $0x0, -0x8(%rax,%r13,8)
movl $0x53, %ebp
cmovnel %ecx, %ebp
jmp 0x5c1a
movl $0x53, %ebp
testq %rax, %rax
je 0x5c1a
movq %rax, 0x58(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]lodepng/lodepng.cpp
// Function: lodepng_add_itext_sized(LodePNGInfo*, char const*, char const*, char const*, char const*, unsigned long)
static unsigned lodepng_add_itext_sized(LodePNGInfo* info, const char* key, const char* langtag,
                                        const char* transkey, const char* str, size_t size) {
  char** new_keys = (char**)(lodepng_realloc(info->itext_keys, sizeof(char*) * (info->itext_num + 1)));
  char** new_langtags = (char**)(lodepng_realloc(info->itext_langtags, sizeof(char*) * (info->itext_num + 1)));
  char** new_transkeys = (char**)(lodepng_realloc(info->itext_transkeys, sizeof(char*) * (info->itext_num + 1)));
  char** new_strings = (char**)(lodepng_realloc(info->itext_strings, sizeof(char*) * (info->itext_num + 1)));

  if(new_keys) info->itext_keys = new_keys;
  if(new_langtags) info->itext_langtags = new_langtags;
  if(new_transkeys) info->itext_transkeys = new_transkeys;
  if(new_strings) info->itext_strings = new_strings;

  if(!new_keys || !new_langtags || !new_transkeys || !new_strings) return 83; /*alloc fail*/

  ++info->itext_num;

  info->itext_keys[info->itext_num - 1] = alloc_string(key);
  info->itext_langtags[info->itext_num - 1] = alloc_string(langtag);
  info->itext_transkeys[info->itext_num - 1] = alloc_string(transkey);
  info->itext_strings[info->itext_num - 1] = alloc_string_sized(str, size);

  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, (%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rbp
movq %rdi, %r14
movq 0x60(%rdi), %rax
movq 0x68(%rdi), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2360
movq %rax, %r15
movq 0x60(%r14), %rax
movq 0x70(%r14), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2360
movq %rax, %r12
movq 0x60(%r14), %rax
movq 0x78(%r14), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2360
movq %rax, %r13
movq 0x60(%r14), %rax
movq 0x80(%r14), %rdi
leaq 0x8(,%rax,8), %rsi
callq 0x2360
movq %rax, %rcx
testq %r15, %r15
je 0x5dcf
movq %r15, 0x68(%r14)
testq %r12, %r12
je 0x5dd8
movq %r12, 0x70(%r14)
testq %r13, %r13
je 0x5de1
movq %r13, 0x78(%r14)
movl $0x53, %eax
testq %rcx, %rcx
je 0x5e8c
movq %rcx, 0x80(%r14)
testq %r15, %r15
je 0x5e8c
testq %r12, %r12
je 0x5e8c
testq %r13, %r13
je 0x5e8c
incq 0x60(%r14)
movq %rbp, %rdi
callq 0x5fb2
movq 0x60(%r14), %rcx
movq 0x68(%r14), %rdx
movq %rax, -0x8(%rdx,%rcx,8)
movq 0x8(%rsp), %rdi
callq 0x5fb2
movq 0x60(%r14), %rcx
movq 0x70(%r14), %rdx
movq %rax, -0x8(%rdx,%rcx,8)
movq 0x10(%rsp), %rdi
callq 0x5fb2
movq 0x60(%r14), %r12
movq 0x78(%r14), %rcx
movq %rax, -0x8(%rcx,%r12,8)
leaq 0x1(%rbx), %rdi
callq 0x22b0
movq %rax, %r15
testq %rax, %rax
je 0x5e7e
testq %rbx, %rbx
je 0x5e79
movq %r15, %rdi
movq (%rsp), %rsi
movq %rbx, %rdx
callq 0x21e0
movb $0x0, (%r15,%rbx)
movq 0x80(%r14), %rax
movq %r15, -0x8(%rax,%r12,8)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq