// File: /workspace/github_cpp_makefile_star2_O1/probonopd[P]decodeir/DecodeIR.cpp
// Function: Signal::decode2()
void Signal::decode2()
{
	decode();

	int xDevice = *pDevice;
	int xSubDevice = *pSubDevice;
	int xOBC = *pOBC;
	int xHex[4];
	unsigned int wContext[2];	// the pContext for the next iteration
	unsigned int xContext[2];	// the pContext of the first decode of a repeat sequence
	unsigned int yContext[2];	// the pContext of the last decode of a repeat sequence
	int xNote_out = nNote_out;
	int xAuxNote_out = nAuxNote_out;
	int contextLengthOut = 2;
	int xFrameCount;
	int xDittos;
	int xInitLeadIn = bInitLeadIn;
	int n;
	int bSetyContext = true;
	// Test if lead-in only with tryGap, note that nProtocol is already incremented
	int xLeadIn = ( ((pContext[1] & 0xFF) == nGapProtocol + 1) && (pLead) ) ? 1 : 0;
	int yLeadIn;
	char xProtocol[256];
	char xMisc[256];
	int iEndpoint = 0;	// -2 & -1 = saved 1 & 0; 0 = no early end; 1 = early end
	for (n = 0; n < 4; n++) xHex[n] = pHex[n];
	for (n=0; n<2; n++) xContext[n] = nFrameCount == 0 ? pContext[n] : zContext[n];
	strcpy(xProtocol, pProtocol);
	strcpy(xMisc, pMisc);
	if ( *pError == 0 && *pProtocol )
	{
		do
		{
			do	
			{
				if (bSetyContext)
				{
					// yContext is not set if the most recent decode has been suppressed as spurious
					for (n=0; n<2; n++) yContext[n] = pContext[n];	// save the current sequence end
				}
				for (n=0; n<2; n++) wContext[n] = pContext[n];		// save for next iteration
				bSetyContext = true;
				xFrameCount = ++nFrameCount;	// count the frame just validated
				xDittos = nDittos;				// save the ditto count so not upset by next decode
				iEndpoint = ( iEndpoint < 0 ) ? - iEndpoint - 1 :	// if <0 restore old value, else test
					(	nDittos != 0			// don't look for repeats if dittos present
					||	*pFrameEnd > 200000 );	// don't look for repeats if more than 200ms between frames
				sortOn.clear();
				sortOff.clear();
				sortBurst.clear();
				decode();						// check for spurious next frame even if early end
				yLeadIn = ( ((pContext[1] & 0xFF) == nGapProtocol + 1) && (pLead) ) ? 1 : 0;
			}
			while (	*pError == 0	
				&&	strcmp(pProtocol, xProtocol) == 0
				&&	*pDevice == xDevice
				&&	*pSubDevice == xSubDevice
				&&	*pOBC == xOBC
				&&	strcmp(pMisc, xMisc) == 0
				&&	nDittos == 0		// if new frame has dittos, or nDittos=-1, treat as non-matching
				&&	!bInitLeadIn		// if new frame has initial lead-in, treat as non-matching
				&&	(yContext[0] & 0xFFFFF) + (yContext[1] >> 16) + MinFrame
						== (pContext[0] & 0xFFFFF) - yLeadIn	// if not consecutive, treat as non-matching
				&&	!iEndpoint);		// exit loop if early end marked

			// If a generic Gap decode is followed by a real decode starting one burst later,
			// Gap decode was probably spurious, treating a real lead-in as start of data.
			// So cancel the Gap decode, remove it from the count and reset the 'x...' variables
			if (	*pError == 0 && *pProtocol
				&&	strncmp(xProtocol, "Gap-", 4) == 0
				&&	strncmp(pProtocol, "Gap-", 4) != 0
				&&	((pContext[0] - yContext[0]) & 0xFFFFF) == 1 )	// check start difference is 1 burst
			{
				--nFrameCount;			// remove from count
				iEndpoint = 0;			// no early end to count, but let the real decode be tested
				xDevice = *pDevice;
				xSubDevice = *pSubDevice;
				xOBC = *pOBC;
				xNote_out = nNote_out;
				xAuxNote_out = nAuxNote_out;
				xLeadIn = ( ((pContext[1] & 0xFF) == nGapProtocol + 1) && (pLead) ) ? 1 : 0;
				for (n = 0; n < 4; n++) xHex[n] = pHex[n];
				for (n=0; n<2; n++) xContext[n] = pContext[n];
				strcpy(xProtocol, pProtocol);
				strcpy(xMisc, pMisc);
			}
			else
			// If a decode is followed by a generic Gap decode with same start frame or one burst,
			// later, Gap decode was probably spurious, treating two or more real frames as one.
			// So skip the Gap decode and remove it from the count
			if (	*pError == 0 && *pProtocol
				&&	strncmp(pProtocol, "Gap-", 4) == 0
				&&	((pContext[0] - yContext[0]) & 0xFFFFE) == 0 )	// check start burst
			{
				--nFrameCount;					// remove spurious Gap decode from count
				bSetyContext = false;			// do not set yContext from it
				iEndpoint = - iEndpoint - 1;	// allow to continue but save old value
			}
			else
			// If a decode is followed by a Solidtek decode other than the documented ones of
			// Solidtek16 and Solidtek20, or by an S:xx.xx... decode (all these in tryQ2)
			// and the whole of this following decode frame lies within the frame of the
			// previous decode, then this second decode is probably spurious.  So skip
			// it and remove it from the count.
			if (	*pError == 0 && *pProtocol
				&&	(	strncmp(pProtocol, "S:", 2) == 0
					||	(	strncmp(pProtocol, "Solidtek", 8) == 0
						&&	strncmp(pProtocol+8, "16", 2) != 0
						&&	strncmp(pProtocol+8, "20", 2) != 0 ) )
				&&	( (pContext[0] & 0xFFFFF) + (pContext[1] >> 16)	// compare nStart + nFrameL
						<= (yContext[0] & 0xFFFFF) + (yContext[1] >> 16) ) )
			{
				--nFrameCount;					// remove spurious Solidtek decode from count
				bSetyContext = false;			// do not set yContext from it
				iEndpoint = - iEndpoint - 1;	// allow to continue but save old value
			}
			else
			// combine two types of X10 frame
			if (	*pError == 0 
				&&	strcmp(pProtocol, "X10") == 0
				&&	strncmp(xProtocol, "X10", 3) == 0
				&&	xOBC == *pOBC 
				&&	xHex[0] == pHex[0] )
			{
				if ( xInitLeadIn )
				{
					xNote_out = 4;
					xAuxNote_out = -1;
					*xMisc = 0;				// cancel the "invalid signal"
					xInitLeadIn = false;	// only needed once
				}
			}
			else
			// If a Solidtek16 or Solidtek20 decode is followed by various decodes
			// of fewer frames in which the first 8 bits match the Solidtek data then
			// it is probably a spurious decode of a partial Solidtek repeat at the end
			// of a signal.  Skip the spurious decode and remove it from the count.
			if (	*pError == 0
				&&	(	strncmp(pProtocol, "S:", 2) == 0
					||	strcmp(pProtocol, "Blaupunkt{prefix}") == 0 
					||	strcmp(pProtocol, "XX") == 0
					||	strcmp(pProtocol, "DirecTV") == 0)
				&&	(	strcmp(xProtocol, "Solidtek16") == 0
					||	strcmp(xProtocol, "Solidtek20") == 0 ) )	
			{
				int x2;
				int xbits;
				char xstr[3];

				// reconstruct first 8 bits of Solidtek decode as hex string in xstr
				if ( strcmp(xProtocol+8, "16") == 0 ) x2 = xOBC;
				else x2 = xSubDevice;
				xbits = ( msb(xDevice,4)<<3 |  msb(x2,3) ) & 0xFF;
				sprintf(xstr, "%02X", xbits);

				// check those that can be checked with this xbits value
				if (		strcmp(pProtocol, "Blaupunkt{prefix}") == 0
						&&	strcmp(xstr, "00") == 0	// needed to match Blaupunkt
					||		strcmp(pProtocol, "DirecTV") == 0
						&&	*pDevice == 0 && *pOBC == 0
						&&	strcmp(xstr, "00") == 0	// needed to match DirecTV
					||		strncmp(pProtocol, "S:", 2) == 0
						&&	strncmp(pProtocol+5, xstr, 2 ) == 0 )	// test against yy of S.xx.yy....
				{
					--nFrameCount;					// remove spurious decode from count
					bSetyContext = false;			// do not set yContext from it
					iEndpoint = - iEndpoint - 1;	// allow to continue but save old value
				}
				else
				// check the one that needs complemented xbits value
				{	sprintf(xstr, "%02X", 255-xbits);
					if (	strcmp(pProtocol, "XX") == 0
						&&	strncmp(pMisc, xstr, 2 ) == 0 )
					{
						--nFrameCount;					// remove spurious decode from count
						bSetyContext = false;			// do not set yContext from it
						iEndpoint = - iEndpoint - 1;	// allow to continue but save old value
					}
					else break;
				}
			}
			else
			// The Sony protocol can match the Async protocol if the Sony data comprises
			// binary pairs 01 and 10.  The Sony lead-in translates to Async 0x80, the
			// binary pairs 01 and 10 translate to Async 0xE6 and 0x98.  The minimum
			// required for an Async decode is 3 such Sony binary pairs.  So if a Sony
			// decode is followed by such an Async decode then the Async probably comes
			// from a truncated Sony frame. Skip the spurious decode and remove it from
			// the count. 
			if (	*pError == 0
				&&	strncmp(xProtocol, "Sony", 4) == 0
				&&	strncmp(pProtocol, "Async", 5) == 0 
				&&	strncmp(pMisc, "80", 2) == 0
				&&	(	strncmp(pMisc+3, "98", 2) == 0
					||	strncmp(pMisc+3, "E6", 2) == 0 )
				&&	(	strncmp(pMisc+6, "98", 2) == 0
					||	strncmp(pMisc+6, "E6", 2) == 0 )
				&&	(	strncmp(pMisc+9, "98", 2) == 0
					||	strncmp(pMisc+9, "E6", 2) == 0 ) )
			{
				--nFrameCount;					// remove spurious Async decode from count
				bSetyContext = false;			// do not set yContext from it
				iEndpoint = - iEndpoint - 1;	// allow to continue but save old value
			}
			else
			// If an XMP decode with valid first half frame is followed by a Mitsubishi decode with
			// same start frame, Mitsubishi decode was probably a spurious decode of an XMP signal
			// with one or more missing digits (Mitsubishi frame length is 17, valid XMP is 18).
			// So skip the Mitsubishi decode and remove it from the count.  If counts suppressed,
			// i.e. learning remotes rather than IRScope, do same if following decode is consecutive
			// and is another XMP frame.
			if (	*pError == 0 && *pProtocol
				&&  (strcmp(xProtocol, "XMP") == 0 || strncmp(xProtocol, "XMP-", 4) == 0)
				&&	(strcmp(pProtocol, "Mitsubishi") == 0
					&&	((pContext[0] - yContext[0]) & 0xFFFFF) == 0 	// check start burst
				||	strncmp(pProtocol, "XMP", 3) == 0 
					&& (yContext[0] & 0xFFFFF) + (yContext[1] >> 16) + MinFrame
						== (pContext[0] & 0xFFFFF) 
					&& bSuppressCount )
				&&  bXMPHalfValid )
			{
				// char xstr[100];
				// sprintf(xstr, "start1 = %d start2 = %d",(yContext[0] & 0xFFFFF) + (yContext[1] >> 16) + MinFrame,(pContext[0] & 0xFFFFF));
				// MessageBox(0,xstr,"Error",0);
				if (strcmp(pProtocol, "Mitsubishi") == 0)
				{	
					--nFrameCount;					// remove spurious Mitsubishi decode from count
					bSetyContext = false;			// do not set yContext from it
				}
				iEndpoint = - iEndpoint - 1;	// allow to continue but save old value
			}
			else break;
		}
		while ( iEndpoint <= 0 );

		// Frame just decoded does not match earlier frame.  If it comes from
		// extra bursts, treat it as spurious so prevent its decode
		if (	nNonSpurious > 0		// value has been set
			&&	(int)(pContext[0] & 0xFFFFF) >= nNonSpurious	)
		{
			wContext[0] = 0xFFFFF;
		}		
		if  	(	strcmp(xProtocol, "NEC") == 0
				||	strcmp(xProtocol, "NECx") == 0 
				||	strcmp(xProtocol, "48-NEC") == 0 )
		{
			if (xFrameCount > 1 || nDittos == 0 && nRepeat > 6 )  
			{							 //nRepeat > 0 changed to nRepeat > 6  DAR Dec 2010 to avoid detecting faulty 
				strcat(xProtocol, "2");  //ditto(s) as NEC2. Anyway, NEC2 should have nRepeat == 34 if xFrame == 1
			}  
			strcat (xProtocol,pSuffix);   //DAR Nov 2010 
		}
		else if (	strcmp(xProtocol, "JVC") == 0 
				&&	!xInitLeadIn )
		{
			strcat(xProtocol, "{2}");
			xNote_out = 1;
		}
		else if (	strncmp(xProtocol, "RCA", 3) == 0 
				&&	xInitLeadIn )
		{
			strcat(xProtocol, "(Old)");
			xNote_out = 11;
		}
		else if (	strncmp(xProtocol, "Gap-", 4) == 0
				||	strncmp(xProtocol, "??", 2) == 0 )
		{
			xNote_out = 8;
		}

		// Restore pContext to value saved before last call to decode()
		for (n=0; n<2; n++) pContext[n] = wContext[n];

		int iParam = xFrameCount;

		*pDevice = xDevice;
		*pSubDevice = xSubDevice;
		*pOBC = xOBC;
		for (n=0; n < 4; n++) pHex[n] = xHex[n];
		strcpy(pProtocol, xProtocol);
		if (xNote_out == -1)		// if note unset, set default
		{
			if (xDittos > 0)		// if dittos present
			{
				xNote_out = 3;		// set ditto-frame note
				iParam = xDittos;
			}
			else
			{
				xNote_out = 1;		// else set identical repeats note
			}
		}

		if (nContextLength > 2)		// extended context used by IRScope
		{
			// set pContext[2] to the pContext[0] value at start of repeat series
			// but without its preemptLength value as that is no longer relevant
			pContext[2] = xContext[0] & 0xFFFFF;
			// if there was a tryGap() lead-in then actual start is one frame earlier
			if ( pContext[2] > 0 ) pContext[2] -= xLeadIn;
			// carry the preemptLength for the next iteration in pContext[2] and mask
			// it out of pContext[0] as that field of pContext[0] is used for the handshake
			pContext[2] |= pContext[0] & 0xFFF00000;
			pContext[0] &= 0xFFFFF;
			contextLengthOut = 3;	// record the context length to be returned in the handshake
		}
		if (nContextLength > 3)
		{
			// set pContext[3] to the pContext[1] value at start of repeat series
			pContext[3] = xContext[1];
			contextLengthOut = 4;	// record the context length to be returned in the handshake
		}
		if (nContextLength > 5)
		{
			// set pContext[4,5] to the pContext[0,1] values at end of repeat series
			pContext[4] = yContext[0];
			pContext[5] = yContext[1];
			contextLengthOut = 6;
		}
		if (nContextLength > 7)
		{
			// Incoming, pContext[6,7] pass a 64-bit pointer to a Counts array used to calculate
			// the frequency of individual decodes.  Outgoing, pContext[6] provides the frequency of
			// the repeat series being reported in this return.
			pContext[6] = getFreq(pContext[2] & 0xFFFFF, (pContext[0] & 0xFFFFF) + (pContext[1]>>16) + MinFrame);
			contextLengthOut = 8;
		}
		if (nContextLength > 8)
		{
			// pContext[8] returns the note and aux note indexes (1-based, so add 1) for use by
			// IRScope, and the parameter value for the note.
			pContext[8] = iParam | (xNote_out + 1)<<16 | (xAuxNote_out + 1)<<24;
			contextLengthOut = 9;
		}

		if (contextLengthOut > 2)
		{
			// The handshake is that the 12-bit field in pContext[0] that normally carries the
			// preemptLength value is now used to carry a negative value, -(contextLengthOut-2).
			// The calling program checks to see if the top 8 bits of this value are 0xFF.  If
			// so then it is interpreted as a context length value, otherwise as a preemptLength
			// value.  So the maximum supported context length is 18, corresponding to 0xFF0.
			pContext[0] |= (2-contextLengthOut)<<20;
		}

		n = 0;
		if ( !bSuppressCount )
		{
			// nDittos = -1 means no dittos AND treat repeat frames as separate signals
			if ( xFrameCount == 1 && xDittos <= 0 )
			{
				n = sprintf(pMisc, *xMisc == 0 ? "no repeat" : "no repeat: ");
			}
			else if ( xFrameCount == 2 && xDittos <= 0 )	// nDittos < 0 should not occur in this case
			{
				n = sprintf(pMisc, *xMisc == 0 ? "+ 1 copy" : "+ 1 copy: ");
			}
			else if ( xDittos <= 0 )	// nDittos < 0 should not occur in this case
			{
				n = sprintf(pMisc, *xMisc == 0 ? "+ %d copies" : "+ %d copies: ", xFrameCount-1);
			}
			else if ( xFrameCount == 1 && xDittos == 1 )
			{
				n = sprintf(pMisc, *xMisc == 0 ? "+ 1 ditto" : "+ 1 ditto: ");
			}
			else if ( xFrameCount == 1 )
			{
				n = sprintf(pMisc, *xMisc == 0 ? "+ %d dittos" : "+ %d dittos: ", xDittos);
			}
			else	// this case should not occur
			{
				n = sprintf(pMisc, *xMisc == 0 ? "+ %d dittos, %d copies" : "+ %d dittos, %d copies: ", 
						xDittos, xFrameCount-1);
			}
		}
		// next line reports nStart and nFrameL for diagnostic purposes
		// n += sprintf(pMisc+n, "S=%d L=%d ", wContext[0]&0xFFFFF, (wContext[1]>>16)+MinFrame);
		strcpy(pMisc+n, xMisc);	// append original pMisc text
		*pError = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
movq %rdi, %rbx
callq 0x2738
movq 0x160(%rbx), %rax
movq 0x168(%rbx), %rcx
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
movl (%rcx), %eax
movl %eax, -0x58(%rbp)
movq 0x170(%rbx), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movl 0x88(%rbx), %r13d
movl 0x8c(%rbx), %r12d
movq (%rbx), %rax
movzbl 0x4(%rax), %ecx
movl 0x78(%rbx), %edx
incl %edx
cmpl %edx, %ecx
sete %cl
cmpq $0x0, 0xd0(%rbx)
movl 0x70(%rbx), %edx
movl %edx, -0x48(%rbp)
setne %r15b
andb %cl, %r15b
movq 0x178(%rbx), %rcx
movl (%rcx), %edx
movl %edx, -0x6c(%rbp)
movl 0xc(%rcx), %edx
movl %edx, -0xa0(%rbp)
movq 0x4(%rcx), %rcx
movq %rcx, -0xa8(%rbp)
movl 0x60(%rbx), %ecx
leaq 0x80(%rbx), %rdx
xorl %esi, %esi
testl %ecx, %ecx
movq %rdx, %rdi
cmoveq %rax, %rdi
movl (%rdi), %edi
movl %edi, -0x98(%rbp,%rsi,4)
incq %rsi
addq $0x4, %rax
addq $0x4, %rdx
cmpq $0x1, %rsi
je 0xef38
movq 0x148(%rbx), %r14
leaq -0x1c0(%rbp), %rdi
movq %r14, %rsi
movq %rbx, -0x38(%rbp)
callq 0x2100
movq -0x38(%rbp), %rax
movq 0x150(%rax), %rsi
leaq -0x2c0(%rbp), %rdi
callq 0x2100
movq -0x38(%rbp), %r8
movq 0x158(%r8), %rax
cmpb $0x0, (%rax)
jne 0xfcf7
cmpb $0x0, (%r14)
je 0xfcf7
movl %r13d, -0x50(%rbp)
movl %r12d, -0x54(%rbp)
movzbl %r15b, %eax
movl %eax, -0x7c(%rbp)
leaq 0x198(%r8), %rax
movq %rax, -0xb8(%rbp)
leaq 0x60(%r8), %rax
movq %rax, -0x78(%rbp)
movl $0x1, %r15d
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
testl %r15d, %r15d
sete %al
testb $0x1, %al
jne 0xeff2
movq (%r8), %rax
movl (%rax), %ecx
movl %ecx, -0x40(%rbp)
movl 0x4(%rax), %eax
movl %eax, -0x60(%rbp)
movq (%r8), %rax
movl (%rax), %ecx
movl 0x4(%rax), %eax
movl %eax, -0xac(%rbp)
movl 0x60(%r8), %eax
movq %rax, -0x90(%rbp)
incl %eax
movl %eax, -0x84(%rbp)
movl %eax, 0x60(%r8)
movl 0x68(%r8), %eax
movl -0x3c(%rbp), %edx
testl %edx, %edx
movl %eax, -0xb0(%rbp)
movl %ecx, -0x80(%rbp)
js 0xf04a
movl $0x1, %edx
testl %eax, %eax
jne 0xf04c
movq 0x40(%r8), %rax
movss (%rax), %xmm0
xorl %edx, %edx
ucomiss 0x368b(%rip), %xmm0     # 0x126d0
seta %dl
jmp 0xf04c
notl %edx
movl %edx, -0x3c(%rbp)
movaps 0x2fba(%rip), %xmm0     # 0x12010
movups %xmm0, 0x180(%r8)
xorl %ebx, %ebx
movl %ebx, 0x190(%r8)
movq -0xb8(%rbp), %rdi
callq 0x1185a
movq -0x38(%rbp), %rax
movabsq $0x4e6e6b284e6e6b28, %rcx # imm = 0x4E6E6B284E6E6B28
movq %rcx, 0x1c8(%rax)
movq -0x38(%rbp), %rax
movl $0x4e6e6b28, 0x1d0(%rax) # imm = 0x4E6E6B28
movq -0x38(%rbp), %rax
movq $0x0, 0x1dc(%rax)
movq -0x38(%rbp), %rax
movl %ebx, 0x1e4(%rax)
movq -0x38(%rbp), %rdi
callq 0x2738
movq -0x38(%rbp), %r8
movq (%r8), %rax
movq %rax, -0x68(%rbp)
movl 0x4(%rax), %r13d
movzbl %r13b, %eax
movl 0x78(%r8), %r14d
incl %r14d
cmpl %r14d, %eax
sete %r12b
movq 0xd0(%r8), %r15
testq %r15, %r15
setne %bl
movq 0x158(%r8), %rax
movb (%rax), %sil
testb %sil, %sil
jne 0xf456
movb %sil, -0x29(%rbp)
movq 0x148(%r8), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x21b0
movq -0x38(%rbp), %r8
testl %eax, %eax
jne 0xf1a7
movq 0x160(%r8), %rax
movl -0x5c(%rbp), %ecx
cmpl %ecx, (%rax)
jne 0xf1a7
movq 0x168(%r8), %rax
movl -0x58(%rbp), %ecx
cmpl %ecx, (%rax)
jne 0xf1a7
movq 0x170(%r8), %rax
movl -0x4c(%rbp), %ecx
cmpl %ecx, (%rax)
jne 0xf1a7
movq 0x150(%r8), %rdi
leaq -0x2c0(%rbp), %rsi
callq 0x21b0
movq -0x38(%rbp), %r8
testl %eax, %eax
jne 0xf1a7
cmpl $0x0, 0x68(%r8)
jne 0xf1a7
cmpl $0x0, 0x70(%r8)
jne 0xf1a7
andb %bl, %r12b
movzbl %r12b, %eax
negl %eax
movl -0x40(%rbp), %ecx
movl $0xfffff, %esi          # imm = 0xFFFFF
andl %esi, %ecx
movl -0x60(%rbp), %edx
shrl $0x10, %edx
addl %edx, %ecx
addl $0x2, %ecx
movq -0x68(%rbp), %rdx
movl (%rdx), %edx
andl %esi, %edx
addl %eax, %edx
cmpl %edx, %ecx
jne 0xf1a7
xorl %eax, %eax
cmpl $0x0, -0x3c(%rbp)
je 0xefe0
movb -0x29(%rbp), %sil
testb %sil, %sil
jne 0xf456
movq 0x148(%r8), %rbx
cmpb $0x0, (%rbx)
je 0xf2c8
cmpl $0x2d706147, -0x1c0(%rbp) # imm = 0x2D706147
jne 0xf2c8
movl $0x4, %edx
movq %rbx, %rdi
leaq 0x35e9(%rip), %rsi      # 0x127cc
callq 0x20a0
movb -0x29(%rbp), %sil
movq -0x38(%rbp), %r8
testl %eax, %eax
je 0xf2c8
movq -0x68(%rbp), %rax
movl (%rax), %eax
subl -0x40(%rbp), %eax
andl $0xfffff, %eax          # imm = 0xFFFFF
cmpl $0x1, %eax
jne 0xf2c8
testq %r15, %r15
setne %al
decl 0x60(%r8)
movq 0x160(%r8), %rcx
movl (%rcx), %ecx
movl %ecx, -0x5c(%rbp)
movq 0x168(%r8), %rcx
movl (%rcx), %ecx
movl %ecx, -0x58(%rbp)
movq 0x170(%r8), %rcx
movl (%rcx), %ecx
movl %ecx, -0x4c(%rbp)
movl 0x88(%r8), %ecx
movl %ecx, -0x50(%rbp)
movl 0x8c(%r8), %ecx
movl %ecx, -0x54(%rbp)
movq -0x68(%rbp), %rsi
movzbl 0x4(%rsi), %ecx
cmpl %r14d, %ecx
sete %cl
andb %al, %cl
movq 0x178(%r8), %rax
movl (%rax), %edx
movl %edx, -0x6c(%rbp)
movl 0xc(%rax), %edx
movl %edx, -0xa0(%rbp)
movq 0x4(%rax), %rax
movq %rax, -0xa8(%rbp)
movq (%rsi), %rax
movq %rax, -0x98(%rbp)
movzbl %cl, %eax
movl %eax, -0x7c(%rbp)
leaq -0x1c0(%rbp), %rdi
movq %rbx, %rsi
callq 0x2100
movq -0x38(%rbp), %rax
movq 0x150(%rax), %rsi
leaq -0x2c0(%rbp), %rdi
callq 0x2100
movq -0x38(%rbp), %r8
xorl %eax, %eax
movl $0x1, %r15d
jmp 0xf590
testb %sil, %sil
jne 0xf456
movq 0x148(%r8), %rdi
cmpb $0x0, (%rdi)
je 0xf30e
movl $0x4, %edx
leaq 0x34e3(%rip), %rsi      # 0x127cc
callq 0x20a0
movb -0x29(%rbp), %sil
movq -0x38(%rbp), %r8
testl %eax, %eax
jne 0xf30e
movq -0x68(%rbp), %rax
movl (%rax), %eax
subl -0x40(%rbp), %eax
testl $0xffffe, %eax          # imm = 0xFFFFE
je 0xf661
testb %sil, %sil
jne 0xf456
movq 0x148(%r8), %rbx
cmpb $0x0, (%rbx)
je 0xf3b5
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x349b(%rip), %rsi      # 0x127d1
callq 0x20a0
testl %eax, %eax
je 0xf38b
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x3486(%rip), %rsi      # 0x127d4
callq 0x20a0
testl %eax, %eax
jne 0xf3b5
addq $0x8, %rbx
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x3cfb(%rip), %rsi      # 0x13065
callq 0x20a0
testl %eax, %eax
je 0xf3b5
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x3816(%rip), %rsi      # 0x12b98
callq 0x20a0
testl %eax, %eax
je 0xf3b5
movq -0x68(%rbp), %rax
movl (%rax), %eax
movl $0xfffff, %ecx          # imm = 0xFFFFF
andl %ecx, %eax
shrl $0x10, %r13d
addl %eax, %r13d
movl -0x40(%rbp), %eax
andl %ecx, %eax
movl -0x60(%rbp), %ecx
shrl $0x10, %ecx
addl %eax, %ecx
cmpl %ecx, %r13d
jbe 0xf674
movb -0x29(%rbp), %sil
testb %sil, %sil
movq -0x38(%rbp), %r8
jne 0xf456
movq 0x148(%r8), %rdi
leaq 0x3409(%rip), %rsi      # 0x127dd
callq 0x21b0
movq -0x38(%rbp), %r8
testl %eax, %eax
jne 0xf449
movl -0x1c0(%rbp), %eax
movl $0x3158, %ecx           # imm = 0x3158
xorl %ecx, %eax
movzbl -0x1be(%rbp), %ecx
xorl $0x30, %ecx
orw %ax, %cx
jne 0xf449
movq 0x170(%r8), %rax
movl -0x4c(%rbp), %ecx
cmpl (%rax), %ecx
jne 0xf449
movq 0x178(%r8), %rax
movl -0x6c(%rbp), %ecx
cmpl (%rax), %ecx
jne 0xf449
movl $0x1, %r15d
cmpl $0x0, -0x48(%rbp)
je 0xf43a
movb $0x0, -0x2c0(%rbp)
movl $0x4, -0x50(%rbp)
movl $0xffffffff, -0x54(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x48(%rbp)
movl -0x3c(%rbp), %eax
jmp 0xf590
movb -0x29(%rbp), %sil
testb %sil, %sil
je 0xf68b
testb %sil, %sil
sete %al
movl -0x1c0(%rbp), %r14d
cmpl $0x796e6f53, %r14d      # imm = 0x796E6F53
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xf4c1
movq 0x148(%r8), %rdi
movl $0x5, %edx
movl %esi, %ebx
leaq 0x338b(%rip), %rsi      # 0x12814
callq 0x20a0
movl %ebx, %esi
movq -0x38(%rbp), %r8
testl %eax, %eax
jne 0xf4c1
movq 0x150(%r8), %r13
movl $0x2, %edx
movq %r13, %rdi
leaq 0x35e6(%rip), %rsi      # 0x12a94
callq 0x20a0
movl %ebx, %esi
movq -0x38(%rbp), %r8
testl %eax, %eax
je 0xf5a3
testb %sil, %sil
jne 0xf944
movq 0x148(%r8), %r12
cmpb $0x0, (%r12)
je 0xf944
cmpl $0x2d504d58, %r14d      # imm = 0x2D504D58
je 0xf4f2
cmpl $0x504d58, %r14d        # imm = 0x504D58
jne 0xf944
movq %r12, %rdi
leaq 0x3328(%rip), %rsi      # 0x12824
callq 0x21b0
movl %eax, %r13d
testl %eax, %eax
jne 0xf51c
movq -0x68(%rbp), %rax
movl (%rax), %eax
subl -0x40(%rbp), %eax
testl $0xfffff, %eax          # imm = 0xFFFFF
je 0xf59d
movl $0x3, %edx
movq %r12, %rdi
leaq 0x32f5(%rip), %rsi      # 0x12820
callq 0x20a0
testl %eax, %eax
jne 0xf940
movl -0x40(%rbp), %eax
movl $0xfffff, %edx          # imm = 0xFFFFF
andl %edx, %eax
movl -0x60(%rbp), %ecx
shrl $0x10, %ecx
addl %ecx, %eax
addl $0x2, %eax
movq -0x68(%rbp), %rcx
movl (%rcx), %ecx
andl %edx, %ecx
cmpl %ecx, %eax
movq -0x38(%rbp), %r8
jne 0xf944
cmpl $0x0, 0x64(%r8)
je 0xf944
cmpl $0x0, 0x7c(%r8)
je 0xf944
movl $0x1, %r15d
testl %r13d, %r13d
jne 0xf58b
movq -0x78(%rbp), %rax
decl (%rax)
xorl %r15d, %r15d
movl -0x3c(%rbp), %eax
notl %eax
testl %eax, %eax
jle 0xefd7
jmp 0xf944
movq -0x38(%rbp), %r8
jmp 0xf56c
leaq 0x3(%r13), %r15
movl $0x2, %edx
movq %r15, %rdi
leaq 0x3264(%rip), %rsi      # 0x1281a
callq 0x20a0
testl %eax, %eax
je 0xf5e1
movl $0x2, %edx
movq %r15, %rdi
leaq 0x324f(%rip), %rsi      # 0x1281d
callq 0x20a0
movl %ebx, %esi
movq -0x38(%rbp), %r8
testl %eax, %eax
jne 0xf4c1
leaq 0x6(%r13), %r15
movl $0x2, %edx
movq %r15, %rdi
leaq 0x3226(%rip), %rsi      # 0x1281a
callq 0x20a0
testl %eax, %eax
je 0xf61f
movl $0x2, %edx
movq %r15, %rdi
leaq 0x3211(%rip), %rsi      # 0x1281d
callq 0x20a0
movl %ebx, %esi
movq -0x38(%rbp), %r8
testl %eax, %eax
jne 0xf4c1
addq $0x9, %r13
movl $0x2, %edx
movq %r13, %rdi
leaq 0x31e8(%rip), %rsi      # 0x1281a
callq 0x20a0
movq -0x38(%rbp), %r8
testl %eax, %eax
je 0xf661
movl $0x2, %edx
movq %r13, %rdi
leaq 0x31cf(%rip), %rsi      # 0x1281d
callq 0x20a0
movl %ebx, %esi
movq -0x38(%rbp), %r8
testl %eax, %eax
jne 0xf4c1
movq -0x78(%rbp), %rax
decl (%rax)
movl -0x3c(%rbp), %eax
notl %eax
xorl %r15d, %r15d
jmp 0xf590
movq -0x78(%rbp), %rax
decl (%rax)
movl -0x3c(%rbp), %eax
notl %eax
xorl %r15d, %r15d
movq -0x38(%rbp), %r8
jmp 0xf590
movq 0x148(%r8), %r13
movl $0x2, %edx
movq %r13, %rdi
leaq 0x3130(%rip), %rsi      # 0x127d1
callq 0x20a0
movb -0x29(%rbp), %sil
movq -0x38(%rbp), %r8
testl %eax, %eax
je 0xf707
movq %r13, %rdi
leaq 0x3125(%rip), %rsi      # 0x127e1
callq 0x21b0
movb -0x29(%rbp), %sil
movq -0x38(%rbp), %r8
testl %eax, %eax
je 0xf707
movq %r13, %rdi
leaq 0x311c(%rip), %rsi      # 0x127f3
callq 0x21b0
movb -0x29(%rbp), %sil
movq -0x38(%rbp), %r8
testl %eax, %eax
je 0xf707
movq %r13, %rdi
leaq 0x3104(%rip), %rsi      # 0x127f6
callq 0x21b0
movb -0x29(%rbp), %sil
movq -0x38(%rbp), %r8
testl %eax, %eax
jne 0xf456
movq -0x1c0(%rbp), %rax
movabsq $0x6b657464696c6f53, %rcx # imm = 0x6B657464696C6F53
xorq %rcx, %rax
movq -0x1bd(%rbp), %rcx
movabsq $0x36316b65746469, %rdx # imm = 0x36316B65746469
xorq %rdx, %rcx
orq %rax, %rcx
je 0xf765
movq -0x1c0(%rbp), %rax
movabsq $0x6b657464696c6f53, %rcx # imm = 0x6B657464696C6F53
xorq %rcx, %rax
movq -0x1bd(%rbp), %rcx
movabsq $0x30326b65746469, %rdx # imm = 0x30326B65746469
xorq %rdx, %rcx
orq %rax, %rcx
jne 0xf456
movl -0x1b8(%rbp), %eax
movl $0x3631, %ecx           # imm = 0x3631
xorl %ecx, %eax
movzbl -0x1b6(%rbp), %ecx
orw %ax, %cx
movl -0x58(%rbp), %eax
cmovel -0x4c(%rbp), %eax
movl -0x5c(%rbp), %ecx
bswapl %ecx
movl %ecx, %edx
shrl $0x4, %edx
movl $0xf0f0f0f, %edi        # imm = 0xF0F0F0F
andl %edi, %edx
andl %edi, %ecx
shll $0x4, %ecx
orl %edx, %ecx
movl %ecx, %edx
movl $0x33333333, %esi       # imm = 0x33333333
andl %esi, %edx
shrl $0x2, %ecx
andl %esi, %ecx
leal (%rcx,%rdx,4), %ecx
movl %ecx, %edx
movl $0x50000000, %r9d       # imm = 0x50000000
andl %r9d, %edx
shrl %ecx
andl %r9d, %ecx
leal (%rcx,%rdx,2), %ecx
shrl $0x19, %ecx
bswapl %eax
movl %eax, %edx
shrl $0x4, %edx
andl %edi, %edx
movl %eax, %esi
andl %edi, %esi
shll $0x4, %esi
orl %edx, %esi
movl %esi, %edx
andl $0x10000000, %edx       # imm = 0x10000000
shrl $0x2, %esi
leal (%rsi,%rdx,4), %edx
andl %r9d, %edx
shll $0x5, %eax
andl $0x40000000, %eax       # imm = 0x40000000
leal (%rax,%rdx,2), %r14d
shrl $0x1d, %r14d
orl %ecx, %r14d
leaq -0x43(%rbp), %r12
movq %r12, %rdi
leaq 0x370f(%rip), %rsi      # 0x12f15
movl %r14d, %edx
xorl %eax, %eax
movq %r8, %rbx
callq 0x2060
movq 0x148(%rbx), %r13
movq %r13, %rdi
leaq 0x2fbd(%rip), %rsi      # 0x127e1
callq 0x21b0
testl %eax, %eax
jne 0xf843
movzwl -0x43(%rbp), %eax
xorl $0x3030, %eax           # imm = 0x3030
movzbl -0x41(%rbp), %ecx
orw %ax, %cx
je 0xf922
movq %r13, %rdi
leaq 0x2fa9(%rip), %rsi      # 0x127f6
callq 0x21b0
testl %eax, %eax
jne 0xf88c
movq -0x38(%rbp), %rax
movq 0x160(%rax), %rax
cmpl $0x0, (%rax)
jne 0xf88c
movq -0x38(%rbp), %rax
movq 0x170(%rax), %rax
cmpl $0x0, (%rax)
jne 0xf88c
movzwl -0x43(%rbp), %eax
xorl $0x3030, %eax           # imm = 0x3030
movzbl -0x41(%rbp), %ecx
orw %ax, %cx
je 0xf922
movl $0x2, %edx
movq %r13, %rdi
leaq 0x2f36(%rip), %rsi      # 0x127d1
callq 0x20a0
testl %eax, %eax
jne 0xf8bc
addq $0x5, %r13
movl $0x2, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x20a0
testl %eax, %eax
je 0xf922
xorl $0xff, %r14d
xorl %ebx, %ebx
movq %r12, %rdi
leaq 0x3646(%rip), %rsi      # 0x12f15
movl %r14d, %edx
xorl %eax, %eax
callq 0x2060
movq -0x38(%rbp), %r14
movq 0x148(%r14), %rdi
leaq 0x2f08(%rip), %rsi      # 0x127f3
callq 0x21b0
movl $0x1, %r15d
testl %eax, %eax
je 0xf8ff
movq %r14, %r8
jmp 0xf91d
movq 0x150(%r14), %rdi
movl $0x2, %edx
movq %r12, %rsi
callq 0x20a0
testl %eax, %eax
je 0xf922
xorl %ebx, %ebx
movq -0x38(%rbp), %r8
movl -0x3c(%rbp), %eax
jmp 0xf936
movq -0x78(%rbp), %rax
decl (%rax)
movl -0x3c(%rbp), %eax
notl %eax
movb $0x1, %bl
xorl %r15d, %r15d
movq -0x38(%rbp), %r8
testb %bl, %bl
jne 0xf590
jmp 0xf944
movq -0x38(%rbp), %r8
movl 0x6c(%r8), %eax
testl %eax, %eax
jle 0xf96b
movq (%r8), %rcx
movl $0xfffff, %edx          # imm = 0xFFFFF
movl (%rcx), %ecx
andl %edx, %ecx
cmpl %eax, %ecx
movl -0x80(%rbp), %r14d
cmovgel %edx, %r14d
movl -0x54(%rbp), %r12d
movl -0x50(%rbp), %ebx
jmp 0xf976
movl -0x54(%rbp), %r12d
movl -0x50(%rbp), %ebx
movl -0x80(%rbp), %r14d
movl -0x1c0(%rbp), %eax
cmpl $0x43454e, %eax         # imm = 0x43454E
je 0xf9ea
movl $0x7843454e, %ecx       # imm = 0x7843454E
xorl -0x1c0(%rbp), %ecx
movzbl -0x1bc(%rbp), %edx
orl %ecx, %edx
je 0xf9ea
movl $0x4e2d3834, %ecx       # imm = 0x4E2D3834
xorl -0x1c0(%rbp), %ecx
movl $0x43454e, %edx         # imm = 0x43454E
xorl -0x1bd(%rbp), %edx
orl %ecx, %edx
je 0xf9ea
cmpl $0x43564a, %eax         # imm = 0x43564A
jne 0xfc33
cmpl $0x0, -0x48(%rbp)
jne 0xfc33
leaq -0x1c0(%rbp), %rdi
callq 0x2090
movq -0x38(%rbp), %r8
movl $0x7d327b, -0x1c0(%rbp,%rax) # imm = 0x7D327B
movl $0x1, %ebx
jmp 0xfa32
cmpl $0x0, -0x90(%rbp)
jg 0xfa01
cmpl $0x0, 0x68(%r8)
jne 0xfa1b
cmpl $0x7, 0x24(%r8)
jl 0xfa1b
leaq -0x1c0(%rbp), %rdi
callq 0x2090
movq -0x38(%rbp), %r8
movw $0x32, -0x1c0(%rbp,%rax)
movq 0xb0(%r8), %rsi
leaq -0x1c0(%rbp), %rdi
callq 0x2220
movq -0x38(%rbp), %r8
movq (%r8), %rax
movl %r14d, (%rax)
movl -0xac(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq 0x160(%r8), %rax
movl -0x5c(%rbp), %ecx
movl %ecx, (%rax)
movq 0x168(%r8), %rax
movl -0x58(%rbp), %ecx
movl %ecx, (%rax)
movq 0x170(%r8), %rax
movl -0x4c(%rbp), %ecx
movl %ecx, (%rax)
movq 0x178(%r8), %rax
movl -0x6c(%rbp), %ecx
movl %ecx, (%rax)
movq -0xa8(%rbp), %rcx
movq %rcx, 0x4(%rax)
movl -0xa0(%rbp), %ecx
movl %ecx, 0xc(%rax)
movq 0x148(%r8), %rdi
leaq -0x1c0(%rbp), %rsi
callq 0x2100
movq -0x38(%rbp), %r8
xorl %eax, %eax
movl -0xb0(%rbp), %r9d
testl %r9d, %r9d
setg %al
movl -0x84(%rbp), %ecx
movl %ecx, %r14d
cmovgl %r9d, %r14d
cmpl $-0x1, %ebx
leal 0x1(%rax,%rax), %r15d
cmovnel %ebx, %r15d
cmovnel %ecx, %r14d
movl $0x2, %eax
cmpl $0x3, 0x74(%r8)
jl 0xfb06
movl $0xfffff, %eax          # imm = 0xFFFFF
movl -0x98(%rbp), %ecx
andl %eax, %ecx
movq (%r8), %rdx
movl %ecx, %esi
subl -0x7c(%rbp), %esi
testl %ecx, %ecx
cmovel %ecx, %esi
movl (%rdx), %ecx
movl %ecx, %edi
andl $0xfff00000, %edi       # imm = 0xFFF00000
orl %esi, %edi
movl %edi, 0x8(%rdx)
andl %eax, %ecx
movl %ecx, (%rdx)
movl $0x3, %eax
cmpl $0x4, 0x74(%r8)
jl 0xfb1e
movl -0x94(%rbp), %eax
movq (%r8), %rcx
movl %eax, 0xc(%rcx)
movl $0x4, %eax
cmpl $0x6, 0x74(%r8)
jl 0xfb39
movq (%r8), %rax
movl -0x40(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl -0x60(%rbp), %ecx
movl %ecx, 0x14(%rax)
movl $0x6, %eax
cmpl $0x8, 0x74(%r8)
jl 0xfb73
movq (%r8), %rbx
movl $0xfffff, %eax          # imm = 0xFFFFF
movl 0x8(%rbx), %esi
andl %eax, %esi
andl (%rbx), %eax
movzwl 0x6(%rbx), %ecx
leal (%rax,%rcx), %edx
addl $0x2, %edx
movq %r8, %rdi
movl %r9d, %r13d
callq 0xee1c
movl %r13d, %r9d
movq -0x38(%rbp), %r8
movl %eax, 0x18(%rbx)
movl $0x8, %eax
cmpl $0x9, 0x74(%r8)
jl 0xfba2
shll $0x10, %r15d
addl $0x10000, %r15d         # imm = 0x10000
shll $0x18, %r12d
addl $0x1000000, %r12d       # imm = 0x1000000
orl %r12d, %r14d
orl %r15d, %r14d
movq (%r8), %rax
movl %r14d, 0x20(%rax)
movl $0x9, %eax
cmpl $0x3, %eax
jl 0xfbb6
shll $0x14, %eax
movl $0x200000, %ecx         # imm = 0x200000
subl %eax, %ecx
movq (%r8), %rax
orl %ecx, (%rax)
xorl %eax, %eax
cmpl $0x0, 0x64(%r8)
jne 0xfcd4
cmpl $0x0, -0x90(%rbp)
sete %al
testl %r9d, %r9d
setle %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xfbfb
movq 0x150(%r8), %rdi
cmpb $0x0, -0x2c0(%rbp)
leaq 0x2c5a(%rip), %rax      # 0x12849
leaq 0x2c5d(%rip), %rsi      # 0x12853
jmp 0xfcc5
testl %r9d, %r9d
setle %al
cmpl $0x2, -0x84(%rbp)
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xfc8a
movq 0x150(%r8), %rdi
cmpb $0x0, -0x2c0(%rbp)
leaq 0x2c38(%rip), %rax      # 0x1285f
leaq 0x2c3a(%rip), %rsi      # 0x12868
jmp 0xfcc5
movl $0x4352, %ecx           # imm = 0x4352
xorl -0x1c0(%rbp), %ecx
movzbl -0x1be(%rbp), %edx
xorl $0x41, %edx
orw %cx, %dx
jne 0xfd09
cmpl $0x0, -0x48(%rbp)
je 0xfd09
leaq -0x1c0(%rbp), %rdi
callq 0x2090
movq -0x38(%rbp), %r8
movl $0x646c4f28, -0x1c0(%rbp,%rax) # imm = 0x646C4F28
movw $0x29, -0x1bc(%rbp,%rax)
movl $0xb, %ebx
jmp 0xfa32
testl %r9d, %r9d
jle 0xfd2b
movl %r9d, %edx
xorl $0x1, %edx
movq 0x150(%r8), %rdi
movb -0x2c0(%rbp), %al
movq -0x90(%rbp), %rcx
orl %ecx, %edx
jne 0xfd54
testb %al, %al
leaq 0x2bcf(%rip), %rax      # 0x1288d
leaq 0x2bd2(%rip), %rsi      # 0x12897
cmoveq %rax, %rsi
xorl %eax, %eax
callq 0x2060
movq -0x38(%rbp), %r8
movslq %eax, %rdi
addq 0x150(%r8), %rdi
leaq -0x2c0(%rbp), %rsi
movq %r8, %rbx
callq 0x2100
movq 0x158(%rbx), %rax
movb $0x0, (%rax)
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzwl -0x1c0(%rbp), %ecx
cmpl $0x3f3f, %ecx           # imm = 0x3F3F
movl $0x8, %ecx
cmovel %ecx, %ebx
cmpl $0x2d706147, %eax       # imm = 0x2D706147
cmovel %ecx, %ebx
jmp 0xfa32
movq 0x150(%r8), %rdi
cmpb $0x0, -0x2c0(%rbp)
leaq 0x2b33(%rip), %rax      # 0x12873
leaq 0x2b38(%rip), %rsi      # 0x1287f
cmoveq %rax, %rsi
movq -0x90(%rbp), %rdx
jmp 0xfd92
testl %ecx, %ecx
je 0xfd7b
testb %al, %al
leaq 0x2b5c(%rip), %rax      # 0x128bd
leaq 0x2b6c(%rip), %rsi      # 0x128d4
cmoveq %rax, %rsi
movl %r9d, %edx
xorl %eax, %eax
callq 0x2060
jmp 0xfcd0
testb %al, %al
leaq 0x2b1f(%rip), %rax      # 0x128a3
leaq 0x2b24(%rip), %rsi      # 0x128af
cmoveq %rax, %rsi
movl %r9d, %edx
xorl %eax, %eax
callq 0x2060
jmp 0xfcd0