// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xde8, %rsp            # imm = 0xDE8
movl %r9d, 0x178(%rsp)
movq %r8, 0x1d8(%rsp)
movl %ecx, 0x34(%rsp)
movsd %xmm1, 0x38(%rsp)
movsd %xmm0, 0x100(%rsp)
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
testl %edx, %edx
cmoveq %rdi, %r12
leaq 0x3a8(%rsp), %r15
movq %r15, %rdi
callq 0x36c02
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movl %ebx, %ecx
movsd 0x100(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
callq 0x6e3ac
movl $0x3b4ca6f5, %edi       # imm = 0x3B4CA6F5
callq 0x4460
xorpd %xmm0, %xmm0
leaq 0x180(%rsp), %rsi
movapd %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %r12, 0x38(%rsp)
movq %r12, %rdi
callq 0x39ae1
leaq 0x1a0(%rsp), %rsi
andq $0x0, 0x10(%rsi)
xorpd %xmm0, %xmm0
movapd %xmm0, (%rsi)
leaq 0xc70(%rsp), %rdi
leaq 0xd38(%rsp), %r13
movq %r13, %rdx
callq 0x399e9
xorpd %xmm0, %xmm0
leaq 0x160(%rsp), %rsi
movapd %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq 0x38(%rsp), %rbx
movq %rbx, %rdi
callq 0x3929f
leaq 0x180(%rsp), %rsi
leaq 0x160(%rsp), %rdx
movq %rbx, %rdi
callq 0x3957d
leaq 0x1a0(%rsp), %rsi
leaq 0x160(%rsp), %rdx
movq %rbx, %rdi
callq 0x3957d
xorpd %xmm0, %xmm0
movapd %xmm0, 0x140(%rsp)
andq $0x0, 0x150(%rsp)
movapd %xmm0, 0x1c0(%rsp)
andq $0x0, 0x1d0(%rsp)
movapd %xmm0, 0x210(%rsp)
andq $0x0, 0x220(%rsp)
movq 0x115b56(%rip), %rdi    # 0x14ffc0
leaq 0xc6f9b(%rip), %rsi     # 0x10140c
callq 0x4480
movq %rax, %rdi
callq 0x4230
movq 0xe20(%rsp), %rbx
leaq 0xcbe5e(%rip), %rsi     # 0x1062eb
movq %rbx, %rdi
callq 0x4190
testl %eax, %eax
jne 0x3a864
movq 0x115b1c(%rip), %rdi    # 0x14ffc0
leaq 0xc700c(%rip), %rsi     # 0x1014b7
callq 0x4480
movq %rax, %rdi
callq 0x4230
movq 0x115b01(%rip), %rdi    # 0x14ffc0
leaq 0xc6f63(%rip), %rsi     # 0x101429
callq 0x4480
movq %rax, %rdi
movl 0x34(%rsp), %esi
callq 0x4760
movq %rax, %rdi
callq 0x4230
leaq 0x40(%rsp), %rdi
callq 0x3cd72
leaq 0x110(%rsp), %rdi
callq 0x3cd72
leaq 0xc0(%rsp), %rdi
callq 0x3cc56
leaq 0x58(%rsp), %rbx
leaq 0x128(%rsp), %r14
leaq 0xc8(%rsp), %r15
xorl %r12d, %r12d
movl 0x34(%rsp), %eax
testl %eax, %eax
cmovgl %eax, %r12d
leaq 0x90(%rsp), %rbp
subl $0x1, %r12d
jb 0x3a85c
leaq 0x390(%rsp), %rdi
callq 0x39d76
movq 0x3a0(%rsp), %rax
movq %rax, 0x10(%rsp)
movupd 0x390(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq %rbp, %rdi
movq 0x38(%rsp), %rsi
callq 0x3e536
movq 0xa0(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x90(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %rbp, %rdi
callq 0x39c71
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movapd 0x40(%rsp), %xmm0
movupd %xmm0, (%rsp)
leaq 0x3a8(%rsp), %rdi
callq 0x6f112
testb %al, %al
je 0x3a819
movq 0x50(%rsp), %rax
movq %rax, 0x120(%rsp)
movaps 0x40(%rsp), %xmm0
movaps %xmm0, 0x110(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
movsd 0xc5cf1(%rip), %xmm0    # 0x1002e8
callq 0x63d70
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%r14)
movapd 0x40(%rsp), %xmm0
movapd 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
leaq 0x180(%rsp), %rsi
leaq 0x160(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
callq 0x3a134
movsd 0xe0(%rsp), %xmm0
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x63d70
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x90(%rsp), %xmm0
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
andq $0x0, 0xf0(%rsp)
movups %xmm0, (%rbx)
orl $-0x1, 0xe8(%rsp)
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %rbp, %rdi
callq 0x63c46
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r15)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%r15)
movapd 0x110(%rsp), %xmm0
movapd 0x120(%rsp), %xmm1
movaps 0x130(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movupd %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
leaq 0x180(%rsp), %rsi
leaq 0x160(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
callq 0x3a134
movsd 0xe0(%rsp), %xmm0
movq %rbp, %rdi
movq %r14, %rsi
callq 0x63d70
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x63e70
movq 0xa0(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x90(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x63e4e
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movupd 0x90(%rsp), %xmm0
movupd %xmm0, (%rbx)
leaq 0x140(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3cd9a
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
andq $0x0, 0xf0(%rsp)
orl $-0x1, 0xe8(%rsp)
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %rbp, %rdi
callq 0x63c46
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r15)
movupd 0x90(%rsp), %xmm0
movupd %xmm0, (%r15)
jmp 0x3a52d
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %rbp, %rdi
callq 0x63c46
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movupd 0x90(%rsp), %xmm0
movupd %xmm0, (%rbx)
leaq 0x1c0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3cd9a
jmp 0x3a52d
movq 0xe20(%rsp), %rbx
leaq 0xcace6(%rip), %rsi     # 0x105551
movq %rbx, %rdi
callq 0x4190
testl %eax, %eax
jne 0x3ac11
movq 0x11573e(%rip), %rdi    # 0x14ffc0
leaq 0xc6bb4(%rip), %rsi     # 0x10143d
callq 0x4480
movq %rax, %rdi
callq 0x4230
movq 0x115723(%rip), %rdi    # 0x14ffc0
leaq 0xc6b85(%rip), %rsi     # 0x101429
callq 0x4480
movq %rax, %rdi
movl 0x34(%rsp), %esi
callq 0x4760
movq %rax, %rdi
callq 0x4230
leaq 0x40(%rsp), %rdi
callq 0x3cd72
leaq 0x110(%rsp), %rdi
callq 0x3cd72
leaq 0xc0(%rsp), %rdi
callq 0x3cc56
leaq 0x58(%rsp), %rbx
leaq 0x128(%rsp), %r14
xorl %ebp, %ebp
movl 0x34(%rsp), %eax
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movl %ecx, 0xf8(%rsp)
xorl %eax, %eax
movl %eax, 0x100(%rsp)
cmpl 0xf8(%rsp), %eax
je 0x3ac09
incl %ebp
movslq %ebp, %rax
movq 0xd48(%rsp), %rcx
movl 0xd50(%rsp), %edx
subq 0xd38(%rsp), %rcx
leaq (%rdx,%rcx,8), %rcx
cmpq %rax, %rcx
ja 0x3a942
xorl %ebp, %ebp
movslq %ebp, %r15
movq %r13, %rdi
movq %r15, %rsi
callq 0x1043e
testq %rdx, (%rax)
je 0x3a91b
movq 0x1a0(%rsp), %rax
shlq $0x5, %r15
movups (%rax,%r15), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x10(%rax,%r15), %rax
movq %rax, 0x50(%rsp)
leaq 0x90(%rsp), %r15
movq %r15, %rdi
callq 0x39c71
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%rbx)
movaps 0x40(%rsp), %xmm0
movaps %xmm0, 0x110(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x120(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
movsd 0xc5924(%rip), %xmm0    # 0x1002e8
callq 0x63d70
leaq 0x180(%rsp), %r15
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%r14)
movaps 0x40(%rsp), %xmm0
movapd 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
movq %r15, %rsi
leaq 0x160(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
callq 0x3a134
movsd 0xe0(%rsp), %xmm0
leaq 0x90(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x63d70
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x90(%rsp), %xmm0
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
andq $0x0, 0xf0(%rsp)
movups %xmm0, (%rbx)
orl $-0x1, 0xe8(%rsp)
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0x63c46
movq 0xa0(%rsp), %rax
leaq 0xc8(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%rcx)
movaps 0x110(%rsp), %xmm0
movapd 0x120(%rsp), %xmm1
movaps 0x130(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
movq %r15, %rsi
leaq 0x160(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
callq 0x3a134
movsd 0xe0(%rsp), %xmm0
leaq 0x90(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x63d70
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
leaq 0x40(%rsp), %rsi
callq 0x63e70
movq 0xa0(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x90(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x63e4e
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%rbx)
leaq 0x140(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3cd9a
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
andq $0x0, 0xf0(%rsp)
orl $-0x1, 0xe8(%rsp)
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
leaq 0x90(%rsp), %rdi
callq 0x63c46
movq 0xa0(%rsp), %rax
leaq 0xc8(%rsp), %rcx
movq %rax, 0x10(%rcx)
movupd 0x90(%rsp), %xmm0
movupd %xmm0, (%rcx)
movl 0x100(%rsp), %eax
incl %eax
jmp 0x3a907
movq 0xe20(%rsp), %rbx
leaq 0xd34b6(%rip), %rsi     # 0x10e0ce
movq %rbx, %rdi
callq 0x4190
testl %eax, %eax
jne 0x3afba
movq 0x115391(%rip), %rdi    # 0x14ffc0
leaq 0xc682d(%rip), %rsi     # 0x101463
callq 0x4480
movq %rax, %rdi
callq 0x4230
movq 0x115376(%rip), %rdi    # 0x14ffc0
leaq 0xc67d8(%rip), %rsi     # 0x101429
callq 0x4480
movq %rax, %rdi
movl 0x34(%rsp), %esi
callq 0x4760
movq %rax, %rdi
callq 0x4230
leaq 0x40(%rsp), %rdi
callq 0x3cd72
leaq 0x110(%rsp), %rdi
callq 0x3cd72
leaq 0xc0(%rsp), %rdi
callq 0x3cc56
leaq 0x58(%rsp), %rbx
leaq 0x128(%rsp), %r14
leaq 0xc8(%rsp), %r15
xorl %r12d, %r12d
movl 0x34(%rsp), %eax
testl %eax, %eax
cmovgl %eax, %r12d
leaq 0x90(%rsp), %r13
leaq 0x40(%rsp), %rbp
subl $0x1, %r12d
jb 0x3afb2
leaq 0x378(%rsp), %rdi
callq 0x39d76
movq 0x388(%rsp), %rax
movq %rax, 0x10(%rsp)
movupd 0x378(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq %r13, %rdi
movq 0x38(%rsp), %rsi
callq 0x3e536
movq 0xa0(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x90(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r13, %rdi
callq 0x39c71
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%rbx)
movaps 0x40(%rsp), %xmm0
movaps %xmm0, 0x110(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x120(%rsp)
movq %r13, %rdi
movq %rbx, %rsi
movsd 0xc558b(%rip), %xmm0    # 0x1002e8
callq 0x63d70
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%r14)
movaps 0x40(%rsp), %xmm0
movapd 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x39dd8
cmpb $0x0, 0xc0(%rsp)
je 0x3af72
movsd 0xe0(%rsp), %xmm0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x63d70
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x90(%rsp), %xmm0
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
orl $-0x1, 0xe8(%rsp)
movups %xmm0, (%rbx)
andq $0x0, 0xf0(%rsp)
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r13, %rdi
callq 0x63c46
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r15)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%r15)
movaps 0x110(%rsp), %xmm0
movapd 0x120(%rsp), %xmm1
movaps 0x130(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movupd %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x39dd8
movsd 0xe0(%rsp), %xmm0
movq %r13, %rdi
movq %r14, %rsi
callq 0x63d70
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r14)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x63e70
movq 0xa0(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x90(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x63e4e
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x90(%rsp), %xmm0
movups %xmm0, (%rbx)
leaq 0x140(%rsp), %rdi
movq %rbp, %rsi
callq 0x3cd9a
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
andq $0x0, 0xf0(%rsp)
orl $-0x1, 0xe8(%rsp)
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r13, %rdi
callq 0x63c46
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%r15)
movupd 0x90(%rsp), %xmm0
movupd %xmm0, (%r15)
jmp 0x3acbd
xorps %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r13, %rdi
callq 0x63c46
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rbx)
movupd 0x90(%rsp), %xmm0
movupd %xmm0, (%rbx)
leaq 0x1c0(%rsp), %rdi
movq %rbp, %rsi
callq 0x3cd9a
jmp 0x3acbd
movq 0xe20(%rsp), %rbx
leaq 0xd3106(%rip), %rsi     # 0x10e0c7
movq %rbx, %rdi
callq 0x4190
testl %eax, %eax
jne 0x3b5c3
movq 0x114fe8(%rip), %rdi    # 0x14ffc0
leaq 0xc647b(%rip), %rsi     # 0x10145a
callq 0x4480
movq %rax, %rdi
callq 0x4230
movq 0x114fcd(%rip), %rdi    # 0x14ffc0
leaq 0xc642f(%rip), %rsi     # 0x101429
callq 0x4480
movq %rax, %rdi
movl 0x34(%rsp), %esi
callq 0x4760
movq %rax, %rdi
callq 0x4230
leaq 0x40(%rsp), %rdi
callq 0x3cd72
leaq 0x110(%rsp), %rdi
callq 0x3cd72
leaq 0x90(%rsp), %rdi
callq 0x3cd72
leaq 0x1e0(%rsp), %rdi
callq 0x3cd72
leaq 0xc0(%rsp), %rdi
callq 0x3cc56
leaq 0x58(%rsp), %rbx
leaq 0xa8(%rsp), %r13
leaq 0xc8(%rsp), %rbp
movl 0x34(%rsp), %eax
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movl %ecx, 0x17c(%rsp)
movb $0x1, %r15b
leaq 0x78(%rsp), %r14
leaq 0x1a0(%rsp), %r12
xorl %eax, %eax
movl %eax, 0x10c(%rsp)
cmpl 0x17c(%rsp), %eax
je 0x3b5a0
leaq 0x360(%rsp), %rdi
callq 0x39d76
movq 0x370(%rsp), %rax
movq %rax, 0x10(%rsp)
movupd 0x360(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq %r14, %rdi
movq 0x38(%rsp), %rsi
callq 0x3e536
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0x39c71
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rbx)
movaps 0x40(%rsp), %xmm0
movaps %xmm0, 0x110(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x120(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movsd 0xc51b7(%rip), %xmm0    # 0x1002e8
callq 0x63d70
movq 0x88(%rsp), %rax
leaq 0x128(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rcx)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps 0x110(%rsp), %xmm0
movapd 0x120(%rsp), %xmm1
movaps 0x130(%rsp), %xmm2
movaps %xmm0, 0x1e0(%rsp)
movapd %xmm1, 0x1f0(%rsp)
movaps %xmm2, 0x200(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
leaq 0xe8(%rsp), %rsi
callq 0x39bd3
movzbl %r15b, %r15d
testb %al, %al
movl $0x0, %eax
cmovel %eax, %r15d
xorpd %xmm1, %xmm1
movsd 0xc0e57(%rip), %xmm0    # 0xfc040
movsd %xmm1, 0x100(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x3b592
testb $0x1, %r15b
jne 0x3b3be
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
movq %r12, %rsi
leaq 0x160(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
callq 0x3a134
movsd 0xe0(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x63d70
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rbx)
leaq 0x348(%rsp), %rdi
movq %r13, %rsi
movsd 0x100(%rsp), %xmm0
callq 0x63d70
movq 0x358(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x348(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
leaq 0x90(%rsp), %rsi
callq 0x63e70
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0x1c0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3cd9a
movsd 0xe0(%rsp), %xmm0
movsd %xmm0, 0xf8(%rsp)
movq 0x10(%r13), %rax
movq %rax, 0x10(%rbx)
movups (%r13), %xmm0
movups %xmm0, (%rbx)
leaq 0x318(%rsp), %rdi
movq %rbx, %rsi
movsd 0xc5ee0(%rip), %xmm0    # 0x1011e8
callq 0x63d70
movq 0x328(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x318(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x330(%rsp), %rdi
movq %rbp, %rsi
callq 0x63e70
movq 0x340(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x330(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq 0x38(%rsp), %rsi
callq 0x3f9c2
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r14, %rdi
callq 0x63c46
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rbp)
movupd 0x78(%rsp), %xmm0
movupd %xmm0, (%rbp)
orl $-0x1, 0xe8(%rsp)
movb $0x1, %r15b
xorl %eax, %eax
jmp 0x3b573
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
movq %r12, %rsi
leaq 0xc0(%rsp), %rdx
callq 0x39dd8
movsd 0xe0(%rsp), %xmm0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x63d70
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rbx)
leaq 0x300(%rsp), %rdi
movq %r13, %rsi
movsd 0x100(%rsp), %xmm0
callq 0x63d70
movq 0x310(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x300(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
leaq 0x90(%rsp), %rsi
callq 0x63e70
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0x140(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3cd9a
movsd 0xe0(%rsp), %xmm0
movsd %xmm0, 0xf8(%rsp)
movq 0x10(%r13), %rax
movq %rax, 0x10(%rbx)
movups (%r13), %xmm0
movups %xmm0, (%rbx)
leaq 0x2d0(%rsp), %rdi
movq %rbx, %rsi
movsd 0xc5d30(%rip), %xmm0    # 0x1011e8
callq 0x63d70
movq 0x2e0(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x2d0(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x2e8(%rsp), %rdi
movq %rbp, %rsi
callq 0x63e70
movq 0x2f8(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x2e8(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
movq 0x38(%rsp), %rsi
callq 0x3f9c2
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r14, %rdi
callq 0x63c46
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rbp)
movupd 0x78(%rsp), %xmm0
movupd %xmm0, (%rbp)
movslq 0xe8(%rsp), %rax
shlq $0x5, %rax
addq 0x1a0(%rsp), %rax
xorl %r15d, %r15d
movq %rax, 0xf0(%rsp)
movsd 0x100(%rsp), %xmm1
addsd 0xf8(%rsp), %xmm1
jmp 0x3b1e1
movl 0x10c(%rsp), %eax
incl %eax
jmp 0x3b08d
movq 0x114a19(%rip), %rdi    # 0x14ffc0
leaq 0xc5ed4(%rip), %rsi     # 0x101482
callq 0x4480
movq %rax, %rdi
callq 0x4230
movq 0xe20(%rsp), %rbx
leaq 0xd2b4b(%rip), %rsi     # 0x10e115
movq %rbx, %rdi
callq 0x4190
testl %eax, %eax
jne 0x3bcae
movq 0x1149df(%rip), %rdi    # 0x14ffc0
leaq 0xc5ec6(%rip), %rsi     # 0x1014ae
callq 0x4480
movq %rax, %rdi
callq 0x4230
movq 0x1149c4(%rip), %rdi    # 0x14ffc0
leaq 0xc5e26(%rip), %rsi     # 0x101429
callq 0x4480
movq %rax, %rdi
movl 0x34(%rsp), %esi
callq 0x4760
movq %rax, %rdi
callq 0x4230
leaq 0x40(%rsp), %rdi
callq 0x3cd72
leaq 0x110(%rsp), %rdi
callq 0x3cd72
leaq 0x90(%rsp), %rdi
callq 0x3cd72
leaq 0x1e0(%rsp), %rdi
callq 0x3cd72
leaq 0xc0(%rsp), %rdi
callq 0x3cc56
leaq 0x58(%rsp), %r12
leaq 0xa8(%rsp), %rbx
leaq 0xc8(%rsp), %rbp
xorl %r14d, %r14d
movl 0x34(%rsp), %eax
testl %eax, %eax
cmovlel %r14d, %eax
movl %eax, 0x34(%rsp)
leaq 0x78(%rsp), %r13
cmpl 0x34(%rsp), %r14d
je 0x3bc93
leaq 0x2b8(%rsp), %rdi
callq 0x39d76
movq 0x2c8(%rsp), %rax
movq %rax, 0x10(%rsp)
movupd 0x2b8(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq %r13, %rdi
movq 0x38(%rsp), %rsi
callq 0x3e536
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq %r13, %rdi
callq 0x39c71
movl %r14d, 0x10c(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%r12)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%r12)
movaps 0x40(%rsp), %xmm0
movaps %xmm0, 0x110(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x120(%rsp)
movq %r13, %rdi
movq %r12, %rsi
movsd 0xc4bbd(%rip), %xmm0    # 0x1002e8
callq 0x63d70
movq 0x88(%rsp), %rax
leaq 0x128(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rcx)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps 0x110(%rsp), %xmm0
movapd 0x120(%rsp), %xmm1
movaps 0x130(%rsp), %xmm2
movaps %xmm0, 0x1e0(%rsp)
movapd %xmm1, 0x1f0(%rsp)
movaps %xmm2, 0x200(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x180(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x39bd3
movl %eax, %r15d
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x3a8(%rsp), %rdi
callq 0x6f112
movl %eax, %r14d
xorpd %xmm1, %xmm1
movsd 0xc0841(%rip), %xmm0    # 0xfc040
movsd %xmm1, 0x100(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x3bc83
testb $0x1, %r15b
je 0x3b986
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
leaq 0x180(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0x39dd8
movsd 0xe0(%rsp), %xmm0
movq %r13, %rdi
movq %r12, %rsi
callq 0x63d70
movsd 0xe0(%rsp), %xmm0
movsd %xmm0, 0xf8(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r12)
movups (%rbx), %xmm0
movups %xmm0, (%r12)
leaq 0x228(%rsp), %rdi
movq %rbx, %rsi
movsd 0xc594b(%rip), %xmm0    # 0x1011e8
callq 0x63d70
movq 0x238(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x228(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x240(%rsp), %rdi
movq %rbp, %rsi
callq 0x63e70
movq 0x250(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x240(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
movq 0x38(%rsp), %rsi
callq 0x3f9c2
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r13, %rdi
callq 0x63c46
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rbp)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rbp)
movslq 0xe8(%rsp), %rax
shlq $0x5, %rax
addq 0x1a0(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movaps 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x3a8(%rsp), %rdi
callq 0x6f112
movl %eax, %r14d
xorl %r15d, %r15d
jmp 0x3bc68
testb $0x1, %r14b
je 0x3bafa
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
leaq 0x180(%rsp), %rsi
leaq 0x160(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
callq 0x3a134
movsd 0xe0(%rsp), %xmm0
movq %r13, %rdi
movq %r12, %rsi
callq 0x63d70
movq 0x88(%rsp), %rax
movq %rax, 0x10(%r12)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%r12)
leaq 0x140(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3cd9a
movsd 0xe0(%rsp), %xmm0
movsd %xmm0, 0xf8(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r12)
movups (%rbx), %xmm0
movups %xmm0, (%r12)
leaq 0x288(%rsp), %rdi
movq %r12, %rsi
movsd 0xc57a6(%rip), %xmm0    # 0x1011e8
callq 0x63d70
movq 0x298(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x288(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x2a0(%rsp), %rdi
movq %rbp, %rsi
callq 0x63e70
movq 0x2b0(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x2a0(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
movq 0x38(%rsp), %rsi
callq 0x3f9c2
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r13, %rdi
callq 0x63c46
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rbp)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rbp)
orl $-0x1, 0xe8(%rsp)
andq $0x0, 0xf0(%rsp)
jmp 0x3bc65
jne 0x3b81c
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movaps 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x38(%rsp), %rdi
leaq 0x180(%rsp), %rsi
leaq 0x160(%rsp), %rdx
leaq 0xc0(%rsp), %rcx
callq 0x3a134
movsd 0xe0(%rsp), %xmm0
movq %r13, %rdi
movq %r12, %rsi
callq 0x63d70
movq 0x88(%rsp), %rax
movq %rax, 0x10(%r12)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%r12)
leaq 0x1c0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3cd9a
movsd 0xe0(%rsp), %xmm0
movsd %xmm0, 0xf8(%rsp)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r12)
movups (%rbx), %xmm0
movups %xmm0, (%r12)
leaq 0x258(%rsp), %rdi
movq %rbx, %rsi
movsd 0xc5636(%rip), %xmm0    # 0x1011e8
callq 0x63d70
movq 0x268(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x258(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x270(%rsp), %rdi
movq %rbp, %rsi
callq 0x63e70
movq 0x280(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x270(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
movq 0x38(%rsp), %rsi
callq 0x3f9c2
movq 0x88(%rsp), %rax
movq %rax, 0x50(%rsp)
movups 0x78(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0xe0(%rsp)
movb $0x0, 0xc0(%rsp)
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r13, %rdi
callq 0x63c46
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rbp)
movups 0x78(%rsp), %xmm0
movups %xmm0, (%rbp)
andq $0x0, 0xf0(%rsp)
orl $-0x1, 0xe8(%rsp)
movb $0x1, %r15b
movsd 0xf8(%rsp), %xmm0
movsd 0x100(%rsp), %xmm1
addsd %xmm0, %xmm1
jmp 0x3b7f7
movl 0x10c(%rsp), %r14d
incl %r14d
jmp 0x3b685
movq 0x114326(%rip), %rdi    # 0x14ffc0
leaq 0xc5833(%rip), %rsi     # 0x1014d4
callq 0x4480
movq %rax, %rdi
callq 0x4230
cmpb $0x0, 0x178(%rsp)
je 0x3bcda
leaq 0x140(%rsp), %rsi
leaq 0x1c0(%rsp), %rdx
pushq $0x1
popq %rcx
movq 0x1d8(%rsp), %rdi
callq 0x3bee6
jmp 0x3bcfc
movsd 0xc5516(%rip), %xmm0    # 0x1011f8
leaq 0x140(%rsp), %rdx
movq 0x1d8(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x3c799
leaq 0x140(%rsp), %rdi
callq 0x3c8fa
leaq 0x3a8(%rsp), %rbx
movq %rbx, %rdi
callq 0x36e7a
leaq 0x210(%rsp), %rdi
callq 0x3d138
leaq 0x1c0(%rsp), %rdi
callq 0x3d138
leaq 0x140(%rsp), %rdi
callq 0x3d138
leaq 0x160(%rsp), %rdi
callq 0x3d112
leaq 0x1a0(%rsp), %rdi
callq 0x3d0f4
leaq 0x180(%rsp), %rdi
callq 0x3d0f4
movq %rbx, %rdi
callq 0x36e9e
addq $0xde8, %rsp            # imm = 0xDE8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
movq %rax, %rbx
jmp 0x3beb7
movq %rax, %rbx
jmp 0x3bec4
movq %rax, %rbx
jmp 0x3bed1
movq %rax, %rbx
jmp 0x3beaa
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
jmp 0x3be80
movq %rax, %rbx
leaq 0x210(%rsp), %rdi
callq 0x3d138
leaq 0x1c0(%rsp), %rdi
callq 0x3d138
leaq 0x140(%rsp), %rdi
callq 0x3d138
leaq 0x160(%rsp), %rdi
callq 0x3d112
leaq 0x1a0(%rsp), %rdi
callq 0x3d0f4
leaq 0x180(%rsp), %rdi
callq 0x3d0f4
leaq 0x3a8(%rsp), %rdi
callq 0x36e9e
movq %rbx, %rdi
callq 0x4780