// File: Luthaf[P]zeopp/ray.cc
// Function: calcRaysInAV(ATOM_NETWORK*, ATOM_NETWORK*, bool, double, double, int, std::ostream&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void calcRaysInAV(ATOM_NETWORK *hiaccatmnet, ATOM_NETWORK *orgatmnet, bool highAccuracy, double r_probe_chan,double r_probe,int numSamples, ostream &output, bool visualize,string option){

  ATOM_NETWORK *cell;

  if(highAccuracy) cell=orgatmnet; else cell = hiaccatmnet; // this ensures that the loops below loop over original atoms
                                                                // and not "high-acuracy" clusters, which are used only for
                                                                // voronoi decomposition

  // Create an object that handles analysis of accessibility of sampled points
  AccessibilityClass accessAnalysis;
  if(highAccuracy) accessAnalysis.setupAndFindChannels(hiaccatmnet, orgatmnet, highAccuracy, r_probe_chan, r_probe);
    else accessAnalysis.setupAndFindChannels(hiaccatmnet, hiaccatmnet, highAccuracy, r_probe_chan, r_probe);


  srand(randSeed); //randSeed can be set in network.h
  
  //Initialize Ray Trace World
  vector<Sphere> atoms;
  convertAtomToSphere(cell,atoms);
  vector<Sphere> nodes;
  convertNodeToSphere(accessAnalysis.vornet,nodes,accessAnalysis.accessInfo);
  vector<Plane> faces;
  calcPlanesToCell(cell,faces);
  
  //Duplicate the nodes and atoms that intersect with the plane faces	
  duplicateSpheresOnFace(cell,atoms,faces);
  duplicateSpheresOnFace(cell,nodes,faces);	
  
  //Lists of Accessible, Inaccessible, and Resampled Rays
  vector<ray> axsray; //List of successful rays that were shot
  vector<ray> inaxsray;
  vector<ray> resampledray;  // List of resampled rays

#if DEBUG
  //List Atoms, Nodes, and Planes
  cout << "List of Atoms: " << endl;
  for (unsigned int i=0; i<atoms.size(); i++)
    {
      cout << "Center: " << atoms[i].center << " Radius: " << atoms[i].radius << endl;;
    }
  cout << "List of Nodes: " << endl;
  for (unsigned int i=0; i<nodes.size(); i++)
    {
      cout << "Center: " << nodes[i].center << " Radius: " << nodes[i].radius << endl;;
    }
  cout << "List of Cell Wall Faces: " << endl;
  for (unsigned int i=0; i<faces.size(); i++)
    {
      cout << "Point: " << faces[i].point << " Normal: " << faces[i].normal << endl;;
    }
#endif
  
  //Begin Implementaitons of Ray Tracing Algorithm
  cout << "Begin Ray Tracing Analysis: " << endl;
  if (option.compare("atom") == 0)
    {
      cout << "Atom Implementation Chosen: " << endl;
      cout << "Number of Samples: " << numSamples << endl;
      ray rand_ray;
      ray opposite_rand_ray;
      hitdata hitobject;
      for (int i=0; i<numSamples; i++)
	{
	  rand_ray.base =  cell->abc_to_xyz(genRandomPoint());
	  rand_ray.vector = genRandomVec();
	  
	  bool point_accessible = accessAnalysis.isVPointAccessible(rand_ray.base); 
	  
	  if (point_accessible == false)
	    {
              rand_ray.vector = Point(0,0,0);
	      inaxsray.push_back(rand_ray);
	    }
	  else //point is accessible
	    {
	      opposite_rand_ray.base = rand_ray.base;
	      opposite_rand_ray.vector  = rand_ray.vector.scale(-1);
	      
	      rayTraceToSphere(cell,atoms,rand_ray,faces,hitobject);
	      rand_ray.vector = rand_ray.vector.scale(hitobject.dist);
	      
              hitobject.dist = 0.0;
              hitobject.hit = false;
	      hitobject.object = NULL;
	      hitobject.id = -1;
	      hitobject.hitpoint = Point(0,0,0);
	      
	      //Test negative of ray
	      rayTraceToSphere(cell,atoms,opposite_rand_ray,faces,hitobject);
	      opposite_rand_ray.vector = opposite_rand_ray.vector.scale(hitobject.dist);
	      
	      rand_ray.base = rand_ray.base + opposite_rand_ray.vector;
	      rand_ray.vector = rand_ray.vector - opposite_rand_ray.vector;
	      
	      axsray.push_back(rand_ray);
	      
	      hitobject.dist = 0.0;
              hitobject.hit = false;
	      hitobject.object = NULL;
	      hitobject.id = -1;
	      hitobject.hitpoint = Point(0,0,0);
	      
	    }
	}
    }

  if (option.compare("node") == 0)
    {
      cout << "Node Implementation Chosen: " << endl;
      cout << "Number of Samples: " << numSamples << endl;
      int ndx = 0;
      ray rand_ray;
      ray opposite_rand_ray;
      hitdata hitobject;
      for (int i=0; i<numSamples; i++)
	{
	  do {
	    ndx++;
	    if (ndx >= accessAnalysis.accessInfo.size())
	      {
		ndx = 0;
	      }
	  } while(accessAnalysis.accessInfo[ndx] != true);
	  rand_ray.base = nodes[ndx].center;  
	  rand_ray.vector = genRandomVec();
	  
	  opposite_rand_ray.base = rand_ray.base;
	  opposite_rand_ray.vector  = rand_ray.vector.scale(-1);
	  
	  rayTraceToSphere(cell,atoms,rand_ray,faces,hitobject);
	  rand_ray.vector = rand_ray.vector.scale(hitobject.dist);
	  
	  hitobject.dist = 0.0;
	  hitobject.hit = false;
	  hitobject.object = NULL;
	  hitobject.id = -1;
	  hitobject.hitpoint = Point(0,0,0);
	  
	  //Test negative of ray
	  rayTraceToSphere(cell,atoms,opposite_rand_ray,faces,hitobject);
	  opposite_rand_ray.vector = opposite_rand_ray.vector.scale(hitobject.dist);
	  
	  rand_ray.base = rand_ray.base + opposite_rand_ray.vector;
	  rand_ray.vector = rand_ray.vector - opposite_rand_ray.vector;
	  
	  axsray.push_back(rand_ray);
	  
	  hitobject.dist = 0.0;
	  hitobject.hit = false;
	  hitobject.object = NULL;
	  hitobject.id = -1;
	  hitobject.hitpoint = Point(0,0,0);
	}
    }

  
  //Does not require to be found out if point is accessible
  if (option.compare("sphere") == 0)
    {
      cout << "Sphere Implementation Chosen: " << endl;
      cout << "Number of Samples: " << numSamples << endl;
      ray rand_ray;
      ray opposite_rand_ray;
      hitdata hitobject;
      for (int i=0; i<numSamples; i++)
	{
	  rand_ray.base =  cell->abc_to_xyz(genRandomPoint());
	  rand_ray.vector = genRandomVec();
	  opposite_rand_ray.base = rand_ray.base;
	  opposite_rand_ray.vector  = rand_ray.vector.scale(-1);
	      
	  rayTraceInsideSphere(cell,nodes,rand_ray,hitobject);
	  
	  if (hitobject.hit == false)
	    {
	      rand_ray.vector = Point(0,0,0);
	      inaxsray.push_back(rand_ray);
	    }
	  else
	    { //It was traveling within a sphere    
	      rand_ray.vector = rand_ray.vector.scale(hitobject.dist);

              hitobject.dist = 0.0;
              hitobject.hit = false;
	      hitobject.id = -1;
	      hitobject.object = NULL;
	      hitobject.hitpoint = Point(0,0,0);

	      rayTraceInsideSphere(cell,nodes,opposite_rand_ray,hitobject);
	      opposite_rand_ray.vector = opposite_rand_ray.vector.scale(hitobject.dist);

	      rand_ray.base = rand_ray.base + opposite_rand_ray.vector;
	      rand_ray.vector = rand_ray.vector - opposite_rand_ray.vector;

	      axsray.push_back(rand_ray);

	      hitobject.dist = 0.0;
              hitobject.hit = false;
	      hitobject.object = NULL;
	      hitobject.id = -1;
	      hitobject.hitpoint = Point(0,0,0);
	    }
	}
    }
  
  //Does not require to be found out if point is accessible
  if (option.compare("andrew_sphere") == 0)
    {
      cout << "Andrew's Sphere Implementation Chosen: " << endl;
      cout << "Number of Samples: " << numSamples << endl;
      ray rand_ray;
      ray opposite_rand_ray;
      ray init_ray;
      ray opposite_init_ray;
      double distance = 0.0;
      hitdata hitobject;
      bool inside_node = true;
      for (int i=0; i<numSamples; i++)
	{
	  distance = 0.0;
	  
	  rand_ray.base =  cell->abc_to_xyz(genRandomPoint());
	  rand_ray.vector = genRandomVec();
	  
	  //Ray in the opposite direction
	  opposite_rand_ray.base = rand_ray.base;
	  opposite_rand_ray.vector  = rand_ray.vector.scale(-1);
	  
	  //For this implementation I need a reference to the original ray
	  init_ray = rand_ray;
	  opposite_init_ray = opposite_rand_ray;
	  
	  if (findSphereOfPoint(rand_ray.base,nodes,hitobject.id) == false)
	    {
	      inside_node = false; //Point is not within a node
	    }
	  
	  while(distance < MAXRAYDIST) //Iterate Ray untill it reaches max distance
	    {	      
	      if (inside_node == false)
		{
		  rayTraceToSphere(cell,nodes,rand_ray,faces,hitobject);
		  
		  rand_ray.vector = rand_ray.vector.scale(hitobject.dist);
		  rand_ray.base = init_ray.base + init_ray.vector.scale(distance);
		  inaxsray.push_back(rand_ray);
		  
		  //Update Total Info
		  distance += hitobject.dist;
		  rand_ray.vector = init_ray.vector;
		  rand_ray.base = cell->shiftXYZInUC(hitobject.hitpoint+rand_ray.vector.scale(threshold));
		  
		  hitobject.dist = 0.0;
		  hitobject.hit = false;
		  hitobject.hitpoint = Point(0,0,0); 
		  hitobject.id = -1;
		  hitobject.object = NULL;
		  
		  inside_node = true; //Now inside node
		}
	      else
		{ //Shoot Through Nodes    
		  rayTraceInsideSphere(cell,nodes,rand_ray,hitobject);
		  
		  rand_ray.vector = rand_ray.vector.scale(hitobject.dist);
		  rand_ray.base = init_ray.base + init_ray.vector.scale(distance);
		  axsray.push_back(rand_ray);
		  
		  //Update Total Info
		  distance += hitobject.dist;
		  rand_ray.vector = init_ray.vector;
		  rand_ray.base = cell->shiftXYZInUC(hitobject.hitpoint+rand_ray.vector.scale(threshold));
		  
		  hitobject.dist = 0.0;
		  hitobject.hit = false;
		  hitobject.hitpoint = Point(0,0,0);  
		  //Notice that I am not resetting hitobject.id and setting object
		  hitobject.object = &(nodes[hitobject.id]);
		  
		  inside_node = false; //Now outside of nodes
		}
	    }	  
	}
      cout << "Ray Andrew Sphere Implementation Completed:" << endl;
    }
  
  
  //Does not require to be found out if point is accessible
  if (option.compare("andrew_atom") == 0)
    {
      cout << "Andrew's Atom Implementation Chosen: " << endl;
      cout << "Number of Samples: " << numSamples << endl;
      ray rand_ray;
      ray opposite_rand_ray;
      ray init_ray;
      ray opposite_init_ray;
      double distance = 0.0;
      hitdata hitobject;
      bool inside_atom = false;
      bool inside_accessible_region;
      for (int i=0; i<numSamples; i++)
	{
	  distance = 0.0;
	  
	  rand_ray.base =  cell->abc_to_xyz(genRandomPoint());
	  rand_ray.vector = genRandomVec();
	  
	  //Ray in the opposite direction
	  opposite_rand_ray.base = rand_ray.base;
	  opposite_rand_ray.vector  = rand_ray.vector.scale(-1);
	  
	  //For this implementation I need a reference to the original ray
	  init_ray = rand_ray;
	  opposite_init_ray = opposite_rand_ray;
	  
	  if ((findSphereOfPoint(rand_ray.base,atoms,hitobject.id) == true))
	    {
	      inside_atom = true; //Point is within an atom
	    }
	  else //Point is not within an atom
	    {
	      inside_atom = false;
	    }
	  inside_accessible_region = accessAnalysis.isVPointAccessible(rand_ray.base);
	  
	  while(distance < MAXRAYDIST) //Iterate Ray untill it reaches max distance
	    {	      
	      if ((inside_atom == false) && (inside_accessible_region == true))
		{
		  rayTraceToSphere(cell,atoms,rand_ray,faces,hitobject);
		  
		  rand_ray.vector = rand_ray.vector.scale(hitobject.dist);
		  //rand_ray.base = init_ray.base + init_ray.vector.scale(distance);
		  axsray.push_back(rand_ray);
		  
		  //Update Total Info
		  distance += hitobject.dist;
		  rand_ray.vector = init_ray.vector;
		  rand_ray.base = cell->shiftXYZInUC(hitobject.hitpoint+rand_ray.vector.scale(threshold));
		  //Reset all hitobject data
		  hitobject.dist = 0.0;
		  hitobject.hit = false;
		  hitobject.hitpoint = Point(0,0,0); 
		  hitobject.id = -1;
		  hitobject.object = NULL;
		  
		  inside_atom = true; //Now inside atom
		}
	      else if ((inside_atom == false) && (inside_accessible_region == false))
		{ //not within an atom but in inaccessible region
		  rayTraceToSphere(cell,atoms,rand_ray,faces,hitobject);
		  
		  rand_ray.vector = rand_ray.vector.scale(hitobject.dist);
		  //rand_ray.base = init_ray.base + init_ray.vector.scale(distance);
		  inaxsray.push_back(rand_ray);
		  
		  //Update Total Info
		  distance += hitobject.dist;
		  rand_ray.vector = init_ray.vector;
		  rand_ray.base = cell->shiftXYZInUC(hitobject.hitpoint+init_ray.vector.scale(threshold));
		  //Reset all hitobject data
		  hitobject.dist = 0.0;
		  hitobject.hit = false;
		  hitobject.hitpoint = Point(0,0,0); 
		  hitobject.object = NULL;
		  hitobject.id = -1;
		  
		  inside_atom = true; //Now inside atom
		}
	      else // Ray is inside of atoms
		{    
		  rayTraceInsideSphere(cell,atoms,rand_ray,hitobject);
		  		  
		  rand_ray.vector = rand_ray.vector.scale(hitobject.dist);
		  //rand_ray.base = init_ray.base + init_ray.vector.scale(distance);
		  //This is where I would push data on traveling through atoms  
		  //but it is not here yet
   
		  //Update Total Info
		  distance += hitobject.dist;
		  rand_ray.vector = init_ray.vector;
		  rand_ray.base = cell->shiftXYZInUC(hitobject.hitpoint+init_ray.vector.scale(threshold));
		 
		  //Reset all hitobject data besides the last object id hit
		  hitobject.dist = 0.0;
		  hitobject.hit = false;
		  hitobject.hitpoint = Point(0,0,0);  
		  //Notice that I am not resetting hitobject.id and setting object
		  hitobject.object = &(nodes[hitobject.id]);
		  
		  //So at this point I know that I am outside an atom however am
		  //I in an accesible region or not?
		  inside_atom = false; //Now outside of atoms and in accessible region
		  inside_accessible_region = accessAnalysis.isVPointAccessible(rand_ray.base);
		}
	    }	  
	}
      cout << "Ray Andrew Atom Implementation Completed:" << endl;
    }
  
  
  //Post Process Information
  if(visualize)
    {
      reportRays(output, axsray, inaxsray, true);
      //reportAtoms(output,atoms);
      //reportNodes(output,nodes);
    }
  else //no visulization then output a histogram
    {
      //This parameter can be changed in network.h
      reportHistogram(output,BINSIZE,MAXBINS,axsray);
    }
  reportRayInfo(axsray); // A more detailed output of ray info from program

  //FREE MEMORY
  accessAnalysis.deconstruct();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1aa0, %rsp           # imm = 0x1AA0
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %r9, -0x1908(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %dl
movb %dl, -0x11(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd %xmm1, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x11(%rbp)
je 0x8e2ed
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x8e2f5
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0xa88(%rbp), %rdi
callq 0x84640
testb $0x1, -0x11(%rbp)
je 0x8e347
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movzbl -0x11(%rbp), %ecx
andl $0x1, %ecx
leaq -0xa88(%rbp), %rdi
callq 0xfd200
jmp 0x8e32e
jmp 0x8e36f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa90(%rbp)
movl %eax, -0xa94(%rbp)
jmp 0x907e9
movq -0x8(%rbp), %rdx
movsd -0x20(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movzbl -0x11(%rbp), %ecx
andl $0x1, %ecx
leaq -0xa88(%rbp), %rdi
movq %rdx, %rsi
callq 0xfd200
jmp 0x8e36d
jmp 0x8e36f
movl $0x3b4ca6f5, %edi       # imm = 0x3B4CA6F5
callq 0x5510
leaq -0xab0(%rbp), %rdi
movq %rdi, -0x1910(%rbp)
callq 0x91e60
movq -0x1910(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x8d540
jmp 0x8e39e
leaq -0xac8(%rbp), %rdi
movq %rdi, -0x1918(%rbp)
callq 0x91e60
movq -0x1918(%rbp), %rsi
leaq -0x1c0(%rbp), %rdi
leaq -0xf8(%rbp), %rdx
callq 0x8d3b0
jmp 0x8e3cd
leaq -0xae0(%rbp), %rdi
movq %rdi, -0x1920(%rbp)
callq 0x91e80
movq -0x1920(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x8c8f0
jmp 0x8e3f2
movq -0x48(%rbp), %rdi
leaq -0xab0(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
callq 0x8cd70
jmp 0x8e40b
movq -0x48(%rbp), %rdi
leaq -0xac8(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
callq 0x8cd70
jmp 0x8e424
leaq -0xaf8(%rbp), %rdi
callq 0x91ea0
leaq -0xb10(%rbp), %rdi
callq 0x91ea0
leaq -0xb28(%rbp), %rdi
callq 0x91ea0
movq 0x1e4b71(%rip), %rdi    # 0x272fc0
leaq 0x169156(%rip), %rsi    # 0x1f75ac
callq 0x5540
movq %rax, -0x1928(%rbp)
jmp 0x8e464
movq -0x1928(%rbp), %rdi
movq 0x1e4b26(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8e479
movq -0x1908(%rbp), %rdi
leaq 0x170dfc(%rip), %rsi    # 0x1ff283
callq 0x51b0
cmpl $0x0, %eax
jne 0x8ea6f
movq 0x1e4b24(%rip), %rdi    # 0x272fc0
leaq 0x1691b4(%rip), %rsi    # 0x1f7657
callq 0x5540
movq %rax, -0x1930(%rbp)
jmp 0x8e4b1
movq -0x1930(%rbp), %rdi
movq 0x1e4ad9(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8e4c6
movq 0x1e4af3(%rip), %rdi    # 0x272fc0
leaq 0x1690f5(%rip), %rsi    # 0x1f75c9
callq 0x5540
movq %rax, -0x1938(%rbp)
jmp 0x8e4e2
movq -0x1938(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x58d0
movq %rax, -0x1940(%rbp)
jmp 0x8e4fa
movq -0x1940(%rbp), %rdi
movq 0x1e4a90(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8e50f
leaq -0xb60(%rbp), %rdi
callq 0x91ec0
jmp 0x8e51d
leaq -0xb90(%rbp), %rdi
callq 0x91ec0
jmp 0x8e52b
leaq -0xbc8(%rbp), %rdi
callq 0x91b70
jmp 0x8e539
movl $0x0, -0xbcc(%rbp)
movl -0xbcc(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x8ea6d
movq -0x48(%rbp), %rax
movq %rax, -0x1948(%rbp)
leaq -0xc00(%rbp), %rdi
callq 0x8d940
jmp 0x8e56b
movq -0x1948(%rbp), %rsi
movq -0xbf0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0xc00(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xbe8(%rbp), %rdi
callq 0x961d0
jmp 0x8e598
movq -0xbd8(%rbp), %rax
movq %rax, -0xb50(%rbp)
movups -0xbe8(%rbp), %xmm0
movaps %xmm0, -0xb60(%rbp)
leaq -0xc18(%rbp), %rdi
callq 0x8d7c0
jmp 0x8e5c2
movq -0xc08(%rbp), %rax
movq %rax, -0xb38(%rbp)
movups -0xc18(%rbp), %xmm0
movups %xmm0, -0xb48(%rbp)
movq -0xb50(%rbp), %rax
movq %rax, -0xc30(%rbp)
movaps -0xb60(%rbp), %xmm0
movaps %xmm0, -0xc40(%rbp)
movq -0xc30(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0xc40(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xa88(%rbp), %rdi
callq 0xfe7d0
movb %al, -0x1949(%rbp)
jmp 0x8e626
movb -0x1949(%rbp), %al
andb $0x1, %al
movb %al, -0xc19(%rbp)
movb -0xc19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8e715
leaq -0xc58(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8e65f
movq -0xc48(%rbp), %rax
movq %rax, -0xb38(%rbp)
movups -0xc58(%rbp), %xmm0
movups %xmm0, -0xb48(%rbp)
leaq -0xb10(%rbp), %rdi
leaq -0xb60(%rbp), %rsi
callq 0x91f00
jmp 0x8e690
jmp 0x8ea57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa90(%rbp)
movl %eax, -0xa94(%rbp)
jmp 0x907dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa90(%rbp)
movl %eax, -0xa94(%rbp)
jmp 0x907d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa90(%rbp)
movl %eax, -0xa94(%rbp)
jmp 0x907c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa90(%rbp)
movl %eax, -0xa94(%rbp)
leaq -0xb28(%rbp), %rdi
callq 0x91f70
leaq -0xb10(%rbp), %rdi
callq 0x91f70
leaq -0xaf8(%rbp), %rdi
callq 0x91f70
jmp 0x907c5
movq -0xb50(%rbp), %rax
movq %rax, -0xb80(%rbp)
movaps -0xb60(%rbp), %xmm0
movaps %xmm0, -0xb90(%rbp)
leaq -0xb48(%rbp), %rsi
leaq -0xc70(%rbp), %rdi
movsd 0x164031(%rip), %xmm0   # 0x1f2778
callq 0xea000
jmp 0x8e74e
movq -0xc60(%rbp), %rax
movq %rax, -0xb68(%rbp)
movups -0xc70(%rbp), %xmm0
movups %xmm0, -0xb78(%rbp)
movq -0x48(%rbp), %rdi
movaps -0xb60(%rbp), %xmm0
movaps -0xb50(%rbp), %xmm1
movaps -0xb40(%rbp), %xmm2
movaps %xmm2, -0xc80(%rbp)
movaps %xmm1, -0xc90(%rbp)
movaps %xmm0, -0xca0(%rbp)
movaps -0xca0(%rbp), %xmm0
movaps -0xc90(%rbp), %xmm1
movaps -0xc80(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xab0(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
leaq -0xbc8(%rbp), %rcx
callq 0x8e000
jmp 0x8e7d7
leaq -0xb48(%rbp), %rsi
movsd -0xba8(%rbp), %xmm0
leaq -0xcb8(%rbp), %rdi
callq 0xea000
jmp 0x8e7f4
movq -0xca8(%rbp), %rax
movq %rax, -0xb38(%rbp)
movups -0xcb8(%rbp), %xmm0
movups %xmm0, -0xb48(%rbp)
movq $0x0, -0xba8(%rbp)
movb $0x0, -0xbc8(%rbp)
movq $0x0, -0xb98(%rbp)
movl $0xffffffff, -0xba0(%rbp) # imm = 0xFFFFFFFF
leaq -0xcd0(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8e84e
movq -0xcc0(%rbp), %rax
movq %rax, -0xbb0(%rbp)
movups -0xcd0(%rbp), %xmm0
movups %xmm0, -0xbc0(%rbp)
movq -0x48(%rbp), %rdi
movaps -0xb90(%rbp), %xmm0
movaps -0xb80(%rbp), %xmm1
movaps -0xb70(%rbp), %xmm2
movaps %xmm2, -0xce0(%rbp)
movaps %xmm1, -0xcf0(%rbp)
movaps %xmm0, -0xd00(%rbp)
movaps -0xd00(%rbp), %xmm0
movaps -0xcf0(%rbp), %xmm1
movaps -0xce0(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xab0(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
leaq -0xbc8(%rbp), %rcx
callq 0x8e000
jmp 0x8e8d7
leaq -0xb78(%rbp), %rsi
movsd -0xba8(%rbp), %xmm0
leaq -0xd18(%rbp), %rdi
callq 0xea000
jmp 0x8e8f4
movq -0xd08(%rbp), %rax
movq %rax, -0xb68(%rbp)
movups -0xd18(%rbp), %xmm0
movups %xmm0, -0xb78(%rbp)
movq -0xb68(%rbp), %rax
movq %rax, -0xd40(%rbp)
movups -0xb78(%rbp), %xmm0
movaps %xmm0, -0xd50(%rbp)
movq -0xd40(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0xd50(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xd30(%rbp), %rdi
leaq -0xb60(%rbp), %rsi
callq 0xea420
jmp 0x8e959
movq -0xd20(%rbp), %rax
movq %rax, -0xb50(%rbp)
movups -0xd30(%rbp), %xmm0
movaps %xmm0, -0xb60(%rbp)
leaq -0xb48(%rbp), %rsi
movq -0xb68(%rbp), %rax
movq %rax, -0xd70(%rbp)
movups -0xb78(%rbp), %xmm0
movaps %xmm0, -0xd80(%rbp)
movq -0xd70(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0xd80(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xd68(%rbp), %rdi
callq 0xea360
jmp 0x8e9be
movq -0xd58(%rbp), %rax
movq %rax, -0xb38(%rbp)
movups -0xd68(%rbp), %xmm0
movups %xmm0, -0xb48(%rbp)
leaq -0xaf8(%rbp), %rdi
leaq -0xb60(%rbp), %rsi
callq 0x91f00
jmp 0x8e9ef
movq $0x0, -0xba8(%rbp)
movb $0x0, -0xbc8(%rbp)
movq $0x0, -0xb98(%rbp)
movl $0xffffffff, -0xba0(%rbp) # imm = 0xFFFFFFFF
leaq -0xd98(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8ea2d
movq -0xd98(%rbp), %rax
movq %rax, -0xbc0(%rbp)
movq -0xd90(%rbp), %rax
movq %rax, -0xbb8(%rbp)
movq -0xd88(%rbp), %rax
movq %rax, -0xbb0(%rbp)
jmp 0x8ea59
movl -0xbcc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xbcc(%rbp)
jmp 0x8e543
jmp 0x8ea6f
movq -0x1908(%rbp), %rdi
leaq 0x16e7f4(%rip), %rsi    # 0x1fd271
callq 0x51b0
cmpl $0x0, %eax
jne 0x8efa2
movq 0x1e452e(%rip), %rdi    # 0x272fc0
leaq 0x168b44(%rip), %rsi    # 0x1f75dd
callq 0x5540
movq %rax, -0x1958(%rbp)
jmp 0x8eaa7
movq -0x1958(%rbp), %rdi
movq 0x1e44e3(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8eabc
movq 0x1e44fd(%rip), %rdi    # 0x272fc0
leaq 0x168aff(%rip), %rsi    # 0x1f75c9
callq 0x5540
movq %rax, -0x1960(%rbp)
jmp 0x8ead8
movq -0x1960(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x58d0
movq %rax, -0x1968(%rbp)
jmp 0x8eaf0
movq -0x1968(%rbp), %rdi
movq 0x1e449a(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8eb05
movl $0x0, -0xd9c(%rbp)
leaq -0xdd0(%rbp), %rdi
callq 0x91ec0
jmp 0x8eb1d
leaq -0xe00(%rbp), %rdi
callq 0x91ec0
jmp 0x8eb2b
leaq -0xe38(%rbp), %rdi
callq 0x91b70
jmp 0x8eb39
movl $0x0, -0xe3c(%rbp)
movl -0xe3c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x8efa0
jmp 0x8eb54
movl -0xd9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xd9c(%rbp)
movslq -0xd9c(%rbp), %rax
movq %rax, -0x1970(%rbp)
leaq -0xa88(%rbp), %rdi
addq $0x990, %rdi            # imm = 0x990
callq 0x27d50
movq %rax, %rcx
movq -0x1970(%rbp), %rax
cmpq %rcx, %rax
jb 0x8eb9d
movl $0x0, -0xd9c(%rbp)
jmp 0x8eb9f
leaq -0xf8(%rbp), %rdi
movslq -0xd9c(%rbp), %rsi
callq 0x29990
movq %rdx, -0x1980(%rbp)
movq %rax, -0x1978(%rbp)
jmp 0x8ebc2
movq -0x1980(%rbp), %rax
movq -0x1978(%rbp), %rcx
movq %rcx, -0xe50(%rbp)
movq %rax, -0xe48(%rbp)
leaq -0xe50(%rbp), %rdi
callq 0x101a0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x8eb54
movslq -0xd9c(%rbp), %rsi
leaq -0xac8(%rbp), %rdi
callq 0x91c10
movq 0x10(%rax), %rcx
movq %rcx, -0xdc0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0xdd0(%rbp)
leaq -0xe68(%rbp), %rdi
callq 0x8d7c0
jmp 0x8ec2e
leaq -0xdb8(%rbp), %rsi
movq -0xe58(%rbp), %rax
movq %rax, -0xda8(%rbp)
movups -0xe68(%rbp), %xmm0
movups %xmm0, -0xdb8(%rbp)
movq -0xdc0(%rbp), %rax
movq %rax, -0xdf0(%rbp)
movaps -0xdd0(%rbp), %xmm0
movaps %xmm0, -0xe00(%rbp)
leaq -0xe80(%rbp), %rdi
movsd 0x163afc(%rip), %xmm0   # 0x1f2778
callq 0xea000
jmp 0x8ec83
movq -0xe70(%rbp), %rax
movq %rax, -0xdd8(%rbp)
movups -0xe80(%rbp), %xmm0
movups %xmm0, -0xde8(%rbp)
movq -0x48(%rbp), %rdi
movaps -0xdd0(%rbp), %xmm0
movaps -0xdc0(%rbp), %xmm1
movaps -0xdb0(%rbp), %xmm2
movaps %xmm2, -0xe90(%rbp)
movaps %xmm1, -0xea0(%rbp)
movaps %xmm0, -0xeb0(%rbp)
movaps -0xeb0(%rbp), %xmm0
movaps -0xea0(%rbp), %xmm1
movaps -0xe90(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xab0(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
leaq -0xe38(%rbp), %rcx
callq 0x8e000
jmp 0x8ed0c
leaq -0xdb8(%rbp), %rsi
movsd -0xe18(%rbp), %xmm0
leaq -0xec8(%rbp), %rdi
callq 0xea000
jmp 0x8ed29
movq -0xeb8(%rbp), %rax
movq %rax, -0xda8(%rbp)
movups -0xec8(%rbp), %xmm0
movups %xmm0, -0xdb8(%rbp)
movq $0x0, -0xe18(%rbp)
movb $0x0, -0xe38(%rbp)
movq $0x0, -0xe08(%rbp)
movl $0xffffffff, -0xe10(%rbp) # imm = 0xFFFFFFFF
leaq -0xee0(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8ed83
movq -0xed0(%rbp), %rax
movq %rax, -0xe20(%rbp)
movups -0xee0(%rbp), %xmm0
movups %xmm0, -0xe30(%rbp)
movq -0x48(%rbp), %rdi
movaps -0xe00(%rbp), %xmm0
movaps -0xdf0(%rbp), %xmm1
movaps -0xde0(%rbp), %xmm2
movaps %xmm2, -0xef0(%rbp)
movaps %xmm1, -0xf00(%rbp)
movaps %xmm0, -0xf10(%rbp)
movaps -0xf10(%rbp), %xmm0
movaps -0xf00(%rbp), %xmm1
movaps -0xef0(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xab0(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
leaq -0xe38(%rbp), %rcx
callq 0x8e000
jmp 0x8ee0c
leaq -0xde8(%rbp), %rsi
movsd -0xe18(%rbp), %xmm0
leaq -0xf28(%rbp), %rdi
callq 0xea000
jmp 0x8ee29
movq -0xf18(%rbp), %rax
movq %rax, -0xdd8(%rbp)
movups -0xf28(%rbp), %xmm0
movups %xmm0, -0xde8(%rbp)
movq -0xdd8(%rbp), %rax
movq %rax, -0xf50(%rbp)
movups -0xde8(%rbp), %xmm0
movaps %xmm0, -0xf60(%rbp)
movq -0xf50(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0xf60(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xf40(%rbp), %rdi
leaq -0xdd0(%rbp), %rsi
callq 0xea420
jmp 0x8ee8e
movq -0xf30(%rbp), %rax
movq %rax, -0xdc0(%rbp)
movups -0xf40(%rbp), %xmm0
movaps %xmm0, -0xdd0(%rbp)
leaq -0xdb8(%rbp), %rsi
movq -0xdd8(%rbp), %rax
movq %rax, -0xf80(%rbp)
movups -0xde8(%rbp), %xmm0
movaps %xmm0, -0xf90(%rbp)
movq -0xf80(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0xf90(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xf78(%rbp), %rdi
callq 0xea360
jmp 0x8eef3
movq -0xf68(%rbp), %rax
movq %rax, -0xda8(%rbp)
movups -0xf78(%rbp), %xmm0
movups %xmm0, -0xdb8(%rbp)
leaq -0xaf8(%rbp), %rdi
leaq -0xdd0(%rbp), %rsi
callq 0x91f00
jmp 0x8ef24
movq $0x0, -0xe18(%rbp)
movb $0x0, -0xe38(%rbp)
movq $0x0, -0xe08(%rbp)
movl $0xffffffff, -0xe10(%rbp) # imm = 0xFFFFFFFF
leaq -0xfa8(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8ef62
movq -0xfa8(%rbp), %rax
movq %rax, -0xe30(%rbp)
movq -0xfa0(%rbp), %rax
movq %rax, -0xe28(%rbp)
movq -0xf98(%rbp), %rax
movq %rax, -0xe20(%rbp)
movl -0xe3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe3c(%rbp)
jmp 0x8eb43
jmp 0x8efa2
movq -0x1908(%rbp), %rdi
leaq 0x17a66d(%rip), %rsi    # 0x20961d
callq 0x51b0
cmpl $0x0, %eax
jne 0x8f4b0
movq 0x1e3ffb(%rip), %rdi    # 0x272fc0
leaq 0x168637(%rip), %rsi    # 0x1f7603
callq 0x5540
movq %rax, -0x1988(%rbp)
jmp 0x8efda
movq -0x1988(%rbp), %rdi
movq 0x1e3fb0(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8efef
movq 0x1e3fca(%rip), %rdi    # 0x272fc0
leaq 0x1685cc(%rip), %rsi    # 0x1f75c9
callq 0x5540
movq %rax, -0x1990(%rbp)
jmp 0x8f00b
movq -0x1990(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x58d0
movq %rax, -0x1998(%rbp)
jmp 0x8f023
movq -0x1998(%rbp), %rdi
movq 0x1e3f67(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8f038
leaq -0xfe0(%rbp), %rdi
callq 0x91ec0
jmp 0x8f046
leaq -0x1010(%rbp), %rdi
callq 0x91ec0
jmp 0x8f054
leaq -0x1048(%rbp), %rdi
callq 0x91b70
jmp 0x8f062
movl $0x0, -0x104c(%rbp)
movl -0x104c(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x8f4ae
movq -0x48(%rbp), %rax
movq %rax, -0x19a0(%rbp)
leaq -0x1080(%rbp), %rdi
callq 0x8d940
jmp 0x8f094
movq -0x19a0(%rbp), %rsi
movq -0x1070(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1080(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1068(%rbp), %rdi
callq 0x961d0
jmp 0x8f0c1
movq -0x1058(%rbp), %rax
movq %rax, -0xfd0(%rbp)
movups -0x1068(%rbp), %xmm0
movaps %xmm0, -0xfe0(%rbp)
leaq -0x1098(%rbp), %rdi
callq 0x8d7c0
jmp 0x8f0eb
leaq -0xfc8(%rbp), %rsi
movq -0x1088(%rbp), %rax
movq %rax, -0xfb8(%rbp)
movups -0x1098(%rbp), %xmm0
movups %xmm0, -0xfc8(%rbp)
movq -0xfd0(%rbp), %rax
movq %rax, -0x1000(%rbp)
movaps -0xfe0(%rbp), %xmm0
movaps %xmm0, -0x1010(%rbp)
leaq -0x10b0(%rbp), %rdi
movsd 0x16363f(%rip), %xmm0   # 0x1f2778
callq 0xea000
jmp 0x8f140
movq -0x10a0(%rbp), %rax
movq %rax, -0xfe8(%rbp)
movups -0x10b0(%rbp), %xmm0
movups %xmm0, -0xff8(%rbp)
movq -0x48(%rbp), %rdi
movaps -0xfe0(%rbp), %xmm0
movaps -0xfd0(%rbp), %xmm1
movaps -0xfc0(%rbp), %xmm2
movaps %xmm2, -0x10c0(%rbp)
movaps %xmm1, -0x10d0(%rbp)
movaps %xmm0, -0x10e0(%rbp)
movaps -0x10e0(%rbp), %xmm0
movaps -0x10d0(%rbp), %xmm1
movaps -0x10c0(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xac8(%rbp), %rsi
leaq -0x1048(%rbp), %rdx
callq 0x8d9f0
jmp 0x8f1c2
movb -0x1048(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8f21f
leaq -0x10f8(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8f1e9
movq -0x10e8(%rbp), %rax
movq %rax, -0xfb8(%rbp)
movups -0x10f8(%rbp), %xmm0
movups %xmm0, -0xfc8(%rbp)
leaq -0xb10(%rbp), %rdi
leaq -0xfe0(%rbp), %rsi
callq 0x91f00
jmp 0x8f21a
jmp 0x8f498
leaq -0xfc8(%rbp), %rsi
movsd -0x1028(%rbp), %xmm0
leaq -0x1110(%rbp), %rdi
callq 0xea000
jmp 0x8f23c
movq -0x1100(%rbp), %rax
movq %rax, -0xfb8(%rbp)
movups -0x1110(%rbp), %xmm0
movups %xmm0, -0xfc8(%rbp)
movq $0x0, -0x1028(%rbp)
movb $0x0, -0x1048(%rbp)
movl $0xffffffff, -0x1020(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x1018(%rbp)
leaq -0x1128(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8f296
movq -0x1118(%rbp), %rax
movq %rax, -0x1030(%rbp)
movups -0x1128(%rbp), %xmm0
movups %xmm0, -0x1040(%rbp)
movq -0x48(%rbp), %rdi
movaps -0x1010(%rbp), %xmm0
movaps -0x1000(%rbp), %xmm1
movaps -0xff0(%rbp), %xmm2
movaps %xmm2, -0x1140(%rbp)
movaps %xmm1, -0x1150(%rbp)
movaps %xmm0, -0x1160(%rbp)
movaps -0x1160(%rbp), %xmm0
movaps -0x1150(%rbp), %xmm1
movaps -0x1140(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xac8(%rbp), %rsi
leaq -0x1048(%rbp), %rdx
callq 0x8d9f0
jmp 0x8f318
leaq -0xff8(%rbp), %rsi
movsd -0x1028(%rbp), %xmm0
leaq -0x1178(%rbp), %rdi
callq 0xea000
jmp 0x8f335
movq -0x1168(%rbp), %rax
movq %rax, -0xfe8(%rbp)
movups -0x1178(%rbp), %xmm0
movups %xmm0, -0xff8(%rbp)
movq -0xfe8(%rbp), %rax
movq %rax, -0x11a0(%rbp)
movups -0xff8(%rbp), %xmm0
movaps %xmm0, -0x11b0(%rbp)
movq -0x11a0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x11b0(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1190(%rbp), %rdi
leaq -0xfe0(%rbp), %rsi
callq 0xea420
jmp 0x8f39a
movq -0x1180(%rbp), %rax
movq %rax, -0xfd0(%rbp)
movups -0x1190(%rbp), %xmm0
movaps %xmm0, -0xfe0(%rbp)
leaq -0xfc8(%rbp), %rsi
movq -0xfe8(%rbp), %rax
movq %rax, -0x11d0(%rbp)
movups -0xff8(%rbp), %xmm0
movaps %xmm0, -0x11e0(%rbp)
movq -0x11d0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x11e0(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x11c8(%rbp), %rdi
callq 0xea360
jmp 0x8f3ff
movq -0x11b8(%rbp), %rax
movq %rax, -0xfb8(%rbp)
movups -0x11c8(%rbp), %xmm0
movups %xmm0, -0xfc8(%rbp)
leaq -0xaf8(%rbp), %rdi
leaq -0xfe0(%rbp), %rsi
callq 0x91f00
jmp 0x8f430
movq $0x0, -0x1028(%rbp)
movb $0x0, -0x1048(%rbp)
movq $0x0, -0x1018(%rbp)
movl $0xffffffff, -0x1020(%rbp) # imm = 0xFFFFFFFF
leaq -0x11f8(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8f46e
movq -0x11f8(%rbp), %rax
movq %rax, -0x1040(%rbp)
movq -0x11f0(%rbp), %rax
movq %rax, -0x1038(%rbp)
movq -0x11e8(%rbp), %rax
movq %rax, -0x1030(%rbp)
jmp 0x8f49a
movl -0x104c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x104c(%rbp)
jmp 0x8f06c
jmp 0x8f4b0
movq -0x1908(%rbp), %rdi
leaq 0x17a158(%rip), %rsi    # 0x209616
callq 0x51b0
cmpl $0x0, %eax
jne 0x8fcde
movq 0x1e3aed(%rip), %rdi    # 0x272fc0
leaq 0x168120(%rip), %rsi    # 0x1f75fa
callq 0x5540
movq %rax, -0x19a8(%rbp)
jmp 0x8f4e8
movq -0x19a8(%rbp), %rdi
movq 0x1e3aa2(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8f4fd
movq 0x1e3abc(%rip), %rdi    # 0x272fc0
leaq 0x1680be(%rip), %rsi    # 0x1f75c9
callq 0x5540
movq %rax, -0x19b0(%rbp)
jmp 0x8f519
movq -0x19b0(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x58d0
movq %rax, -0x19b8(%rbp)
jmp 0x8f531
movq -0x19b8(%rbp), %rdi
movq 0x1e3a59(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8f546
leaq -0x1230(%rbp), %rdi
callq 0x91ec0
jmp 0x8f554
leaq -0x1260(%rbp), %rdi
callq 0x91ec0
jmp 0x8f562
leaq -0x1290(%rbp), %rdi
callq 0x91ec0
jmp 0x8f570
leaq -0x12c0(%rbp), %rdi
callq 0x91ec0
jmp 0x8f57e
movq $0x0, -0x12c8(%rbp)
leaq -0x1300(%rbp), %rdi
callq 0x91b70
jmp 0x8f597
movb $0x1, -0x1301(%rbp)
movl $0x0, -0x1308(%rbp)
movl -0x1308(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x8fcab
movq $0x0, -0x12c8(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x19c0(%rbp)
leaq -0x1338(%rbp), %rdi
callq 0x8d940
jmp 0x8f5db
movq -0x19c0(%rbp), %rsi
movq -0x1328(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1338(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1320(%rbp), %rdi
callq 0x961d0
jmp 0x8f608
movq -0x1310(%rbp), %rax
movq %rax, -0x1220(%rbp)
movups -0x1320(%rbp), %xmm0
movaps %xmm0, -0x1230(%rbp)
leaq -0x1350(%rbp), %rdi
callq 0x8d7c0
jmp 0x8f632
leaq -0x1218(%rbp), %rsi
movq -0x1340(%rbp), %rax
movq %rax, -0x1208(%rbp)
movups -0x1350(%rbp), %xmm0
movups %xmm0, -0x1218(%rbp)
movq -0x1220(%rbp), %rax
movq %rax, -0x1250(%rbp)
movaps -0x1230(%rbp), %xmm0
movaps %xmm0, -0x1260(%rbp)
leaq -0x1368(%rbp), %rdi
movsd 0x1630f8(%rip), %xmm0   # 0x1f2778
callq 0xea000
jmp 0x8f687
movq -0x1358(%rbp), %rax
movq %rax, -0x1238(%rbp)
movups -0x1368(%rbp), %xmm0
movups %xmm0, -0x1248(%rbp)
movaps -0x1230(%rbp), %xmm0
movaps -0x1220(%rbp), %xmm1
movaps -0x1210(%rbp), %xmm2
movaps %xmm2, -0x1270(%rbp)
movaps %xmm1, -0x1280(%rbp)
movaps %xmm0, -0x1290(%rbp)
movaps -0x1260(%rbp), %xmm0
movaps -0x1250(%rbp), %xmm1
movaps -0x1240(%rbp), %xmm2
movaps %xmm2, -0x12a0(%rbp)
movaps %xmm1, -0x12b0(%rbp)
movaps %xmm0, -0x12c0(%rbp)
movq -0x1220(%rbp), %rax
movq %rax, -0x1370(%rbp)
movaps -0x1230(%rbp), %xmm0
movaps %xmm0, -0x1380(%rbp)
leaq -0x12d8(%rbp), %rsi
movq -0x1370(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x1380(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xac8(%rbp), %rdi
callq 0x8d690
movb %al, -0x19c1(%rbp)
jmp 0x8f746
movb -0x19c1(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8f75d
movb $0x0, -0x1301(%rbp)
jmp 0x8f75f
movsd 0x1628d9(%rip), %xmm0   # 0x1f2040
ucomisd -0x12c8(%rbp), %xmm0
jbe 0x8fc95
movb -0x1301(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8fa10
movq -0x48(%rbp), %rdi
movaps -0x1230(%rbp), %xmm0
movaps -0x1220(%rbp), %xmm1
movaps -0x1210(%rbp), %xmm2
movaps %xmm2, -0x1390(%rbp)
movaps %xmm1, -0x13a0(%rbp)
movaps %xmm0, -0x13b0(%rbp)
movaps -0x13b0(%rbp), %xmm0
movaps -0x13a0(%rbp), %xmm1
movaps -0x1390(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xac8(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
leaq -0x1300(%rbp), %rcx
callq 0x8e000
jmp 0x8f7f6
leaq -0x1218(%rbp), %rsi
movsd -0x12e0(%rbp), %xmm0
leaq -0x13c8(%rbp), %rdi
callq 0xea000
jmp 0x8f813
movq -0x13b8(%rbp), %rax
movq %rax, -0x1208(%rbp)
movups -0x13c8(%rbp), %xmm0
movups %xmm0, -0x1218(%rbp)
leaq -0x1290(%rbp), %rax
movq %rax, -0x19d0(%rbp)
leaq -0x1278(%rbp), %rsi
movsd -0x12c8(%rbp), %xmm0
leaq -0x13f8(%rbp), %rdi
callq 0xea000
jmp 0x8f85a
movq -0x19d0(%rbp), %rsi
movq -0x13e8(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x13f8(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x13e0(%rbp), %rdi
callq 0xea420
jmp 0x8f887
movq -0x13d0(%rbp), %rax
movq %rax, -0x1220(%rbp)
movups -0x13e0(%rbp), %xmm0
movaps %xmm0, -0x1230(%rbp)
leaq -0xb10(%rbp), %rdi
leaq -0x1230(%rbp), %rsi
callq 0x91f00
jmp 0x8f8b8
movsd -0x12e0(%rbp), %xmm1
movsd -0x12c8(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x12c8(%rbp)
leaq -0x1218(%rbp), %rsi
movq -0x1268(%rbp), %rax
movq %rax, -0x1208(%rbp)
movups -0x1278(%rbp), %xmm0
movups %xmm0, -0x1218(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x19e0(%rbp)
leaq -0x12f8(%rbp), %rax
movq %rax, -0x19d8(%rbp)
leaq -0x1440(%rbp), %rdi
movsd 0x167a79(%rip), %xmm0   # 0x1f7398
callq 0xea000
jmp 0x8f926
movq -0x19d8(%rbp), %rsi
movq -0x1430(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1440(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1428(%rbp), %rdi
callq 0xea420
jmp 0x8f953
movq -0x19e0(%rbp), %rsi
movq -0x1418(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1428(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1410(%rbp), %rdi
callq 0x97f20
jmp 0x8f980
movq -0x1400(%rbp), %rax
movq %rax, -0x1220(%rbp)
movups -0x1410(%rbp), %xmm0
movaps %xmm0, -0x1230(%rbp)
movq $0x0, -0x12e0(%rbp)
movb $0x0, -0x1300(%rbp)
leaq -0x1458(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8f9c5
movq -0x1458(%rbp), %rax
movq %rax, -0x12f8(%rbp)
movq -0x1450(%rbp), %rax
movq %rax, -0x12f0(%rbp)
movq -0x1448(%rbp), %rax
movq %rax, -0x12e8(%rbp)
movl $0xffffffff, -0x12d8(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x12d0(%rbp)
movb $0x1, -0x1301(%rbp)
jmp 0x8fc90
movq -0x48(%rbp), %rdi
movaps -0x1230(%rbp), %xmm0
movaps -0x1220(%rbp), %xmm1
movaps -0x1210(%rbp), %xmm2
movaps %xmm2, -0x1470(%rbp)
movaps %xmm1, -0x1480(%rbp)
movaps %xmm0, -0x1490(%rbp)
movaps -0x1490(%rbp), %xmm0
movaps -0x1480(%rbp), %xmm1
movaps -0x1470(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xac8(%rbp), %rsi
leaq -0x1300(%rbp), %rdx
callq 0x8d9f0
jmp 0x8fa76
leaq -0x1218(%rbp), %rsi
movsd -0x12e0(%rbp), %xmm0
leaq -0x14a8(%rbp), %rdi
callq 0xea000
jmp 0x8fa93
movq -0x1498(%rbp), %rax
movq %rax, -0x1208(%rbp)
movups -0x14a8(%rbp), %xmm0
movups %xmm0, -0x1218(%rbp)
leaq -0x1290(%rbp), %rax
movq %rax, -0x19e8(%rbp)
leaq -0x1278(%rbp), %rsi
movsd -0x12c8(%rbp), %xmm0
leaq -0x14d8(%rbp), %rdi
callq 0xea000
jmp 0x8fada
movq -0x19e8(%rbp), %rsi
movq -0x14c8(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x14d8(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x14c0(%rbp), %rdi
callq 0xea420
jmp 0x8fb07
movq -0x14b0(%rbp), %rax
movq %rax, -0x1220(%rbp)
movups -0x14c0(%rbp), %xmm0
movaps %xmm0, -0x1230(%rbp)
leaq -0xaf8(%rbp), %rdi
leaq -0x1230(%rbp), %rsi
callq 0x91f00
jmp 0x8fb38
movsd -0x12e0(%rbp), %xmm1
movsd -0x12c8(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x12c8(%rbp)
leaq -0x1218(%rbp), %rsi
movq -0x1268(%rbp), %rax
movq %rax, -0x1208(%rbp)
movups -0x1278(%rbp), %xmm0
movups %xmm0, -0x1218(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x19f8(%rbp)
leaq -0x12f8(%rbp), %rax
movq %rax, -0x19f0(%rbp)
leaq -0x1520(%rbp), %rdi
movsd 0x1677f9(%rip), %xmm0   # 0x1f7398
callq 0xea000
jmp 0x8fba6
movq -0x19f0(%rbp), %rsi
movq -0x1510(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1520(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1508(%rbp), %rdi
callq 0xea420
jmp 0x8fbd3
movq -0x19f8(%rbp), %rsi
movq -0x14f8(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1508(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x14f0(%rbp), %rdi
callq 0x97f20
jmp 0x8fc00
movq -0x14e0(%rbp), %rax
movq %rax, -0x1220(%rbp)
movups -0x14f0(%rbp), %xmm0
movaps %xmm0, -0x1230(%rbp)
movq $0x0, -0x12e0(%rbp)
movb $0x0, -0x1300(%rbp)
leaq -0x1538(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x8fc45
movq -0x1538(%rbp), %rax
movq %rax, -0x12f8(%rbp)
movq -0x1530(%rbp), %rax
movq %rax, -0x12f0(%rbp)
movq -0x1528(%rbp), %rax
movq %rax, -0x12e8(%rbp)
movslq -0x12d8(%rbp), %rsi
leaq -0xac8(%rbp), %rdi
callq 0x91c10
movq %rax, -0x12d0(%rbp)
movb $0x0, -0x1301(%rbp)
jmp 0x8f75f
jmp 0x8fc97
movl -0x1308(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1308(%rbp)
jmp 0x8f5a8
movq 0x1e330e(%rip), %rdi    # 0x272fc0
leaq 0x167969(%rip), %rsi    # 0x1f7622
callq 0x5540
movq %rax, -0x1a00(%rbp)
jmp 0x8fcc7
movq -0x1a00(%rbp), %rdi
movq 0x1e32c3(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8fcdc
jmp 0x8fcde
movq -0x1908(%rbp), %rdi
leaq 0x179978(%rip), %rsi    # 0x209664
callq 0x51b0
cmpl $0x0, %eax
jne 0x90705
movq 0x1e32bf(%rip), %rdi    # 0x272fc0
leaq 0x167946(%rip), %rsi    # 0x1f764e
callq 0x5540
movq %rax, -0x1a08(%rbp)
jmp 0x8fd16
movq -0x1a08(%rbp), %rdi
movq 0x1e3274(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8fd2b
movq 0x1e328e(%rip), %rdi    # 0x272fc0
leaq 0x167890(%rip), %rsi    # 0x1f75c9
callq 0x5540
movq %rax, -0x1a10(%rbp)
jmp 0x8fd47
movq -0x1a10(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x58d0
movq %rax, -0x1a18(%rbp)
jmp 0x8fd5f
movq -0x1a18(%rbp), %rdi
movq 0x1e322b(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x8fd74
leaq -0x1570(%rbp), %rdi
callq 0x91ec0
jmp 0x8fd82
leaq -0x15a0(%rbp), %rdi
callq 0x91ec0
jmp 0x8fd90
leaq -0x15d0(%rbp), %rdi
callq 0x91ec0
jmp 0x8fd9e
leaq -0x1600(%rbp), %rdi
callq 0x91ec0
jmp 0x8fdac
movq $0x0, -0x1608(%rbp)
leaq -0x1640(%rbp), %rdi
callq 0x91b70
jmp 0x8fdc5
movb $0x0, -0x1641(%rbp)
movl $0x0, -0x1648(%rbp)
movl -0x1648(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x906d2
movq $0x0, -0x1608(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x1a20(%rbp)
leaq -0x1678(%rbp), %rdi
callq 0x8d940
jmp 0x8fe09
movq -0x1a20(%rbp), %rsi
movq -0x1668(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1678(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1660(%rbp), %rdi
callq 0x961d0
jmp 0x8fe36
movq -0x1650(%rbp), %rax
movq %rax, -0x1560(%rbp)
movups -0x1660(%rbp), %xmm0
movaps %xmm0, -0x1570(%rbp)
leaq -0x1690(%rbp), %rdi
callq 0x8d7c0
jmp 0x8fe60
leaq -0x1558(%rbp), %rsi
movq -0x1680(%rbp), %rax
movq %rax, -0x1548(%rbp)
movups -0x1690(%rbp), %xmm0
movups %xmm0, -0x1558(%rbp)
movq -0x1560(%rbp), %rax
movq %rax, -0x1590(%rbp)
movaps -0x1570(%rbp), %xmm0
movaps %xmm0, -0x15a0(%rbp)
leaq -0x16a8(%rbp), %rdi
movsd 0x1628ca(%rip), %xmm0   # 0x1f2778
callq 0xea000
jmp 0x8feb5
movq -0x1698(%rbp), %rax
movq %rax, -0x1578(%rbp)
movups -0x16a8(%rbp), %xmm0
movups %xmm0, -0x1588(%rbp)
movaps -0x1570(%rbp), %xmm0
movaps -0x1560(%rbp), %xmm1
movaps -0x1550(%rbp), %xmm2
movaps %xmm2, -0x15b0(%rbp)
movaps %xmm1, -0x15c0(%rbp)
movaps %xmm0, -0x15d0(%rbp)
movaps -0x15a0(%rbp), %xmm0
movaps -0x1590(%rbp), %xmm1
movaps -0x1580(%rbp), %xmm2
movaps %xmm2, -0x15e0(%rbp)
movaps %xmm1, -0x15f0(%rbp)
movaps %xmm0, -0x1600(%rbp)
movq -0x1560(%rbp), %rax
movq %rax, -0x16b0(%rbp)
movaps -0x1570(%rbp), %xmm0
movaps %xmm0, -0x16c0(%rbp)
leaq -0x1618(%rbp), %rsi
movq -0x16b0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x16c0(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xab0(%rbp), %rdi
callq 0x8d690
movb %al, -0x1a21(%rbp)
jmp 0x8ff74
movb -0x1a21(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x8ff8d
movb $0x1, -0x1641(%rbp)
jmp 0x8ff94
movb $0x0, -0x1641(%rbp)
movq -0x1560(%rbp), %rax
movq %rax, -0x16d0(%rbp)
movaps -0x1570(%rbp), %xmm0
movaps %xmm0, -0x16e0(%rbp)
movq -0x16d0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x16e0(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xa88(%rbp), %rdi
callq 0xfe7d0
movb %al, -0x1a22(%rbp)
jmp 0x8ffdc
movb -0x1a22(%rbp), %al
andb $0x1, %al
movb %al, -0x1642(%rbp)
movsd 0x16204e(%rip), %xmm0   # 0x1f2040
ucomisd -0x1608(%rbp), %xmm0
jbe 0x906bc
movb -0x1641(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9023b
movb -0x1642(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x9023b
movq -0x48(%rbp), %rdi
movaps -0x1570(%rbp), %xmm0
movaps -0x1560(%rbp), %xmm1
movaps -0x1550(%rbp), %xmm2
movaps %xmm2, -0x16f0(%rbp)
movaps %xmm1, -0x1700(%rbp)
movaps %xmm0, -0x1710(%rbp)
movaps -0x1710(%rbp), %xmm0
movaps -0x1700(%rbp), %xmm1
movaps -0x16f0(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xab0(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
leaq -0x1640(%rbp), %rcx
callq 0x8e000
jmp 0x90095
leaq -0x1558(%rbp), %rsi
movsd -0x1620(%rbp), %xmm0
leaq -0x1728(%rbp), %rdi
callq 0xea000
jmp 0x900b2
movq -0x1718(%rbp), %rax
movq %rax, -0x1548(%rbp)
movups -0x1728(%rbp), %xmm0
movups %xmm0, -0x1558(%rbp)
leaq -0xaf8(%rbp), %rdi
leaq -0x1570(%rbp), %rsi
callq 0x91f00
jmp 0x900e3
movsd -0x1620(%rbp), %xmm1
movsd -0x1608(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x1608(%rbp)
leaq -0x1558(%rbp), %rsi
movq -0x15a8(%rbp), %rax
movq %rax, -0x1548(%rbp)
movups -0x15b8(%rbp), %xmm0
movups %xmm0, -0x1558(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x1a38(%rbp)
leaq -0x1638(%rbp), %rax
movq %rax, -0x1a30(%rbp)
leaq -0x1770(%rbp), %rdi
movsd 0x16724e(%rip), %xmm0   # 0x1f7398
callq 0xea000
jmp 0x90151
movq -0x1a30(%rbp), %rsi
movq -0x1760(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1770(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1758(%rbp), %rdi
callq 0xea420
jmp 0x9017e
movq -0x1a38(%rbp), %rsi
movq -0x1748(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1758(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1740(%rbp), %rdi
callq 0x97f20
jmp 0x901ab
movq -0x1730(%rbp), %rax
movq %rax, -0x1560(%rbp)
movups -0x1740(%rbp), %xmm0
movaps %xmm0, -0x1570(%rbp)
movq $0x0, -0x1620(%rbp)
movb $0x0, -0x1640(%rbp)
leaq -0x1788(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x901f0
movq -0x1788(%rbp), %rax
movq %rax, -0x1638(%rbp)
movq -0x1780(%rbp), %rax
movq %rax, -0x1630(%rbp)
movq -0x1778(%rbp), %rax
movq %rax, -0x1628(%rbp)
movl $0xffffffff, -0x1618(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x1610(%rbp)
movb $0x1, -0x1641(%rbp)
jmp 0x906b7
movb -0x1641(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x90476
movb -0x1642(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x90476
movq -0x48(%rbp), %rdi
movaps -0x1570(%rbp), %xmm0
movaps -0x1560(%rbp), %xmm1
movaps -0x1550(%rbp), %xmm2
movaps %xmm2, -0x17a0(%rbp)
movaps %xmm1, -0x17b0(%rbp)
movaps %xmm0, -0x17c0(%rbp)
movaps -0x17c0(%rbp), %xmm0
movaps -0x17b0(%rbp), %xmm1
movaps -0x17a0(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xab0(%rbp), %rsi
leaq -0xae0(%rbp), %rdx
leaq -0x1640(%rbp), %rcx
callq 0x8e000
jmp 0x902d0
leaq -0x1558(%rbp), %rsi
movsd -0x1620(%rbp), %xmm0
leaq -0x17d8(%rbp), %rdi
callq 0xea000
jmp 0x902ed
movq -0x17c8(%rbp), %rax
movq %rax, -0x1548(%rbp)
movups -0x17d8(%rbp), %xmm0
movups %xmm0, -0x1558(%rbp)
leaq -0xb10(%rbp), %rdi
leaq -0x1570(%rbp), %rsi
callq 0x91f00
jmp 0x9031e
movsd -0x1620(%rbp), %xmm1
movsd -0x1608(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x1608(%rbp)
leaq -0x15b8(%rbp), %rsi
movq -0x15a8(%rbp), %rax
movq %rax, -0x1548(%rbp)
movups -0x15b8(%rbp), %xmm0
movups %xmm0, -0x1558(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x1a48(%rbp)
leaq -0x1638(%rbp), %rax
movq %rax, -0x1a40(%rbp)
leaq -0x1820(%rbp), %rdi
movsd 0x167013(%rip), %xmm0   # 0x1f7398
callq 0xea000
jmp 0x9038c
movq -0x1a40(%rbp), %rsi
movq -0x1810(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1820(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1808(%rbp), %rdi
callq 0xea420
jmp 0x903b9
movq -0x1a48(%rbp), %rsi
movq -0x17f8(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x1808(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x17f0(%rbp), %rdi
callq 0x97f20
jmp 0x903e6
movq -0x17e0(%rbp), %rax
movq %rax, -0x1560(%rbp)
movups -0x17f0(%rbp), %xmm0
movaps %xmm0, -0x1570(%rbp)
movq $0x0, -0x1620(%rbp)
movb $0x0, -0x1640(%rbp)
leaq -0x1838(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x9042b
movq -0x1838(%rbp), %rax
movq %rax, -0x1638(%rbp)
movq -0x1830(%rbp), %rax
movq %rax, -0x1630(%rbp)
movq -0x1828(%rbp), %rax
movq %rax, -0x1628(%rbp)
movq $0x0, -0x1610(%rbp)
movl $0xffffffff, -0x1618(%rbp) # imm = 0xFFFFFFFF
movb $0x1, -0x1641(%rbp)
jmp 0x906b5
movq -0x48(%rbp), %rdi
movaps -0x1570(%rbp), %xmm0
movaps -0x1560(%rbp), %xmm1
movaps -0x1550(%rbp), %xmm2
movaps %xmm2, -0x1850(%rbp)
movaps %xmm1, -0x1860(%rbp)
movaps %xmm0, -0x1870(%rbp)
movaps -0x1870(%rbp), %xmm0
movaps -0x1860(%rbp), %xmm1
movaps -0x1850(%rbp), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq -0xab0(%rbp), %rsi
leaq -0x1640(%rbp), %rdx
callq 0x8d9f0
jmp 0x904dc
leaq -0x1558(%rbp), %rsi
movsd -0x1620(%rbp), %xmm0
leaq -0x1888(%rbp), %rdi
callq 0xea000
jmp 0x904f9
movq -0x1878(%rbp), %rax
movq %rax, -0x1548(%rbp)
movups -0x1888(%rbp), %xmm0
movups %xmm0, -0x1558(%rbp)
movsd -0x1620(%rbp), %xmm1
movsd -0x1608(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x1608(%rbp)
leaq -0x15b8(%rbp), %rsi
movq -0x15a8(%rbp), %rax
movq %rax, -0x1548(%rbp)
movups -0x15b8(%rbp), %xmm0
movups %xmm0, -0x1558(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x1a58(%rbp)
leaq -0x1638(%rbp), %rax
movq %rax, -0x1a50(%rbp)
leaq -0x18d0(%rbp), %rdi
movsd 0x166e1c(%rip), %xmm0   # 0x1f7398
callq 0xea000
jmp 0x90583
movq -0x1a50(%rbp), %rsi
movq -0x18c0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x18d0(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x18b8(%rbp), %rdi
callq 0xea420
jmp 0x905b0
movq -0x1a58(%rbp), %rsi
movq -0x18a8(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0x18b8(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x18a0(%rbp), %rdi
callq 0x97f20
jmp 0x905dd
movq -0x1890(%rbp), %rax
movq %rax, -0x1560(%rbp)
movups -0x18a0(%rbp), %xmm0
movaps %xmm0, -0x1570(%rbp)
movq $0x0, -0x1620(%rbp)
movb $0x0, -0x1640(%rbp)
leaq -0x18e8(%rbp), %rdi
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0xe9c70
jmp 0x90622
movq -0x18d8(%rbp), %rax
movq %rax, -0x1628(%rbp)
movups -0x18e8(%rbp), %xmm0
movups %xmm0, -0x1638(%rbp)
movslq -0x1618(%rbp), %rsi
leaq -0xac8(%rbp), %rdi
callq 0x91c10
movq %rax, -0x1610(%rbp)
movb $0x0, -0x1641(%rbp)
movq -0x1560(%rbp), %rax
movq %rax, -0x18f0(%rbp)
movaps -0x1570(%rbp), %xmm0
movaps %xmm0, -0x1900(%rbp)
movq -0x18f0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x1900(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0xa88(%rbp), %rdi
callq 0xfe7d0
movb %al, -0x1a59(%rbp)
jmp 0x906a7
movb -0x1a59(%rbp), %al
andb $0x1, %al
movb %al, -0x1642(%rbp)
jmp 0x906b7
jmp 0x8ffea
jmp 0x906be
movl -0x1648(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1648(%rbp)
jmp 0x8fdd6
movq 0x1e28e7(%rip), %rdi    # 0x272fc0
leaq 0x166f94(%rip), %rsi    # 0x1f7674
callq 0x5540
movq %rax, -0x1a68(%rbp)
jmp 0x906ee
movq -0x1a68(%rbp), %rdi
movq 0x1e289c(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x90703
jmp 0x90705
testb $0x1, -0x39(%rbp)
je 0x9072b
movq -0x38(%rbp), %rdi
leaq -0xaf8(%rbp), %rsi
leaq -0xb10(%rbp), %rdx
movl $0x1, %ecx
callq 0x90810
jmp 0x90729
jmp 0x9074c
movq -0x38(%rbp), %rdi
movsd 0x166c71(%rip), %xmm0   # 0x1f73a8
movl $0x3e8, %esi            # imm = 0x3E8
leaq -0xaf8(%rbp), %rdx
callq 0x91430
jmp 0x9074a
jmp 0x9074c
leaq -0xaf8(%rbp), %rdi
callq 0x91600
jmp 0x9075a
leaq -0xa88(%rbp), %rdi
callq 0x849f0
jmp 0x90768
leaq -0xb28(%rbp), %rdi
callq 0x91f70
leaq -0xb10(%rbp), %rdi
callq 0x91f70
leaq -0xaf8(%rbp), %rdi
callq 0x91f70
leaq -0xae0(%rbp), %rdi
callq 0x91fd0
leaq -0xac8(%rbp), %rdi
callq 0x92030
leaq -0xab0(%rbp), %rdi
callq 0x92030
leaq -0xa88(%rbp), %rdi
callq 0x84a30
addq $0x1aa0, %rsp           # imm = 0x1AA0
popq %rbp
retq
leaq -0xae0(%rbp), %rdi
callq 0x91fd0
leaq -0xac8(%rbp), %rdi
callq 0x92030
leaq -0xab0(%rbp), %rdi
callq 0x92030
leaq -0xa88(%rbp), %rdi
callq 0x84a30
movq -0xa90(%rbp), %rdi
callq 0x58f0
nopw %cs:(%rax,%rax)