// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/paeq160/ref/encrypt.cpp
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
       unsigned char *c,unsigned long long *clen,
       const unsigned char *m,unsigned long long mlen,
       const unsigned char *ad,unsigned long long adlen,
       const unsigned char *nsec,
       const unsigned char *npub,
       const unsigned char *k
     )

     {
		 Init();//Initializing GF(256) multiplication table for AES

		 if(clen==NULL)
			 return -1;
		 if((mlen==0) && (adlen==0))
		 {
			 *clen=0;
			 return 0;
		 }

		 //Assume that we do encryption and/or authentication so we need a key and a ciphertext pointer valid
		 if( (k==NULL) || (c==NULL) )
			 return -2;

		 if(npub==NULL)
			 return -7;

		 //Initializing constants
		unsigned char D0[2];
		D0[0] = CRYPTO_NPUBBYTES*8; //nonce length in bits, zero for 256-bit nonce
		D0[1] = CRYPTO_KEYBYTES*8; //key length in bits
		(*clen)=0;
		 
		 //Block variables
		 unsigned char BlockInput[64];  //V1 - input to the first layer call of F
			 unsigned char BlockMiddle[64];  //W1 - output of the first layer call of F
			 unsigned char BlockOutput[64];  //Y1 - output of the second layer call of F
			
		 unsigned char BlockLastInput[64];  //Z1 - input to the last call of F
		 memset(BlockLastInput,0,64);
		 unsigned char Tag[64]; //Tag output
		 
		 unsigned long long encrypted_bytes=0;//Encrypted bytes counter
		 

		 //Encryption part
		 if(mlen!=0)
		 {
			 if(m==NULL)
			 {
				 //Clearing variables
				for(unsigned i=0; i<64; ++i)
					BlockInput[i] = BlockMiddle[i] = BlockOutput[i] = BlockLastInput[i] = 0;
				return -3;
			 }
				 
			 unsigned long long mblock_counter=1;   //Message block counter
			 
			 while((mlen>0))
			 {
				 /* I. First layer */

				 //1. Domain-separation constant
				 BlockInput[1] = D0[1]; 
				 if(mlen>= CRYPTO_MBLOCK)
					 BlockInput[0] = D0[0];
				 else //Last incomplete block
					 BlockInput[0] = D0[0]+1;

				 //2. Counter
				 for(unsigned i=0; i<CRYPTO_COUNTERBYTES; ++i)
				 {
					 BlockInput[i+2] = (i<sizeof(mblock_counter))?(mblock_counter>>(8*i))&0xff :0;//copying counter bytewise
				 }
				 
				 //3. Nonce
				 for(unsigned i=0; i<CRYPTO_NPUBBYTES; ++i) 
				 {
					 BlockInput[i+2+CRYPTO_COUNTERBYTES] = npub[i];
				 }

				 //4. Key
				 for(unsigned i=0; i<CRYPTO_KEYBYTES; ++i) 
				 {
					 BlockInput[i+2+CRYPTO_COUNTERBYTES+CRYPTO_NPUBBYTES] = k[i];
				 }	 

				 //5. Permutation call
				 FPerm(BlockInput, BlockMiddle); //First layer call to F

				

				 /* II. Encryption*/

				 if(mlen>=CRYPTO_MBLOCK)//Full block encryption
				 {
					 for(unsigned i=0; i<CRYPTO_MBLOCK; ++i)
					 {
						 BlockMiddle[i+2] ^= m[encrypted_bytes+i];
						 c[encrypted_bytes+i] = BlockMiddle[i+2];
						 
					 }
					 BlockMiddle[1] =  D0[1];
					 BlockMiddle[0] = D0[0]+2;  //New Di constant

				 }

				 else //Last incomplete block
				 {
					 for(unsigned i=0; i<(unsigned)mlen; ++i)//Incomplete block Encryption
					 {
						 BlockMiddle[i+2] ^= m[encrypted_bytes+i];
						 c[encrypted_bytes+i] = BlockMiddle[i+2];						 
					 }
					 for(unsigned i=(unsigned)mlen; i<CRYPTO_MBLOCK; ++i)
					 {
						 BlockMiddle[i+2] ^=  (unsigned char)mlen;  //Extra Padding: extra bytes filled with the last block length in bytes
					 }

					 BlockMiddle[1] =  D0[1];
					 BlockMiddle[0] = D0[0]+3;  //New Di constant
				 }

				 //III. Second permutation call
				 //1. Call
				 FPerm(BlockMiddle, BlockOutput); //Second layer call to F
				 
				 //2. Buffer update
				 for(unsigned i=0; i<64-2-CRYPTO_KEYBYTES; ++i)//Adding the output to tag preparation buffer
				 {
					 BlockLastInput[i+2] ^= BlockOutput[i+2];
				 }


				 //Counters increment
				 mblock_counter++;
				 if(mlen>=CRYPTO_MBLOCK)
				 {					 
					 encrypted_bytes += CRYPTO_MBLOCK;
					 mlen-=CRYPTO_MBLOCK;
				 }
				 else 
				 {
					 encrypted_bytes += mlen;
					 mlen=0;
				 }
				 (*clen) = encrypted_bytes;
			 }
		 }

		//Associated data part	  
		if(adlen!=0)
		{
			if(ad==NULL)
			{
				//Clearing variables
				for(unsigned i=0; i<64; ++i)
					BlockInput[i] = BlockMiddle[i] = BlockOutput[i] = BlockLastInput[i] = 0;
				return -4;
			}

			 unsigned long long adblock_counter=1;   //AD block counter
			 unsigned long long auth_bytes=0;

			while(adlen>0)
			{
				//1. Constant
				BlockInput[1] = D0[1];
				if(adlen>= CRYPTO_ADBLOCK)
					 BlockInput[0] = D0[0]+4;
				 else //Last incomplete block
					 BlockInput[0] = D0[0]+5;


				//2. Counter
				for(unsigned i=0; i<CRYPTO_KEYBYTES; ++i)
					BlockInput[i+2] =  (i<sizeof(adblock_counter))? (adblock_counter>>(8*i))&0xff:0;//copying counter bytewise

				//3. AD block
				if(adlen >= CRYPTO_ADBLOCK) //Filling AD block
				{
					for(unsigned i=0; i<CRYPTO_ADBLOCK; ++i)
						BlockInput[i+2+CRYPTO_KEYBYTES] = ad[auth_bytes+i];
					
				}
				else //Last incomplete block
				{
					for(unsigned i=0; i<adlen; ++i)
						BlockInput[i+2+CRYPTO_KEYBYTES] = ad[auth_bytes+i];
					for(unsigned i=(unsigned)adlen; i<CRYPTO_ADBLOCK; ++i)
						BlockInput[i+2+CRYPTO_KEYBYTES] = (unsigned char)adlen;
				}

				//4. Key
				for(unsigned i=0; i<CRYPTO_KEYBYTES; ++i) 
				{
					 BlockInput[i+CRYPTO_ADBLOCK+CRYPTO_KEYBYTES+2] = k[i];
				}
				

				//5.Call to the F permutation

				FPerm(BlockInput,BlockOutput);//Call to the F permutation

				 for(unsigned i=0; i<64-2-CRYPTO_KEYBYTES; ++i)//Adding the output to Z
				 {
					 BlockLastInput[i+2] ^= BlockOutput[i+2];
				 }

				//Counters increment
				 adblock_counter++;
				 if(adlen>=CRYPTO_ADBLOCK)
				 {
					 auth_bytes += CRYPTO_ADBLOCK;
					 adlen-=CRYPTO_ADBLOCK;
				 }
				 else 
				 {
					 auth_bytes += adlen;
					 adlen=0;
				 }
			}
		}

		// Tag production 
		for(unsigned i=0; i<CRYPTO_KEYBYTES; ++i) //Key to the Z input
			BlockLastInput[64-CRYPTO_KEYBYTES+i] = k[i];
		 BlockLastInput[0] = D0[0]+6;
		 BlockLastInput[1] = D0[1];

		//1. Permutation call
		FPerm(BlockLastInput,Tag);
		//2. Key injection
		for(unsigned i=0; i<CRYPTO_KEYBYTES; ++i) 
		{
				Tag[64-CRYPTO_KEYBYTES+i] ^= k[i];
		}

		//3. Truncation
		for(unsigned i=0; i<CRYPTO_ABYTES; ++i)
			c[(*clen)+i] = Tag[i];
		*clen += CRYPTO_ABYTES;


		//Clearing variables
		for(unsigned i=0; i<64; ++i)
			BlockInput[i] = BlockMiddle[i] = BlockOutput[i] = BlockLastInput[i] = 0;
		

	   
		return 0;
     }

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movq 0x220(%rsp), %rax
movq 0x218(%rsp), %rax
movq 0x210(%rsp), %rax
movq %rdi, 0x1f8(%rsp)
movq %rsi, 0x1f0(%rsp)
movq %rdx, 0x1e8(%rsp)
movq %rcx, 0x1e0(%rsp)
movq %r8, 0x1d8(%rsp)
movq %r9, 0x1d0(%rsp)
callq 0x1060
cmpq $0x0, 0x1f0(%rsp)
jne 0x1eef
movl $0xffffffff, 0x204(%rsp) # imm = 0xFFFFFFFF
jmp 0x2837
cmpq $0x0, 0x1e0(%rsp)
jne 0x1f24
cmpq $0x0, 0x1d0(%rsp)
jne 0x1f24
movq 0x1f0(%rsp), %rax
movq $0x0, (%rax)
movl $0x0, 0x204(%rsp)
jmp 0x2837
cmpq $0x0, 0x220(%rsp)
je 0x1f3a
cmpq $0x0, 0x1f8(%rsp)
jne 0x1f4a
movl $0xfffffffe, 0x204(%rsp) # imm = 0xFFFFFFFE
jmp 0x2837
cmpq $0x0, 0x218(%rsp)
jne 0x1f65
movl $0xfffffff9, 0x204(%rsp) # imm = 0xFFFFFFF9
jmp 0x2837
movb $-0x60, 0x1ce(%rsp)
movb $-0x60, 0x1cf(%rsp)
movq 0x1f0(%rsp), %rax
movq $0x0, (%rax)
leaq 0xc0(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x1030
movq $0x0, 0x78(%rsp)
cmpq $0x0, 0x1e0(%rsp)
je 0x23bc
cmpq $0x0, 0x1e8(%rsp)
jne 0x2017
movl $0x0, 0x74(%rsp)
cmpl $0x40, 0x74(%rsp)
jae 0x2007
movl 0x74(%rsp), %eax
movb $0x0, 0xc0(%rsp,%rax)
movl 0x74(%rsp), %eax
movb $0x0, 0x100(%rsp,%rax)
movl 0x74(%rsp), %eax
movb $0x0, 0x140(%rsp,%rax)
movl 0x74(%rsp), %eax
movb $0x0, 0x180(%rsp,%rax)
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x1fc3
movl $0xfffffffd, 0x204(%rsp) # imm = 0xFFFFFFFD
jmp 0x2837
movq $0x1, 0x68(%rsp)
cmpq $0x0, 0x1e0(%rsp)
jbe 0x23ba
movb 0x1cf(%rsp), %al
movb %al, 0x181(%rsp)
cmpq $0x2a, 0x1e0(%rsp)
jb 0x2058
movb 0x1ce(%rsp), %al
movb %al, 0x180(%rsp)
jmp 0x206a
movzbl 0x1ce(%rsp), %eax
addl $0x1, %eax
movb %al, 0x180(%rsp)
movl $0x0, 0x64(%rsp)
cmpl $0x16, 0x64(%rsp)
jae 0x20ce
movl 0x64(%rsp), %eax
cmpq $0x8, %rax
jae 0x20a1
movq 0x68(%rsp), %rax
movl 0x64(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0xff, %rax
movq %rax, 0x8(%rsp)
jmp 0x20aa
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x20aa
movq 0x8(%rsp), %rax
movb %al, %cl
movl 0x64(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movb %cl, 0x180(%rsp,%rax)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x2072
movl $0x0, 0x60(%rsp)
cmpl $0x14, 0x60(%rsp)
jae 0x210c
movq 0x218(%rsp), %rax
movl 0x60(%rsp), %ecx
movb (%rax,%rcx), %cl
movl 0x60(%rsp), %eax
addl $0x2, %eax
addl $0x16, %eax
movl %eax, %eax
movb %cl, 0x180(%rsp,%rax)
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x20d6
movl $0x0, 0x5c(%rsp)
cmpl $0x14, 0x5c(%rsp)
jae 0x214d
movq 0x220(%rsp), %rax
movl 0x5c(%rsp), %ecx
movb (%rax,%rcx), %cl
movl 0x5c(%rsp), %eax
addl $0x2, %eax
addl $0x16, %eax
addl $0x14, %eax
movl %eax, %eax
movb %cl, 0x180(%rsp,%rax)
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x2114
leaq 0x180(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x1090
cmpq $0x2a, 0x1e0(%rsp)
jb 0x220b
movl $0x0, 0x58(%rsp)
cmpl $0x2a, 0x58(%rsp)
jae 0x21e6
movq 0x1e8(%rsp), %rax
movq 0x78(%rsp), %rcx
movl 0x58(%rsp), %edx
addq %rdx, %rcx
movzbl (%rax,%rcx), %edx
movl 0x58(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movzbl 0x140(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x140(%rsp,%rax)
movl 0x58(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movb 0x140(%rsp,%rax), %dl
movq 0x1f8(%rsp), %rax
movq 0x78(%rsp), %rcx
movl 0x58(%rsp), %esi
addq %rsi, %rcx
movb %dl, (%rax,%rcx)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x2179
movb 0x1cf(%rsp), %al
movb %al, 0x141(%rsp)
movzbl 0x1ce(%rsp), %eax
addl $0x2, %eax
movb %al, 0x140(%rsp)
jmp 0x22ee
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movq 0x1e0(%rsp), %rcx
cmpl %ecx, %eax
jae 0x2289
movq 0x1e8(%rsp), %rax
movq 0x78(%rsp), %rcx
movl 0x54(%rsp), %edx
addq %rdx, %rcx
movzbl (%rax,%rcx), %edx
movl 0x54(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movzbl 0x140(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x140(%rsp,%rax)
movl 0x54(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movb 0x140(%rsp,%rax), %dl
movq 0x1f8(%rsp), %rax
movq 0x78(%rsp), %rcx
movl 0x54(%rsp), %esi
addq %rsi, %rcx
movb %dl, (%rax,%rcx)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x2213
movq 0x1e0(%rsp), %rax
movl %eax, 0x50(%rsp)
cmpl $0x2a, 0x50(%rsp)
jae 0x22ce
movq 0x1e0(%rsp), %rax
movzbl %al, %edx
movl 0x50(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movzbl 0x140(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x140(%rsp,%rax)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x2295
movb 0x1cf(%rsp), %al
movb %al, 0x141(%rsp)
movzbl 0x1ce(%rsp), %eax
addl $0x3, %eax
movb %al, 0x140(%rsp)
leaq 0x140(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x1090
movl $0x0, 0x4c(%rsp)
cmpl $0x2a, 0x4c(%rsp)
jae 0x234a
movl 0x4c(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movzbl 0x100(%rsp,%rax), %edx
movl 0x4c(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movzbl 0xc0(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, 0xc0(%rsp,%rax)
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x230b
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
cmpq $0x2a, 0x1e0(%rsp)
jb 0x2387
movq 0x78(%rsp), %rax
addq $0x2a, %rax
movq %rax, 0x78(%rsp)
movq 0x1e0(%rsp), %rax
subq $0x2a, %rax
movq %rax, 0x1e0(%rsp)
jmp 0x23a5
movq 0x1e0(%rsp), %rax
addq 0x78(%rsp), %rax
movq %rax, 0x78(%rsp)
movq $0x0, 0x1e0(%rsp)
movq 0x78(%rsp), %rcx
movq 0x1f0(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2020
jmp 0x23bc
cmpq $0x0, 0x1d0(%rsp)
je 0x26d4
cmpq $0x0, 0x1d8(%rsp)
jne 0x2432
movl $0x0, 0x48(%rsp)
cmpl $0x40, 0x48(%rsp)
jae 0x2422
movl 0x48(%rsp), %eax
movb $0x0, 0xc0(%rsp,%rax)
movl 0x48(%rsp), %eax
movb $0x0, 0x100(%rsp,%rax)
movl 0x48(%rsp), %eax
movb $0x0, 0x140(%rsp,%rax)
movl 0x48(%rsp), %eax
movb $0x0, 0x180(%rsp,%rax)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x23de
movl $0xfffffffc, 0x204(%rsp) # imm = 0xFFFFFFFC
jmp 0x2837
movq $0x1, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
cmpq $0x0, 0x1d0(%rsp)
jbe 0x26d2
movb 0x1cf(%rsp), %al
movb %al, 0x181(%rsp)
cmpq $0x16, 0x1d0(%rsp)
jb 0x2480
movzbl 0x1ce(%rsp), %eax
addl $0x4, %eax
movb %al, 0x180(%rsp)
jmp 0x2492
movzbl 0x1ce(%rsp), %eax
addl $0x5, %eax
movb %al, 0x180(%rsp)
movl $0x0, 0x34(%rsp)
cmpl $0x14, 0x34(%rsp)
jae 0x24f3
movl 0x34(%rsp), %eax
cmpq $0x8, %rax
jae 0x24c8
movq 0x40(%rsp), %rax
movl 0x34(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq $0xff, %rax
movq %rax, (%rsp)
jmp 0x24d0
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x24d0
movq (%rsp), %rax
movb %al, %cl
movl 0x34(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movb %cl, 0x180(%rsp,%rax)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x249a
cmpq $0x16, 0x1d0(%rsp)
jb 0x2549
movl $0x0, 0x30(%rsp)
cmpl $0x16, 0x30(%rsp)
jae 0x2544
movq 0x1d8(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x30(%rsp), %edx
addq %rdx, %rcx
movb (%rax,%rcx), %cl
movl 0x30(%rsp), %eax
addl $0x2, %eax
addl $0x14, %eax
movl %eax, %eax
movb %cl, 0x180(%rsp,%rax)
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x2506
jmp 0x25d5
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpq 0x1d0(%rsp), %rax
jae 0x2596
movq 0x1d8(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x2c(%rsp), %edx
addq %rdx, %rcx
movb (%rax,%rcx), %cl
movl 0x2c(%rsp), %eax
addl $0x2, %eax
addl $0x14, %eax
movl %eax, %eax
movb %cl, 0x180(%rsp,%rax)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2551
movq 0x1d0(%rsp), %rax
movl %eax, 0x28(%rsp)
cmpl $0x16, 0x28(%rsp)
jae 0x25d3
movq 0x1d0(%rsp), %rax
movb %al, %cl
movl 0x28(%rsp), %eax
addl $0x2, %eax
addl $0x14, %eax
movl %eax, %eax
movb %cl, 0x180(%rsp,%rax)
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x25a2
jmp 0x25d5
movl $0x0, 0x24(%rsp)
cmpl $0x14, 0x24(%rsp)
jae 0x2616
movq 0x220(%rsp), %rax
movl 0x24(%rsp), %ecx
movb (%rax,%rcx), %cl
movl 0x24(%rsp), %eax
addl $0x16, %eax
addl $0x14, %eax
addl $0x2, %eax
movl %eax, %eax
movb %cl, 0x180(%rsp,%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x25dd
leaq 0x180(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x1090
movl $0x0, 0x20(%rsp)
cmpl $0x2a, 0x20(%rsp)
jae 0x2672
movl 0x20(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movzbl 0x100(%rsp,%rax), %edx
movl 0x20(%rsp), %eax
addl $0x2, %eax
movl %eax, %eax
movzbl 0xc0(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, 0xc0(%rsp,%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2633
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
cmpq $0x16, 0x1d0(%rsp)
jb 0x26af
movq 0x38(%rsp), %rax
addq $0x16, %rax
movq %rax, 0x38(%rsp)
movq 0x1d0(%rsp), %rax
subq $0x16, %rax
movq %rax, 0x1d0(%rsp)
jmp 0x26cd
movq 0x1d0(%rsp), %rax
addq 0x38(%rsp), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x1d0(%rsp)
jmp 0x2444
jmp 0x26d4
movl $0x0, 0x1c(%rsp)
cmpl $0x14, 0x1c(%rsp)
jae 0x270f
movq 0x220(%rsp), %rax
movl 0x1c(%rsp), %ecx
movb (%rax,%rcx), %cl
movl 0x1c(%rsp), %eax
addl $0x2c, %eax
movl %eax, %eax
movb %cl, 0xc0(%rsp,%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x26dc
movzbl 0x1ce(%rsp), %eax
addl $0x6, %eax
movb %al, 0xc0(%rsp)
movb 0x1cf(%rsp), %al
movb %al, 0xc1(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x1090
movl $0x0, 0x18(%rsp)
cmpl $0x14, 0x18(%rsp)
jae 0x278a
movq 0x220(%rsp), %rax
movl 0x18(%rsp), %ecx
movzbl (%rax,%rcx), %edx
movl 0x18(%rsp), %eax
addl $0x2c, %eax
movl %eax, %eax
movzbl 0x80(%rsp,%rax), %ecx
xorl %edx, %ecx
movb %cl, 0x80(%rsp,%rax)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x274c
movl $0x0, 0x14(%rsp)
cmpl $0x14, 0x14(%rsp)
jae 0x27ce
movl 0x14(%rsp), %eax
movb 0x80(%rsp,%rax), %dl
movq 0x1f8(%rsp), %rax
movq 0x1f0(%rsp), %rcx
movq (%rcx), %rcx
movl 0x14(%rsp), %esi
addq %rsi, %rcx
movb %dl, (%rax,%rcx)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2792
movq 0x1f0(%rsp), %rax
movq (%rax), %rcx
addq $0x14, %rcx
movq %rcx, (%rax)
movl $0x0, 0x10(%rsp)
cmpl $0x40, 0x10(%rsp)
jae 0x282c
movl 0x10(%rsp), %eax
movb $0x0, 0xc0(%rsp,%rax)
movl 0x10(%rsp), %eax
movb $0x0, 0x100(%rsp,%rax)
movl 0x10(%rsp), %eax
movb $0x0, 0x140(%rsp,%rax)
movl 0x10(%rsp), %eax
movb $0x0, 0x180(%rsp,%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x27e8
movl $0x0, 0x204(%rsp)
movl 0x204(%rsp), %eax
addq $0x208, %rsp            # imm = 0x208
retq
nopw %cs:(%rax,%rax)