// File: /workspace/github_cpp_makefile_star2_O3/ashlall[P]StreamStats/Test/GK_test.cpp
// Function: test_GK(int, int)
void test_GK(int stream_size, int sample_size)
{
	double epsilon = log(stream_size)/sample_size;
	
	double quantA,quantB,quantC,quantD,quantE,quantF,quantG,quantH;
	bool condA,condB,condC,condD,condE,condF,condG,condH;
	double upper,lower;
	
	int random_fix1 = rand()% RAND_MAX;
 	int random_fix2 = rand()% RAND_MAX;
 	int random_fix3 = rand()% RAND_MAX;
        
    	GK a(sample_size);
 	GK b(sample_size);
	GK c(sample_size);
	GK d(sample_size);
 	GK e(sample_size);
	GK f(sample_size);
	GK g(sample_size);
 	GK h(sample_size);

	
	for (double j = 0; j <= stream_size; j++) //inserting in decreasing order
   	{	
  		a.insert(j); 
    	}
    	bool condA1;
	int LA = a.get_stream_size(); //test the function get_stream_size()
	condA1= (LA == stream_size+1);
	assert(condA1 == true);

	for (double i = stream_size; i >= 0; i--) //inserting in desceding order
    	{
  		b.insert(i); 
    	}
    	bool condB1;
	int LB = b.get_stream_size(); //test the function get_stream_size()
	condB1= (LB == stream_size+1);
	assert(condB1 == true);

	/*
	Generate three uniform distribution with the following range. In order to have a "good" uniform distribution, recommend large stream size.
	*/
	int uni_lower_bound1 = 500;
	int uni_upper_bound1 = 1000;

	int uni_lower_bound2 = 1234;
	int uni_upper_bound2 = 5678;

	int uni_lower_bound3 = 0;
	int uni_upper_bound3 = 5000;
	for (int m = 1; m <= 3; m++) //create 3 "random" sequences that holds their randomness every time runs the code
  	{
		double data;
  		if (m == 1)
  		{	
			default_random_engine generator(5);
			uniform_real_distribution<double> distribution(uni_lower_bound1,uni_upper_bound1);
			for (int i = 0; i <= stream_size; i++)
			{
   				data = distribution(generator);
  				c.insert(data);
			} 
  		}
  		
  		else if(m == 2)
  		{
			default_random_engine generator(10);
			uniform_real_distribution<double> distribution(uni_lower_bound2,uni_upper_bound2);
			for (int i = 0; i <= stream_size; i++)
			{
   				data = distribution(generator);
  				d.insert(data);
			}
  		}	
  		
  		else 
  		{	
			default_random_engine generator(20);
			uniform_real_distribution<double> distribution(uni_lower_bound3,uni_upper_bound3);
			for (int i = 0; i <= stream_size; i++)
			{
   				data = distribution(generator);
  				e.insert(data);
			}
  		}
  	}
  	
  	  f.insert(random_fix1); //test corner case where n = 1
  	  g.insert(random_fix2); 
  	  h.insert(random_fix3);   	
  	  bool condF1,condG1,condH1;
	  long LF = f.get_stream_size(); //test the function get_stream_size()
	  long LG = g.get_stream_size();
 	  long LH = h.get_stream_size();
          condF1 = (LF == 1);
     	  condG1 = (LG == 1);
	  condH1 = (LH == 1);
	  assert(condF1 == true);
	  assert(condG1 == true);
	  assert(condH1 == true);  
	  	
  for (float i=1;i<=stream_size;i++)
  {
  	  double interval=i/stream_size; //getting each probabilty interval
  	  
  	  quantA=a.getQuantile(interval); //getting quantile for each probability interval
  	  quantB=b.getQuantile(interval);
  	  quantC=c.getQuantile(interval);
  	  quantD=d.getQuantile(interval);
  	  quantE=e.getQuantile(interval);
  	  quantF=f.getQuantile(interval);
  	  quantG=g.getQuantile(interval);
  	  quantH=h.getQuantile(interval);
  	  
  	  lower=(interval-epsilon)*stream_size;//Used for first two cases.
  	  upper=(interval+epsilon)*stream_size;
  	  //cout << "l: " << lower << "  " << "u: " << upper <<endl;

  	  condA= ((lower<=quantA) && (upper>=quantA));
  	  condB= ((lower<=quantB) && (upper >=quantB));
  	  //checking if quantile is within error range
  	  
	
	 // cout << "cao:" << quantD<<endl;
	  //cout << (uni_lower_bound2 + (uni_upper_bound2-uni_lower_bound2)*interval)+epsilon*stream_size << endl;
 	 //cout << (uni_lower_bound2 + (uni_upper_bound2 - uni_lower_bound2)*interval)-epsilon*stream_size << endl;
	 //cout << "" <<endl;

	 condC = (quantC >= (uni_lower_bound1+(uni_upper_bound1 - uni_lower_bound1)*interval)- epsilon*stream_size) && (quantC <= (uni_lower_bound1+(uni_upper_bound1 - uni_lower_bound1)*interval) + epsilon*stream_size);
	 condD = (quantD >= (uni_lower_bound2+(uni_upper_bound2 - uni_lower_bound2)*interval)- epsilon*stream_size) && (quantD <= (uni_lower_bound2+(uni_upper_bound2 - uni_lower_bound2)*interval) + epsilon*stream_size);
	 condE = (quantE >= (uni_lower_bound3+(uni_upper_bound3 - uni_lower_bound3)*interval)- epsilon*stream_size) && (quantE <= (uni_lower_bound3+(uni_upper_bound3 - uni_lower_bound3)*interval) + epsilon*stream_size);
  	  //checking if quantile is within error range
  	  
  	  
  	  condF= (random_fix1 == quantF);
  	  condG= (random_fix2 == quantG);
  	  condH= (random_fix3 == quantH);
  	  //checking if the condition holds in the corner case where stream size = 1

  	  
  	  assert(condA==true);
  	  assert(condB==true);
  	  assert(condC==true);
  	  assert(condD==true);
  	  assert(condE==true);
  	  assert(condF==true);
  	  assert(condG==true);
  	  assert(condH==true);
  } 	  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movl %esi, %r14d
movq %rdi, -0x48(%rbp)
cvtsi2sd %edi, %xmm0
movsd %xmm0, -0x58(%rbp)
callq 0x10a0
movapd %xmm0, -0xa0(%rbp)
callq 0x1050
movl %eax, -0x90(%rbp)
callq 0x1050
movl %eax, -0x80(%rbp)
callq 0x1050
movl %eax, %r13d
leaq 0x3636(%rip), %rbx      # 0x4d80
movq %rbx, -0x1c0(%rbp)
movl $0x0, -0x1a8(%rbp)
movq $0x0, -0x1a0(%rbp)
movl %r14d, -0x1b8(%rbp)
movl %r14d, %r15d
shlq $0x3, %r15
testl %r14d, %r14d
movq $-0x1, %r12
cmovnsq %r15, %r12
movq %r12, %rdi
callq 0x1030
movq %rax, -0x1b0(%rbp)
testl %r14d, %r14d
jle 0x17a3
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
xorl %eax, %eax
movq %rax, -0x198(%rbp)
movq %rbx, -0x190(%rbp)
movl $0x0, -0x178(%rbp)
movq %rax, -0x170(%rbp)
movl %r14d, -0x188(%rbp)
movq %r12, %rdi
callq 0x1030
movq %rax, -0x180(%rbp)
testl %r14d, %r14d
jle 0x17ec
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
xorl %eax, %eax
movq %rax, -0x168(%rbp)
movq %rbx, -0x250(%rbp)
movl $0x0, -0x238(%rbp)
movq %rax, -0x230(%rbp)
movl %r14d, -0x248(%rbp)
movq %r12, %rdi
callq 0x1030
movq %rax, -0x240(%rbp)
testl %r14d, %r14d
jle 0x1835
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
xorl %eax, %eax
movq %rax, -0x228(%rbp)
movq %rbx, -0x220(%rbp)
movl $0x0, -0x208(%rbp)
movq %rax, -0x200(%rbp)
movl %r14d, -0x218(%rbp)
movq %r12, %rdi
callq 0x1030
movq %rax, -0x210(%rbp)
testl %r14d, %r14d
jle 0x187e
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
xorl %eax, %eax
movq %rax, -0x1f8(%rbp)
movq %rbx, -0x1f0(%rbp)
movl $0x0, -0x1d8(%rbp)
movq %rax, -0x1d0(%rbp)
movl %r14d, -0x1e8(%rbp)
movq %r12, %rdi
callq 0x1030
movq %rax, -0x1e0(%rbp)
testl %r14d, %r14d
jle 0x18c7
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
xorl %eax, %eax
movq %rax, -0x1c8(%rbp)
movq %rbx, -0x160(%rbp)
movl $0x0, -0x148(%rbp)
movq %rax, -0x140(%rbp)
movl %r14d, -0x158(%rbp)
movq %r12, %rdi
callq 0x1030
movq %rax, -0x150(%rbp)
testl %r14d, %r14d
jle 0x1910
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
xorl %eax, %eax
movq %rax, -0x138(%rbp)
movq %rbx, -0x130(%rbp)
movl $0x0, -0x118(%rbp)
movq %rax, -0x110(%rbp)
movl %r14d, -0x128(%rbp)
movq %r12, %rdi
callq 0x1030
movq %rax, -0x120(%rbp)
testl %r14d, %r14d
jle 0x1959
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
xorl %eax, %eax
movq %rax, -0x108(%rbp)
movq %rbx, -0x100(%rbp)
movl $0x0, -0xe8(%rbp)
movq %rax, -0xe0(%rbp)
movl %r14d, -0xf8(%rbp)
movq %r12, %rdi
callq 0x1030
movq %rax, -0xf0(%rbp)
testl %r14d, %r14d
movq -0x48(%rbp), %rbx
jle 0x19a6
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
movq $0x0, -0xd8(%rbp)
testl %ebx, %ebx
js 0x1a39
xorpd %xmm1, %xmm1
leaq -0x1c0(%rbp), %r15
movq %r15, %rdi
movsd %xmm1, -0x40(%rbp)
movapd %xmm1, %xmm0
callq 0x13a6
movsd -0x40(%rbp), %xmm1
addsd 0x162e(%rip), %xmm1     # 0x3010
movsd -0x58(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x19c4
movl -0x198(%rbp), %ecx
leal 0x1(%rbx), %eax
movl %ecx, -0x40(%rbp)
cmpl %ecx, %eax
jne 0x1a45
testl %ebx, %ebx
js 0x1a64
leaq -0x190(%rbp), %r15
movsd -0x58(%rbp), %xmm0
movq %r15, %rdi
movsd %xmm0, -0x50(%rbp)
callq 0x13a6
movsd -0x50(%rbp), %xmm0
addsd 0x15e1(%rip), %xmm0     # 0x3008
ucomisd 0x1609(%rip), %xmm0     # 0x3038
jae 0x1a0d
movl -0x168(%rbp), %eax
jmp 0x1a66
movl $0x0, -0x40(%rbp)
cmpl $-0x1, %ebx
je 0x1a6f
leaq 0x1650(%rip), %rdi      # 0x309c
leaq 0x1658(%rip), %rsi      # 0x30ab
leaq 0x165d(%rip), %rcx      # 0x30b7
movl $0x2c, %edx
callq 0x1080
xorl %eax, %eax
cmpl -0x40(%rbp), %eax
jne 0x211b
movslq -0x90(%rbp), %rdx
movslq -0x80(%rbp), %rcx
movslq %r13d, %rax
movq %rdx, %r11
shlq $0x1e, %r11
movq %rcx, %r10
shlq $0x1e, %r10
movq %rax, %r9
shlq $0x1e, %r9
addq %rdx, %r11
addq %rcx, %r10
addq %rax, %r9
movq %r11, %rsi
shrq $0x3f, %rsi
sarq $0x3d, %r11
movq %r10, %rdi
shrq $0x3f, %rdi
sarq $0x3d, %r10
movq %r9, %r8
shrq $0x3f, %r8
sarq $0x3d, %r9
addl %esi, %r11d
addl %edi, %r10d
addl %r8d, %r9d
addl %r11d, %edx
shll $0x1f, %r11d
addl %edx, %r11d
movq %r11, -0x50(%rbp)
addl %r10d, %ecx
shll $0x1f, %r10d
addl %ecx, %r10d
movq %r10, -0x90(%rbp)
addl %r9d, %eax
shll $0x1f, %r9d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
addl %eax, %r9d
movq %r9, -0x80(%rbp)
movapd -0xa0(%rbp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, -0xa0(%rbp)
movl $0x1, %ebx
leaq -0x60(%rbp), %r14
leaq -0x250(%rbp), %r12
leaq -0x1f0(%rbp), %r13
cmpl $0x2, %ebx
je 0x1b6c
cmpl $0x1, %ebx
jne 0x1ba9
movq $0x5, -0x60(%rbp)
movl -0x40(%rbp), %r15d
cmpl $0x0, -0x48(%rbp)
js 0x1be0
movq %r14, %rdi
callq 0x25a0
movsd 0x14d3(%rip), %xmm1     # 0x3028
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
movq %r12, %rdi
callq 0x13a6
decl %r15d
jne 0x1b45
jmp 0x1be0
movq $0xa, -0x60(%rbp)
movl -0x40(%rbp), %r15d
cmpl $0x0, -0x48(%rbp)
js 0x1be0
movq %r14, %rdi
callq 0x25a0
mulsd 0x148a(%rip), %xmm0     # 0x3018
addsd 0x148a(%rip), %xmm0     # 0x3020
leaq -0x220(%rbp), %rdi
callq 0x13a6
decl %r15d
jne 0x1b7e
jmp 0x1be0
movq $0x14, -0x60(%rbp)
movl -0x40(%rbp), %r15d
cmpl $0x0, -0x48(%rbp)
js 0x1be0
movq %r14, %rdi
callq 0x25a0
mulsd 0x1465(%rip), %xmm0     # 0x3030
addsd 0x1465(%rip), %xmm0     # 0x3038
movq %r13, %rdi
callq 0x13a6
decl %r15d
jne 0x1bbb
incl %ebx
cmpl $0x4, %ebx
jne 0x1b25
xorps %xmm0, %xmm0
cvtsi2sdl -0x50(%rbp), %xmm0
leaq -0x160(%rbp), %rdi
movsd %xmm0, -0xb8(%rbp)
callq 0x13a6
xorps %xmm0, %xmm0
cvtsi2sdl -0x90(%rbp), %xmm0
leaq -0x130(%rbp), %rdi
movsd %xmm0, -0xb0(%rbp)
callq 0x13a6
xorps %xmm0, %xmm0
cvtsi2sdl -0x80(%rbp), %xmm0
leaq -0x100(%rbp), %rdi
movsd %xmm0, -0xa8(%rbp)
callq 0x13a6
cmpq $0x1, -0x138(%rbp)
movq -0x48(%rbp), %rax
jne 0x20be
cmpq $0x1, -0x108(%rbp)
jne 0x20dd
cmpq $0x1, -0xd8(%rbp)
jne 0x20fc
testl %eax, %eax
jle 0x1f54
cvtsi2ss %eax, %xmm2
movapd 0x13dc(%rip), %xmm3     # 0x3060
movapd -0xa0(%rbp), %xmm1
xorpd %xmm1, %xmm3
movss 0x13f8(%rip), %xmm4     # 0x3090
leaq -0x1f0(%rbp), %r12
leaq -0x160(%rbp), %r13
leaq -0x130(%rbp), %rbx
leaq -0x100(%rbp), %r14
movsd -0x58(%rbp), %xmm0
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm1
leaq -0x190(%rbp), %r15
movaps %xmm4, %xmm0
movss %xmm2, -0x64(%rbp)
movapd %xmm3, -0x270(%rbp)
movapd %xmm1, -0x260(%rbp)
movss %xmm0, -0x68(%rbp)
divss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x166e
movsd %xmm0, -0x48(%rbp)
leaq -0x250(%rbp), %rdi
movaps -0x40(%rbp), %xmm0
callq 0x166e
movaps %xmm0, -0x90(%rbp)
leaq -0x220(%rbp), %rdi
movaps -0x40(%rbp), %xmm0
callq 0x166e
movaps %xmm0, -0x2b0(%rbp)
movq %r12, %rdi
movaps -0x40(%rbp), %xmm0
callq 0x166e
movaps %xmm0, -0x290(%rbp)
movq %r13, %rdi
movaps -0x40(%rbp), %xmm0
callq 0x166e
movsd %xmm0, -0xd0(%rbp)
movq %rbx, %rdi
movaps -0x40(%rbp), %xmm0
callq 0x166e
movsd %xmm0, -0xc8(%rbp)
movq %r14, %rdi
movaps -0x40(%rbp), %xmm0
callq 0x166e
movsd -0x48(%rbp), %xmm4
movapd -0x40(%rbp), %xmm2
movsd %xmm0, -0xc0(%rbp)
movapd %xmm2, %xmm3
movapd -0xa0(%rbp), %xmm1
subsd %xmm1, %xmm3
movsd -0x58(%rbp), %xmm0
mulsd %xmm0, %xmm3
movsd %xmm3, -0x50(%rbp)
ucomisd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulsd 0x1261(%rip), %xmm3     # 0x3018
addsd 0x1261(%rip), %xmm3     # 0x3020
movapd %xmm3, -0x2a0(%rbp)
movapd %xmm2, %xmm3
mulsd 0x125d(%rip), %xmm3     # 0x3030
movapd %xmm3, -0x280(%rbp)
jb 0x209f
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, -0x80(%rbp)
ucomisd %xmm4, %xmm1
jb 0x209f
movq %r15, %rdi
movapd %xmm2, %xmm0
callq 0x166e
ucomisd -0x50(%rbp), %xmm0
jb 0x2080
movapd -0x80(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jb 0x2080
movsd 0x1202(%rip), %xmm0     # 0x3028
movapd -0x40(%rbp), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm0, %xmm2
movapd -0x270(%rbp), %xmm3
movapd %xmm3, %xmm0
addsd %xmm2, %xmm0
movapd -0x260(%rbp), %xmm1
addsd %xmm1, %xmm2
movapd -0x90(%rbp), %xmm4
cmplepd %xmm4, %xmm0
cmplepd %xmm2, %xmm4
andpd %xmm0, %xmm4
movd %xmm4, %eax
testb $0x1, %al
movss -0x64(%rbp), %xmm2
je 0x2061
movapd %xmm3, %xmm0
movapd -0x2a0(%rbp), %xmm5
addsd %xmm5, %xmm0
addsd %xmm1, %xmm5
movapd -0x2b0(%rbp), %xmm4
cmplepd %xmm4, %xmm0
cmplepd %xmm5, %xmm4
andpd %xmm0, %xmm4
movd %xmm4, %eax
testb $0x1, %al
je 0x2042
movapd -0x280(%rbp), %xmm5
addsd 0x117c(%rip), %xmm5     # 0x3038
movapd %xmm3, %xmm0
addsd %xmm5, %xmm0
addsd %xmm1, %xmm5
movapd -0x290(%rbp), %xmm4
cmplepd %xmm4, %xmm0
cmplepd %xmm5, %xmm4
andpd %xmm0, %xmm4
movd %xmm4, %eax
testb $0x1, %al
je 0x2023
movsd -0xd0(%rbp), %xmm0
ucomisd -0xb8(%rbp), %xmm0
movss -0x68(%rbp), %xmm0
jne 0x2004
jp 0x2004
movsd -0xc8(%rbp), %xmm4
ucomisd -0xb0(%rbp), %xmm4
jne 0x1fe5
jp 0x1fe5
movsd -0xc0(%rbp), %xmm4
ucomisd -0xa8(%rbp), %xmm4
jne 0x1fc6
jp 0x1fc6
addss 0x1145(%rip), %xmm0     # 0x3090
ucomiss %xmm0, %xmm2
jae 0x1ce0
leaq -0x100(%rbp), %rdi
callq 0x1358
leaq -0x130(%rbp), %rdi
callq 0x1358
leaq -0x160(%rbp), %rdi
callq 0x1358
leaq -0x1f0(%rbp), %rdi
callq 0x1358
leaq -0x220(%rbp), %rdi
callq 0x1358
leaq -0x250(%rbp), %rdi
callq 0x1358
leaq -0x190(%rbp), %rdi
callq 0x1358
leaq -0x1c0(%rbp), %rdi
callq 0x1358
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1191(%rip), %rdi      # 0x315e
leaq 0x10d7(%rip), %rsi      # 0x30ab
leaq 0x10dc(%rip), %rcx      # 0x30b7
movl $0xa3, %edx
callq 0x1080
leaq 0x1166(%rip), %rdi      # 0x3152
leaq 0x10b8(%rip), %rsi      # 0x30ab
leaq 0x10bd(%rip), %rcx      # 0x30b7
movl $0xa2, %edx
callq 0x1080
leaq 0x113b(%rip), %rdi      # 0x3146
leaq 0x1099(%rip), %rsi      # 0x30ab
leaq 0x109e(%rip), %rcx      # 0x30b7
movl $0xa1, %edx
callq 0x1080
leaq 0x1110(%rip), %rdi      # 0x313a
leaq 0x107a(%rip), %rsi      # 0x30ab
leaq 0x107f(%rip), %rcx      # 0x30b7
movl $0xa0, %edx
callq 0x1080
leaq 0x10e5(%rip), %rdi      # 0x312e
leaq 0x105b(%rip), %rsi      # 0x30ab
leaq 0x1060(%rip), %rcx      # 0x30b7
movl $0x9f, %edx
callq 0x1080
leaq 0x10ba(%rip), %rdi      # 0x3122
leaq 0x103c(%rip), %rsi      # 0x30ab
leaq 0x1041(%rip), %rcx      # 0x30b7
movl $0x9e, %edx
callq 0x1080
leaq 0x108f(%rip), %rdi      # 0x3116
leaq 0x101d(%rip), %rsi      # 0x30ab
leaq 0x1022(%rip), %rcx      # 0x30b7
movl $0x9d, %edx
callq 0x1080
leaq 0x1064(%rip), %rdi      # 0x310a
leaq 0xffe(%rip), %rsi       # 0x30ab
leaq 0x1003(%rip), %rcx      # 0x30b7
movl $0x9c, %edx
callq 0x1080
leaq 0x1018(%rip), %rdi      # 0x30dd
leaq 0xfdf(%rip), %rsi       # 0x30ab
leaq 0xfe4(%rip), %rcx       # 0x30b7
movl $0x71, %edx
callq 0x1080
leaq 0x1008(%rip), %rdi      # 0x30ec
leaq 0xfc0(%rip), %rsi       # 0x30ab
leaq 0xfc5(%rip), %rcx       # 0x30b7
movl $0x72, %edx
callq 0x1080
leaq 0xff8(%rip), %rdi       # 0x30fb
leaq 0xfa1(%rip), %rsi       # 0x30ab
leaq 0xfa6(%rip), %rcx       # 0x30b7
movl $0x73, %edx
callq 0x1080
leaq 0xfac(%rip), %rdi       # 0x30ce
leaq 0xf82(%rip), %rsi       # 0x30ab
leaq 0xf87(%rip), %rcx       # 0x30b7
movl $0x35, %edx
callq 0x1080
movq %rax, %rbx
jmp 0x2176
movq %rax, %rbx
jmp 0x2182
movq %rax, %rbx
jmp 0x218e
movq %rax, %rbx
jmp 0x219a
movq %rax, %rbx
jmp 0x21a6
movq %rax, %rbx
jmp 0x21b2
movq %rax, %rbx
jmp 0x21be
jmp 0x2167
jmp 0x2167
jmp 0x2167
jmp 0x2167
jmp 0x2167
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x1358
leaq -0x130(%rbp), %rdi
callq 0x1358
leaq -0x160(%rbp), %rdi
callq 0x1358
leaq -0x1f0(%rbp), %rdi
callq 0x1358
leaq -0x220(%rbp), %rdi
callq 0x1358
leaq -0x250(%rbp), %rdi
callq 0x1358
leaq -0x190(%rbp), %rdi
callq 0x1358
leaq -0x1c0(%rbp), %rdi
callq 0x1358
movq %rbx, %rdi
callq 0x1110