// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/paeq128/aesni/encrypt.cpp
// Function: PAEQ128_opt_AESNI_decrypt(unsigned char*, unsigned long long*, unsigned char const*, unsigned long long, unsigned char const*, unsigned long long, unsigned char const*, unsigned char const*)
int PAEQ128_opt_AESNI_decrypt(unsigned char *m, unsigned long long *mlen,
	const unsigned char *c, unsigned long long clen,
	const unsigned char *ad, unsigned long long adlen,
	const unsigned char *npub,
	const unsigned char *k)
{

	if (mlen == NULL)
		return -1;
	if ((clen == 0) && (adlen == 0))
	{
		*mlen = 0;
		return 0;
	}

	(*mlen) = 0;
	//Minimum tag length verification
	if (clen < CRYPTO_ABYTES)
		return -1;

	//Here we do decryption and/or authentication so we need a key and a ciphertext pointer valid
	if ((k == NULL) || (c == NULL))
		return -2;

	//1.1 Initializing constants
	uint64_t D_left = ((uint64_t)CRYPTO_NPUBBYTES * 8) + (((uint64_t)CRYPTO_KEYBYTES * 8) << 8);
	__m128i D0 = _mm_set_epi64x(0, D_left);
	__m128i D2 = _mm_set_epi64x(0, D_left + 2);
	__m128i D3 = _mm_set_epi64x(0, D_left + 3);
	__m128i one128 = _mm_set_epi64x(0, 1);
	__m128i four128 = _mm_set_epi64x(0, 4);
	__m128i six128 = _mm_set_epi64x(0, 6);
	__m128i counter_one128 = _mm_set_epi64x(0, 1 << 16);  //value to increase the counter
	__m128i Dmask = _mm_set_epi32(0xffffffff, 0xffffffff, 0xffffffff, 0xffff0000);

	//Block variables
	__m128i BlockInput[4];  //V1 - input to the first layer call of F
	__m128i BlockMiddle[4];  //W1 - output of the first layer call of F
	__m128i BlockOutput[4];  //Y1 - output of the second layer call of F

	//Extra variables
	__m128i BlockExtraInput[4];
	__m128i BlockExtraMiddle[4];
	__m128i BlockExtraOutput[4];


	__m128i BlockLastInput[4];  //Z1 - input to the last call of F
	__m128i Tag[4]; //Tag output

	//1.2 Clearing variables
	memset(BlockLastInput, 0, 64);
	memset(BlockInput, 0, 64);
	memset(BlockOutput, 0, 64);
	memset(BlockMiddle, 0, 64);
	memset(BlockMiddle, 0, 64);

	//1.3 Setting first block
	BlockInput[0] = D0;  //Domain separation constant
	uint64_t nonce_low = (*((uint64_t*)npub)) << 32;
	uint64_t nonce_high = *((uint64_t*)(npub + 4));
	BlockInput[2] = _mm_set_epi64x(nonce_high, nonce_low);   //Nonce
	__m128i Key = _mm_set_epi64x(*((uint64_t*)(k + 8)), (*((uint64_t*)k)));
	BlockInput[3] = Key;


	unsigned long long decrypted_bytes = 0;//Encrypted bytes counter


	//Encryption part
	if (clen != 0)
	{
		if (c == NULL)
			return -3;

		while ((clen>CRYPTO_ABYTES))
		{
			/* I. First layer */

			if ((clen < (2 * CRYPTO_MBLOCK + CRYPTO_ABYTES)) || (decrypted_bytes == 0))
			{

				//1. Domain-separation constant
				if (clen < CRYPTO_MBLOCK + CRYPTO_ABYTES) //Last incomplete block
					BlockInput[0] = _mm_add_epi64(BlockInput[0], one128);

				//2. Counter incrementing
				BlockInput[0] = _mm_add_epi64(BlockInput[0], counter_one128);

				//3. Permutation call
				FPermAsm(BlockInput, BlockMiddle); //First layer call to F

				/* II. Encryption*/

				//1. Filling ciphertext buffers
				__m128i ciphertext128[3];
				__m128i plaintext_buffer[3];
				__m128i padding[3];
				__m128i boundary[3];
				memset(ciphertext128, 0, sizeof(__m128i) * 3);
				if (clen >= CRYPTO_MBLOCK + CRYPTO_ABYTES)//Full block encryption
				{
					ciphertext128[0] = D2;
					memcpy(((char*)ciphertext128) + 2, c + decrypted_bytes, CRYPTO_MBLOCK);
					memset(boundary, 0, sizeof(__m128i) * 3);
				}
				else
				{
					ciphertext128[0] = D3;
					memcpy(((char*)ciphertext128) + 2, c + decrypted_bytes, clen - CRYPTO_ABYTES);

					padding[0] = padding[1] = padding[2] = _mm_set1_epi8(clen - CRYPTO_ABYTES);
					boundary[0] = boundary[1] = boundary[2] = _mm_set1_epi8(0xff);
					memset(boundary, 0, clen - CRYPTO_ABYTES + 2);
				}


				//3. Getting plaintext
				plaintext_buffer[0] = _mm_xor_si128(BlockMiddle[0], ciphertext128[0]);
				plaintext_buffer[1] = _mm_xor_si128(BlockMiddle[1], ciphertext128[1]);
				plaintext_buffer[2] = _mm_xor_si128(BlockMiddle[2], ciphertext128[2]);

				if (clen >= CRYPTO_MBLOCK + CRYPTO_ABYTES)
					memcpy(m + decrypted_bytes, ((char*)plaintext_buffer) + 2, CRYPTO_MBLOCK);
				else //Last incomplete block
					memcpy(m + decrypted_bytes, ((char*)plaintext_buffer) + 2, (clen - CRYPTO_ABYTES));
				memset(plaintext_buffer, 0, 6 * sizeof(uint64_t));

				//4. Loading ciphertext
				BlockMiddle[0] = _mm_xor_si128(_mm_andnot_si128(boundary[0], ciphertext128[0]), _mm_and_si128(boundary[0], _mm_xor_si128(BlockMiddle[0], padding[0])));
				BlockMiddle[1] = _mm_xor_si128(_mm_andnot_si128(boundary[1], ciphertext128[1]), _mm_and_si128(boundary[1], _mm_xor_si128(BlockMiddle[1], padding[1])));
				BlockMiddle[2] = _mm_xor_si128(_mm_andnot_si128(boundary[2], ciphertext128[2]), _mm_and_si128(boundary[2], _mm_xor_si128(BlockMiddle[2], padding[2])));

				//III. Second permutation call
				//1. Call
				FPermAsm(BlockMiddle, BlockOutput); //Second layer call to F

				//2. Buffer update: Adding the output to tag preparation buffer
				BlockLastInput[0] = _mm_xor_si128(BlockOutput[0], BlockLastInput[0]);
				BlockLastInput[1] = _mm_xor_si128(BlockOutput[1], BlockLastInput[1]);
				BlockLastInput[2] = _mm_xor_si128(BlockOutput[2], BlockLastInput[2]);

				//Counters increment
				if (clen >= CRYPTO_MBLOCK + CRYPTO_ABYTES)
				{
					decrypted_bytes += CRYPTO_MBLOCK;
					clen -= CRYPTO_MBLOCK;
				}
				else
				{
					decrypted_bytes += (clen - CRYPTO_ABYTES);
					clen = CRYPTO_ABYTES;
				}
				(*mlen) = decrypted_bytes;
			}//end of <138 byte condition


			else //More than 137 bytes to encrypt
			{
				BlockExtraInput[0] = _mm_add_epi64(BlockInput[0], counter_one128);
				BlockInput[0] = _mm_add_epi64(BlockExtraInput[0], counter_one128);
				BlockExtraInput[1] = BlockInput[1];
				BlockExtraInput[2] = BlockInput[2];
				BlockExtraInput[3] = BlockInput[3];

				//2. Two-permutation call
				DoubleFPermAsm(BlockExtraInput, BlockInput, BlockExtraMiddle, BlockMiddle); //First layer call to F


				//3. Preparing plaintext buffer
				__m128i plaintext_buffer[6];  //96-byte storage
				plaintext_buffer[0] = BlockExtraMiddle[0];
				plaintext_buffer[1] = BlockExtraMiddle[1];
				plaintext_buffer[2] = BlockExtraMiddle[2];
				plaintext_buffer[3] = BlockMiddle[0];
				plaintext_buffer[4] = BlockMiddle[1];
				plaintext_buffer[5] = BlockMiddle[2];

				//4.Loading ciphertext
				BlockExtraMiddle[0] = _mm_loadu_si128((__m128i*)(c + decrypted_bytes - 2));   //Bytes [0:13]
				BlockExtraMiddle[1] = _mm_loadu_si128((__m128i*)(c + decrypted_bytes + 14));  //Bytes [14:29]
				BlockExtraMiddle[2] = _mm_loadu_si128((__m128i*)(c + decrypted_bytes + 30));  //Bytes [30:45]
				BlockMiddle[0] = _mm_loadu_si128((__m128i*)(c + decrypted_bytes + 44));  //Bytes [0:13]
				BlockMiddle[1] = _mm_loadu_si128((__m128i*)(c + decrypted_bytes + 60));   //Bytes [14:29]
				BlockMiddle[2] = _mm_loadu_si128((__m128i*)(c + decrypted_bytes + 76));  //Bytes [30:45]

				//5. Preparing the middle layer
				BlockMiddle[0] = _mm_and_si128(BlockMiddle[0], Dmask); //Clearing first two bytes
				BlockExtraMiddle[0] = _mm_and_si128(BlockExtraMiddle[0], Dmask);
				BlockMiddle[0] = _mm_xor_si128(BlockMiddle[0], D2);    //Loading D2
				BlockExtraMiddle[0] = _mm_xor_si128(BlockExtraMiddle[0], D2);

				//6. Getting plaintext
				plaintext_buffer[0] = _mm_xor_si128(plaintext_buffer[0], BlockExtraMiddle[0]);
				plaintext_buffer[1] = _mm_xor_si128(plaintext_buffer[1], BlockExtraMiddle[1]);
				plaintext_buffer[2] = _mm_xor_si128(plaintext_buffer[2], BlockExtraMiddle[2]);
				plaintext_buffer[3] = _mm_xor_si128(plaintext_buffer[3], BlockMiddle[0]);
				plaintext_buffer[4] = _mm_xor_si128(plaintext_buffer[4], BlockMiddle[1]);
				plaintext_buffer[5] = _mm_xor_si128(plaintext_buffer[5], BlockMiddle[2]);
				memcpy(m + decrypted_bytes, ((char*)plaintext_buffer) + 2, CRYPTO_MBLOCK);
				memcpy(m + decrypted_bytes + 46, ((char*)plaintext_buffer) + 50, CRYPTO_MBLOCK);

				//7. Second layer permutation
				DoubleFPermAsm(BlockExtraMiddle, BlockMiddle, BlockExtraOutput, BlockOutput); //Second layer call to F

				//8. Buffer update: Adding the output to tag preparation buffer
				BlockLastInput[0] = _mm_xor_si128(BlockOutput[0], BlockLastInput[0]);
				BlockLastInput[1] = _mm_xor_si128(BlockOutput[1], BlockLastInput[1]);
				BlockLastInput[2] = _mm_xor_si128(BlockOutput[2], BlockLastInput[2]);
				BlockLastInput[0] = _mm_xor_si128(BlockExtraOutput[0], BlockLastInput[0]);
				BlockLastInput[1] = _mm_xor_si128(BlockExtraOutput[1], BlockLastInput[1]);
				BlockLastInput[2] = _mm_xor_si128(BlockExtraOutput[2], BlockLastInput[2]);


				//9.Counter update
				decrypted_bytes += 2 * CRYPTO_MBLOCK;
				clen -= 2 * CRYPTO_MBLOCK;
				(*mlen) = decrypted_bytes;
			}


		}//end of encryption loop
	}//end of encryption part

	//Clearing variables
	for (unsigned i = 0; i < 4; ++i)
	{
		BlockInput[i] = _mm_xor_si128(BlockInput[i], BlockInput[i]);
		BlockMiddle[i] = _mm_xor_si128(BlockMiddle[i], BlockMiddle[i]);
		BlockOutput[i] = _mm_xor_si128(BlockOutput[i], BlockOutput[i]);

		BlockExtraInput[i] = _mm_xor_si128(BlockExtraInput[i], BlockExtraInput[i]);
		BlockExtraMiddle[i] = _mm_xor_si128(BlockExtraMiddle[i], BlockExtraMiddle[i]);
		BlockExtraOutput[i] = _mm_xor_si128(BlockExtraOutput[i], BlockExtraOutput[i]);
	}



	//Associated data part	  
	if (adlen != 0)
	{
		if (ad == NULL)
		{
			for (unsigned i = 0; i < 4; ++i)
				BlockLastInput[i] = _mm_xor_si128(BlockLastInput[i], BlockLastInput[i]);
			Key = _mm_xor_si128(Key, Key);
			return -4;
		}

		unsigned long long adblock_counter = 1;   //AD block counter
		unsigned long long auth_bytes = 0;

		//Preparing the block
		BlockInput[0] = _mm_add_epi64(D0, four128);
		BlockInput[3] = Key;
		while (adlen>0)
		{
			if ((adlen <= (2 * CRYPTO_ADBLOCK)) || (auth_bytes == 0))
			{

				//1. Constant
				if (adlen < CRYPTO_ADBLOCK)
					BlockInput[0] = _mm_add_epi64(BlockInput[0], one128);


				//2. Counter
				BlockInput[0] = _mm_add_epi64(BlockInput[0], counter_one128);

				//3. AD block

				//3.1 Filling AD buffers
				uint64_t ad_buffer[4];
				ad_buffer[0] = 0;
				if (adlen >= CRYPTO_ADBLOCK)//Full block encryption
					memcpy(((char*)ad_buffer) + 2, ad + auth_bytes, CRYPTO_ADBLOCK);
				else
				{
					//Filling buffers with adlen
					ad_buffer[0] = ((uint64_t)adlen * 0x01010000) ^ (((uint64_t)adlen * 0x01010101) << 32);
					for (unsigned i = 1; i < 4; ++i)
						ad_buffer[i] = (((uint64_t)adlen * 0x01010101) << 32) ^ ((uint64_t)adlen * 0x01010101);
					memcpy(((char*)ad_buffer) + 2, ad + auth_bytes, adlen);
				}

				//3.2 Working with BlockInput
				BlockInput[1] = _mm_set_epi64x(ad_buffer[1], ad_buffer[0]);
				BlockInput[2] = _mm_set_epi64x(ad_buffer[3], ad_buffer[2]);


				//4.Call to the F permutation
				FPermAsm(BlockInput, BlockOutput);//Call to the F permutation

				//Adding the output to tag preparation buffer
				BlockLastInput[0] = _mm_xor_si128(BlockOutput[0], BlockLastInput[0]);
				BlockLastInput[1] = _mm_xor_si128(BlockOutput[1], BlockLastInput[1]);
				BlockLastInput[2] = _mm_xor_si128(BlockOutput[2], BlockLastInput[2]);


				//Counters increment
				adblock_counter++;
				if (adlen >= CRYPTO_ADBLOCK)
				{
					auth_bytes += CRYPTO_ADBLOCK;
					adlen -= CRYPTO_ADBLOCK;
				}
				else
				{
					auth_bytes += adlen;
					adlen = 0;
				}
			}//end of 60-byte condition
			else //We authenticate 60-byte chunks
			{

				//1.Preparing input
				BlockExtraInput[0] = _mm_add_epi64(BlockInput[0], counter_one128);
				BlockInput[0] = _mm_add_epi64(BlockExtraInput[0], counter_one128);
				BlockExtraInput[3] = BlockInput[3]; //Key is constant

				//2. Loading AD
				BlockExtraInput[1] = _mm_loadu_si128((__m128i*)(ad + auth_bytes - 2));   //Bytes [0:13]
				BlockExtraInput[1] = _mm_and_si128(BlockExtraInput[1], Dmask); //Clearing first two bytes
				BlockExtraInput[2] = _mm_loadu_si128((__m128i*)(ad + auth_bytes + 14));  //Bytes [14:29]
				BlockInput[1] = _mm_loadu_si128((__m128i*)(ad + auth_bytes + 28));  //Bytes [0:13]
				BlockInput[1] = _mm_and_si128(BlockInput[1], Dmask); //Clearing first two bytes
				BlockInput[2] = _mm_loadu_si128((__m128i*)(ad + auth_bytes + 44));  //Bytes [14:29]

				//3. Call to the permutation
				DoubleFPermAsm(BlockExtraInput, BlockInput, BlockExtraOutput, BlockOutput);

				//4. Buffer update: Adding the output to tag preparation buffer
				BlockLastInput[0] = _mm_xor_si128(BlockOutput[0], BlockLastInput[0]);
				BlockLastInput[1] = _mm_xor_si128(BlockOutput[1], BlockLastInput[1]);
				BlockLastInput[2] = _mm_xor_si128(BlockOutput[2], BlockLastInput[2]);
				BlockLastInput[0] = _mm_xor_si128(BlockExtraOutput[0], BlockLastInput[0]);
				BlockLastInput[1] = _mm_xor_si128(BlockExtraOutput[1], BlockLastInput[1]);
				BlockLastInput[2] = _mm_xor_si128(BlockExtraOutput[2], BlockLastInput[2]);

				//5. Counter update
				auth_bytes += 2 * CRYPTO_ADBLOCK;
				adlen -= 2 * CRYPTO_ADBLOCK;
			}
		}//end of AD loop
	}//end of AD part

	// Tag production 
	BlockLastInput[3] = Key;
	BlockLastInput[0] = _mm_and_si128(BlockLastInput[0], Dmask); //Clearing first two bytes
	BlockLastInput[0] = _mm_add_epi64(BlockLastInput[0], six128);
	BlockLastInput[0] = _mm_add_epi64(BlockLastInput[0], D0);

	//1. Permutation call
	FPermAsm(BlockLastInput, Tag);
	//2. Key injection
	Tag[3] = _mm_xor_si128(Tag[3], Key);

	//3. Clearing variables
	for (unsigned i = 0; i < 4; ++i)
	{
		BlockInput[i] = _mm_xor_si128(BlockInput[i], BlockInput[i]);
		BlockMiddle[i] = _mm_xor_si128(BlockMiddle[i], BlockMiddle[i]);
		BlockOutput[i] = _mm_xor_si128(BlockOutput[i], BlockOutput[i]);

		BlockExtraInput[i] = _mm_xor_si128(BlockExtraInput[i], BlockExtraInput[i]);
		BlockExtraMiddle[i] = _mm_xor_si128(BlockExtraMiddle[i], BlockExtraMiddle[i]);
		BlockExtraOutput[i] = _mm_xor_si128(BlockExtraOutput[i], BlockExtraOutput[i]);
		BlockLastInput[i] = _mm_xor_si128(BlockLastInput[i], BlockLastInput[i]);
	}
	Key = _mm_xor_si128(Key, Key);

	//4. Checking tag
	__m128i ciphertext_tag = _mm_loadu_si128((__m128i*)(c + (*mlen)));
	ciphertext_tag = _mm_xor_si128(ciphertext_tag, Tag[0]);
	uint32_t* test = (uint32_t*)(&ciphertext_tag);
	
	if ((test[0] == 0) && (test[1] == 0) && (test[2] == 0) && (test[3] == 0))
		return 0;
	else return -1;
}

// Assembly:
subq $0x1058, %rsp           # imm = 0x1058
movq 0x1068(%rsp), %rax
movq 0x1060(%rsp), %rax
movq %rdi, 0x4b0(%rsp)
movq %rsi, 0x4a8(%rsp)
movq %rdx, 0x4a0(%rsp)
movq %rcx, 0x498(%rsp)
movq %r8, 0x490(%rsp)
movq %r9, 0x488(%rsp)
cmpq $0x0, 0x4a8(%rsp)
jne 0x2912
movl $0xffffffff, 0x4bc(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f69
cmpq $0x0, 0x498(%rsp)
jne 0x2947
cmpq $0x0, 0x488(%rsp)
jne 0x2947
movq 0x4a8(%rsp), %rax
movq $0x0, (%rax)
movl $0x0, 0x4bc(%rsp)
jmp 0x4f69
movq 0x4a8(%rsp), %rax
movq $0x0, (%rax)
cmpq $0x10, 0x498(%rsp)
jae 0x2971
movl $0xffffffff, 0x4bc(%rsp) # imm = 0xFFFFFFFF
jmp 0x4f69
cmpq $0x0, 0x1068(%rsp)
je 0x2987
cmpq $0x0, 0x4a0(%rsp)
jne 0x2997
movl $0xfffffffe, 0x4bc(%rsp) # imm = 0xFFFFFFFE
jmp 0x4f69
movq $0x8060, 0x480(%rsp) # imm = 0x8060
movq 0x480(%rsp), %rax
movq $0x0, 0x618(%rsp)
movq %rax, 0x610(%rsp)
vmovq 0x618(%rsp), %xmm1
vmovq 0x610(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x600(%rsp)
vmovdqa 0x600(%rsp), %xmm0
vmovdqa %xmm0, 0x470(%rsp)
movq 0x480(%rsp), %rax
addq $0x2, %rax
movq $0x0, 0x5f8(%rsp)
movq %rax, 0x5f0(%rsp)
vmovq 0x5f8(%rsp), %xmm1
vmovq 0x5f0(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x5e0(%rsp)
vmovdqa 0x5e0(%rsp), %xmm0
vmovdqa %xmm0, 0x460(%rsp)
movq 0x480(%rsp), %rax
addq $0x3, %rax
movq $0x0, 0x5d8(%rsp)
movq %rax, 0x5d0(%rsp)
vmovq 0x5d8(%rsp), %xmm1
vmovq 0x5d0(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x5c0(%rsp)
vmovdqa 0x5c0(%rsp), %xmm0
vmovdqa %xmm0, 0x450(%rsp)
movq $0x0, 0x5b8(%rsp)
movq $0x1, 0x5b0(%rsp)
vmovq 0x5b8(%rsp), %xmm1
vmovq 0x5b0(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x5a0(%rsp)
vmovdqa 0x5a0(%rsp), %xmm0
vmovdqa %xmm0, 0x440(%rsp)
movq $0x0, 0x598(%rsp)
movq $0x4, 0x590(%rsp)
vmovq 0x598(%rsp), %xmm1
vmovq 0x590(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x580(%rsp)
vmovdqa 0x580(%rsp), %xmm0
vmovdqa %xmm0, 0x430(%rsp)
movq $0x0, 0x578(%rsp)
movq $0x6, 0x570(%rsp)
vmovq 0x578(%rsp), %xmm1
vmovq 0x570(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x560(%rsp)
vmovdqa 0x560(%rsp), %xmm0
vmovdqa %xmm0, 0x420(%rsp)
movq $0x0, 0x558(%rsp)
movq $0x10000, 0x550(%rsp) # imm = 0x10000
vmovq 0x558(%rsp), %xmm1
vmovq 0x550(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x540(%rsp)
vmovdqa 0x540(%rsp), %xmm0
vmovdqa %xmm0, 0x410(%rsp)
movl $0xffffffff, 0x7a8(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x7a4(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x7a0(%rsp) # imm = 0xFFFFFFFF
movl $0xffff0000, 0x79c(%rsp) # imm = 0xFFFF0000
movl 0x7a0(%rsp), %edx
movl 0x7a4(%rsp), %ecx
movl 0x7a8(%rsp), %eax
vmovd 0x79c(%rsp), %xmm0
vpinsrd $0x1, %edx, %xmm0, %xmm0
vpinsrd $0x2, %ecx, %xmm0, %xmm0
vpinsrd $0x3, %eax, %xmm0, %xmm0
vmovdqa %xmm0, 0x780(%rsp)
vmovdqa 0x780(%rsp), %xmm0
vmovdqa %xmm0, 0x400(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x20(%rsp)
vmovdqu %ymm0, 0x260(%rsp)
vmovdqu %ymm0, 0x240(%rsp)
vmovdqu %ymm0, 0x3e0(%rsp)
vmovdqu %ymm0, 0x3c0(%rsp)
vmovdqu %ymm0, 0x360(%rsp)
vmovdqu %ymm0, 0x340(%rsp)
vmovdqu %ymm0, 0x3a0(%rsp)
vmovdqu %ymm0, 0x380(%rsp)
vmovdqu %ymm0, 0x3a0(%rsp)
vmovdqu %ymm0, 0x380(%rsp)
vmovdqa 0x470(%rsp), %xmm0
vmovdqa %xmm0, 0x3c0(%rsp)
movq 0x1060(%rsp), %rax
movq (%rax), %rax
shlq $0x20, %rax
movq %rax, 0x1f8(%rsp)
movq 0x1060(%rsp), %rax
movq 0x4(%rax), %rax
movq %rax, 0x1f0(%rsp)
movq 0x1f0(%rsp), %rcx
movq 0x1f8(%rsp), %rax
movq %rcx, 0x538(%rsp)
movq %rax, 0x530(%rsp)
vmovq 0x538(%rsp), %xmm1
vmovq 0x530(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x520(%rsp)
vmovdqa 0x520(%rsp), %xmm0
vmovdqa %xmm0, 0x3e0(%rsp)
movq 0x1068(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
movq %rcx, 0x518(%rsp)
movq %rax, 0x510(%rsp)
vmovq 0x518(%rsp), %xmm1
vmovq 0x510(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x500(%rsp)
vmovdqa 0x500(%rsp), %xmm0
vmovdqa %xmm0, 0x1e0(%rsp)
vmovdqa 0x1e0(%rsp), %xmm0
vmovdqa %xmm0, 0x3f0(%rsp)
movq $0x0, 0x1d8(%rsp)
cmpq $0x0, 0x498(%rsp)
je 0x3e7f
cmpq $0x0, 0x4a0(%rsp)
jne 0x2db7
movl $0xfffffffd, 0x4bc(%rsp) # imm = 0xFFFFFFFD
jmp 0x4f69
jmp 0x2db9
cmpq $0x10, 0x498(%rsp)
jbe 0x3e7d
cmpq $0x6c, 0x498(%rsp)
jb 0x2de2
cmpq $0x0, 0x1d8(%rsp)
jne 0x376a
cmpq $0x3e, 0x498(%rsp)
jae 0x2e2c
vmovdqa 0x3c0(%rsp), %xmm1
vmovdqa 0x440(%rsp), %xmm0
vmovdqa %xmm1, 0x770(%rsp)
vmovdqa %xmm0, 0x760(%rsp)
vmovdqa 0x770(%rsp), %xmm0
vpaddq 0x760(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x3c0(%rsp)
vmovdqa 0x3c0(%rsp), %xmm1
vmovdqa 0x410(%rsp), %xmm0
vmovdqa %xmm1, 0x750(%rsp)
vmovdqa %xmm0, 0x740(%rsp)
vmovdqa 0x750(%rsp), %xmm0
vpaddq 0x740(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x3c0(%rsp)
leaq 0x3c0(%rsp), %rdi
leaq 0x380(%rsp), %rsi
vzeroupper
callq 0x10a0
leaq 0x1a0(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1030
cmpq $0x3e, 0x498(%rsp)
jb 0x2ef3
vmovdqa 0x460(%rsp), %xmm0
vmovdqa %xmm0, 0x1a0(%rsp)
leaq 0x1a0(%rsp), %rdi
addq $0x2, %rdi
movq 0x4a0(%rsp), %rsi
addq 0x1d8(%rsp), %rsi
movl $0x2e, %edx
callq 0x10c0
leaq 0x110(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1030
jmp 0x3274
vmovdqa 0x450(%rsp), %xmm0
vmovdqa %xmm0, 0x1a0(%rsp)
leaq 0x1a2(%rsp), %rdi
movq 0x4a0(%rsp), %rsi
movq 0x1d8(%rsp), %rax
addq %rax, %rsi
movq 0x498(%rsp), %rdx
addq $-0x10, %rdx
callq 0x10c0
movb 0x498(%rsp), %al
addb $-0x10, %al
movb %al, 0x7af(%rsp)
movb 0x7af(%rsp), %al
movb %al, 0x1e(%rsp)
movb %al, 0x102f(%rsp)
movb %al, 0x102e(%rsp)
movb %al, 0x102d(%rsp)
movb %al, 0x102c(%rsp)
movb %al, 0x102b(%rsp)
movb %al, 0x102a(%rsp)
movb %al, 0x1029(%rsp)
movb %al, 0x1028(%rsp)
movb %al, 0x1027(%rsp)
movb %al, 0x1026(%rsp)
movb %al, 0x1025(%rsp)
movb %al, 0x1024(%rsp)
movb %al, 0x1023(%rsp)
movb %al, 0x1022(%rsp)
movb %al, 0x1021(%rsp)
movb %al, 0x1020(%rsp)
movzbl 0x1020(%rsp), %eax
vmovd %eax, %xmm0
movzbl 0x1021(%rsp), %eax
vpinsrb $0x1, %eax, %xmm0, %xmm0
movzbl 0x1022(%rsp), %eax
vpinsrb $0x2, %eax, %xmm0, %xmm0
movzbl 0x1023(%rsp), %eax
vpinsrb $0x3, %eax, %xmm0, %xmm0
movzbl 0x1024(%rsp), %eax
vpinsrb $0x4, %eax, %xmm0, %xmm0
movzbl 0x1025(%rsp), %eax
vpinsrb $0x5, %eax, %xmm0, %xmm0
movzbl 0x1026(%rsp), %eax
vpinsrb $0x6, %eax, %xmm0, %xmm0
movzbl 0x1027(%rsp), %eax
vpinsrb $0x7, %eax, %xmm0, %xmm0
movzbl 0x1028(%rsp), %eax
vpinsrb $0x8, %eax, %xmm0, %xmm0
movzbl 0x1029(%rsp), %eax
vpinsrb $0x9, %eax, %xmm0, %xmm0
movzbl 0x102a(%rsp), %eax
vpinsrb $0xa, %eax, %xmm0, %xmm0
movzbl 0x102b(%rsp), %eax
vpinsrb $0xb, %eax, %xmm0, %xmm0
movzbl 0x102c(%rsp), %eax
vpinsrb $0xc, %eax, %xmm0, %xmm0
movzbl 0x102d(%rsp), %eax
vpinsrb $0xd, %eax, %xmm0, %xmm0
movzbl 0x102e(%rsp), %eax
vpinsrb $0xe, %eax, %xmm0, %xmm0
movzbl 0x102f(%rsp), %eax
vpinsrb $0xf, %eax, %xmm0, %xmm0
vmovdqa %xmm0, 0x1010(%rsp)
vmovdqa 0x1010(%rsp), %xmm0
vmovdqa %xmm0, 0x160(%rsp)
vmovdqa %xmm0, 0x150(%rsp)
vmovdqa %xmm0, 0x140(%rsp)
movb $-0x1, 0x7ae(%rsp)
movb 0x7ae(%rsp), %al
movb %al, 0x1f(%rsp)
movb %al, 0x1057(%rsp)
movb %al, 0x1056(%rsp)
movb %al, 0x1055(%rsp)
movb %al, 0x1054(%rsp)
movb %al, 0x1053(%rsp)
movb %al, 0x1052(%rsp)
movb %al, 0x1051(%rsp)
movb %al, 0x1050(%rsp)
movb %al, 0x104f(%rsp)
movb %al, 0x104e(%rsp)
movb %al, 0x104d(%rsp)
movb %al, 0x104c(%rsp)
movb %al, 0x104b(%rsp)
movb %al, 0x104a(%rsp)
movb %al, 0x1049(%rsp)
movb %al, 0x1048(%rsp)
movzbl 0x1048(%rsp), %eax
vmovd %eax, %xmm0
movzbl 0x1049(%rsp), %eax
vpinsrb $0x1, %eax, %xmm0, %xmm0
movzbl 0x104a(%rsp), %eax
vpinsrb $0x2, %eax, %xmm0, %xmm0
movzbl 0x104b(%rsp), %eax
vpinsrb $0x3, %eax, %xmm0, %xmm0
movzbl 0x104c(%rsp), %eax
vpinsrb $0x4, %eax, %xmm0, %xmm0
movzbl 0x104d(%rsp), %eax
vpinsrb $0x5, %eax, %xmm0, %xmm0
movzbl 0x104e(%rsp), %eax
vpinsrb $0x6, %eax, %xmm0, %xmm0
movzbl 0x104f(%rsp), %eax
vpinsrb $0x7, %eax, %xmm0, %xmm0
movzbl 0x1050(%rsp), %eax
vpinsrb $0x8, %eax, %xmm0, %xmm0
movzbl 0x1051(%rsp), %eax
vpinsrb $0x9, %eax, %xmm0, %xmm0
movzbl 0x1052(%rsp), %eax
vpinsrb $0xa, %eax, %xmm0, %xmm0
movzbl 0x1053(%rsp), %eax
vpinsrb $0xb, %eax, %xmm0, %xmm0
movzbl 0x1054(%rsp), %eax
vpinsrb $0xc, %eax, %xmm0, %xmm0
movzbl 0x1055(%rsp), %eax
vpinsrb $0xd, %eax, %xmm0, %xmm0
movzbl 0x1056(%rsp), %eax
vpinsrb $0xe, %eax, %xmm0, %xmm0
movzbl 0x1057(%rsp), %eax
vpinsrb $0xf, %eax, %xmm0, %xmm0
vmovdqa %xmm0, 0x1030(%rsp)
vmovdqa 0x1030(%rsp), %xmm0
vmovdqa %xmm0, 0x130(%rsp)
vmovdqa %xmm0, 0x120(%rsp)
vmovdqa %xmm0, 0x110(%rsp)
leaq 0x110(%rsp), %rdi
movq 0x498(%rsp), %rdx
subq $0x10, %rdx
addq $0x2, %rdx
xorl %esi, %esi
callq 0x1030
vmovdqa 0x380(%rsp), %xmm1
vmovdqa 0x1a0(%rsp), %xmm0
vmovdqa %xmm1, 0xe40(%rsp)
vmovdqa %xmm0, 0xe30(%rsp)
vmovdqa 0xe40(%rsp), %xmm0
vpxor 0xe30(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x170(%rsp)
vmovdqa 0x390(%rsp), %xmm1
vmovdqa 0x1b0(%rsp), %xmm0
vmovdqa %xmm1, 0xe20(%rsp)
vmovdqa %xmm0, 0xe10(%rsp)
vmovdqa 0xe20(%rsp), %xmm0
vpxor 0xe10(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x180(%rsp)
vmovdqa 0x3a0(%rsp), %xmm1
vmovdqa 0x1c0(%rsp), %xmm0
vmovdqa %xmm1, 0xe00(%rsp)
vmovdqa %xmm0, 0xdf0(%rsp)
vmovdqa 0xe00(%rsp), %xmm0
vpxor 0xdf0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x190(%rsp)
cmpq $0x3e, 0x498(%rsp)
jb 0x3364
movq 0x4b0(%rsp), %rdi
addq 0x1d8(%rsp), %rdi
leaq 0x170(%rsp), %rsi
addq $0x2, %rsi
movl $0x2e, %edx
callq 0x10c0
jmp 0x3391
movq 0x4b0(%rsp), %rdi
addq 0x1d8(%rsp), %rdi
leaq 0x170(%rsp), %rsi
addq $0x2, %rsi
movq 0x498(%rsp), %rdx
subq $0x10, %rdx
callq 0x10c0
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, 0x180(%rsp)
vmovdqu %ymm0, 0x170(%rsp)
vmovdqa 0x110(%rsp), %xmm1
vmovdqa 0x1a0(%rsp), %xmm0
vmovdqa %xmm1, 0xea0(%rsp)
vmovdqa %xmm0, 0xe90(%rsp)
vmovdqa 0xea0(%rsp), %xmm0
vmovdqa 0xe90(%rsp), %xmm1
vpandn %xmm1, %xmm0, %xmm1
vmovdqa 0x110(%rsp), %xmm2
vmovdqa 0x380(%rsp), %xmm3
vmovdqa 0x140(%rsp), %xmm0
vmovdqa %xmm3, 0xde0(%rsp)
vmovdqa %xmm0, 0xdd0(%rsp)
vmovdqa 0xde0(%rsp), %xmm0
vmovdqa 0xdd0(%rsp), %xmm3
vpxor %xmm3, %xmm0, %xmm0
vmovdqa %xmm2, 0xfa0(%rsp)
vmovdqa %xmm0, 0xf90(%rsp)
vmovdqa 0xfa0(%rsp), %xmm0
vmovdqa 0xf90(%rsp), %xmm2
vpand %xmm2, %xmm0, %xmm0
vmovdqa %xmm1, 0xdc0(%rsp)
vmovdqa %xmm0, 0xdb0(%rsp)
vmovdqa 0xdc0(%rsp), %xmm0
vmovdqa 0xdb0(%rsp), %xmm1
vpxor %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, 0x380(%rsp)
vmovdqa 0x120(%rsp), %xmm1
vmovdqa 0x1b0(%rsp), %xmm0
vmovdqa %xmm1, 0xe80(%rsp)
vmovdqa %xmm0, 0xe70(%rsp)
vmovdqa 0xe80(%rsp), %xmm0
vmovdqa 0xe70(%rsp), %xmm1
vpandn %xmm1, %xmm0, %xmm1
vmovdqa 0x120(%rsp), %xmm2
vmovdqa 0x390(%rsp), %xmm3
vmovdqa 0x150(%rsp), %xmm0
vmovdqa %xmm3, 0xda0(%rsp)
vmovdqa %xmm0, 0xd90(%rsp)
vmovdqa 0xda0(%rsp), %xmm0
vmovdqa 0xd90(%rsp), %xmm3
vpxor %xmm3, %xmm0, %xmm0
vmovdqa %xmm2, 0xf80(%rsp)
vmovdqa %xmm0, 0xf70(%rsp)
vmovdqa 0xf80(%rsp), %xmm0
vmovdqa 0xf70(%rsp), %xmm2
vpand %xmm2, %xmm0, %xmm0
vmovdqa %xmm1, 0xd80(%rsp)
vmovdqa %xmm0, 0xd70(%rsp)
vmovdqa 0xd80(%rsp), %xmm0
vmovdqa 0xd70(%rsp), %xmm1
vpxor %xmm1, %xmm0, %xmm0
vmovdqa %xmm0, 0x390(%rsp)
vmovdqa 0x130(%rsp), %xmm1
vmovdqa 0x1c0(%rsp), %xmm0
vmovdqa %xmm1, 0xe60(%rsp)
vmovdqa %xmm0, 0xe50(%rsp)
vmovdqa 0xe60(%rsp), %xmm0
vpternlogq $0xf, %xmm0, %xmm0, %xmm0
vpand 0xe50(%rsp), %xmm0, %xmm1
vmovdqa 0x130(%rsp), %xmm2
vmovdqa 0x3a0(%rsp), %xmm3
vmovdqa 0x160(%rsp), %xmm0
vmovdqa %xmm3, 0xd60(%rsp)
vmovdqa %xmm0, 0xd50(%rsp)
vmovdqa 0xd60(%rsp), %xmm0
vpxor 0xd50(%rsp), %xmm0, %xmm0
vmovdqa %xmm2, 0xf60(%rsp)
vmovdqa %xmm0, 0xf50(%rsp)
vmovdqa 0xf60(%rsp), %xmm0
vpand 0xf50(%rsp), %xmm0, %xmm0
vmovdqa %xmm1, 0xd40(%rsp)
vmovdqa %xmm0, 0xd30(%rsp)
vmovdqa 0xd40(%rsp), %xmm0
vpxor 0xd30(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x3a0(%rsp)
leaq 0x380(%rsp), %rdi
leaq 0x340(%rsp), %rsi
vzeroupper
callq 0x10a0
vmovdqa 0x340(%rsp), %xmm1
vmovdqa 0x240(%rsp), %xmm0
vmovdqa %xmm1, 0xd20(%rsp)
vmovdqa %xmm0, 0xd10(%rsp)
vmovdqa 0xd20(%rsp), %xmm0
vpxor 0xd10(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x240(%rsp)
vmovdqa 0x350(%rsp), %xmm1
vmovdqa 0x250(%rsp), %xmm0
vmovdqa %xmm1, 0xd00(%rsp)
vmovdqa %xmm0, 0xcf0(%rsp)
vmovdqa 0xd00(%rsp), %xmm0
vpxor 0xcf0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x250(%rsp)
vmovdqa 0x360(%rsp), %xmm1
vmovdqa 0x260(%rsp), %xmm0
vmovdqa %xmm1, 0xce0(%rsp)
vmovdqa %xmm0, 0xcd0(%rsp)
vmovdqa 0xce0(%rsp), %xmm0
vpxor 0xcd0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x260(%rsp)
cmpq $0x3e, 0x498(%rsp)
jb 0x372a
movq 0x1d8(%rsp), %rax
addq $0x2e, %rax
movq %rax, 0x1d8(%rsp)
movq 0x498(%rsp), %rax
subq $0x2e, %rax
movq %rax, 0x498(%rsp)
jmp 0x3752
movq 0x498(%rsp), %rax
subq $0x10, %rax
addq 0x1d8(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movq $0x10, 0x498(%rsp)
movq 0x1d8(%rsp), %rcx
movq 0x4a8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x3e78
vmovdqa 0x3c0(%rsp), %xmm1
vmovdqa 0x410(%rsp), %xmm0
vmovdqa %xmm1, 0x730(%rsp)
vmovdqa %xmm0, 0x720(%rsp)
vmovdqa 0x730(%rsp), %xmm0
vpaddq 0x720(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x300(%rsp)
vmovdqa 0x300(%rsp), %xmm1
vmovdqa 0x410(%rsp), %xmm0
vmovdqa %xmm1, 0x710(%rsp)
vmovdqa %xmm0, 0x700(%rsp)
vmovdqa 0x710(%rsp), %xmm0
vpaddq 0x700(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x3c0(%rsp)
vmovdqa 0x3d0(%rsp), %xmm0
vmovdqa %xmm0, 0x310(%rsp)
vmovdqa 0x3e0(%rsp), %xmm0
vmovdqa %xmm0, 0x320(%rsp)
vmovdqa 0x3f0(%rsp), %xmm0
vmovdqa %xmm0, 0x330(%rsp)
leaq 0x300(%rsp), %rdi
leaq 0x3c0(%rsp), %rsi
leaq 0x2c0(%rsp), %rdx
leaq 0x380(%rsp), %rcx
vzeroupper
callq 0x10b0
vmovdqa 0x2c0(%rsp), %xmm0
vmovdqa %xmm0, 0xb0(%rsp)
vmovdqa 0x2d0(%rsp), %xmm0
vmovdqa %xmm0, 0xc0(%rsp)
vmovdqa 0x2e0(%rsp), %xmm0
vmovdqa %xmm0, 0xd0(%rsp)
vmovdqa 0x380(%rsp), %xmm0
vmovdqa %xmm0, 0xe0(%rsp)
vmovdqa 0x390(%rsp), %xmm0
vmovdqa %xmm0, 0xf0(%rsp)
vmovdqa 0x3a0(%rsp), %xmm0
vmovdqa %xmm0, 0x100(%rsp)
movq 0x4a0(%rsp), %rax
addq 0x1d8(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0x1008(%rsp)
movq 0x1008(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x2c0(%rsp)
movq 0x4a0(%rsp), %rax
addq 0x1d8(%rsp), %rax
addq $0xe, %rax
movq %rax, 0x1000(%rsp)
movq 0x1000(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x2d0(%rsp)
movq 0x4a0(%rsp), %rax
addq 0x1d8(%rsp), %rax
addq $0x1e, %rax
movq %rax, 0xff8(%rsp)
movq 0xff8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x2e0(%rsp)
movq 0x4a0(%rsp), %rax
addq 0x1d8(%rsp), %rax
addq $0x2c, %rax
movq %rax, 0xff0(%rsp)
movq 0xff0(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x380(%rsp)
movq 0x4a0(%rsp), %rax
addq 0x1d8(%rsp), %rax
addq $0x3c, %rax
movq %rax, 0xfe8(%rsp)
movq 0xfe8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x390(%rsp)
movq 0x4a0(%rsp), %rax
addq 0x1d8(%rsp), %rax
addq $0x4c, %rax
movq %rax, 0xfe0(%rsp)
movq 0xfe0(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x3a0(%rsp)
vmovdqa 0x380(%rsp), %xmm1
vmovdqa 0x400(%rsp), %xmm0
vmovdqa %xmm1, 0xf40(%rsp)
vmovdqa %xmm0, 0xf30(%rsp)
vmovdqa 0xf40(%rsp), %xmm0
vpand 0xf30(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x380(%rsp)
vmovdqa 0x2c0(%rsp), %xmm1
vmovdqa 0x400(%rsp), %xmm0
vmovdqa %xmm1, 0xf20(%rsp)
vmovdqa %xmm0, 0xf10(%rsp)
vmovdqa 0xf20(%rsp), %xmm0
vpand 0xf10(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x2c0(%rsp)
vmovdqa 0x380(%rsp), %xmm1
vmovdqa 0x460(%rsp), %xmm0
vmovdqa %xmm1, 0xcc0(%rsp)
vmovdqa %xmm0, 0xcb0(%rsp)
vmovdqa 0xcc0(%rsp), %xmm0
vpxor 0xcb0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x380(%rsp)
vmovdqa 0x2c0(%rsp), %xmm1
vmovdqa 0x460(%rsp), %xmm0
vmovdqa %xmm1, 0xca0(%rsp)
vmovdqa %xmm0, 0xc90(%rsp)
vmovdqa 0xca0(%rsp), %xmm0
vpxor 0xc90(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x2c0(%rsp)
vmovdqa 0xb0(%rsp), %xmm1
vmovdqa 0x2c0(%rsp), %xmm0
vmovdqa %xmm1, 0xc80(%rsp)
vmovdqa %xmm0, 0xc70(%rsp)
vmovdqa 0xc80(%rsp), %xmm0
vpxor 0xc70(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0xb0(%rsp)
vmovdqa 0xc0(%rsp), %xmm1
vmovdqa 0x2d0(%rsp), %xmm0
vmovdqa %xmm1, 0xc60(%rsp)
vmovdqa %xmm0, 0xc50(%rsp)
vmovdqa 0xc60(%rsp), %xmm0
vpxor 0xc50(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0xc0(%rsp)
vmovdqa 0xd0(%rsp), %xmm1
vmovdqa 0x2e0(%rsp), %xmm0
vmovdqa %xmm1, 0xc40(%rsp)
vmovdqa %xmm0, 0xc30(%rsp)
vmovdqa 0xc40(%rsp), %xmm0
vpxor 0xc30(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0xd0(%rsp)
vmovdqa 0xe0(%rsp), %xmm1
vmovdqa 0x380(%rsp), %xmm0
vmovdqa %xmm1, 0xc20(%rsp)
vmovdqa %xmm0, 0xc10(%rsp)
vmovdqa 0xc20(%rsp), %xmm0
vpxor 0xc10(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0xe0(%rsp)
vmovdqa 0xf0(%rsp), %xmm1
vmovdqa 0x390(%rsp), %xmm0
vmovdqa %xmm1, 0xc00(%rsp)
vmovdqa %xmm0, 0xbf0(%rsp)
vmovdqa 0xc00(%rsp), %xmm0
vpxor 0xbf0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0xf0(%rsp)
vmovdqa 0x100(%rsp), %xmm1
vmovdqa 0x3a0(%rsp), %xmm0
vmovdqa %xmm1, 0xbe0(%rsp)
vmovdqa %xmm0, 0xbd0(%rsp)
vmovdqa 0xbe0(%rsp), %xmm0
vpxor 0xbd0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x100(%rsp)
movq 0x4b0(%rsp), %rdi
addq 0x1d8(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
addq $0x2, %rsi
movl $0x2e, %edx
callq 0x10c0
movq 0x4b0(%rsp), %rdi
addq 0x1d8(%rsp), %rdi
addq $0x2e, %rdi
leaq 0xb0(%rsp), %rsi
addq $0x32, %rsi
movl $0x2e, %edx
callq 0x10c0
leaq 0x2c0(%rsp), %rdi
leaq 0x380(%rsp), %rsi
leaq 0x280(%rsp), %rdx
leaq 0x340(%rsp), %rcx
callq 0x10b0
vmovdqa 0x340(%rsp), %xmm1
vmovdqa 0x240(%rsp), %xmm0
vmovdqa %xmm1, 0xbc0(%rsp)
vmovdqa %xmm0, 0xbb0(%rsp)
vmovdqa 0xbc0(%rsp), %xmm0
vpxor 0xbb0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x240(%rsp)
vmovdqa 0x350(%rsp), %xmm1
vmovdqa 0x250(%rsp), %xmm0
vmovdqa %xmm1, 0xba0(%rsp)
vmovdqa %xmm0, 0xb90(%rsp)
vmovdqa 0xba0(%rsp), %xmm0
vpxor 0xb90(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x250(%rsp)
vmovdqa 0x360(%rsp), %xmm1
vmovdqa 0x260(%rsp), %xmm0
vmovdqa %xmm1, 0xb80(%rsp)
vmovdqa %xmm0, 0xb70(%rsp)
vmovdqa 0xb80(%rsp), %xmm0
vpxor 0xb70(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x260(%rsp)
vmovdqa 0x280(%rsp), %xmm1
vmovdqa 0x240(%rsp), %xmm0
vmovdqa %xmm1, 0xb60(%rsp)
vmovdqa %xmm0, 0xb50(%rsp)
vmovdqa 0xb60(%rsp), %xmm0
vpxor 0xb50(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x240(%rsp)
vmovdqa 0x290(%rsp), %xmm1
vmovdqa 0x250(%rsp), %xmm0
vmovdqa %xmm1, 0xb40(%rsp)
vmovdqa %xmm0, 0xb30(%rsp)
vmovdqa 0xb40(%rsp), %xmm0
vpxor 0xb30(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x250(%rsp)
vmovdqa 0x2a0(%rsp), %xmm1
vmovdqa 0x260(%rsp), %xmm0
vmovdqa %xmm1, 0xb20(%rsp)
vmovdqa %xmm0, 0xb10(%rsp)
vmovdqa 0xb20(%rsp), %xmm0
vpxor 0xb10(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x260(%rsp)
movq 0x1d8(%rsp), %rax
addq $0x5c, %rax
movq %rax, 0x1d8(%rsp)
movq 0x498(%rsp), %rax
subq $0x5c, %rax
movq %rax, 0x498(%rsp)
movq 0x1d8(%rsp), %rcx
movq 0x4a8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2db9
jmp 0x3e7f
movl $0x0, 0xac(%rsp)
cmpl $0x4, 0xac(%rsp)
jae 0x417e
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x3c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x3c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xb00(%rsp)
vmovdqa %xmm0, 0xaf0(%rsp)
vmovdqa 0xb00(%rsp), %xmm0
vpxor 0xaf0(%rsp), %xmm0, %xmm0
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x3c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x380(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x380(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xae0(%rsp)
vmovdqa %xmm0, 0xad0(%rsp)
vmovdqa 0xae0(%rsp), %xmm0
vpxor 0xad0(%rsp), %xmm0, %xmm0
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x380(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x340(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x340(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xac0(%rsp)
vmovdqa %xmm0, 0xab0(%rsp)
vmovdqa 0xac0(%rsp), %xmm0
vpxor 0xab0(%rsp), %xmm0, %xmm0
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x340(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x300(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x300(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xaa0(%rsp)
vmovdqa %xmm0, 0xa90(%rsp)
vmovdqa 0xaa0(%rsp), %xmm0
vpxor 0xa90(%rsp), %xmm0, %xmm0
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x300(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x2c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x2c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xa80(%rsp)
vmovdqa %xmm0, 0xa70(%rsp)
vmovdqa 0xa80(%rsp), %xmm0
vpxor 0xa70(%rsp), %xmm0, %xmm0
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x2c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x280(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x280(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xa60(%rsp)
vmovdqa %xmm0, 0xa50(%rsp)
vmovdqa 0xa60(%rsp), %xmm0
vpxor 0xa50(%rsp), %xmm0, %xmm0
movl 0xac(%rsp), %eax
movl %eax, %ecx
leaq 0x280(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x3e8a
cmpq $0x0, 0x488(%rsp)
je 0x4a25
cmpq $0x0, 0x490(%rsp)
jne 0x4292
movl $0x0, 0xa8(%rsp)
cmpl $0x4, 0xa8(%rsp)
jae 0x4243
movl 0xa8(%rsp), %eax
movl %eax, %ecx
leaq 0x240(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0xa8(%rsp), %eax
movl %eax, %ecx
leaq 0x240(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0xa40(%rsp)
vmovdqa %xmm0, 0xa30(%rsp)
vmovdqa 0xa40(%rsp), %xmm0
vpxor 0xa30(%rsp), %xmm0, %xmm0
movl 0xa8(%rsp), %eax
movl %eax, %ecx
leaq 0x240(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0xa8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa8(%rsp)
jmp 0x41a7
vmovdqa 0x1e0(%rsp), %xmm1
vmovdqa 0x1e0(%rsp), %xmm0
vmovdqa %xmm1, 0xa20(%rsp)
vmovdqa %xmm0, 0xa10(%rsp)
vmovdqa 0xa20(%rsp), %xmm0
vpxor 0xa10(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x1e0(%rsp)
movl $0xfffffffc, 0x4bc(%rsp) # imm = 0xFFFFFFFC
jmp 0x4f69
movq $0x1, 0xa0(%rsp)
movq $0x0, 0x98(%rsp)
vmovdqa 0x470(%rsp), %xmm1
vmovdqa 0x430(%rsp), %xmm0
vmovdqa %xmm1, 0x6f0(%rsp)
vmovdqa %xmm0, 0x6e0(%rsp)
vmovdqa 0x6f0(%rsp), %xmm0
vpaddq 0x6e0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x3c0(%rsp)
vmovdqa 0x1e0(%rsp), %xmm0
vmovdqa %xmm0, 0x3f0(%rsp)
cmpq $0x0, 0x488(%rsp)
jbe 0x4a23
cmpq $0x3c, 0x488(%rsp)
jbe 0x4324
cmpq $0x0, 0x98(%rsp)
jne 0x4682
cmpq $0x1e, 0x488(%rsp)
jae 0x436e
vmovdqa 0x3c0(%rsp), %xmm1
vmovdqa 0x440(%rsp), %xmm0
vmovdqa %xmm1, 0x6d0(%rsp)
vmovdqa %xmm0, 0x6c0(%rsp)
vmovdqa 0x6d0(%rsp), %xmm0
vpaddq 0x6c0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x3c0(%rsp)
vmovdqa 0x3c0(%rsp), %xmm1
vmovdqa 0x410(%rsp), %xmm0
vmovdqa %xmm1, 0x6b0(%rsp)
vmovdqa %xmm0, 0x6a0(%rsp)
vmovdqa 0x6b0(%rsp), %xmm0
vpaddq 0x6a0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x3c0(%rsp)
movq $0x0, 0x70(%rsp)
cmpq $0x1e, 0x488(%rsp)
jb 0x440e
movq 0x490(%rsp), %rax
movq 0x98(%rsp), %rcx
movq (%rax,%rcx), %rdx
movq %rdx, 0x72(%rsp)
movq 0x8(%rax,%rcx), %rdx
movq %rdx, 0x7a(%rsp)
movq 0x10(%rax,%rcx), %rdx
movq %rdx, 0x82(%rsp)
movl 0x18(%rax,%rcx), %edx
movl %edx, 0x8a(%rsp)
movw 0x1c(%rax,%rcx), %ax
movw %ax, 0x8e(%rsp)
jmp 0x449f
imulq $0x1010000, 0x488(%rsp), %rax # imm = 0x1010000
imulq $0x1010101, 0x488(%rsp), %rcx # imm = 0x1010101
shlq $0x20, %rcx
xorq %rcx, %rax
movq %rax, 0x70(%rsp)
movl $0x1, 0x6c(%rsp)
cmpl $0x4, 0x6c(%rsp)
jae 0x4476
imulq $0x1010101, 0x488(%rsp), %rcx # imm = 0x1010101
shlq $0x20, %rcx
imulq $0x1010101, 0x488(%rsp), %rax # imm = 0x1010101
xorq %rax, %rcx
movl 0x6c(%rsp), %eax
movq %rcx, 0x70(%rsp,%rax,8)
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x443a
leaq 0x70(%rsp), %rdi
addq $0x2, %rdi
movq 0x490(%rsp), %rsi
addq 0x98(%rsp), %rsi
movq 0x488(%rsp), %rdx
vzeroupper
callq 0x10c0
movq 0x70(%rsp), %rax
movq 0x78(%rsp), %rcx
movq %rcx, 0x4f8(%rsp)
movq %rax, 0x4f0(%rsp)
vmovq 0x4f8(%rsp), %xmm1
vmovq 0x4f0(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x4e0(%rsp)
vmovdqa 0x4e0(%rsp), %xmm0
vmovdqa %xmm0, 0x3d0(%rsp)
movq 0x80(%rsp), %rax
movq 0x88(%rsp), %rcx
movq %rcx, 0x4d8(%rsp)
movq %rax, 0x4d0(%rsp)
vmovq 0x4d8(%rsp), %xmm1
vmovq 0x4d0(%rsp), %xmm0
vpunpcklqdq %xmm1, %xmm0, %xmm0 # xmm0 = xmm0[0],xmm1[0]
vmovdqa %xmm0, 0x4c0(%rsp)
vmovdqa 0x4c0(%rsp), %xmm0
vmovdqa %xmm0, 0x3e0(%rsp)
leaq 0x3c0(%rsp), %rdi
leaq 0x340(%rsp), %rsi
vzeroupper
callq 0x10a0
vmovdqa 0x340(%rsp), %xmm1
vmovdqa 0x240(%rsp), %xmm0
vmovdqa %xmm1, 0xa00(%rsp)
vmovdqa %xmm0, 0x9f0(%rsp)
vmovdqa 0xa00(%rsp), %xmm0
vpxor 0x9f0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x240(%rsp)
vmovdqa 0x350(%rsp), %xmm1
vmovdqa 0x250(%rsp), %xmm0
vmovdqa %xmm1, 0x9e0(%rsp)
vmovdqa %xmm0, 0x9d0(%rsp)
vmovdqa 0x9e0(%rsp), %xmm0
vpxor 0x9d0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x250(%rsp)
vmovdqa 0x360(%rsp), %xmm1
vmovdqa 0x260(%rsp), %xmm0
vmovdqa %xmm1, 0x9c0(%rsp)
vmovdqa %xmm0, 0x9b0(%rsp)
vmovdqa 0x9c0(%rsp), %xmm0
vpxor 0x9b0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x260(%rsp)
movq 0xa0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0xa0(%rsp)
cmpq $0x1e, 0x488(%rsp)
jb 0x4659
movq 0x98(%rsp), %rax
addq $0x1e, %rax
movq %rax, 0x98(%rsp)
movq 0x488(%rsp), %rax
subq $0x1e, %rax
movq %rax, 0x488(%rsp)
jmp 0x467d
movq 0x488(%rsp), %rax
addq 0x98(%rsp), %rax
movq %rax, 0x98(%rsp)
movq $0x0, 0x488(%rsp)
jmp 0x4a1e
vmovdqa 0x3c0(%rsp), %xmm1
vmovdqa 0x410(%rsp), %xmm0
vmovdqa %xmm1, 0x690(%rsp)
vmovdqa %xmm0, 0x680(%rsp)
vmovdqa 0x690(%rsp), %xmm0
vpaddq 0x680(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x300(%rsp)
vmovdqa 0x300(%rsp), %xmm1
vmovdqa 0x410(%rsp), %xmm0
vmovdqa %xmm1, 0x670(%rsp)
vmovdqa %xmm0, 0x660(%rsp)
vmovdqa 0x670(%rsp), %xmm0
vpaddq 0x660(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x3c0(%rsp)
vmovdqa 0x3f0(%rsp), %xmm0
vmovdqa %xmm0, 0x330(%rsp)
movq 0x490(%rsp), %rax
addq 0x98(%rsp), %rax
addq $-0x2, %rax
movq %rax, 0xfd8(%rsp)
movq 0xfd8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x310(%rsp)
vmovdqa 0x310(%rsp), %xmm1
vmovdqa 0x400(%rsp), %xmm0
vmovdqa %xmm1, 0xf00(%rsp)
vmovdqa %xmm0, 0xef0(%rsp)
vmovdqa 0xf00(%rsp), %xmm0
vpand 0xef0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x310(%rsp)
movq 0x490(%rsp), %rax
addq 0x98(%rsp), %rax
addq $0xe, %rax
movq %rax, 0xfd0(%rsp)
movq 0xfd0(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x320(%rsp)
movq 0x490(%rsp), %rax
addq 0x98(%rsp), %rax
addq $0x1c, %rax
movq %rax, 0xfc8(%rsp)
movq 0xfc8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x3d0(%rsp)
vmovdqa 0x3d0(%rsp), %xmm1
vmovdqa 0x400(%rsp), %xmm0
vmovdqa %xmm1, 0xee0(%rsp)
vmovdqa %xmm0, 0xed0(%rsp)
vmovdqa 0xee0(%rsp), %xmm0
vpand 0xed0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x3d0(%rsp)
movq 0x490(%rsp), %rax
addq 0x98(%rsp), %rax
addq $0x2c, %rax
movq %rax, 0xfc0(%rsp)
movq 0xfc0(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x3e0(%rsp)
leaq 0x300(%rsp), %rdi
leaq 0x3c0(%rsp), %rsi
leaq 0x280(%rsp), %rdx
leaq 0x340(%rsp), %rcx
vzeroupper
callq 0x10b0
vmovdqa 0x340(%rsp), %xmm1
vmovdqa 0x240(%rsp), %xmm0
vmovdqa %xmm1, 0x9a0(%rsp)
vmovdqa %xmm0, 0x990(%rsp)
vmovdqa 0x9a0(%rsp), %xmm0
vpxor 0x990(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x240(%rsp)
vmovdqa 0x350(%rsp), %xmm1
vmovdqa 0x250(%rsp), %xmm0
vmovdqa %xmm1, 0x980(%rsp)
vmovdqa %xmm0, 0x970(%rsp)
vmovdqa 0x980(%rsp), %xmm0
vpxor 0x970(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x250(%rsp)
vmovdqa 0x360(%rsp), %xmm1
vmovdqa 0x260(%rsp), %xmm0
vmovdqa %xmm1, 0x960(%rsp)
vmovdqa %xmm0, 0x950(%rsp)
vmovdqa 0x960(%rsp), %xmm0
vpxor 0x950(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x260(%rsp)
vmovdqa 0x280(%rsp), %xmm1
vmovdqa 0x240(%rsp), %xmm0
vmovdqa %xmm1, 0x940(%rsp)
vmovdqa %xmm0, 0x930(%rsp)
vmovdqa 0x940(%rsp), %xmm0
vpxor 0x930(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x240(%rsp)
vmovdqa 0x290(%rsp), %xmm1
vmovdqa 0x250(%rsp), %xmm0
vmovdqa %xmm1, 0x920(%rsp)
vmovdqa %xmm0, 0x910(%rsp)
vmovdqa 0x920(%rsp), %xmm0
vpxor 0x910(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x250(%rsp)
vmovdqa 0x2a0(%rsp), %xmm1
vmovdqa 0x260(%rsp), %xmm0
vmovdqa %xmm1, 0x900(%rsp)
vmovdqa %xmm0, 0x8f0(%rsp)
vmovdqa 0x900(%rsp), %xmm0
vpxor 0x8f0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x260(%rsp)
movq 0x98(%rsp), %rax
addq $0x3c, %rax
movq %rax, 0x98(%rsp)
movq 0x488(%rsp), %rax
subq $0x3c, %rax
movq %rax, 0x488(%rsp)
jmp 0x42fb
jmp 0x4a25
vmovdqa 0x1e0(%rsp), %xmm0
vmovdqa %xmm0, 0x270(%rsp)
vmovdqa 0x240(%rsp), %xmm1
vmovdqa 0x400(%rsp), %xmm0
vmovdqa %xmm1, 0xec0(%rsp)
vmovdqa %xmm0, 0xeb0(%rsp)
vmovdqa 0xec0(%rsp), %xmm0
vpand 0xeb0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x240(%rsp)
vmovdqa 0x240(%rsp), %xmm1
vmovdqa 0x420(%rsp), %xmm0
vmovdqa %xmm1, 0x650(%rsp)
vmovdqa %xmm0, 0x640(%rsp)
vmovdqa 0x650(%rsp), %xmm0
vpaddq 0x640(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x240(%rsp)
vmovdqa 0x240(%rsp), %xmm1
vmovdqa 0x470(%rsp), %xmm0
vmovdqa %xmm1, 0x630(%rsp)
vmovdqa %xmm0, 0x620(%rsp)
vmovdqa 0x630(%rsp), %xmm0
vpaddq 0x620(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x240(%rsp)
leaq 0x240(%rsp), %rdi
leaq 0x200(%rsp), %rsi
vzeroupper
callq 0x10a0
vmovdqa 0x230(%rsp), %xmm1
vmovdqa 0x1e0(%rsp), %xmm0
vmovdqa %xmm1, 0x8e0(%rsp)
vmovdqa %xmm0, 0x8d0(%rsp)
vmovdqa 0x8e0(%rsp), %xmm0
vpxor 0x8d0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x230(%rsp)
movl $0x0, 0x68(%rsp)
cmpl $0x4, 0x68(%rsp)
jae 0x4e77
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x3c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x3c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x8c0(%rsp)
vmovdqa %xmm0, 0x8b0(%rsp)
vmovdqa 0x8c0(%rsp), %xmm0
vpxor 0x8b0(%rsp), %xmm0, %xmm0
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x3c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x380(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x380(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x8a0(%rsp)
vmovdqa %xmm0, 0x890(%rsp)
vmovdqa 0x8a0(%rsp), %xmm0
vpxor 0x890(%rsp), %xmm0, %xmm0
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x380(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x340(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x340(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x880(%rsp)
vmovdqa %xmm0, 0x870(%rsp)
vmovdqa 0x880(%rsp), %xmm0
vpxor 0x870(%rsp), %xmm0, %xmm0
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x340(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x300(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x300(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x860(%rsp)
vmovdqa %xmm0, 0x850(%rsp)
vmovdqa 0x860(%rsp), %xmm0
vpxor 0x850(%rsp), %xmm0, %xmm0
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x300(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x2c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x2c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x840(%rsp)
vmovdqa %xmm0, 0x830(%rsp)
vmovdqa 0x840(%rsp), %xmm0
vpxor 0x830(%rsp), %xmm0, %xmm0
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x2c0(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x280(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x280(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x820(%rsp)
vmovdqa %xmm0, 0x810(%rsp)
vmovdqa 0x820(%rsp), %xmm0
vpxor 0x810(%rsp), %xmm0, %xmm0
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x280(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x240(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm1
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x240(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa (%rax), %xmm0
vmovdqa %xmm1, 0x800(%rsp)
vmovdqa %xmm0, 0x7f0(%rsp)
vmovdqa 0x800(%rsp), %xmm0
vpxor 0x7f0(%rsp), %xmm0, %xmm0
movl 0x68(%rsp), %eax
movl %eax, %ecx
leaq 0x240(%rsp), %rax
shlq $0x4, %rcx
addq %rcx, %rax
vmovdqa %xmm0, (%rax)
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x4b53
vmovdqa 0x1e0(%rsp), %xmm1
vmovdqa 0x1e0(%rsp), %xmm0
vmovdqa %xmm1, 0x7e0(%rsp)
vmovdqa %xmm0, 0x7d0(%rsp)
vmovdqa 0x7e0(%rsp), %xmm0
vpxor 0x7d0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x1e0(%rsp)
movq 0x4a0(%rsp), %rax
movq 0x4a8(%rsp), %rcx
addq (%rcx), %rax
movq %rax, 0xfb8(%rsp)
movq 0xfb8(%rsp), %rax
vmovdqu (%rax), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
vmovdqa 0x50(%rsp), %xmm1
vmovdqa 0x200(%rsp), %xmm0
vmovdqa %xmm1, 0x7c0(%rsp)
vmovdqa %xmm0, 0x7b0(%rsp)
vmovdqa 0x7c0(%rsp), %xmm0
vpxor 0x7b0(%rsp), %xmm0, %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x4f5e
movq 0x48(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x4f5e
movq 0x48(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x4f5e
movq 0x48(%rsp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x4f5e
movl $0x0, 0x4bc(%rsp)
jmp 0x4f69
movl $0xffffffff, 0x4bc(%rsp) # imm = 0xFFFFFFFF
movl 0x4bc(%rsp), %eax
addq $0x1058, %rsp           # imm = 0x1058
vzeroupper
retq
nopl (%rax,%rax)