// File: /workspace/github_cpp_makefile_star2_O3/Luthaf[P]zeopp/feature.cc
// Function: FEATURE::calculateSurfaceArea_OLD(ATOM_NETWORK*, std::vector<DIJKSTRA_NODE, std::allocator<DIJKSTRA_NODE>>*, std::vector<int, std::allocator<int>>*, int, char*, int)
double FEATURE::calculateSurfaceArea_OLD(ATOM_NETWORK *uc,vector<DIJKSTRA_NODE> *ChanNodeList,vector <int> *featnodemap,int curr_f,char *name,int fid){
 
  long int i,j,k,counter=0;  
  double volume;
  int step;
  double r_tr; // threshold for r
  XYZ max,min;
  XYZ box;
  XYZ pt;

  vector <double> SA_holo;  // stores hologram for each feature
  vector <double> SA_holo_otherf; // as above but excluding surface that is covered by other segments

  srand(randSeed2);
  SPHERE sph,sph2;
  vector <SPHERE> object; // a vector of spheres that define object (segemnt/feature/channel)

  vector <SPHERE> other_object; // vectors of spheres corresponding to other segments

    // Draw the components located in each unit cell
    for(unsigned int i = 0; i < unitCells.size(); i++){
      vector<int> nodeIDs = ucNodes.at(i);
      DELTA_POS disp = unitCells.at(i);
      
      // Iterate over all nodes in the unit cell
      for(unsigned int j = 0; j < nodeIDs.size(); j++){
	DIJKSTRA_NODE curNode = nodes.at(nodeIDs.at(j));
	
	// Find node coordinates

        if(dimensionality<1) 
           { // if feature is not a channel, use reconstrcted feature
	   sph.x = curNode.x + v_a.x*disp.x + v_b.x*disp.y + v_c.x*disp.z;
	   sph.y = curNode.y + v_a.y*disp.x + v_b.y*disp.y + v_c.y*disp.z;
	   sph.z = curNode.z + v_a.z*disp.x + v_b.z*disp.y + v_c.z*disp.z;
           } else {
           sph.x = nodes.at(nodeIDs.at(j)).x;sph.y = nodes.at(nodeIDs.at(j)).y;sph.z = nodes.at(nodeIDs.at(j)).z;
//           cout << "draw sphere { " << sph.x << "  " << sph.y << "  " << sph.z << " } radius 0.1 " << "\n"; 
           };

	sph.r = SPHERE_SCALE*curNode.max_radius;

        object.push_back(sph);

        if(object.size()==1)
          { // first sphere added
          min.x=sph.x-sph.r;max.x=sph.x+sph.r;
          min.y=sph.y-sph.r;max.y=sph.y+sph.r;
          min.z=sph.z-sph.r;max.z=sph.z+sph.r;
          }else
          {
          if(min.x>(sph.x-sph.r)) min.x=sph.x-sph.r;
          if(max.x<(sph.x+sph.r)) max.x=sph.x+sph.r;
          if(min.y>(sph.y-sph.r)) min.y=sph.y-sph.r;
          if(max.y<(sph.y+sph.r)) max.y=sph.y+sph.r;
          if(min.z>(sph.z-sph.r)) min.z=sph.z-sph.r;
          if(max.z<(sph.z+sph.r)) max.z=sph.z+sph.r;
          };
		
      }
    } // end of analysis of object



// Create a list of spheres that overlap with the current feature
/*
 for(j=0;j<(int)ChanNodeList->size();j++)
    {
    int count=0;
    int count2=0;
    Point node;
    node.x=ChanNodeList->at(j).x; node.y=ChanNodeList->at(j).y; node.z=ChanNodeList->at(j).z;
    node=uc->shiftXYZInUC(node);

    for(int i = 0; i < (int)object.size(); i++){
       Point p;
       p.x=object[i].x;p.y=object[i].y;p.z=object[i].z;
       Point p_shifted=uc->shiftXYZInUC(p);

       double dist = uc->calcDistanceXYZ(p.x,p.y,p.z,node.x,node.y,node.z);
       if(dist<0.01&&fabs(ChanNodeList->at(j).max_radius*SPHERE_SCALE-object[i].r)<0.01) 
          {
          count++; break;
          };

       if(dist<ChanNodeList->at(j).max_radius*SPHERE_SCALE+object[i].r)
         {
         count2++;
         };

       };

    if(count==0) // if node is not a part of the current feature
      {
      if(count2>0) {
        //origDNet->nodes[j] is an sphere overlapping with the current feature
        sph2.r=ChanNodeList->at(j).max_radius*SPHERE_SCALE;
        sph2.x=node.x; sph2.y=node.y; sph2.z=node.z;
        other_object.push_back(sph2);
        };
      };

    };
*/

// New version of code to find overlapping nodes

vector <int> conn_feat;

 for(j=0;j<(int)ChanNodeList->size();j++)
    {
    if(featnodemap->at(j)==curr_f)
      {
      for(i=0;i<(int)(ChanNodeList->at(j).connections.size());i++)      
         {
         if(featnodemap->at(ChanNodeList->at(j).connections.at(i).to)!=curr_f)
            {
            int flag=0;
            for(k=0;k<(int)conn_feat.size();k++)
               {
               if(conn_feat[k]==featnodemap->at(ChanNodeList->at(j).connections.at(i).to)) flag=1;
               };
            if(flag==0) conn_feat.push_back(featnodemap->at(ChanNodeList->at(j).connections.at(i).to));
            };
         };
      };
    }

for(i=0;i<(int)conn_feat.size();i++)
 for(j=0;j<(int)ChanNodeList->size();j++)
    {
    if(featnodemap->at(j)==i)
       {
       Point node;
       node[0]=ChanNodeList->at(j).x; node[1]=ChanNodeList->at(j).y; node[2]=ChanNodeList->at(j).z;
       node=uc->shiftXYZInUC(node);

       sph2.r=ChanNodeList->at(j).max_radius*SPHERE_SCALE;
       sph2.x=node[0]; sph2.y=node[1]; sph2.z=node[2];
       other_object.push_back(sph2);

       };
    };



cout << "Outside spheres list contain " << other_object.size() << " spheres (of " << ChanNodeList->size() << " nodes)." << "\n";


//

  box.x=max.x-min.x;
  box.y=max.y-min.y;
  box.z=max.z-min.z;
 
  volume=box.x*box.y*box.z;

//  cout << "Segment Box volume= " << volume << "\n"; 

// Now MC integration of surface

//int pos_origDNet;

SA_holo.resize(NBINS_SA_HOLO,0);
SA_holo_otherf.resize(NBINS_SA_HOLO,0);

for(step=0;step<NBINS_SA_HOLO;step++) // loop over all bins for surface area holograms
   {
   r_tr=(double)step*SA_HOLO_STEP;

   counter=0;

   for(j=0;j<(int)object.size();j++)
      {
      if(object[j].r>r_tr) { counter++;break;}; // at least one sphere larger than r_tr, sampling makes sense
      };


   if(counter>0)
     { // sampling makes sense

//     double totalSA = 0;
//     int sampleCount = 0;

     // Sample around each of the object's spheres
     for(int i = 0; i < (int)object.size(); i++){


        // now go to sampling

//        cout << "Object " << i << "\n"; cout.flush();

        int count = 0;
        int count_otherf=0;

        if(object[i].r-r_tr>0)
        for(int j = 0; j < N_MC_SA_SAMPLE; j++){

        bool overlap=false;
        bool overlap_otherf=false; // overlap with other features

        // Randomly sample point on a sphere of radius 1
        double theta = (rand()*1.0/RAND_MAX)*2*PI;
        double cosphi = 1.0 - (rand()*1.0/RAND_MAX)*2.0;
        double phi = acos(cosphi);

        // Convert spherical coordinates to xyz coordinates
        double xpoint = sin(phi)*cos(theta); //Don't need abs(sin(phi)) becase phi is from 0 to pi
        double ypoint = sin(phi)*sin(theta);
        double zpoint = cosphi;	
      
        // Scale the point to lie on a radius of r_probe + r_atom#i
        xpoint *= (object[i].r-r_tr);
        ypoint *= (object[i].r-r_tr);
        zpoint *= (object[i].r-r_tr);

        // move the point to the segment

        pt.x=object[i].x+xpoint;
        pt.y=object[i].y+ypoint;
        pt.z=object[i].z+zpoint;


        if(dimensionality<1)
          { // if the feature is not a channel, just check overlap with other spheres

          for(k=0;k<(int)object.size();k++)
             {
             if(k!=i)
                {
                if(calcEuclideanDistance(pt.x,pt.y,pt.z,object[k].x,object[k].y,object[k].z)<(object[k].r-r_tr)- 0.00001)
                   {
                   overlap=true; break;
                   };
                };
             };

          if(overlap==false) count++;


          //otherlap with other segments

         if(overlap==false)
         for(int jj=0;jj<(int)other_object.size();jj++)
            {
            Point p;
            p[0]=pt.x;p[1]=pt.y;p[2]=pt.z;
            Point p_shifted=uc->shiftXYZInUC(p);

            double dist = uc->calcDistanceXYZ(p[0],p[1],p[2],other_object[jj].x,other_object[jj].y,other_object[jj].z);

            if(dist<other_object[jj].r) {
                 overlap_otherf=true; break;
                 };

           };

 
          if(overlap_otherf==false) count_otherf++;

          }else{
          // sample points in case of channels, have to use pbc here

          // Convert (x,y,z) coordinates to ones relative to the unit cell vectors
          Point abc_coords = uc->xyz_to_abc(pt.x, pt.y, pt.z);

          abc_coords=uc->shiftABCInUC(abc_coords);
/*
          if(abc_coords.x<0||abc_coords.x>=1||abc_coords.y<0||abc_coords.y>=1||abc_coords.z<0||abc_coords.z>=1)
             {
             overlap=true;           
             };
*/
          if(overlap!=true)
            {
            for(k=0;k<(int)object.size();k++)
               {
               if(k!=i)
                  {
                  Point new_abc=uc->xyz_to_abc(object[k].x, object[k].y, object[k].z);
                  double centerDist = uc->calcDistanceABC(new_abc[0],new_abc[1],new_abc[2],abc_coords[0],abc_coords[1],abc_coords[2]);
                  if(centerDist < (object[k].r-r_tr) - 0.00001){
                     overlap=true; break;
                     };
                  };
               };

            };
          if(overlap==false) count++;

         // check otherlap with other segments
  
         if(overlap==false)
         for(int jk=0;jk<(int)other_object.size();jk++)
            {
            Point p;
            p[0]=pt.x;p[1]=pt.y;p[2]=pt.z;
            Point p_shifted=uc->shiftXYZInUC(p);

            double dist = uc->calcDistanceXYZ(p[0],p[1],p[2],other_object[jk].x,other_object[jk].y,other_object[jk].z);

            if(dist<other_object[jk].r) {
                 overlap_otherf=true; break;
                 };

           };
          

          if(overlap_otherf == false) 
	    count_otherf++;

          }; // end if, for channels (dim>0)

     
       }; // ends for(int j = 0; j < N_MC_SA_SAMPLE; j++){

//     cout << " count= " << count << "    cont_otherf= " << count_otherf << "\n";

     SA_holo[step]+= ((double)count/(double)N_MC_SA_SAMPLE)* 4.0 * PI * pow(object[i].r-r_tr,2);
     SA_holo_otherf[step]+= ((double)count_otherf/(double)N_MC_SA_SAMPLE)* 4.0 * PI * pow(object[i].r-r_tr,2);
     }; // ends for(int i = 0; i < (int)object.size() 

     }else   // from if(counter>0)
     {
     // surface area is 0
     SA_holo[step]=0;
     }; // ends  if(counter>0)

   }; // ends for(step=0;step<NBINS_SA_HOLO;step++)


cout << "##SA_holo:  " << name << "  Feature=  " << fid << "   ";
for(i=0;i<NBINS_SA_HOLO;i++)
   {
   cout << SA_holo[i] << "   ";
   };

cout << " Other:  ";
for(i=0;i<NBINS_SA_HOLO;i++)
   {
   cout << SA_holo_otherf[i] << "   ";
   };

cout << "\n";

//volume=volume*((double)(N_MC_SAMPLE-counter))/(double)N_MC_SAMPLE;

return SA_holo[0];


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x288, %rsp            # imm = 0x288
movq %r9, 0x228(%rsp)
movl %r8d, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x150(%rsp), %rdi
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
callq 0x84364
leaq 0x100(%rsp), %rdi
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
callq 0x84364
leaq 0x250(%rsp), %rdi
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
callq 0x84364
leaq 0xc0(%rsp), %rdi
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
callq 0x84364
xorl %r14d, %r14d
movq %r14, 0xf0(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0xe0(%rsp)
movq %r14, 0x190(%rsp)
movapd %xmm0, 0x180(%rsp)
movl $0x3b4ca6f5, %edi       # imm = 0x3B4CA6F5
callq 0x4410
movq %r14, 0x70(%rsp)
xorpd %xmm0, %xmm0
movapd %xmm0, 0x60(%rsp)
movq %r14, 0x90(%rsp)
movapd %xmm0, 0x80(%rsp)
movq 0x98(%rbx), %rax
cmpq 0x90(%rbx), %rax
movq %r15, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
je 0x7da73
leaq 0x1c0(%rsp), %rbp
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq 0xa8(%rbx), %rax
movq 0xb0(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x7ea46
leaq (%r14,%r14,2), %rbx
leaq (%rax,%rbx,8), %rsi
leaq 0x40(%rsp), %rdi
callq 0xe8f8
movq 0x38(%rsp), %rcx
movq 0x90(%rcx), %rax
movq 0x98(%rcx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
imulq %r13, %rdx
cmpq %r14, %rdx
jbe 0x7ea35
movq 0x40(%rsp), %rdi
cmpq %rdi, 0x48(%rsp)
je 0x7da3a
movq %r14, 0x98(%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl (%rax,%rbx,4), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdl 0x4(%rax,%rbx,4), %xmm1
xorps %xmm2, %xmm2
cvtsi2sdl 0x8(%rax,%rbx,4), %xmm2
movapd %xmm2, 0xa0(%rsp)
unpcklpd %xmm2, %xmm2            # xmm2 = xmm2[0,0]
movapd %xmm2, 0x210(%rsp)
movapd %xmm1, 0x170(%rsp)
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
movapd %xmm1, 0x120(%rsp)
movapd %xmm0, 0xb0(%rsp)
unpcklpd %xmm0, %xmm0            # xmm0 = xmm0[0,0]
movapd %xmm0, 0x200(%rsp)
movl $0x1, %r13d
xorl %ebx, %ebx
movslq (%rdi,%rbx,4), %rsi
movq 0x38(%rsp), %rax
movq 0x60(%rax), %r14
movq 0x68(%rax), %rdx
subq %r14, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rax # imm = 0x8E38E38E38E38E39
imulq %rax, %rdx
cmpq %rsi, %rdx
jbe 0x7ea0e
leaq (%rsi,%rsi,8), %r15
leaq (%r14,%r15,8), %rsi
addq $0x20, %rsi
movupd -0x20(%rsi), %xmm0
movupd -0x10(%rsi), %xmm1
movapd %xmm1, 0x1b0(%rsp)
movapd %xmm0, 0x1a0(%rsp)
movq %rbp, %rdi
callq 0x37e9e
leaq (%r14,%r15,8), %rax
movb 0x40(%rax), %cl
movb %cl, 0x20(%rbp)
movq 0x38(%rax), %rax
movq %rax, 0x18(%rbp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x108(%rax)
jle 0x7d7b3
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
movq 0x30(%rsp), %r15
jbe 0x7e9fd
movslq (%rax,%rbx,4), %rbx
movq 0x38(%rsp), %rcx
movq 0x60(%rcx), %rax
movq 0x68(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %rbx, %rdx
jbe 0x7e9fd
leaq (%rbx,%rbx,8), %rcx
movups 0x8(%rax,%rcx,8), %xmm0
movaps %xmm0, 0x130(%rsp)
movsd 0x18(%rax,%rcx,8), %xmm0
jmp 0x7d84d
movupd 0x1a8(%rsp), %xmm0
movupd 0xc0(%rax), %xmm1
mulpd 0x200(%rsp), %xmm1
addpd %xmm0, %xmm1
movupd 0xd8(%rax), %xmm0
mulpd 0x120(%rsp), %xmm0
addpd %xmm1, %xmm0
movupd 0xf0(%rax), %xmm1
mulpd 0x210(%rsp), %xmm1
addpd %xmm0, %xmm1
movapd %xmm1, 0x130(%rsp)
movsd 0xd0(%rax), %xmm0
mulsd 0xb0(%rsp), %xmm0
addsd 0x1b8(%rsp), %xmm0
movsd 0xe8(%rax), %xmm1
mulsd 0x170(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x100(%rax), %xmm0
mulsd 0xa0(%rsp), %xmm0
addsd %xmm1, %xmm0
movq 0x30(%rsp), %r15
movsd %xmm0, 0x140(%rsp)
movsd 0x1d8(%rsp), %xmm0
mulsd 0xd4969(%rip), %xmm0    # 0x1521d0
movsd %xmm0, 0x148(%rsp)
movq 0x68(%rsp), %rsi
cmpq 0x70(%rsp), %rsi
je 0x7d8a2
movapd 0x130(%rsp), %xmm0
movapd 0x140(%rsp), %xmm1
movupd %xmm1, 0x10(%rsi)
movupd %xmm0, (%rsi)
addq $0x20, %rsi
movq %rsi, 0x68(%rsp)
jmp 0x7d8b9
leaq 0x60(%rsp), %rdi
leaq 0x130(%rsp), %rdx
callq 0x499ba
movq 0x68(%rsp), %rsi
subq 0x60(%rsp), %rsi
cmpq $0x20, %rsi
jne 0x7d91f
movsd 0x148(%rsp), %xmm0
movapd 0x130(%rsp), %xmm1
movapd %xmm0, %xmm2
unpcklpd %xmm0, %xmm2            # xmm2 = xmm2[0],xmm0[0]
movapd %xmm1, %xmm3
subpd %xmm2, %xmm3
movapd %xmm3, 0x100(%rsp)
addpd %xmm1, %xmm2
movapd %xmm2, 0x150(%rsp)
movsd 0x140(%rsp), %xmm1
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x110(%rsp)
addsd %xmm1, %xmm0
jmp 0x7d9e2
movsd 0x100(%rsp), %xmm3
movsd 0x130(%rsp), %xmm1
movsd 0x148(%rsp), %xmm0
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
ucomisd %xmm2, %xmm3
jbe 0x7d951
movsd %xmm2, 0x100(%rsp)
addsd %xmm0, %xmm1
ucomisd 0x150(%rsp), %xmm1
jbe 0x7d969
movsd %xmm1, 0x150(%rsp)
movsd 0x108(%rsp), %xmm3
movsd 0x138(%rsp), %xmm1
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
ucomisd %xmm2, %xmm3
jbe 0x7d992
movsd %xmm2, 0x108(%rsp)
addsd %xmm0, %xmm1
ucomisd 0x158(%rsp), %xmm1
jbe 0x7d9aa
movsd %xmm1, 0x158(%rsp)
movsd 0x110(%rsp), %xmm3
movsd 0x140(%rsp), %xmm1
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
ucomisd %xmm2, %xmm3
jbe 0x7d9d3
movsd %xmm2, 0x110(%rsp)
addsd %xmm1, %xmm0
ucomisd 0x160(%rsp), %xmm0
jbe 0x7d9eb
movsd %xmm0, 0x160(%rsp)
movq 0x1c0(%rsp), %rdi
testq %rdi, %rdi
je 0x7da08
movq 0x1d0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movl %r13d, %ebx
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rax
subq %rdi, %rax
sarq $0x2, %rax
incl %r13d
cmpq %rbx, %rax
ja 0x7d6ca
movq 0x98(%rsp), %r14
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
testq %rdi, %rdi
je 0x7da4c
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x38(%rsp), %rbx
movq 0x98(%rbx), %rax
subq 0x90(%rbx), %rax
incl %r14d
sarq $0x2, %rax
imulq %r13, %rax
cmpq %r14, %rax
ja 0x7d5f3
xorpd %xmm0, %xmm0
movapd %xmm0, 0x1a0(%rsp)
movq $0x0, 0x1b0(%rsp)
movq (%r12), %rax
movq 0x8(%r12), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
imull $0x38e38e39, %edx, %edx # imm = 0x38E38E39
testl %edx, %edx
jle 0x7dc7d
xorl %r15d, %r15d
movabsq $-0x3333333333333333, %r14 # imm = 0xCCCCCCCCCCCCCCCD
movl $0x1, %r13d
movq 0x20(%rsp), %rbx
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
subq %rsi, %rdx
sarq $0x2, %rdx
cmpq %r15, %rdx
jbe 0x7ea24
movl 0x28(%rsp), %edx
cmpl %edx, (%rsi,%r15,4)
jne 0x7dc42
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rsi # imm = 0x8E38E38E38E38E39
imulq %rsi, %rdx
cmpq %r15, %rdx
jbe 0x7ea24
leaq (%r15,%r15,8), %rbp
movq 0x20(%rax,%rbp,8), %rsi
movq 0x28(%rax,%rbp,8), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
testl %edx, %edx
jle 0x7dc42
xorl %ebx, %ebx
movq %rbp, 0xb0(%rsp)
cmpq %rbx, %rdx
jbe 0x7ea21
leaq (%rbx,%rbx,4), %rdx
movslq 0x4(%rsi,%rdx,8), %rdi
movq 0x20(%rsp), %rdx
movq (%rdx), %r8
movq 0x8(%rdx), %rdx
subq %r8, %rdx
sarq $0x2, %rdx
cmpq %rdi, %rdx
jbe 0x7ea1c
movl (%r8,%rdi,4), %edx
cmpl 0x28(%rsp), %edx
je 0x7dbfd
movq 0x1a0(%rsp), %r9
movq 0x1a8(%rsp), %rsi
movq %rsi, %r10
subq %r9, %r10
shrq $0x2, %r10
movslq %r10d, %r10
testq %r10, %r10
jle 0x7dbc9
movq %rcx, %rbp
movq %r12, %rcx
movq %r14, %r12
xorl %r11d, %r11d
xorl %r14d, %r14d
cmpl %edx, (%r9,%r11,4)
cmovel %r13d, %r14d
incq %r11
cmpq %r11, %r10
jne 0x7dba3
testl %r14d, %r14d
movq %r12, %r14
movq %rcx, %r12
movq %rbp, %rcx
movq 0xb0(%rsp), %rbp
jne 0x7dbfd
cmpq 0x1b0(%rsp), %rsi
je 0x7dbe3
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x1a8(%rsp)
jmp 0x7dbfd
leaq (%r8,%rdi,4), %rdx
leaq 0x1a0(%rsp), %rdi
callq 0xf864
movq (%r12), %rax
movq 0x8(%r12), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rsi # imm = 0x8E38E38E38E38E39
imulq %rsi, %rdx
cmpq %r15, %rdx
jbe 0x7ea24
incq %rbx
movq 0x20(%rax,%rbp,8), %rsi
movq 0x28(%rax,%rbp,8), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
movslq %edx, %rdi
cmpq %rdi, %rbx
jl 0x7db36
incq %r15
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
imull $0x38e38e39, %edx, %edx # imm = 0x38E38E39
movslq %edx, %rdx
cmpq %rdx, %r15
movq 0x20(%rsp), %rbx
jl 0x7dac5
movq 0x1a0(%rsp), %rdx
movq 0x1a8(%rsp), %rsi
movq 0x30(%rsp), %r15
jmp 0x7dc86
xorl %edx, %edx
xorl %esi, %esi
movq 0x20(%rsp), %rbx
subq %rdx, %rsi
shlq $0x1e, %rsi
testq %rsi, %rsi
jle 0x7df44
xorl %r13d, %r13d
leaq 0x40(%rsp), %rbp
movq %rcx, %rsi
subq %rax, %rsi
shrq $0x3, %rsi
imull $0x38e38e39, %esi, %esi # imm = 0x38E38E39
testl %esi, %esi
jle 0x7df26
xorl %r14d, %r14d
xorl %r15d, %r15d
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
subq %rsi, %rdx
sarq $0x2, %rdx
cmpq %r15, %rdx
jbe 0x7ea24
movslq (%rsi,%r15,4), %rdx
cmpq %rdx, %r13
jne 0x7def6
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %rbp, %rdi
callq 0x83f68
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %r15, %rdx
jbe 0x7e9ec
movsd 0x8(%rax,%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbp, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %r15, %rdx
jbe 0x7e9ec
movsd 0x10(%rax,%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbp, %rdi
movl $0x1, %esi
callq 0x83f9a
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %r15, %rdx
jbe 0x7e9ec
movsd 0x18(%rax,%r14), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbp, %rdi
movl $0x2, %esi
callq 0x83f9a
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
leaq 0x1e8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x53b0e
movq 0x1f8(%rsp), %rax
movq %rax, 0x50(%rsp)
movupd 0x1e8(%rsp), %xmm0
movapd %xmm0, 0x40(%rsp)
movq (%r12), %rax
movq 0x8(%r12), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %r15, %rdx
jbe 0x7e9ec
movsd 0x38(%rax,%r14), %xmm0
mulsd 0xd4387(%rip), %xmm0    # 0x1521d0
movsd %xmm0, 0x248(%rsp)
movq %rbp, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x230(%rsp)
movq %rbp, %rdi
movl $0x1, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x238(%rsp)
movq %rbp, %rdi
movl $0x2, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x240(%rsp)
movq 0x88(%rsp), %rsi
cmpq 0x90(%rsp), %rsi
je 0x7ded8
movupd 0x230(%rsp), %xmm0
movupd 0x240(%rsp), %xmm1
movupd %xmm1, 0x10(%rsi)
movupd %xmm0, (%rsi)
addq $0x20, %rsi
movq %rsi, 0x88(%rsp)
jmp 0x7deed
leaq 0x80(%rsp), %rdi
leaq 0x230(%rsp), %rdx
callq 0x499ba
movq (%r12), %rax
movq 0x8(%r12), %rcx
incq %r15
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
imull $0x38e38e39, %edx, %edx # imm = 0x38E38E39
movslq %edx, %rdx
addq $0x48, %r14
cmpq %rdx, %r15
jl 0x7dcbc
movq 0x1a0(%rsp), %rdx
movq 0x30(%rsp), %r15
incq %r13
movq 0x1a8(%rsp), %rsi
subq %rdx, %rsi
shrq $0x2, %rsi
movslq %esi, %rsi
cmpq %rsi, %r13
jl 0x7dc9e
movq 0x117075(%rip), %rdi    # 0x194fc0
leaq 0xd6fed(%rip), %rsi     # 0x154f3f
movl $0x1d, %edx
callq 0x44e0
movq 0x88(%rsp), %rsi
subq 0x80(%rsp), %rsi
sarq $0x5, %rsi
movq 0x117049(%rip), %rdi    # 0x194fc0
callq 0x42b0
movq %rax, %rbx
leaq 0xd6fd7(%rip), %rsi     # 0x154f5d
movl $0xd, %edx
movq %rax, %rdi
callq 0x44e0
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x3, %rsi
movabsq $-0x71c71c71c71c71c7, %rax # imm = 0x8E38E38E38E38E39
imulq %rax, %rsi
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rbx
leaq 0xd6fab(%rip), %rsi     # 0x154f6b
movl $0x8, %edx
movq %rax, %rdi
callq 0x44e0
leaq 0xd564a(%rip), %rsi     # 0x15361e
movl $0x1, %edx
movq %rbx, %rdi
callq 0x44e0
movapd 0x150(%rsp), %xmm0
subpd 0x100(%rsp), %xmm0
movsd 0x160(%rsp), %xmm1
subsd 0x110(%rsp), %xmm1
movapd %xmm0, 0x250(%rsp)
movsd %xmm1, 0x260(%rsp)
leaq 0x40(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0xe0(%rsp), %rdi
movl $0x1, %esi
callq 0x48ca6
leaq 0x40(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x180(%rsp), %rdi
movl $0x1, %esi
callq 0x48ca6
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x5, %rdx
movslq %edx, %rsi
testq %rsi, %rsi
jle 0x7e08a
leaq 0x18(%rax), %rdi
xorpd %xmm0, %xmm0
movsd (%rdi), %xmm1
ucomisd %xmm0, %xmm1
ja 0x7e09e
addq $0x20, %rdi
decq %rsi
jne 0x7e077
movq 0xe0(%rsp), %rax
movq $0x0, (%rax)
jmp 0x7e815
testl %edx, %edx
jle 0x7e815
xorl %ebx, %ebx
leaq 0x40(%rsp), %r12
leaq 0x1e8(%rsp), %r13
movq %rbx, %rsi
shlq $0x5, %rsi
movsd 0x18(%rax,%rsi), %xmm1
ucomisd 0xd3286(%rip), %xmm1    # 0x151350
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
jbe 0x7e796
movq %rsi, 0x200(%rsp)
xorl %edx, %edx
xorl %eax, %eax
movl $0x0, 0x98(%rsp)
movl %edx, 0x120(%rsp)
movl %eax, 0x210(%rsp)
callq 0x4150
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0xd34df(%rip), %xmm0    # 0x1515f0
addsd %xmm0, %xmm0
mulsd 0xd34f3(%rip), %xmm0    # 0x151610
movsd %xmm0, 0x20(%rsp)
callq 0x4150
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
divsd 0xd34e1(%rip), %xmm0    # 0x151618
addsd %xmm0, %xmm0
addsd 0xcef15(%rip), %xmm0    # 0x14d058
movsd %xmm0, 0x28(%rsp)
callq 0x4400
movsd %xmm0, 0xa0(%rsp)
callq 0x4100
movapd %xmm0, 0xb0(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x4800
movaps %xmm0, 0x170(%rsp)
movsd 0xa0(%rsp), %xmm0
callq 0x4100
movaps %xmm0, 0xa0(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x4100
movsd 0x28(%rsp), %xmm2
movq 0x60(%rsp), %rax
movq 0x200(%rsp), %rcx
movsd 0x18(%rax,%rcx), %xmm1
mulsd %xmm1, %xmm2
movapd 0xb0(%rsp), %xmm3
unpcklpd 0xa0(%rsp), %xmm3       # xmm3 = xmm3[0],mem[0]
movapd 0x170(%rsp), %xmm4
unpcklpd %xmm0, %xmm4            # xmm4 = xmm4[0],xmm0[0]
mulpd %xmm3, %xmm4
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm4, %xmm1
movupd (%rax,%rcx), %xmm0
addpd %xmm1, %xmm0
movapd %xmm0, 0xc0(%rsp)
addsd 0x10(%rax,%rcx), %xmm2
movsd %xmm2, 0xd0(%rsp)
movq 0x38(%rsp), %rcx
cmpl $0x0, 0x108(%rcx)
jle 0x7e52d
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
movq %r12, %rdi
movq %r15, %rsi
callq 0x52eec
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x40(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x53a92
movq 0x1f8(%rsp), %rax
movq %rax, 0x50(%rsp)
movupd 0x1e8(%rsp), %xmm0
movapd %xmm0, 0x40(%rsp)
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shlq $0x1b, %rdx
movabsq $0x100000000, %rsi      # imm = 0x100000000
cmpq %rsi, %rdx
jl 0x7e3ab
xorl %r14d, %r14d
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x7e38e
movsd (%rax,%r14), %xmm0
movsd 0x8(%rax,%r14), %xmm1
movsd 0x10(%rax,%r14), %xmm2
movq %r13, %rdi
movq %r15, %rsi
callq 0x52eec
movq %r13, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r13, %rdi
movl $0x1, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r13, %rdi
movl $0x2, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0xb0(%rsp)
movq %r12, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x170(%rsp)
movq %r12, %rdi
movl $0x1, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0xa0(%rsp)
movq %r12, %rdi
movl $0x2, %esi
callq 0x83f9a
movsd (%rax), %xmm5
movq %r15, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
movsd 0xb0(%rsp), %xmm2
movsd 0x170(%rsp), %xmm3
movsd 0xa0(%rsp), %xmm4
callq 0x5339c
movq 0x60(%rsp), %rax
movsd 0x18(%rax,%r14), %xmm1
addsd 0xd6901(%rip), %xmm1    # 0x154c80
ucomisd %xmm0, %xmm1
ja 0x7e73a
movq 0x68(%rsp), %rcx
incq %rbp
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x5, %rdx
movslq %edx, %rdx
addq $0x20, %r14
cmpq %rdx, %rbp
jl 0x7e28d
incl 0x98(%rsp)
movq 0x88(%rsp), %rax
subq 0x80(%rsp), %rax
shrq $0x5, %rax
testl %eax, %eax
jle 0x7e73a
xorl %r14d, %r14d
xorl %ebp, %ebp
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %r13, %rdi
callq 0x83f68
movsd 0xc0(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0xc8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r13, %rdi
movl $0x1, %esi
callq 0x83f9a
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0xd0(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r13, %rdi
movl $0x2, %esi
callq 0x83f9a
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x1f8(%rsp), %rax
movq %rax, 0x10(%rsp)
movupd 0x1e8(%rsp), %xmm0
movupd %xmm0, (%rsp)
leaq 0x270(%rsp), %rdi
movq %r15, %rsi
callq 0x53b0e
movq %r13, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r13, %rdi
movl $0x1, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r13, %rdi
movl $0x2, %esi
callq 0x83f9a
movsd (%rax), %xmm2
movq 0x80(%rsp), %rax
movsd (%rax,%r14), %xmm3
movsd 0x8(%rax,%r14), %xmm4
movsd 0x10(%rax,%r14), %xmm5
movq %r15, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x5364c
movq 0x80(%rsp), %rax
movsd 0x18(%rax,%r14), %xmm1
ucomisd %xmm0, %xmm1
ja 0x7e72f
incq %rbp
movq 0x88(%rsp), %rcx
subq %rax, %rcx
shrq $0x5, %rcx
movslq %ecx, %rax
addq $0x20, %r14
cmpq %rax, %rbp
jl 0x7e3d3
jmp 0x7e72f
movq 0x68(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shlq $0x1b, %rdx
testq %rdx, %rdx
jle 0x7e5bc
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x7e5a3
movsd 0xc0(%rsp), %xmm0
movsd 0xc8(%rsp), %xmm1
movsd 0xd0(%rsp), %xmm2
movsd (%rax,%r14), %xmm3
movsd 0x8(%rax,%r14), %xmm4
movsd 0x10(%rax,%r14), %xmm5
callq 0x84cbb
movq 0x60(%rsp), %rax
movsd 0x18(%rax,%r14), %xmm1
addsd 0xd66ec(%rip), %xmm1    # 0x154c80
ucomisd %xmm0, %xmm1
ja 0x7e741
movq 0x68(%rsp), %rcx
incq %r15
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x5, %rdx
movslq %edx, %rdx
addq $0x20, %r14
cmpq %rdx, %r15
jl 0x7e547
incl 0x98(%rsp)
movq 0x88(%rsp), %rax
subq 0x80(%rsp), %rax
shrq $0x5, %rax
testl %eax, %eax
jle 0x7e741
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x30(%rsp), %r15
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %r12, %rdi
callq 0x83f68
movsd 0xc0(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0xc8(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movl $0x1, %esi
callq 0x83f9a
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movsd 0xd0(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movl $0x2, %esi
callq 0x83f9a
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movupd 0x40(%rsp), %xmm0
movupd %xmm0, (%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x53b0e
movq %r12, %rdi
xorl %esi, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq %r12, %rdi
movl $0x1, %esi
callq 0x83f9a
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq %r12, %rdi
movl $0x2, %esi
callq 0x83f9a
movsd (%rax), %xmm2
movq 0x80(%rsp), %rax
movsd (%rax,%r14), %xmm3
movsd 0x8(%rax,%r14), %xmm4
movsd 0x10(%rax,%r14), %xmm5
movq %r15, %rdi
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x5364c
movq 0x80(%rsp), %rax
movsd 0x18(%rax,%r14), %xmm1
ucomisd %xmm0, %xmm1
ja 0x7e72f
incq %rbp
movq 0x88(%rsp), %rcx
subq %rax, %rcx
shrq $0x5, %rcx
movslq %ecx, %rax
addq $0x20, %r14
cmpq %rax, %rbp
jl 0x7e5e9
xorl %eax, %eax
ucomisd %xmm0, %xmm1
setbe %al
jmp 0x7e74b
movl $0x1, %eax
jmp 0x7e74b
movl $0x1, %eax
movq 0x30(%rsp), %r15
movl 0x120(%rsp), %edx
movl 0x210(%rsp), %ecx
addl %eax, %ecx
movl %ecx, %eax
incl %edx
cmpl $0x1f4, %edx            # imm = 0x1F4
jne 0x7e0ef
xorps %xmm2, %xmm2
cvtsi2sdl 0x98(%rsp), %xmm2
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
movq 0x60(%rsp), %rax
movq 0x68(%rsp), %rcx
movq 0x200(%rsp), %rsi
movsd 0x18(%rax,%rsi), %xmm1
movsd 0xd64ea(%rip), %xmm4    # 0x154c88
divsd %xmm4, %xmm2
movsd 0xd2e76(%rip), %xmm5    # 0x151620
mulsd %xmm5, %xmm2
movsd 0xd2e5a(%rip), %xmm3    # 0x151610
mulsd %xmm3, %xmm2
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
movq 0xe0(%rsp), %rdx
addsd (%rdx), %xmm1
movsd %xmm1, (%rdx)
divsd %xmm4, %xmm0
mulsd %xmm5, %xmm0
mulsd %xmm3, %xmm0
movsd 0x18(%rax,%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm1
movq 0x180(%rsp), %rdx
addsd (%rdx), %xmm1
movsd %xmm1, (%rdx)
incq %rbx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x5, %rdx
movslq %edx, %rdx
cmpq %rdx, %rbx
jl 0x7e0b5
movq 0x1167a4(%rip), %rbx    # 0x194fc0
leaq 0xd6751(%rip), %rsi     # 0x154f74
movl $0xc, %edx
movq %rbx, %rdi
callq 0x44e0
movq 0x228(%rsp), %r14
testq %r14, %r14
je 0x7e859
movq %r14, %rdi
callq 0x41e0
movq 0x116774(%rip), %rdi    # 0x194fc0
movq %r14, %rsi
movq %rax, %rdx
callq 0x44e0
jmp 0x7e870
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %rdi
movl 0x20(%rbx,%rax), %esi
orl $0x1, %esi
callq 0x4710
movq 0x116749(%rip), %rdi    # 0x194fc0
leaq 0xd6703(%rip), %rsi     # 0x154f81
movl $0xc, %edx
callq 0x44e0
movl 0x2c0(%rsp), %esi
movq 0x11672a(%rip), %rdi    # 0x194fc0
callq 0x4750
leaq 0xcec3c(%rip), %rsi     # 0x14d4de
movl $0x3, %edx
movq %rax, %rdi
callq 0x44e0
movq 0xe0(%rsp), %rax
movsd (%rax), %xmm0
movq 0x1166fe(%rip), %rdi    # 0x194fc0
callq 0x46b0
leaq 0xcec10(%rip), %rsi     # 0x14d4de
movl $0x3, %edx
movq %rax, %rdi
callq 0x44e0
movq 0x1166de(%rip), %rdi    # 0x194fc0
leaq 0xd66a5(%rip), %rsi     # 0x154f8e
movl $0x9, %edx
callq 0x44e0
movq 0x180(%rsp), %rax
movsd (%rax), %xmm0
movq 0x1166ba(%rip), %rdi    # 0x194fc0
callq 0x46b0
leaq 0xcebcc(%rip), %rsi     # 0x14d4de
movl $0x3, %edx
movq %rax, %rdi
callq 0x44e0
movq 0x11669a(%rip), %rdi    # 0x194fc0
leaq 0xd4cf1(%rip), %rsi     # 0x15361e
movl $0x1, %edx
callq 0x44e0
movq 0xe0(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x1a0(%rsp), %rdi
testq %rdi, %rdi
je 0x7e966
movq 0x1b0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x7e983
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x7e99a
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x180(%rsp), %rdi
testq %rdi, %rdi
je 0x7e9b7
movq 0x190(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0x7e9d4
movq 0xf0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movsd 0x38(%rsp), %xmm0
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xced02(%rip), %rdi     # 0x14d6f5
movq %r15, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xcecf1(%rip), %rdi     # 0x14d6f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xcece0(%rip), %rdi     # 0x14d6f5
xorl %eax, %eax
callq 0x4630
movq %rdi, %r15
jmp 0x7ea24
movq %rbx, %r15
leaq 0xcecca(%rip), %rdi     # 0x14d6f5
movq %r15, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xcecb9(%rip), %rdi     # 0x14d6f5
movq %r14, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xceca8(%rip), %rdi     # 0x14d6f5
movq %r14, %rsi
xorl %eax, %eax
callq 0x4630
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7ea5d
movq %rax, %rbx
jmp 0x7eadc
jmp 0x7ea76
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7ea7b
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7ea76
movq %rax, %rbx
jmp 0x7ea9b
movq %rax, %rbx
movq 0x1c0(%rsp), %rdi
testq %rdi, %rdi
je 0x7ea9b
movq 0x1d0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x7eadc
movq 0x50(%rsp), %rsi
jmp 0x7ead4
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7eabc
jmp 0x7eabc
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
testq %rdi, %rdi
je 0x7eadc
movq 0x1b0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x7eaf9
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x7eb10
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x180(%rsp), %rdi
testq %rdi, %rdi
je 0x7eb2d
movq 0x190(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0x7eb4a
movq 0xf0(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780