// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/network.cc
// Function: getStructureInformation(char*, char*, ATOM_NETWORK*, bool)
void getStructureInformation(char *filename, char *filenameExtendedOutput, ATOM_NETWORK *atmnet, bool extendedOutput){

 // to speed up calculations, identify atoms on the "surface" of the unit cell 

 vector <int> surfaceIDs;
 vector <bool> surfaceFlag;

 double surface_slab_d = 2.5; // cutoff distance from the surface 

 double a_step = surface_slab_d/atmnet->a;
 double b_step = surface_slab_d/atmnet->b;
 double c_step = surface_slab_d/atmnet->c;

 surfaceFlag.resize(atmnet->atoms.size(), false);

 if(a_step>=1.0 || b_step>=1.0 || c_step>=1.0)
   {//no speed up
   for(unsigned int i = 0; i < atmnet->atoms.size(); i++) 
      {
      surfaceIDs.push_back(i);
      surfaceFlag.at(i) = true;
      };
   cout << "Small unit cell. All(" << atmnet->atoms.size() << ") atoms considered to be on the unit cell surface." << endl;
   }else
   {
   for(unsigned int i = 0; i < atmnet->atoms.size(); i++)
      {
      double a = atmnet->atoms.at(i).a_coord; double b = atmnet->atoms.at(i).b_coord; double c = atmnet->atoms.at(i).c_coord;

      if(a < a_step || a > (1-a_step) || b < b_step || b > (1-b_step) || c < c_step || c > (1-c_step) )
        {
        surfaceIDs.push_back(i); surfaceFlag.at(i) = true;
        };
      };
   cout << "Big unit cell. " << surfaceIDs.size() << " out of " << atmnet->atoms.size() << " atoms considered to be on the unit cell surface. Surface definition = " << surface_slab_d << endl;
   };



 // Define connectivity of atoms in terms of Dijkstra graph
 DIJKSTRA_NETWORK DijkstraAtomNetwork;
 DijkstraAtomNetwork.v_a = atmnet->v_a;  DijkstraAtomNetwork.v_b = atmnet->v_b; DijkstraAtomNetwork.v_c = atmnet->v_c;

 for(unsigned int i = 0; i < atmnet->atoms.size(); i++)
    {
    DijkstraAtomNetwork.nodes.push_back(DIJKSTRA_NODE(i, atmnet->atoms.at(i).x, atmnet->atoms.at(i).y, atmnet->atoms.at(i).z,
                                                           lookupCovRadius(atmnet->atoms.at(i).type), true));
    };
 // now need to update CONN connections for each node

 for(unsigned int i = 0; i < DijkstraAtomNetwork.nodes.size(); i++)
    {
    XYZ atom1(DijkstraAtomNetwork.nodes.at(i).x, DijkstraAtomNetwork.nodes.at(i).y, DijkstraAtomNetwork.nodes.at(i).z);
// CONN(int myFrom, int myTo, double len, double maxR, DELTA_POS deltaP);
// DELTA_POS(int myX = 0, int myY = 0, int myZ = 0);

    for(int x=-1; x<2; x++) // loop over all unit cells
    for(int y=-1; y<2; y++)
    for(int z=-1; z<2; z++)
       {
       if(x==0 && y==0 && z==0)
         { // connectivity inside cell
         for(unsigned int j = i+1; j < DijkstraAtomNetwork.nodes.size(); j++)
            {
            XYZ atom2(DijkstraAtomNetwork.nodes.at(j).x, DijkstraAtomNetwork.nodes.at(j).y, DijkstraAtomNetwork.nodes.at(j).z);
            XYZ va = DijkstraAtomNetwork.v_a; XYZ vb = DijkstraAtomNetwork.v_b; XYZ vc = DijkstraAtomNetwork.v_c;
            atom2 = atom2 + va.scale(x) + vb.scale(y) + vc.scale(z);
            double dist = calcEuclideanDistance(atom1.x, atom1.y, atom1.z, atom2.x, atom2.y, atom2.z);
            if(dist < DijkstraAtomNetwork.nodes.at(i).max_radius + DijkstraAtomNetwork.nodes.at(j).max_radius + 0.4)
               { // connected;
               DijkstraAtomNetwork.nodes.at(i).connections.push_back(CONN(i, j, dist, 0.10, DELTA_POS (x,y,z)));
               DijkstraAtomNetwork.nodes.at(j).connections.push_back(CONN(j, i, dist, 0.10, DELTA_POS (x,y,z)));
               };
            };
         }else
         { // connectivity outside cell
         if(surfaceFlag.at(i) == true) // only investigate if surface atom (other will not have a chance to be connected)
           {
           for(unsigned int k = 0; k < surfaceIDs.size(); k++)
              {
              unsigned int j = surfaceIDs.at(k);

              XYZ atom2(DijkstraAtomNetwork.nodes.at(j).x, DijkstraAtomNetwork.nodes.at(j).y, DijkstraAtomNetwork.nodes.at(j).z);
              XYZ va = DijkstraAtomNetwork.v_a; XYZ vb = DijkstraAtomNetwork.v_b; XYZ vc = DijkstraAtomNetwork.v_c; 
              atom2 = atom2 + va.scale(x) + vb.scale(y) + vc.scale(z);

              double dist = calcEuclideanDistance(atom1.x, atom1.y, atom1.z, atom2.x, atom2.y, atom2.z);
              if(dist < DijkstraAtomNetwork.nodes.at(i).max_radius + DijkstraAtomNetwork.nodes.at(j).max_radius + 0.4)
                 { // connected
                 DijkstraAtomNetwork.nodes.at(i).connections.push_back(CONN(i, j, dist, 0.10, DELTA_POS (x,y,z)));
                 };
              }; // ends loop over k
            }; // ends surfaceFlag.at(i) if

        }; // end loop over cells outside the central cell
       }; //ends loop over supercell (x,y,z)
    };


 // Find frameworks
 vector<bool> accessInfo;
 vector<PORE> structureSegments;
 PORE::findChannelsAndPockets(&DijkstraAtomNetwork, &accessInfo, &structureSegments);

 // Save output
 fstream output;
 output.open(filename, fstream::out);
 int nPockets=0, nChan1D=0, nChan2D=0, nChan3D=0;
 for(unsigned int i = 0; i < structureSegments.size(); i++){
    if(structureSegments[i].dimensionality == 0) nPockets++;
    if(structureSegments[i].dimensionality == 1) nChan1D++;
    if(structureSegments[i].dimensionality == 2) nChan2D++;
    if(structureSegments[i].dimensionality == 3) nChan3D++;
    };
 output << filename << "   "<< atmnet->returnChemicalFormula() << "   " << structureSegments.size() << " segments: " << (structureSegments.size() - nPockets) << " framework(s) (1D/2D/3D " 
        << nChan1D << " " << nChan2D << " " << nChan3D
        << " ) and  "  << nPockets << "  molecule(s). Identified dimensionality of framework(s): ";
 for(unsigned int i = 0; i < structureSegments.size(); i++){
    if(structureSegments[i].dimensionality > 0 ) output << structureSegments[i].dimensionality << " ";
    };
 output << "\n";
 output.close();

 // Save extended output: coordinates with framework and molecule ID


// original function
/*
 if(extendedOutput == true)
   {
   fstream output2;
   output2.open(filenameExtendedOutput, fstream::out);

   for(unsigned int i = 0; i < structureSegments.size(); i++)
      {
      for(unsigned int j = 0; j< structureSegments[i].reverseIDMappings.size(); j++)
         {
         int atomID = structureSegments[i].reverseIDMappings.find(j)->second;
         output2 << atmnet->atoms.at(atomID).type << "    ";
//         output2 << atmnet->atoms.at(atomID).x << "   " << atmnet->atoms.at(atomID).y << "   "
//                 << atmnet->atoms.at(atomID).z << "   " ;
         output2 << structureSegments[i].nodes.at(j).x << "   " << structureSegments[i].nodes.at(j).y << "  "
                 << structureSegments[i].nodes.at(j).z << "   ";
         output2 << atmnet->atoms.at(atomID).a_coord << "   "
                 << atmnet->atoms.at(atomID).b_coord << "   " << atmnet->atoms.at(atomID).c_coord << "   "
                 << structureSegments[i].dimensionality << "   " << i << "   ";
         output2 << structureSegments[i].unitCells.size();
         output2 << "\n";
         };
      };

   output2 << "#Center of mass information(XYZ coords, no atoms, ABC coordinates, and radii)\n";
   for(unsigned int i = 0; i < structureSegments.size(); i++)
      {
      pair <XYZ,double> COM = structureSegments[i].getCenterOfMass();
      Point p(COM.first.x, COM.first.y, COM.first.z);
      Point pabc = atmnet->xyz_to_abc(atmnet->shiftXYZInUC(p));
      output2 << "X    " << COM.first.x << "  " << COM.first.y << "  " << COM.first.z << "      ";
      output2 << structureSegments[i].nodes.size() << "    ";
      output2 << pabc[0] << "  " << pabc[1] << "  " << pabc[2] << "     ";
      output2 << i << "  " << 2.0*(COM.second-1.5) << "\n";   // 1.5 stands for average radii of atoms
                                                              // 2.0 multiplyer to convert to diameters
      };

   output2.close();
   };
*/


/* Analysis of cages ONLY 
 * for Ismael  */
/*
 if(extendedOutput == true)
   {
   fstream output2;
   output2.open(filenameExtendedOutput, fstream::out);

   for(unsigned int i = 0; i < structureSegments.size(); i++)
      {
      if(structureSegments[i].dimensionality == 0)
        {
        vector < pair <int,XYZ> > cageReconstructedCoords = structureSegments[i].getReconstructedPore();
        
        for(unsigned int j = 0; j< structureSegments[i].reverseIDMappings.size(); j++)
           {
           int atomID = structureSegments[i].reverseIDMappings.find((cageReconstructedCoords.at(j).first))->second;
           output2 << atmnet->atoms.at(atomID).type << "    ";
           output2 << atmnet->atoms.at(atomID).x << "   " << atmnet->atoms.at(atomID).y << "   "
                   << atmnet->atoms.at(atomID).z << "   " ;
           output2 << atmnet->atoms.at(atomID).radius << "   ";
           output2 << structureSegments[i].nodes.at(j).x << "   " << structureSegments[i].nodes.at(j).y << "  "
                   << structureSegments[i].nodes.at(j).z << "   ";
*/
/* DEBUG
           output2 << atmnet->atoms.at(atomID).a_coord << "   "
                   << atmnet->atoms.at(atomID).b_coord << "   " << atmnet->atoms.at(atomID).c_coord << "   "
                   << structureSegments[i].dimensionality << "   " << i << "   ";
         output2 << structureSegments[i].unitCells.size();
*/
/*
           output2 << cageReconstructedCoords.at(j).second.x << "  " << cageReconstructedCoords.at(j).second.y << "  "
                   << cageReconstructedCoords.at(j).second.z << "  ";
          output2 << "  " << i << "  ";
          output2 << "\n";
            };
         };
      };


   output2.close();
   };
*/

 /* Alternative version of the above, which saves multiple copies of molecules that cross boundry */
//getReconstructredPoresWithCrossBoundryCopies

 if(extendedOutput == true)
   {
   fstream output2;
   output2.open(filenameExtendedOutput, fstream::out);

   for(unsigned int i = 0; i < structureSegments.size(); i++)
      {
      if(structureSegments[i].dimensionality == 0)
        {
        vector< vector < pair <int,XYZ> > > cagesMultipleCopiesReconstructedCoords = structureSegments[i].getReconstructredPoresWithCrossBoundryCopies();

        vector < pair <int,int> > cageBonds;

        for(unsigned int m = 0; m < cagesMultipleCopiesReconstructedCoords[0].size(); m++)
           for(unsigned int n = m + 1; n < cagesMultipleCopiesReconstructedCoords[0].size(); n++)
              {
              int atomID1 = structureSegments[i].reverseIDMappings.find((cagesMultipleCopiesReconstructedCoords[0].at(m).first))->second;
              int atomID2 = structureSegments[i].reverseIDMappings.find((cagesMultipleCopiesReconstructedCoords[0].at(n).first))->second;

              if(cagesMultipleCopiesReconstructedCoords[0].at(m).second.euclid_dist(cagesMultipleCopiesReconstructedCoords[0].at(n).second)
                     < ( lookupCovRadius(atmnet->atoms.at(atomID1).type) + lookupCovRadius(atmnet->atoms.at(atomID2).type) + 0.45 ))
                     {
                     cageBonds.push_back(pair <int,int> (m,n));
                     //if(i==28) cout << m << "   " << n << endl;
                     };
              };
//        cout << "Molecule: " << i << " Atoms: " << cagesMultipleCopiesReconstructedCoords[0].size() << " Bonds: " << cageBonds.size() << endl;

        for(unsigned int k = 0; k< cagesMultipleCopiesReconstructedCoords.size(); k++)
           {
           /* beging loop over all atoms/to be saved in frmaid format */
/*
           for(unsigned int j = 0; j< structureSegments[i].reverseIDMappings.size(); j++)
              {
              int atomID = structureSegments[i].reverseIDMappings.find((cagesMultipleCopiesReconstructedCoords[k].at(j).first))->second;
              output2 << atmnet->atoms.at(atomID).type << "    ";
              output2 << atmnet->atoms.at(atomID).x << "   " << atmnet->atoms.at(atomID).y << "   "
                      << atmnet->atoms.at(atomID).z << "   " ;
              output2 << atmnet->atoms.at(atomID).radius << "   ";
              output2 << structureSegments[i].nodes.at(j).x << "   " << structureSegments[i].nodes.at(j).y << "  "
                      << structureSegments[i].nodes.at(j).z << "   ";
              output2 << cagesMultipleCopiesReconstructedCoords[k].at(j).second.x << "  " << cagesMultipleCopiesReconstructedCoords[k].at(j).second.y << "  "
                   << cagesMultipleCopiesReconstructedCoords[k].at(j).second.z << "  ";
              output2 << "  " << i << "  " << k << " ";
              output2 << "\n";
              };
 */
           /* ends saving file in frameid format */

           /* beging loop over all atoms in SDF format */

           /* SDF header */
           output2 << i << endl;
           output2 << "Zeomolecule" << endl << endl;
           output2 << "  " << structureSegments[i].reverseIDMappings.size() << " " << cageBonds.size() << " 0     0  0  0  0  0  0999 V2000\n"; 
           for(unsigned int j = 0; j< structureSegments[i].reverseIDMappings.size(); j++)
              {
              int atomID = structureSegments[i].reverseIDMappings.find((cagesMultipleCopiesReconstructedCoords[k].at(j).first))->second;
              output2 << "    ";
              output2 << cagesMultipleCopiesReconstructedCoords[k].at(j).second.x << "  " << cagesMultipleCopiesReconstructedCoords[k].at(j).second.y << "  "
                   << cagesMultipleCopiesReconstructedCoords[k].at(j).second.z << "  ";
              output2 << atmnet->atoms.at(atomID).type << "   0  0  0  0  0  0  0  0  0  0  0  0\n";
              };
           for(unsigned int k = 0; k < cageBonds.size(); k++)
              {
              output2 << cageBonds[k].first << "  " << cageBonds[k].second << " 1 0 0 0 0\n" ;
              };
           output2 << "M  END\n$$$$\n";  
           /* ends saving file in SDF format */

           }; // ends for loop over copies of the segment i (each molecule)
         }; // ends if(structureSegments[i].dimensionality == 0)
      };


   output2.close();
   };




/* Save additional atom statistics */
/*
 if(extendedOutput == true)
   {
   fstream output2;
   output2.open(filenameExtendedOutput, fstream::out);


   int nMetals=0, nCs=0, nHs=0;
   std::map<std::string,int> metalmap;

//  mymap['a']="an element";
   for(unsigned int i=0; i < atmnet->atoms.size(); i++)
      {
      if(atmnet->atoms.at(i).type == "C") nCs++;
      if(atmnet->atoms.at(i).type == "H") nHs++;
      if(isMetal(atmnet->atoms.at(i).type) == true) 
        {
        nMetals++;
        if(metalmap[atmnet->atoms.at(i).type] == 0) metalmap[atmnet->atoms.at(i).type] =1;
         else metalmap[atmnet->atoms.at(i).type] = metalmap[atmnet->atoms.at(i).type] +1;
        };
      };

   output2 << filename << "    nCs: " << nCs << "  nHs: " << nHs << "  nMetals: " << nMetals << " nMetalTypes: " << metalmap.size() << "  ";

   std::map<std::string,int>::iterator it;
   for(it=metalmap.begin(); it!=metalmap.end(); ++it)
      {
      output2 << "  " << (*it).first << " " << (*it).second; 
      };


//   for(auto& x: metalmap) {
//      output2 << "  "  << x.first << " " << x.second;
//      };


   output2 << "\n";
   output2.close();
   };
*/

/* quick fix for Greg */
/*
 cout << "Running experimetnal pruning for Greg, uncomment this routine after use !!!!!!!!!!\n";
 if(extendedOutput == true)
   {
   fstream output2;
   output2.open(filenameExtendedOutput, fstream::out);

   output2 << "Processing: " << filenameExtendedOutput << "\n";
   output2 << "Unit_cell: " << atmnet->a <<"  " <<  atmnet->b <<"  " <<  atmnet->c << "  "
           << atmnet->alpha << "  " << atmnet->beta << "   " << atmnet->gamma << "\n";

   for(unsigned int i = 0; i < structureSegments.size(); i++)
      {
      if(structureSegments[i].dimensionality>2) 
      {
      for(unsigned int j = 0; j< structureSegments[i].reverseIDMappings.size(); j++)
         {
         int atomID = structureSegments[i].reverseIDMappings.find(j)->second;
         output2 << atmnet->atoms.at(atomID).type << "    ";
         output2 << atmnet->atoms.at(atomID).a_coord << "   "
                 << atmnet->atoms.at(atomID).b_coord << "   " << atmnet->atoms.at(atomID).c_coord << "\n";
         };
      };

      };

   output2.close();
   };
*/
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6d8, %rsp            # imm = 0x6D8
movl %ecx, 0xc8(%rsp)
andq $0x0, 0xe0(%rsp)
leaq 0x188(%rsp), %rcx
andq $0x0, (%rcx)
movq %rsi, 0x138(%rsp)
andl $0x0, 0x8(%rcx)
movq %rdi, 0x118(%rsp)
andq $0x0, 0x10(%rcx)
xorps %xmm0, %xmm0
andl $0x0, 0x18(%rcx)
movaps %xmm0, 0xd0(%rsp)
andq $0x0, 0x20(%rcx)
movups 0x8(%rdx), %xmm0
movaps %xmm0, (%rsp)
movsd 0xf4f88(%rip), %xmm0    # 0xfc050
divsd 0x18(%rdx), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x2f8(%rdx), %rax
movq %rdx, 0x20(%rsp)
subq 0x2f0(%rdx), %rax
movl $0x98, %esi
cqto
idivq %rsi
movq %rcx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xab36
movapd 0xf4fbb(%rip), %xmm2    # 0xfc0c0
divpd (%rsp), %xmm2
movq 0x20(%rsp), %rax
addq $0x2f0, %rax            # imm = 0x2F0
movq %rax, 0x80(%rsp)
ucomisd 0xf4f33(%rip), %xmm2    # 0xfc058
jae 0x728b
movapd %xmm2, %xmm0
unpckhpd %xmm2, %xmm0            # xmm0 = xmm0[1],xmm2[1]
ucomisd 0xf4f1d(%rip), %xmm0    # 0xfc058
jae 0x728b
movsd 0x30(%rsp), %xmm1
ucomisd 0xf4f09(%rip), %xmm1    # 0xfc058
jae 0x728b
movsd 0xf4efb(%rip), %xmm1    # 0xfc058
movapd %xmm1, %xmm3
movapd %xmm2, 0xb0(%rsp)
subsd %xmm2, %xmm3
movsd %xmm3, 0x58(%rsp)
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0x28(%rsp)
subsd 0x30(%rsp), %xmm1
movsd %xmm1, 0xa8(%rsp)
xorl %ebp, %ebp
movl $0x98, %r13d
leaq 0x2b8(%rsp), %r14
leaq 0x188(%rsp), %r15
movq 0x80(%rsp), %rbx
movl %ebp, %r12d
movq 0x20(%rsp), %rcx
movq 0x2f8(%rcx), %rax
subq 0x2f0(%rcx), %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x733e
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa73a
movsd 0x18(%rax), %xmm0
movaps %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa73a
movsd 0x20(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa73a
movapd (%rsp), %xmm1
movapd %xmm1, %xmm0
movapd 0x10(%rsp), %xmm2
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
cmpltpd 0xb0(%rsp), %xmm0
movmskpd %xmm0, %ecx
testb $0x1, %cl
jne 0x725f
ucomisd 0x58(%rsp), %xmm1
ja 0x725f
shrb %cl
jne 0x725f
ucomisd 0x28(%rsp), %xmm2
ja 0x725f
movsd 0x28(%rax), %xmm0
movsd 0x30(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x725f
ucomisd 0xa8(%rsp), %xmm0
jbe 0x7284
movl %ebp, 0x2b8(%rsp)
leaq 0xd0(%rsp), %rdi
movq %r14, %rsi
callq 0x10324
movq %r15, %rdi
movq %r12, %rsi
callq 0xaba4
orq %rdx, (%rax)
incl %ebp
jmp 0x71b1
xorl %ebp, %ebp
movl $0x98, %r13d
leaq 0xd0(%rsp), %rbx
leaq 0x2b8(%rsp), %r14
leaq 0x188(%rsp), %r15
movl %ebp, %r12d
movq 0x20(%rsp), %rcx
movq 0x2f8(%rcx), %rax
subq 0x2f0(%rcx), %rax
cqto
idivq %r13
cmpq %r12, %rax
jbe 0x72ef
movl %ebp, 0x2b8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10324
movq %r15, %rdi
movq %r12, %rsi
callq 0xaba4
orq %rdx, (%rax)
incl %ebp
jmp 0x72ab
movq 0x148cca(%rip), %rdi    # 0x14ffc0
leaq 0xf504e(%rip), %rsi     # 0xfc34b
callq 0x4480
movq %rax, %rdi
movq 0x20(%rsp), %rcx
movq 0x2f8(%rcx), %rax
subq 0x2f0(%rcx), %rax
movl $0x98, %ecx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x42e0
leaq 0xf5030(%rip), %rsi     # 0xfc361
movq %rax, %rdi
callq 0x4480
jmp 0x73c3
movq 0x148c7b(%rip), %rdi    # 0x14ffc0
leaq 0xf5048(%rip), %rsi     # 0xfc394
callq 0x4480
movq 0xd8(%rsp), %rsi
subq 0xd0(%rsp), %rsi
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x42e0
leaq 0xf9800(%rip), %rsi     # 0x100b74
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movq 0x20(%rsp), %rcx
movq 0x2f8(%rcx), %rax
subq 0x2f0(%rcx), %rax
movl $0x98, %ecx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x42e0
leaq 0xf4ff9(%rip), %rsi     # 0xfc3a4
movq %rax, %rdi
callq 0x4480
movsd 0xf4c95(%rip), %xmm0    # 0xfc050
movq %rax, %rdi
callq 0x46c0
movq %rax, %rdi
callq 0x4230
leaq 0x1d0(%rsp), %rdi
callq 0x3d70e
leaq 0x1e8(%rsp), %r13
movq 0x20(%rsp), %rcx
movq 0x48(%rcx), %rax
movq %rax, 0x10(%r13)
movups 0x38(%rcx), %xmm0
movups %xmm0, (%r13)
movups 0x50(%rcx), %xmm0
movups %xmm0, 0x18(%r13)
movq 0x60(%rcx), %rax
movq %rax, 0x28(%r13)
movdqu 0x68(%rcx), %xmm0
movdqu %xmm0, 0x30(%r13)
movq 0x78(%rcx), %rax
movq %rax, 0x40(%r13)
xorl %ebx, %ebx
leaq 0x298(%rsp), %r15
leaq 0x2b8(%rsp), %r12
pushq $0x1
popq %rax
movl %eax, 0x8c(%rsp)
leaq 0x1d0(%rsp), %rbp
movq 0x80(%rsp), %r14
movl %ebx, %ebx
movq 0x20(%rsp), %rcx
movq 0x2f8(%rcx), %rax
subq 0x2f0(%rcx), %rax
cqto
movl $0x98, %ecx
idivq %rcx
cmpq %rbx, %rax
jbe 0x751f
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa73a
movq (%rax), %xmm0
movq %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa73a
movq 0x8(%rax), %xmm0
movq %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa73a
movq 0x10(%rax), %xmm0
movq %xmm0, 0xb0(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa73a
addq $0x40, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x45d0
movq %r15, %rdi
callq 0x1b3ff
movdqa %xmm0, %xmm3
movq %r12, %rdi
movl %ebx, %esi
movq (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movsd 0xb0(%rsp), %xmm2
pushq $0x1
popq %rdx
callq 0x3d56e
movq %rbp, %rdi
movq %r12, %rsi
callq 0x1046c
leaq 0x2d8(%rsp), %rdi
callq 0xaf14
movq %r15, %rdi
callq 0x4210
incl %ebx
jmp 0x7446
xorl %r14d, %r14d
pushq $0x48
popq %rbx
leaq 0x1d0(%rsp), %rbp
movl %r14d, %r14d
movq 0x1d8(%rsp), %rax
subq 0x1d0(%rsp), %rax
cqto
idivq %rbx
cmpq %r14, %rax
jbe 0x7b9b
movq %rbp, %rdi
movq %r14, %rsi
callq 0xabe2
movq 0x8(%rax), %xmm0
movq %xmm0, (%rsp)
movq %rbp, %rdi
movq %r14, %rsi
callq 0xabe2
movq 0x10(%rax), %xmm0
movq %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
callq 0xabe2
movsd 0x18(%rax), %xmm2
leaq 0x4c8(%rsp), %rdi
movq (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x6402e
pushq $-0x1
popq %rax
cmpl $0x2, %eax
je 0x7b8c
movl %eax, 0x3c(%rsp)
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x30(%rsp)
pushq $-0x1
popq %rax
cmpl $0x2, %eax
je 0x7b81
movl %eax, %ecx
orl 0x3c(%rsp), %ecx
movl %ecx, 0xcc(%rsp)
movl %eax, 0xa8(%rsp)
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x58(%rsp)
pushq $-0x1
popq %rcx
cmpl $0x2, %ecx
je 0x7b73
movl 0xcc(%rsp), %eax
movl %ecx, 0x28(%rsp)
orl %ecx, %eax
je 0x78a1
leaq 0x188(%rsp), %rdi
movq %r14, %rsi
callq 0xaba4
testq %rdx, (%rax)
je 0x7b65
cvtsi2sdl 0x28(%rsp), %xmm0
movsd %xmm0, 0xb0(%rsp)
xorl %ebx, %ebx
movl %ebx, %ebx
movq 0xd8(%rsp), %rax
subq 0xd0(%rsp), %rax
sarq $0x2, %rax
cmpq %rbx, %rax
jbe 0x7b65
leaq 0xd0(%rsp), %rdi
movq %rbx, %rsi
callq 0xac00
movl (%rax), %r12d
movq %rbp, %rdi
movq %r12, %rsi
callq 0xabe2
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0xabe2
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0xabe2
movsd 0x18(%rax), %xmm2
leaq 0xf0(%rsp), %rdi
movsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x6402e
movq 0x10(%r13), %rax
movq %rax, 0x50(%rsp)
movups (%r13), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x28(%r13), %rax
movq %rax, 0x70(%rsp)
movups 0x18(%r13), %xmm0
movaps %xmm0, 0x60(%rsp)
movq 0x40(%r13), %rax
movq %rax, 0xa0(%rsp)
movups 0x30(%r13), %xmm0
movaps %xmm0, 0x90(%rsp)
leaq 0x280(%rsp), %r15
movq %r15, %rdi
leaq 0x40(%rsp), %rsi
movsd 0x30(%rsp), %xmm0
callq 0x640ba
leaq 0x170(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
movq %r15, %rdx
callq 0x642d2
leaq 0x268(%rsp), %r15
movq %r15, %rdi
leaq 0x60(%rsp), %rsi
movsd 0x58(%rsp), %xmm0
callq 0x640ba
leaq 0x120(%rsp), %rdi
leaq 0x170(%rsp), %rsi
movq %r15, %rdx
callq 0x642d2
leaq 0x250(%rsp), %r15
movq %r15, %rdi
leaq 0x90(%rsp), %rsi
movsd 0xb0(%rsp), %xmm0
callq 0x640ba
leaq 0x2b8(%rsp), %rdi
leaq 0x120(%rsp), %rsi
movq %r15, %rdx
callq 0x642d2
movq 0x2c8(%rsp), %rax
movq %rax, 0x100(%rsp)
movups 0x2b8(%rsp), %xmm0
movaps %xmm0, 0xf0(%rsp)
movsd 0x4c8(%rsp), %xmm0
movsd 0x4d0(%rsp), %xmm1
movsd 0x4d8(%rsp), %xmm2
movsd 0xf0(%rsp), %xmm3
movsd 0xf8(%rsp), %xmm4
movsd 0x100(%rsp), %xmm5
callq 0x64934
movsd %xmm0, (%rsp)
movq %rbp, %rdi
movq %r14, %rsi
callq 0xabe2
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %r12, %rsi
callq 0xabe2
movsd 0x10(%rsp), %xmm0
addsd 0x38(%rax), %xmm0
addsd 0xf4843(%rip), %xmm0    # 0xfc068
ucomisd (%rsp), %xmm0
jbe 0x789a
movq %rbp, %rdi
movq %r14, %rsi
callq 0xabe2
movq %rax, %r15
leaq 0x140(%rsp), %rdi
movl 0x3c(%rsp), %esi
movl 0xa8(%rsp), %edx
movl 0x28(%rsp), %ecx
callq 0x3d328
movq 0x140(%rsp), %rcx
movl 0x148(%rsp), %r8d
leaq 0x2b8(%rsp), %rdi
movl %r14d, %esi
movl %r12d, %edx
movsd (%rsp), %xmm0
movsd 0xf47ef(%rip), %xmm1    # 0xfc070
callq 0x3d47e
addq $0x20, %r15
movq %r15, %rdi
leaq 0x2b8(%rsp), %rsi
callq 0x106b8
incl %ebx
jmp 0x762e
movl 0x8c(%rsp), %eax
movl %eax, %ebx
movl %ebx, %ebx
movq 0x1d8(%rsp), %rax
subq 0x1d0(%rsp), %rax
cqto
pushq $0x48
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jbe 0x7b65
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xabe2
movsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xabe2
movsd 0x10(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xabe2
movsd 0x18(%rax), %xmm2
leaq 0xf0(%rsp), %rdi
movsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x6402e
movq 0x10(%r13), %rax
movq %rax, 0x50(%rsp)
movups (%r13), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x28(%r13), %rax
movq %rax, 0x70(%rsp)
movups 0x18(%r13), %xmm0
movaps %xmm0, 0x60(%rsp)
movq 0x40(%r13), %rax
movq %rax, 0xa0(%rsp)
movupd 0x30(%r13), %xmm0
movapd %xmm0, 0x90(%rsp)
xorpd %xmm0, %xmm0
leaq 0x280(%rsp), %r15
movq %r15, %rdi
leaq 0x40(%rsp), %rsi
callq 0x640ba
leaq 0x170(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
movq %r15, %rdx
callq 0x642d2
xorpd %xmm0, %xmm0
leaq 0x268(%rsp), %r15
movq %r15, %rdi
leaq 0x60(%rsp), %rsi
callq 0x640ba
leaq 0x120(%rsp), %rdi
leaq 0x170(%rsp), %rsi
movq %r15, %rdx
callq 0x642d2
xorpd %xmm0, %xmm0
leaq 0x250(%rsp), %r15
movq %r15, %rdi
leaq 0x90(%rsp), %rsi
callq 0x640ba
leaq 0x2b8(%rsp), %rdi
leaq 0x120(%rsp), %rsi
movq %r15, %rdx
callq 0x642d2
movq 0x2c8(%rsp), %rax
movq %rax, 0x100(%rsp)
movups 0x2b8(%rsp), %xmm0
movaps %xmm0, 0xf0(%rsp)
movsd 0x4c8(%rsp), %xmm0
movsd 0x4d0(%rsp), %xmm1
movsd 0x4d8(%rsp), %xmm2
movsd 0xf0(%rsp), %xmm3
movsd 0xf8(%rsp), %xmm4
movsd 0x100(%rsp), %xmm5
callq 0x64934
movsd %xmm0, (%rsp)
movq %rbp, %rdi
movq %r14, %rsi
callq 0xabe2
movsd 0x38(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xabe2
movsd 0x10(%rsp), %xmm0
addsd 0x38(%rax), %xmm0
addsd 0xf45dd(%rip), %xmm0    # 0xfc068
ucomisd (%rsp), %xmm0
jbe 0x7b5e
movq %rbp, %rdi
movq %r14, %rsi
callq 0xabe2
movq %rax, %r12
leaq 0x160(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3d328
movq 0x160(%rsp), %rcx
movl 0x168(%rsp), %r8d
leaq 0x2b8(%rsp), %rdi
movl %r14d, %esi
movl %ebx, %edx
movsd (%rsp), %xmm0
movsd 0xf458f(%rip), %xmm1    # 0xfc070
callq 0x3d47e
addq $0x20, %r12
movq %r12, %rdi
leaq 0x2b8(%rsp), %rsi
callq 0x106b8
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xabe2
movq %rax, %r15
leaq 0x150(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x3d328
movq 0x150(%rsp), %rcx
movl 0x158(%rsp), %r8d
leaq 0x2b8(%rsp), %rdi
movl %ebx, %esi
movl %r14d, %edx
movsd (%rsp), %xmm0
movsd 0xf452b(%rip), %xmm1    # 0xfc070
callq 0x3d47e
addq $0x20, %r15
movq %r15, %rdi
leaq 0x2b8(%rsp), %rsi
callq 0x106b8
incl %ebx
jmp 0x78aa
movl 0x28(%rsp), %ecx
incl %ecx
pushq $0x48
popq %rbx
jmp 0x75e8
movl 0xa8(%rsp), %eax
incl %eax
jmp 0x75be
movl 0x3c(%rsp), %eax
incl %eax
jmp 0x75a4
incl %r14d
incl 0x8c(%rsp)
jmp 0x752d
leaq 0xf0(%rsp), %rsi
andq $0x0, (%rsi)
andl $0x0, 0x8(%rsi)
andq $0x0, 0x10(%rsi)
andl $0x0, 0x18(%rsi)
andq $0x0, 0x20(%rsi)
pxor %xmm0, %xmm0
leaq 0x40(%rsp), %rdx
movdqa %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x1d0(%rsp), %rdi
callq 0x52ce6
leaq 0x2b8(%rsp), %rdi
callq 0x4540
leaq 0x2b8(%rsp), %rdi
pushq $0x10
popq %rdx
movq 0x118(%rsp), %rsi
callq 0x4410
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rax
subq %rcx, %rax
movl $0x130, %esi            # imm = 0x130
cqto
idivq %rsi
pxor %xmm0, %xmm0
movdqa %xmm0, (%rsp)
xorl %edx, %edx
movdqa 0xf44a9(%rip), %xmm0    # 0xfc0d0
movl %edx, %edx
cmpq %rdx, %rax
jbe 0x7c59
imulq $0x130, %rdx, %rsi      # imm = 0x130
movd 0x108(%rcx,%rsi), %xmm1
pshufd $0x0, %xmm1, %xmm1      # xmm1 = xmm1[0,0,0,0]
pcmpeqd %xmm0, %xmm1
movdqa (%rsp), %xmm2
psubd %xmm1, %xmm2
movdqa %xmm2, (%rsp)
incl %edx
jmp 0x7c27
leaq 0x2c8(%rsp), %rbx
movq %rbx, %rdi
movq 0x118(%rsp), %rsi
callq 0x4480
leaq 0xf4856(%rip), %rsi     # 0xfc4ce
movq %rax, %rdi
callq 0x4480
movq %rax, %r14
leaq 0x4c8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x405de
leaq 0x4c8(%rsp), %rsi
movq %r14, %rdi
callq 0x43f0
leaq 0xf4822(%rip), %rsi     # 0xfc4ce
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movq 0x48(%rsp), %rax
subq 0x40(%rsp), %rax
movl $0x130, %ecx            # imm = 0x130
cqto
idivq %rcx
movq %rax, %rsi
callq 0x42e0
leaq 0xf4712(%rip), %rsi     # 0xfc3ec
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movq 0x48(%rsp), %rax
subq 0x40(%rsp), %rax
movl $0x130, %ecx            # imm = 0x130
cqto
idivq %rcx
pshufd $0xff, (%rsp), %xmm0    # xmm0 = mem[3,3,3,3]
movd %xmm0, %r14d
subq %r14, %rax
movq %rax, %rsi
callq 0x42e0
leaq 0xf46e2(%rip), %rsi     # 0xfc3f8
movq %rax, %rdi
callq 0x4480
movdqa (%rsp), %xmm0
movd %xmm0, %esi
movq %rax, %rdi
callq 0x4760
leaq 0xfc7dc(%rip), %rsi     # 0x104512
movq %rax, %rdi
callq 0x4480
pshufd $0x55, (%rsp), %xmm0    # xmm0 = mem[1,1,1,1]
movd %xmm0, %esi
movq %rax, %rdi
callq 0x4760
leaq 0xfc7bb(%rip), %rsi     # 0x104512
movq %rax, %rdi
callq 0x4480
pshufd $0xee, (%rsp), %xmm0    # xmm0 = mem[2,3,2,3]
movd %xmm0, %esi
movq %rax, %rdi
callq 0x4760
leaq 0xf4699(%rip), %rsi     # 0xfc411
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movl %r14d, %esi
callq 0x4760
leaq 0xf4688(%rip), %rsi     # 0xfc41a
movq %rax, %rdi
callq 0x4480
leaq 0x4c8(%rsp), %rdi
callq 0x4210
xorl %r15d, %r15d
movl $0x130, %r12d           # imm = 0x130
leaq 0xfc75b(%rip), %r14     # 0x104512
movl %r15d, %r15d
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %r15, %rax
jbe 0x7dfb
imulq $0x130, %r15, %rax      # imm = 0x130
movl 0x108(%rcx,%rax), %esi
testl %esi, %esi
jle 0x7df6
movq %rbx, %rdi
callq 0x4760
movq %rax, %rdi
movq %r14, %rsi
callq 0x4480
incl %r15d
jmp 0x7db7
leaq 0xfa77c(%rip), %rsi     # 0x10257e
movq %rbx, %rdi
callq 0x4480
leaq 0x2b8(%rsp), %rdi
callq 0x4080
cmpb $0x0, 0xc8(%rsp)
je 0x8328
leaq 0x4c8(%rsp), %rdi
callq 0x4540
leaq 0x4c8(%rsp), %rdi
pushq $0x10
popq %rdx
movq 0x138(%rsp), %rsi
callq 0x4410
xorl %ecx, %ecx
movl $0x130, %edi            # imm = 0x130
movl %ecx, %ecx
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
subq %rsi, %rax
cqto
idivq %rdi
cmpq %rcx, %rax
jbe 0x830e
imulq $0x130, %rcx, %r15      # imm = 0x130
cmpl $0x0, 0x108(%rsi,%r15)
jne 0x8307
movq %rcx, 0x28(%rsp)
addq %r15, %rsi
leaq 0x60(%rsp), %rdi
callq 0x53d5c
pxor %xmm0, %xmm0
movdqa %xmm0, 0x90(%rsp)
andq $0x0, 0xa0(%rsp)
movq 0x60(%rsp), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
xorl %esi, %esi
pushq $0x1
popq %r14
movq %r15, 0x10(%rsp)
movl %esi, %ebp
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rbp, %rdx
jbe 0x807a
movl %esi, 0x58(%rsp)
movl %r14d, 0x30(%rsp)
movl %r14d, %r15d
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %r15, %rdx
jbe 0x8062
movq 0x40(%rsp), %rbx
movq %rbp, %rsi
callq 0xac22
movq 0x10(%rsp), %rcx
leaq (%rbx,%rcx), %rdi
addq $0x30, %rdi
movq %rax, %rsi
callq 0x10996
movslq 0x24(%rax), %r13
movq 0x40(%rsp), %rbx
movq 0x60(%rsp), %rdi
movq %r15, %rsi
callq 0xac22
movq 0x10(%rsp), %rcx
leaq (%rbx,%rcx), %rdi
addq $0x30, %rdi
movq %rax, %rsi
callq 0x10996
movslq 0x24(%rax), %r12
movq 0x60(%rsp), %rdi
movq %rbp, %rsi
callq 0xac22
movq %rax, %rbx
movq 0x60(%rsp), %rdi
movq %r15, %rsi
callq 0xac22
addq $0x8, %rbx
addq $0x8, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6431c
movq %xmm0, 0xb0(%rsp)
movq 0x80(%rsp), %rdi
movq %r13, %rsi
callq 0xa73a
addq $0x40, %rax
leaq 0x1b0(%rsp), %rdi
movq %rax, %rsi
callq 0x45d0
leaq 0x1b0(%rsp), %rdi
callq 0x1b3ff
movq %xmm0, (%rsp)
movq 0x80(%rsp), %rdi
movq %r12, %rsi
callq 0xa73a
addq $0x40, %rax
leaq 0x230(%rsp), %rdi
movq %rax, %rsi
callq 0x45d0
leaq 0x230(%rsp), %rbx
movq %rbx, %rdi
callq 0x1b3ff
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
addsd 0xf4064(%rip), %xmm1    # 0xfc060
movsd %xmm1, (%rsp)
movq %rbx, %rdi
callq 0x4210
leaq 0x1b0(%rsp), %rdi
callq 0x4210
movsd (%rsp), %xmm0
ucomisd 0xb0(%rsp), %xmm0
jbe 0x804e
movl 0x58(%rsp), %eax
movl %eax, 0x120(%rsp)
movl %r14d, 0x124(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x109e8
movq 0x60(%rsp), %rdi
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
incl %r14d
jmp 0x7ee1
movl 0x58(%rsp), %esi
incl %esi
movl 0x30(%rsp), %r14d
incl %r14d
movq 0x10(%rsp), %r15
jmp 0x7ec3
xorl %ebx, %ebx
movl %ebx, %ebx
movq 0x68(%rsp), %rax
subq %rdi, %rax
cqto
pushq $0x18
popq %rcx
idivq %rcx
cmpq %rbx, %rax
jbe 0x82e6
leaq 0x4d8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x42e0
movq %rax, %rdi
callq 0x4230
leaq 0x4d8(%rsp), %rdi
leaq 0xf4395(%rip), %rsi     # 0xfc455
callq 0x4480
movq %rax, %rdi
callq 0x4230
movq %rax, %rdi
callq 0x4230
leaq 0x4d8(%rsp), %rdi
leaq 0xf43eb(%rip), %rsi     # 0xfc4cf
callq 0x4480
movq 0x40(%rsp), %rcx
movq 0x58(%rcx,%r15), %rsi
movq %rax, %rdi
callq 0x42e0
movq %rax, %rdi
leaq 0xfc40d(%rip), %rsi     # 0x104512
callq 0x4480
movq 0x98(%rsp), %rsi
subq 0x90(%rsp), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x42e0
movq %rax, %rdi
leaq 0xf4331(%rip), %rsi     # 0xfc461
callq 0x4480
xorl %ebp, %ebp
movl %ebp, %ebp
movq 0x40(%rsp), %r14
cmpq %rbp, 0x58(%r14,%r15)
jbe 0x8253
imulq $0x18, %rbx, %r12
movq 0x60(%rsp), %rdi
addq %r12, %rdi
movq %rbp, %rsi
callq 0xac22
leaq (%r14,%r15), %rdi
addq $0x30, %rdi
movq %rax, %rsi
callq 0x10996
movslq 0x24(%rax), %r15
leaq 0x4d8(%rsp), %rdi
leaq 0xf434d(%rip), %rsi     # 0xfc4cd
callq 0x4480
movq 0x60(%rsp), %rdi
addq %r12, %rdi
movq %rbp, %rsi
callq 0xac22
movq 0x8(%rax), %xmm0
leaq 0x4d8(%rsp), %rdi
callq 0x46c0
movq %rax, %rdi
leaq 0xf431e(%rip), %rsi     # 0xfc4cf
callq 0x4480
movq %rax, %r13
movq 0x60(%rsp), %rdi
addq %r12, %rdi
movq %rbp, %rsi
callq 0xac22
movq 0x10(%rax), %xmm0
movq %r13, %rdi
callq 0x46c0
movq %rax, %rdi
leaq 0xf42ef(%rip), %rsi     # 0xfc4cf
callq 0x4480
movq %rax, %r13
addq 0x60(%rsp), %r12
movq %r12, %rdi
movq %rbp, %rsi
callq 0xac22
movq 0x18(%rax), %xmm0
movq %r13, %rdi
callq 0x46c0
movq %rax, %rdi
leaq 0xf42c0(%rip), %rsi     # 0xfc4cf
callq 0x4480
movq 0x80(%rsp), %rdi
movq %r15, %rsi
callq 0xa73a
addq $0x40, %rax
leaq 0x4d8(%rsp), %rdi
movq %rax, %rsi
callq 0x43f0
movq %rax, %rdi
leaq 0xf4241(%rip), %rsi     # 0xfc483
callq 0x4480
incl %ebp
movq 0x10(%rsp), %r15
jmp 0x8137
xorl %r14d, %r14d
leaq 0xf424d(%rip), %r15     # 0xfc4aa
movl %r14d, %r14d
movq 0x90(%rsp), %rax
movq 0x98(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x82c1
movl (%rax,%r14,8), %esi
leaq 0x4d8(%rsp), %rdi
callq 0x4760
movq %rax, %rdi
leaq 0xf4238(%rip), %rsi     # 0xfc4cf
callq 0x4480
movq 0x90(%rsp), %rcx
movl 0x4(%rcx,%r14,8), %esi
movq %rax, %rdi
callq 0x4760
movq %rax, %rdi
movq %r15, %rsi
callq 0x4480
incl %r14d
jmp 0x825d
leaq 0x4d8(%rsp), %rdi
leaq 0xf41e6(%rip), %rsi     # 0xfc4b6
callq 0x4480
movq 0x10(%rsp), %r15
incl %ebx
movq 0x60(%rsp), %rdi
jmp 0x807c
leaq 0x90(%rsp), %rdi
callq 0x10942
leaq 0x60(%rsp), %rdi
callq 0xac44
movq 0x28(%rsp), %rcx
movl $0x130, %edi            # imm = 0x130
incl %ecx
jmp 0x7e51
leaq 0x4c8(%rsp), %rdi
callq 0x4080
leaq 0x4c8(%rsp), %rdi
callq 0x4120
leaq 0x2b8(%rsp), %rdi
callq 0x4120
leaq 0x40(%rsp), %rdi
callq 0xac66
leaq 0xf0(%rsp), %rdi
callq 0xa976
leaq 0x1d0(%rsp), %rdi
callq 0xae22
leaq 0x188(%rsp), %rdi
callq 0xa976
leaq 0xd0(%rsp), %rdi
callq 0xb290
addq $0x6d8, %rsp            # imm = 0x6D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x83b8
jmp 0x8399
jmp 0x83b8
jmp 0x83b8
jmp 0x838f
movq %rax, %rbx
jmp 0x846f
jmp 0x83b8
movq %rax, %rbx
jmp 0x8455
movq %rax, %rbx
leaq 0x4c8(%rsp), %rdi
callq 0x4210
jmp 0x8462
jmp 0x83d3
movq %rax, %rbx
jmp 0x8462
jmp 0x84a2
jmp 0x83d3
jmp 0x83d3
jmp 0x83d3
jmp 0x83d3
jmp 0x83d3
jmp 0x83d3
jmp 0x83d3
movq %rax, %rbx
jmp 0x84b2
movq %rax, %rbx
leaq 0x2d8(%rsp), %rdi
callq 0xaf14
jmp 0x83f2
jmp 0x843b
movq %rax, %rbx
leaq 0x298(%rsp), %rdi
callq 0x4210
jmp 0x84a5
jmp 0x843b
movq %rax, %rbx
leaq 0x230(%rsp), %rdi
callq 0x4210
jmp 0x8426
jmp 0x84a2
jmp 0x843b
jmp 0x843b
jmp 0x843b
movq %rax, %rbx
leaq 0x1b0(%rsp), %rdi
callq 0x4210
jmp 0x843e
jmp 0x843b
jmp 0x843b
jmp 0x84a2
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x10942
leaq 0x60(%rsp), %rdi
callq 0xac44
leaq 0x4c8(%rsp), %rdi
callq 0x4120
leaq 0x2b8(%rsp), %rdi
callq 0x4120
leaq 0x40(%rsp), %rdi
callq 0xac66
leaq 0xf0(%rsp), %rdi
callq 0xa976
jmp 0x84a5
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
jmp 0x84a2
movq %rax, %rbx
leaq 0x1d0(%rsp), %rdi
callq 0xae22
leaq 0x188(%rsp), %rdi
callq 0xa976
leaq 0xd0(%rsp), %rdi
callq 0xb290
movq %rbx, %rdi
callq 0x4780