// File: /workspace/github_cpp_makefile_star2_O1/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 $0x278, %rsp            # imm = 0x278
movl %esi, %r14d
movq %rdi, -0x30(%rbp)
cvtsi2sd %edi, %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0x10a0
movapd %xmm0, -0x90(%rbp)
callq 0x1050
movl %eax, -0x80(%rbp)
callq 0x1050
movl %eax, -0x70(%rbp)
callq 0x1050
movl %eax, -0xa0(%rbp)
leaq 0x35fb(%rip), %rbx      # 0x4d80
movq %rbx, -0x1c0(%rbp)
movl $0x0, -0x1a8(%rbp)
movq $0x0, -0x1a0(%rbp)
movl %r14d, -0x1b8(%rbp)
movslq %r14d, %r13
leaq (,%r13,8), %rax
testl %r13d, %r13d
movq $-0x1, %r12
cmovnsq %rax, %r12
movq %r12, %rdi
callq 0x1030
movq %rax, -0x1b0(%rbp)
movl %r14d, %r15d
testl %r13d, %r13d
jle 0x17ea
leaq (,%r15,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
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 0x1838
leaq (,%r15,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
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 0x1886
leaq (,%r15,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
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 0x18d4
leaq (,%r15,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
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 0x1922
leaq (,%r15,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
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 0x1970
leaq (,%r15,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
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 0x19be
leaq (,%r15,8), %rdx
movq %rax, %rdi
xorl %esi, %esi
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 -0x30(%rbp), %rbx
jle 0x1a0f
shlq $0x3, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1070
movq $0x0, -0xd8(%rbp)
testl %ebx, %ebx
js 0x1a52
xorpd %xmm1, %xmm1
leaq -0x1c0(%rbp), %r15
movq %r15, %rdi
movsd %xmm1, -0x40(%rbp)
movapd %xmm1, %xmm0
callq 0x13ae
movsd -0x40(%rbp), %xmm1
addsd 0x15c9(%rip), %xmm1     # 0x3010
movsd -0x50(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x1a29
leal 0x1(%rbx), %eax
movl %eax, -0x48(%rbp)
cmpl -0x198(%rbp), %eax
jne 0x20eb
testl %ebx, %ebx
js 0x1a98
leaq -0x190(%rbp), %r15
movsd -0x50(%rbp), %xmm0
movq %r15, %rdi
movsd %xmm0, -0x40(%rbp)
callq 0x13ae
movsd -0x40(%rbp), %xmm0
addsd 0x157a(%rip), %xmm0     # 0x3008
ucomisd 0x15a2(%rip), %xmm0     # 0x3038
jae 0x1a74
movl -0x48(%rbp), %eax
cmpl -0x168(%rbp), %eax
jne 0x210a
movslq -0x80(%rbp), %rdx
movslq -0x70(%rbp), %rcx
movslq -0xa0(%rbp), %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, -0x40(%rbp)
addl %r10d, %ecx
shll $0x1f, %r10d
addl %ecx, %r10d
movq %r10, -0x80(%rbp)
addl %r9d, %eax
shll $0x1f, %r9d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
addl %eax, %r9d
movq %r9, -0x70(%rbp)
movapd -0x90(%rbp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, -0x90(%rbp)
movl $0x1, %ebx
leaq -0x58(%rbp), %r14
leaq -0x250(%rbp), %r12
leaq -0x1f0(%rbp), %r13
cmpl $0x2, %ebx
je 0x1ba2
cmpl $0x1, %ebx
jne 0x1bdf
movq $0x5, -0x58(%rbp)
movl -0x48(%rbp), %r15d
cmpl $0x0, -0x30(%rbp)
js 0x1c16
movq %r14, %rdi
callq 0x260e
movsd 0x149d(%rip), %xmm1     # 0x3028
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
movq %r12, %rdi
callq 0x13ae
decl %r15d
jne 0x1b7b
jmp 0x1c16
movq $0xa, -0x58(%rbp)
movl -0x48(%rbp), %r15d
cmpl $0x0, -0x30(%rbp)
js 0x1c16
movq %r14, %rdi
callq 0x260e
mulsd 0x1454(%rip), %xmm0     # 0x3018
addsd 0x1454(%rip), %xmm0     # 0x3020
leaq -0x220(%rbp), %rdi
callq 0x13ae
decl %r15d
jne 0x1bb4
jmp 0x1c16
movq $0x14, -0x58(%rbp)
movl -0x48(%rbp), %r15d
cmpl $0x0, -0x30(%rbp)
js 0x1c16
movq %r14, %rdi
callq 0x260e
mulsd 0x142f(%rip), %xmm0     # 0x3030
addsd 0x142f(%rip), %xmm0     # 0x3038
movq %r13, %rdi
callq 0x13ae
decl %r15d
jne 0x1bf1
incl %ebx
cmpl $0x4, %ebx
jne 0x1b5b
xorps %xmm0, %xmm0
cvtsi2sdl -0x40(%rbp), %xmm0
leaq -0x160(%rbp), %rdi
movsd %xmm0, -0xb8(%rbp)
callq 0x13ae
xorps %xmm0, %xmm0
cvtsi2sdl -0x80(%rbp), %xmm0
leaq -0x130(%rbp), %rdi
movsd %xmm0, -0xb0(%rbp)
callq 0x13ae
xorps %xmm0, %xmm0
cvtsi2sdl -0x70(%rbp), %xmm0
leaq -0x100(%rbp), %rdi
movsd %xmm0, -0xa8(%rbp)
callq 0x13ae
cmpq $0x1, -0x138(%rbp)
movq -0x30(%rbp), %rax
jne 0x2129
cmpq $0x1, -0x108(%rbp)
jne 0x2148
cmpq $0x1, -0xd8(%rbp)
jne 0x2167
testl %eax, %eax
jle 0x1f81
cvtsi2ss %eax, %xmm2
movapd 0x13a9(%rip), %xmm3     # 0x3060
movapd -0x90(%rbp), %xmm1
xorpd %xmm1, %xmm3
movss 0x13c5(%rip), %xmm4     # 0x3090
leaq -0x1f0(%rbp), %r12
leaq -0x160(%rbp), %r13
leaq -0x130(%rbp), %rbx
leaq -0x100(%rbp), %r14
movsd -0x50(%rbp), %xmm0
mulsd %xmm0, %xmm3
mulsd %xmm0, %xmm1
leaq -0x190(%rbp), %r15
movaps %xmm4, %xmm0
movss %xmm2, -0x5c(%rbp)
movapd %xmm3, -0x270(%rbp)
movapd %xmm1, -0x260(%rbp)
movss %xmm0, -0x60(%rbp)
divss %xmm2, %xmm0
cvtss2sd %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x168c
movsd %xmm0, -0x30(%rbp)
leaq -0x250(%rbp), %rdi
movaps -0x40(%rbp), %xmm0
callq 0x168c
movaps %xmm0, -0x80(%rbp)
leaq -0x220(%rbp), %rdi
movaps -0x40(%rbp), %xmm0
callq 0x168c
movaps %xmm0, -0xa0(%rbp)
movq %r12, %rdi
movaps -0x40(%rbp), %xmm0
callq 0x168c
movaps %xmm0, -0x290(%rbp)
movq %r13, %rdi
movaps -0x40(%rbp), %xmm0
callq 0x168c
movsd %xmm0, -0xd0(%rbp)
movq %rbx, %rdi
movaps -0x40(%rbp), %xmm0
callq 0x168c
movsd %xmm0, -0xc8(%rbp)
movq %r14, %rdi
movaps -0x40(%rbp), %xmm0
callq 0x168c
movsd -0x30(%rbp), %xmm4
movapd -0x40(%rbp), %xmm2
movsd %xmm0, -0xc0(%rbp)
movapd %xmm2, %xmm3
movapd -0x90(%rbp), %xmm1
subsd %xmm1, %xmm3
movsd -0x50(%rbp), %xmm0
mulsd %xmm0, %xmm3
movsd %xmm3, -0x48(%rbp)
ucomisd %xmm3, %xmm4
movapd %xmm2, %xmm3
mulsd 0x1231(%rip), %xmm3     # 0x3018
addsd 0x1231(%rip), %xmm3     # 0x3020
movapd %xmm3, -0x2a0(%rbp)
movapd %xmm2, %xmm3
mulsd 0x122d(%rip), %xmm3     # 0x3030
movapd %xmm3, -0x280(%rbp)
jb 0x20cc
addsd %xmm2, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, -0x70(%rbp)
ucomisd %xmm4, %xmm1
jb 0x20cc
movq %r15, %rdi
movapd %xmm2, %xmm0
callq 0x168c
ucomisd -0x48(%rbp), %xmm0
jb 0x20ad
movapd -0x70(%rbp), %xmm1
ucomisd %xmm0, %xmm1
jb 0x20ad
movsd 0x11d2(%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 -0x80(%rbp), %xmm4
cmplepd %xmm4, %xmm0
cmplepd %xmm2, %xmm4
andpd %xmm0, %xmm4
movd %xmm4, %eax
testb $0x1, %al
movss -0x5c(%rbp), %xmm2
je 0x208e
movapd %xmm3, %xmm0
movapd -0x2a0(%rbp), %xmm5
addsd %xmm5, %xmm0
addsd %xmm1, %xmm5
movapd -0xa0(%rbp), %xmm4
cmplepd %xmm4, %xmm0
cmplepd %xmm5, %xmm4
andpd %xmm0, %xmm4
movd %xmm4, %eax
testb $0x1, %al
je 0x206f
movapd -0x280(%rbp), %xmm5
addsd 0x114f(%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 0x2050
movsd -0xd0(%rbp), %xmm0
ucomisd -0xb8(%rbp), %xmm0
movss -0x60(%rbp), %xmm0
jne 0x2031
jp 0x2031
movsd -0xc8(%rbp), %xmm4
ucomisd -0xb0(%rbp), %xmm4
jne 0x2012
jp 0x2012
movsd -0xc0(%rbp), %xmm4
ucomisd -0xa8(%rbp), %xmm4
jne 0x1ff3
jp 0x1ff3
addss 0x1118(%rip), %xmm0     # 0x3090
ucomiss %xmm0, %xmm2
jae 0x1d13
leaq -0x100(%rbp), %rdi
callq 0x135c
leaq -0x130(%rbp), %rdi
callq 0x135c
leaq -0x160(%rbp), %rdi
callq 0x135c
leaq -0x1f0(%rbp), %rdi
callq 0x135c
leaq -0x220(%rbp), %rdi
callq 0x135c
leaq -0x250(%rbp), %rdi
callq 0x135c
leaq -0x190(%rbp), %rdi
callq 0x135c
leaq -0x1c0(%rbp), %rdi
callq 0x135c
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1164(%rip), %rdi      # 0x315e
leaq 0x10aa(%rip), %rsi      # 0x30ab
leaq 0x10af(%rip), %rcx      # 0x30b7
movl $0xa3, %edx
callq 0x1080
leaq 0x1139(%rip), %rdi      # 0x3152
leaq 0x108b(%rip), %rsi      # 0x30ab
leaq 0x1090(%rip), %rcx      # 0x30b7
movl $0xa2, %edx
callq 0x1080
leaq 0x110e(%rip), %rdi      # 0x3146
leaq 0x106c(%rip), %rsi      # 0x30ab
leaq 0x1071(%rip), %rcx      # 0x30b7
movl $0xa1, %edx
callq 0x1080
leaq 0x10e3(%rip), %rdi      # 0x313a
leaq 0x104d(%rip), %rsi      # 0x30ab
leaq 0x1052(%rip), %rcx      # 0x30b7
movl $0xa0, %edx
callq 0x1080
leaq 0x10b8(%rip), %rdi      # 0x312e
leaq 0x102e(%rip), %rsi      # 0x30ab
leaq 0x1033(%rip), %rcx      # 0x30b7
movl $0x9f, %edx
callq 0x1080
leaq 0x108d(%rip), %rdi      # 0x3122
leaq 0x100f(%rip), %rsi      # 0x30ab
leaq 0x1014(%rip), %rcx      # 0x30b7
movl $0x9e, %edx
callq 0x1080
leaq 0x1062(%rip), %rdi      # 0x3116
leaq 0xff0(%rip), %rsi       # 0x30ab
leaq 0xff5(%rip), %rcx       # 0x30b7
movl $0x9d, %edx
callq 0x1080
leaq 0x1037(%rip), %rdi      # 0x310a
leaq 0xfd1(%rip), %rsi       # 0x30ab
leaq 0xfd6(%rip), %rcx       # 0x30b7
movl $0x9c, %edx
callq 0x1080
leaq 0xfaa(%rip), %rdi       # 0x309c
leaq 0xfb2(%rip), %rsi       # 0x30ab
leaq 0xfb7(%rip), %rcx       # 0x30b7
movl $0x2c, %edx
callq 0x1080
leaq 0xfbd(%rip), %rdi       # 0x30ce
leaq 0xf93(%rip), %rsi       # 0x30ab
leaq 0xf98(%rip), %rcx       # 0x30b7
movl $0x35, %edx
callq 0x1080
leaq 0xfad(%rip), %rdi       # 0x30dd
leaq 0xf74(%rip), %rsi       # 0x30ab
leaq 0xf79(%rip), %rcx       # 0x30b7
movl $0x71, %edx
callq 0x1080
leaq 0xf9d(%rip), %rdi       # 0x30ec
leaq 0xf55(%rip), %rsi       # 0x30ab
leaq 0xf5a(%rip), %rcx       # 0x30b7
movl $0x72, %edx
callq 0x1080
leaq 0xf8d(%rip), %rdi       # 0x30fb
leaq 0xf36(%rip), %rsi       # 0x30ab
leaq 0xf3b(%rip), %rcx       # 0x30b7
movl $0x73, %edx
callq 0x1080
movq %rax, %rbx
jmp 0x21c2
movq %rax, %rbx
jmp 0x21ce
movq %rax, %rbx
jmp 0x21da
movq %rax, %rbx
jmp 0x21e6
movq %rax, %rbx
jmp 0x21f2
movq %rax, %rbx
jmp 0x21fe
movq %rax, %rbx
jmp 0x220a
jmp 0x21b3
jmp 0x21b3
jmp 0x21b3
jmp 0x21b3
jmp 0x21b3
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x135c
leaq -0x130(%rbp), %rdi
callq 0x135c
leaq -0x160(%rbp), %rdi
callq 0x135c
leaq -0x1f0(%rbp), %rdi
callq 0x135c
leaq -0x220(%rbp), %rdi
callq 0x135c
leaq -0x250(%rbp), %rdi
callq 0x135c
leaq -0x190(%rbp), %rdi
callq 0x135c
leaq -0x1c0(%rbp), %rdi
callq 0x135c
movq %rbx, %rdi
callq 0x1110