// File: 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
movq %rsp, %rbp
subq $0xed0, %rsp            # imm = 0xED0
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xd0d0
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa70(%rbp)
callq 0xf670
movabsq $0x4004000000000000, %rax # imm = 0x4004000000000000
movq %rax, -0x68(%rbp)
movsd -0x68(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x68(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd 0x10(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x78(%rbp)
movsd -0x68(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd 0x18(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x80(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xf060
movq -0xa70(%rbp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xfea0
jmp 0x98ed
movsd -0x70(%rbp), %xmm0
movsd 0x1e8756(%rip), %xmm1   # 0x1f2050
ucomisd %xmm1, %xmm0
jae 0x992a
movsd -0x78(%rbp), %xmm0
movsd 0x1e8743(%rip), %xmm1   # 0x1f2050
ucomisd %xmm1, %xmm0
jae 0x992a
movsd -0x80(%rbp), %xmm0
movsd 0x1e8730(%rip), %xmm1   # 0x1f2050
ucomisd %xmm1, %xmm0
jb 0x9a75
movl $0x0, -0x90(%rbp)
movl -0x90(%rbp), %eax
movq %rax, -0xa78(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xf060
movq %rax, %rcx
movq -0xa78(%rbp), %rax
cmpq %rcx, %rax
jae 0x99fb
movl -0x90(%rbp), %eax
movl %eax, -0x94(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x94(%rbp), %rsi
callq 0xffc0
jmp 0x9982
movl -0x90(%rbp), %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0xfff0
movq %rdx, -0xa88(%rbp)
movq %rax, -0xa80(%rbp)
jmp 0x99a3
movq -0xa88(%rbp), %rax
movq -0xa80(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movq %rax, -0xa0(%rbp)
leaq -0xa8(%rbp), %rdi
movl $0x1, %esi
callq 0x10040
movl -0x90(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x90(%rbp)
jmp 0x9934
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xb9a9
movq 0x2695be(%rip), %rdi    # 0x272fc0
leaq 0x1e88fb(%rip), %rsi    # 0x1f2304
callq 0x5540
movq %rax, -0xa90(%rbp)
jmp 0x9a17
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xf060
movq -0xa90(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, -0xa98(%rbp)
jmp 0x9a3f
movq -0xa98(%rbp), %rdi
leaq 0x1e88cd(%rip), %rsi    # 0x1f231a
callq 0x5540
movq %rax, -0xaa0(%rbp)
jmp 0x9a5b
movq -0xaa0(%rbp), %rdi
movq 0x26952f(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x9a70
jmp 0x9d28
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
movq %rax, -0xaa8(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xf060
movq %rax, %rcx
movq -0xaa8(%rbp), %rax
cmpq %rcx, %rax
jae 0x9c5a
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl -0xac(%rbp), %eax
movl %eax, %esi
callq 0xf090
movq %rax, -0xab0(%rbp)
jmp 0x9ad0
movq -0xab0(%rbp), %rax
movsd 0x18(%rax), %xmm0
movsd %xmm0, -0xb8(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl -0xac(%rbp), %eax
movl %eax, %esi
callq 0xf090
movq %rax, -0xab8(%rbp)
jmp 0x9b05
movq -0xab8(%rbp), %rax
movsd 0x20(%rax), %xmm0
movsd %xmm0, -0xc0(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl -0xac(%rbp), %eax
movl %eax, %esi
callq 0xf090
movq %rax, -0xac0(%rbp)
jmp 0x9b3a
movq -0xac0(%rbp), %rax
movsd 0x28(%rax), %xmm0
movsd %xmm0, -0xc8(%rbp)
movsd -0xb8(%rbp), %xmm1
movsd -0x70(%rbp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x9bd8
movsd -0xb8(%rbp), %xmm0
movsd 0x1e84df(%rip), %xmm1   # 0x1f2050
subsd -0x70(%rbp), %xmm1
ucomisd %xmm1, %xmm0
ja 0x9bd8
movsd -0xc0(%rbp), %xmm1
movsd -0x78(%rbp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x9bd8
movsd -0xc0(%rbp), %xmm0
movsd 0x1e84b1(%rip), %xmm1   # 0x1f2050
subsd -0x78(%rbp), %xmm1
ucomisd %xmm1, %xmm0
ja 0x9bd8
movsd -0xc8(%rbp), %xmm1
movsd -0x80(%rbp), %xmm0
ucomisd %xmm1, %xmm0
ja 0x9bd8
movsd -0xc8(%rbp), %xmm0
movsd 0x1e8483(%rip), %xmm1   # 0x1f2050
subsd -0x80(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x9c44
movl -0xac(%rbp), %eax
movl %eax, -0xcc(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0xcc(%rbp), %rsi
callq 0xffc0
jmp 0x9bf6
movl -0xac(%rbp), %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0xfff0
movq %rdx, -0xad0(%rbp)
movq %rax, -0xac8(%rbp)
jmp 0x9c17
movq -0xad0(%rbp), %rax
movq -0xac8(%rbp), %rcx
movq %rcx, -0xe0(%rbp)
movq %rax, -0xd8(%rbp)
leaq -0xe0(%rbp), %rdi
movl $0x1, %esi
callq 0x10040
jmp 0x9c46
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x9a7f
movq 0x26935f(%rip), %rdi    # 0x272fc0
leaq 0x1e86e5(%rip), %rsi    # 0x1f234d
callq 0x5540
movq %rax, -0xad8(%rbp)
jmp 0x9c76
leaq -0x38(%rbp), %rdi
callq 0x10090
movq -0xad8(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, -0xae0(%rbp)
jmp 0x9c97
movq -0xae0(%rbp), %rdi
leaq 0x1ecf2f(%rip), %rsi    # 0x1f6bd4
callq 0x5540
movq %rax, -0xae8(%rbp)
jmp 0x9cb3
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xf060
movq -0xae8(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, -0xaf0(%rbp)
jmp 0x9cdb
movq -0xaf0(%rbp), %rdi
leaq 0x1e8674(%rip), %rsi    # 0x1f235d
callq 0x5540
movq %rax, -0xaf8(%rbp)
jmp 0x9cf7
movq -0xaf8(%rbp), %rdi
movsd -0x68(%rbp), %xmm0
callq 0x5980
movq %rax, -0xb00(%rbp)
jmp 0x9d11
movq -0xb00(%rbp), %rdi
movq 0x269279(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0x9d26
jmp 0x9d28
leaq -0x140(%rbp), %rdi
callq 0x94790
jmp 0x9d36
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movq %rcx, -0x128(%rbp)
movq 0x40(%rax), %rcx
movq %rcx, -0x120(%rbp)
movq 0x48(%rax), %rax
movq %rax, -0x118(%rbp)
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
movq %rcx, -0x110(%rbp)
movq 0x58(%rax), %rcx
movq %rcx, -0x108(%rbp)
movq 0x60(%rax), %rax
movq %rax, -0x100(%rbp)
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rcx
movq %rcx, -0xf8(%rbp)
movq 0x70(%rax), %rcx
movq %rcx, -0xf0(%rbp)
movq 0x78(%rax), %rax
movq %rax, -0xe8(%rbp)
movl $0x0, -0x144(%rbp)
movl -0x144(%rbp), %eax
movq %rax, -0xb08(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
callq 0xf060
movq %rax, %rcx
movq -0xb08(%rbp), %rax
cmpq %rcx, %rax
jae 0x9fb5
leaq -0x140(%rbp), %rax
movq %rax, -0xb20(%rbp)
movl -0x144(%rbp), %eax
movl %eax, -0xb14(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl %eax, %esi
callq 0xf090
movq %rax, -0xb10(%rbp)
jmp 0x9e14
movq -0xb10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0xb30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl -0x144(%rbp), %eax
movl %eax, %esi
callq 0xf090
movq %rax, -0xb28(%rbp)
jmp 0x9e48
movq -0xb28(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0xb40(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl -0x144(%rbp), %eax
movl %eax, %esi
callq 0xf090
movq %rax, -0xb38(%rbp)
jmp 0x9e7d
movq -0xb38(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0xb50(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movl -0x144(%rbp), %eax
movl %eax, %esi
callq 0xf090
movq %rax, -0xb48(%rbp)
jmp 0x9eb2
movq -0xb48(%rbp), %rsi
addq $0x40, %rsi
leaq -0x1b0(%rbp), %rdi
callq 0x5220
jmp 0x9ecb
leaq -0x1b0(%rbp), %rdi
callq 0x46a20
movsd %xmm0, -0xb58(%rbp)
jmp 0x9ee1
movsd -0xb58(%rbp), %xmm3
movsd -0xb50(%rbp), %xmm2
movsd -0xb40(%rbp), %xmm1
movsd -0xb30(%rbp), %xmm0
movl -0xb14(%rbp), %esi
leaq -0x190(%rbp), %rdi
movl $0x1, %edx
callq 0x94580
jmp 0x9f1a
movq -0xb20(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x100b0
jmp 0x9f2f
leaq -0x190(%rbp), %rdi
callq 0x100e0
leaq -0x1b0(%rbp), %rdi
callq 0x5300
movl -0x144(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
jmp 0x9daf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xb99d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x9fa4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x100e0
leaq -0x1b0(%rbp), %rdi
callq 0x5300
jmp 0xb99d
movl $0x0, -0x1b4(%rbp)
movl -0x1b4(%rbp), %eax
movq %rax, -0xb60(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x10100
movq %rax, %rcx
movq -0xb60(%rbp), %rax
cmpq %rcx, %rax
jae 0xaa5f
movl -0x1b4(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xb68(%rbp)
jmp 0xa008
movq -0xb68(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0xb78(%rbp)
movl -0x1b4(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xb70(%rbp)
jmp 0xa039
movq -0xb70(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0xb88(%rbp)
movl -0x1b4(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xb80(%rbp)
jmp 0xa06a
movsd -0xb88(%rbp), %xmm1
movsd -0xb78(%rbp), %xmm0
movq -0xb80(%rbp), %rax
movsd 0x18(%rax), %xmm2
leaq -0x1d0(%rbp), %rdi
callq 0xea8e0
jmp 0xa094
movl $0xffffffff, -0x1d4(%rbp) # imm = 0xFFFFFFFF
cmpl $0x2, -0x1d4(%rbp)
jge 0xaa49
movl $0xffffffff, -0x1d8(%rbp) # imm = 0xFFFFFFFF
cmpl $0x2, -0x1d8(%rbp)
jge 0xaa33
movl $0xffffffff, -0x1dc(%rbp) # imm = 0xFFFFFFFF
cmpl $0x2, -0x1dc(%rbp)
jge 0xaa1d
cmpl $0x0, -0x1d4(%rbp)
jne 0xa5b7
cmpl $0x0, -0x1d8(%rbp)
jne 0xa5b7
cmpl $0x0, -0x1dc(%rbp)
jne 0xa5b7
movl -0x1b4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e0(%rbp)
movl -0x1e0(%rbp), %eax
movq %rax, -0xb90(%rbp)
leaq -0x140(%rbp), %rdi
callq 0x10100
movq %rax, %rcx
movq -0xb90(%rbp), %rax
cmpq %rcx, %rax
jae 0xa5b2
movl -0x1e0(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xb98(%rbp)
jmp 0xa158
movq -0xb98(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0xba8(%rbp)
movl -0x1e0(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xba0(%rbp)
jmp 0xa189
movq -0xba0(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0xbb8(%rbp)
movl -0x1e0(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xbb0(%rbp)
jmp 0xa1ba
movsd -0xbb8(%rbp), %xmm1
movsd -0xba8(%rbp), %xmm0
movq -0xbb0(%rbp), %rax
movsd 0x18(%rax), %xmm2
leaq -0x200(%rbp), %rdi
callq 0xea8e0
jmp 0xa1e4
movq -0x118(%rbp), %rax
movq %rax, -0x210(%rbp)
movups -0x128(%rbp), %xmm0
movaps %xmm0, -0x220(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0x230(%rbp)
movups -0x110(%rbp), %xmm0
movaps %xmm0, -0x240(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0x250(%rbp)
movups -0xf8(%rbp), %xmm0
movaps %xmm0, -0x260(%rbp)
cvtsi2sdl -0x1d4(%rbp), %xmm0
leaq -0x2c0(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0xea9f0
jmp 0xa255
leaq -0x2a8(%rbp), %rdi
leaq -0x200(%rbp), %rsi
leaq -0x2c0(%rbp), %rdx
callq 0xeae50
jmp 0xa271
cvtsi2sdl -0x1d8(%rbp), %xmm0
leaq -0x2d8(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0xea9f0
jmp 0xa28e
leaq -0x290(%rbp), %rdi
leaq -0x2a8(%rbp), %rsi
leaq -0x2d8(%rbp), %rdx
callq 0xeae50
jmp 0xa2aa
cvtsi2sdl -0x1dc(%rbp), %xmm0
leaq -0x2f0(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0xea9f0
jmp 0xa2c7
leaq -0x278(%rbp), %rdi
leaq -0x290(%rbp), %rsi
leaq -0x2f0(%rbp), %rdx
callq 0xeae50
jmp 0xa2e3
movq -0x268(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movups -0x278(%rbp), %xmm0
movaps %xmm0, -0x200(%rbp)
movsd -0x1d0(%rbp), %xmm0
movsd -0x1c8(%rbp), %xmm1
movsd -0x1c0(%rbp), %xmm2
movsd -0x200(%rbp), %xmm3
movsd -0x1f8(%rbp), %xmm4
movsd -0x1f0(%rbp), %xmm5
callq 0xebaf0
movsd %xmm0, -0xbc0(%rbp)
jmp 0xa33e
movsd -0xbc0(%rbp), %xmm0
movsd %xmm0, -0x2f8(%rbp)
movsd -0x2f8(%rbp), %xmm0
movsd %xmm0, -0xbd0(%rbp)
movl -0x1b4(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xbc8(%rbp)
jmp 0xa37b
movq -0xbc8(%rbp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0xbe0(%rbp)
movl -0x1e0(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xbd8(%rbp)
jmp 0xa3ac
movsd -0xbd0(%rbp), %xmm1
movq -0xbd8(%rbp), %rax
movsd -0xbe0(%rbp), %xmm0
addsd 0x38(%rax), %xmm0
movsd 0x1e7c90(%rip), %xmm2   # 0x1f2060
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa59c
movl -0x1b4(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xbe8(%rbp)
jmp 0xa3fb
movq -0xbe8(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xc00(%rbp)
movl -0x1b4(%rbp), %eax
movl %eax, -0xbf8(%rbp)
movl -0x1e0(%rbp), %eax
movl %eax, -0xbf4(%rbp)
movsd -0x2f8(%rbp), %xmm0
movsd %xmm0, -0xbf0(%rbp)
movl -0x1d4(%rbp), %esi
movl -0x1d8(%rbp), %edx
movl -0x1dc(%rbp), %ecx
leaq -0x32c(%rbp), %rdi
callq 0x94010
jmp 0xa455
movsd -0xbf0(%rbp), %xmm0
movl -0xbf4(%rbp), %edx
movl -0xbf8(%rbp), %esi
movl -0x324(%rbp), %eax
movl %eax, -0x338(%rbp)
movq -0x32c(%rbp), %rax
movq %rax, -0x340(%rbp)
movq -0x340(%rbp), %rcx
movl -0x338(%rbp), %r8d
leaq -0x320(%rbp), %rdi
movsd 0x1e7bc8(%rip), %xmm1   # 0x1f2068
callq 0x94400
jmp 0xa4a7
movq -0xc00(%rbp), %rdi
leaq -0x320(%rbp), %rsi
callq 0x10170
jmp 0xa4bc
movl -0x1e0(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xc08(%rbp)
jmp 0xa4d9
movq -0xc08(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xc20(%rbp)
movl -0x1e0(%rbp), %eax
movl %eax, -0xc18(%rbp)
movl -0x1b4(%rbp), %eax
movl %eax, -0xc14(%rbp)
movsd -0x2f8(%rbp), %xmm0
movsd %xmm0, -0xc10(%rbp)
movl -0x1d4(%rbp), %esi
movl -0x1d8(%rbp), %edx
movl -0x1dc(%rbp), %ecx
leaq -0x374(%rbp), %rdi
callq 0x94010
jmp 0xa533
movsd -0xc10(%rbp), %xmm0
movl -0xc14(%rbp), %edx
movl -0xc18(%rbp), %esi
movl -0x36c(%rbp), %eax
movl %eax, -0x380(%rbp)
movq -0x374(%rbp), %rax
movq %rax, -0x388(%rbp)
movq -0x388(%rbp), %rcx
movl -0x380(%rbp), %r8d
leaq -0x368(%rbp), %rdi
movsd 0x1e7aea(%rip), %xmm1   # 0x1f2068
callq 0x94400
jmp 0xa585
movq -0xc20(%rbp), %rdi
leaq -0x368(%rbp), %rsi
callq 0x10170
jmp 0xa59a
jmp 0xa59c
jmp 0xa59e
movl -0x1e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e0(%rbp)
jmp 0xa10f
jmp 0xaa07
movl -0x1b4(%rbp), %eax
movl %eax, %esi
leaq -0x60(%rbp), %rdi
callq 0xfff0
movq %rdx, -0xc30(%rbp)
movq %rax, -0xc28(%rbp)
jmp 0xa5d8
movq -0xc30(%rbp), %rax
movq -0xc28(%rbp), %rcx
movq %rcx, -0x398(%rbp)
movq %rax, -0x390(%rbp)
leaq -0x398(%rbp), %rdi
callq 0x101a0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xaa05
movl $0x0, -0x39c(%rbp)
movl -0x39c(%rbp), %eax
movq %rax, -0xc38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x10090
movq %rax, %rcx
movq -0xc38(%rbp), %rax
cmpq %rcx, %rax
jae 0xaa03
movl -0x39c(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x101d0
movq %rax, -0xc40(%rbp)
jmp 0xa65b
movq -0xc40(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3a0(%rbp)
movl -0x3a0(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xc48(%rbp)
jmp 0xa687
movq -0xc48(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0xc58(%rbp)
movl -0x3a0(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xc50(%rbp)
jmp 0xa6b8
movq -0xc50(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0xc68(%rbp)
movl -0x3a0(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xc60(%rbp)
jmp 0xa6e9
movsd -0xc68(%rbp), %xmm1
movsd -0xc58(%rbp), %xmm0
movq -0xc60(%rbp), %rax
movsd 0x18(%rax), %xmm2
leaq -0x3c0(%rbp), %rdi
callq 0xea8e0
jmp 0xa713
movq -0x118(%rbp), %rax
movq %rax, -0x3d0(%rbp)
movups -0x128(%rbp), %xmm0
movaps %xmm0, -0x3e0(%rbp)
movq -0x100(%rbp), %rax
movq %rax, -0x3f0(%rbp)
movups -0x110(%rbp), %xmm0
movaps %xmm0, -0x400(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0x410(%rbp)
movups -0xf8(%rbp), %xmm0
movaps %xmm0, -0x420(%rbp)
cvtsi2sdl -0x1d4(%rbp), %xmm0
leaq -0x480(%rbp), %rdi
leaq -0x3e0(%rbp), %rsi
callq 0xea9f0
jmp 0xa784
leaq -0x468(%rbp), %rdi
leaq -0x3c0(%rbp), %rsi
leaq -0x480(%rbp), %rdx
callq 0xeae50
jmp 0xa7a0
cvtsi2sdl -0x1d8(%rbp), %xmm0
leaq -0x498(%rbp), %rdi
leaq -0x400(%rbp), %rsi
callq 0xea9f0
jmp 0xa7bd
leaq -0x450(%rbp), %rdi
leaq -0x468(%rbp), %rsi
leaq -0x498(%rbp), %rdx
callq 0xeae50
jmp 0xa7d9
cvtsi2sdl -0x1dc(%rbp), %xmm0
leaq -0x4b0(%rbp), %rdi
leaq -0x420(%rbp), %rsi
callq 0xea9f0
jmp 0xa7f6
leaq -0x438(%rbp), %rdi
leaq -0x450(%rbp), %rsi
leaq -0x4b0(%rbp), %rdx
callq 0xeae50
jmp 0xa812
movq -0x428(%rbp), %rax
movq %rax, -0x3b0(%rbp)
movups -0x438(%rbp), %xmm0
movaps %xmm0, -0x3c0(%rbp)
movsd -0x1d0(%rbp), %xmm0
movsd -0x1c8(%rbp), %xmm1
movsd -0x1c0(%rbp), %xmm2
movsd -0x3c0(%rbp), %xmm3
movsd -0x3b8(%rbp), %xmm4
movsd -0x3b0(%rbp), %xmm5
callq 0xebaf0
movsd %xmm0, -0xc70(%rbp)
jmp 0xa86d
movsd -0xc70(%rbp), %xmm0
movsd %xmm0, -0x4b8(%rbp)
movsd -0x4b8(%rbp), %xmm0
movsd %xmm0, -0xc80(%rbp)
movl -0x1b4(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xc78(%rbp)
jmp 0xa8aa
movq -0xc78(%rbp), %rax
movsd 0x38(%rax), %xmm0
movsd %xmm0, -0xc90(%rbp)
movl -0x3a0(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xc88(%rbp)
jmp 0xa8db
movsd -0xc80(%rbp), %xmm1
movq -0xc88(%rbp), %rax
movsd -0xc90(%rbp), %xmm0
addsd 0x38(%rax), %xmm0
movsd 0x1e7761(%rip), %xmm2   # 0x1f2060
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0xa9ed
movl -0x1b4(%rbp), %eax
movl %eax, %esi
leaq -0x140(%rbp), %rdi
callq 0x10130
movq %rax, -0xc98(%rbp)
jmp 0xa92a
movq -0xc98(%rbp), %rax
addq $0x20, %rax
movq %rax, -0xcb0(%rbp)
movl -0x1b4(%rbp), %eax
movl %eax, -0xca8(%rbp)
movl -0x3a0(%rbp), %eax
movl %eax, -0xca4(%rbp)
movsd -0x4b8(%rbp), %xmm0
movsd %xmm0, -0xca0(%rbp)
movl -0x1d4(%rbp), %esi
movl -0x1d8(%rbp), %edx
movl -0x1dc(%rbp), %ecx
leaq -0x4ec(%rbp), %rdi
callq 0x94010
jmp 0xa984
movsd -0xca0(%rbp), %xmm0
movl -0xca4(%rbp), %edx
movl -0xca8(%rbp), %esi
movl -0x4e4(%rbp), %eax
movl %eax, -0x4f8(%rbp)
movq -0x4ec(%rbp), %rax
movq %rax, -0x500(%rbp)
movq -0x500(%rbp), %rcx
movl -0x4f8(%rbp), %r8d
leaq -0x4e0(%rbp), %rdi
movsd 0x1e7699(%rip), %xmm1   # 0x1f2068
callq 0x94400
jmp 0xa9d6
movq -0xcb0(%rbp), %rdi
leaq -0x4e0(%rbp), %rsi
callq 0x10170
jmp 0xa9eb
jmp 0xa9ed
jmp 0xa9ef
movl -0x39c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x39c(%rbp)
jmp 0xa618
jmp 0xaa05
jmp 0xaa07
jmp 0xaa09
movl -0x1dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1dc(%rbp)
jmp 0xa0cc
jmp 0xaa1f
movl -0x1d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d8(%rbp)
jmp 0xa0b5
jmp 0xaa35
movl -0x1d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d4(%rbp)
jmp 0xa09e
jmp 0xaa4b
movl -0x1b4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1b4(%rbp)
jmp 0x9fbf
leaq -0x528(%rbp), %rdi
movq %rdi, -0xcc0(%rbp)
callq 0xf670
leaq -0x540(%rbp), %rdi
movq %rdi, -0xcb8(%rbp)
callq 0x10210
movq -0xcc0(%rbp), %rsi
movq -0xcb8(%rbp), %rdx
leaq -0x140(%rbp), %rdi
callq 0xc55c0
jmp 0xaaa1
leaq -0x750(%rbp), %rdi
callq 0x5660
jmp 0xaaaf
movq -0x8(%rbp), %rsi
leaq -0x750(%rbp), %rdi
movl $0x10, %edx
callq 0x54b0
jmp 0xaac6
movl $0x0, -0x754(%rbp)
movl $0x0, -0x758(%rbp)
movl $0x0, -0x75c(%rbp)
movl $0x0, -0x760(%rbp)
movl $0x0, -0x764(%rbp)
movl -0x764(%rbp), %eax
movq %rax, -0xcc8(%rbp)
leaq -0x540(%rbp), %rdi
callq 0x10230
movq %rax, %rcx
movq -0xcc8(%rbp), %rax
cmpq %rcx, %rax
jae 0xac1a
movl -0x764(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
cmpl $0x0, 0x108(%rax)
jne 0xab80
movl -0x754(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x754(%rbp)
jmp 0xab80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xb985
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xb979
movl -0x764(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
cmpl $0x1, 0x108(%rax)
jne 0xabac
movl -0x758(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x758(%rbp)
movl -0x764(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
cmpl $0x2, 0x108(%rax)
jne 0xabd8
movl -0x75c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x75c(%rbp)
movl -0x764(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
cmpl $0x3, 0x108(%rax)
jne 0xac04
movl -0x760(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x760(%rbp)
jmp 0xac06
movl -0x764(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x764(%rbp)
jmp 0xaaf8
leaq -0x740(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x5540
movq %rax, -0xcd0(%rbp)
jmp 0xac33
movq -0xcd0(%rbp), %rdi
leaq 0x1e7846(%rip), %rsi    # 0x1f2487
callq 0x5540
movq %rax, -0xcd8(%rbp)
jmp 0xac4f
movq -0x18(%rbp), %rsi
leaq -0x788(%rbp), %rdi
callq 0x99590
jmp 0xac61
movq -0xcd8(%rbp), %rdi
leaq -0x788(%rbp), %rsi
callq 0x5480
movq %rax, -0xce0(%rbp)
jmp 0xac7d
movq -0xce0(%rbp), %rdi
leaq 0x1e77fc(%rip), %rsi    # 0x1f2487
callq 0x5540
movq %rax, -0xce8(%rbp)
jmp 0xac99
leaq -0x540(%rbp), %rdi
callq 0x10230
movq -0xce8(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, -0xcf0(%rbp)
jmp 0xacbd
movq -0xcf0(%rbp), %rdi
leaq 0x1e76da(%rip), %rsi    # 0x1f23a5
callq 0x5540
movq %rax, -0xcf8(%rbp)
jmp 0xacd9
leaq -0x540(%rbp), %rdi
callq 0x10230
movq -0xcf8(%rbp), %rdi
movq %rax, %rsi
movslq -0x754(%rbp), %rax
subq %rax, %rsi
callq 0x5160
movq %rax, -0xd00(%rbp)
jmp 0xad07
movq -0xd00(%rbp), %rdi
leaq 0x1e769c(%rip), %rsi    # 0x1f23b1
callq 0x5540
movq %rax, -0xd08(%rbp)
jmp 0xad23
movq -0xd08(%rbp), %rdi
movl -0x758(%rbp), %esi
callq 0x58d0
movq %rax, -0xd10(%rbp)
jmp 0xad3e
movq -0xd10(%rbp), %rdi
leaq 0x1f1562(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0xd18(%rbp)
jmp 0xad5a
movq -0xd18(%rbp), %rdi
movl -0x75c(%rbp), %esi
callq 0x58d0
movq %rax, -0xd20(%rbp)
jmp 0xad75
movq -0xd20(%rbp), %rdi
leaq 0x1f152b(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0xd28(%rbp)
jmp 0xad91
movq -0xd28(%rbp), %rdi
movl -0x760(%rbp), %esi
callq 0x58d0
movq %rax, -0xd30(%rbp)
jmp 0xadac
movq -0xd30(%rbp), %rdi
leaq 0x1e7610(%rip), %rsi    # 0x1f23ca
callq 0x5540
movq %rax, -0xd38(%rbp)
jmp 0xadc8
movq -0xd38(%rbp), %rdi
movl -0x754(%rbp), %esi
callq 0x58d0
movq %rax, -0xd40(%rbp)
jmp 0xade3
movq -0xd40(%rbp), %rdi
leaq 0x1e75e2(%rip), %rsi    # 0x1f23d3
callq 0x5540
jmp 0xadf8
leaq -0x788(%rbp), %rdi
callq 0x5300
movl $0x0, -0x78c(%rbp)
movl -0x78c(%rbp), %eax
movq %rax, -0xd48(%rbp)
leaq -0x540(%rbp), %rdi
callq 0x10230
movq %rax, %rcx
movq -0xd48(%rbp), %rax
cmpq %rcx, %rax
jae 0xaee4
movl -0x78c(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
cmpl $0x0, 0x108(%rax)
jle 0xaece
leaq -0x740(%rbp), %rax
movq %rax, -0xd58(%rbp)
movl -0x78c(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
movq -0xd58(%rbp), %rdi
movl 0x108(%rax), %esi
callq 0x58d0
movq %rax, -0xd50(%rbp)
jmp 0xae94
movq -0xd50(%rbp), %rdi
leaq 0x1f140c(%rip), %rsi    # 0x1fc2ae
callq 0x5540
jmp 0xaea9
jmp 0xaece
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x788(%rbp), %rdi
callq 0x5300
jmp 0xb979
jmp 0xaed0
movl -0x78c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x78c(%rbp)
jmp 0xae0e
leaq -0x740(%rbp), %rdi
leaq 0x1ee733(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0xaef9
leaq -0x750(%rbp), %rdi
callq 0x50a0
jmp 0xaf07
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xb92e
leaq -0x9a0(%rbp), %rdi
callq 0x5660
jmp 0xaf26
movq -0x10(%rbp), %rsi
leaq -0x9a0(%rbp), %rdi
movl $0x10, %edx
callq 0x54b0
jmp 0xaf3d
movl $0x0, -0x9a4(%rbp)
movl -0x9a4(%rbp), %eax
movq %rax, -0xd60(%rbp)
leaq -0x540(%rbp), %rdi
callq 0x10230
movq %rax, %rcx
movq -0xd60(%rbp), %rax
cmpq %rcx, %rax
jae 0xb904
movl -0x9a4(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
cmpl $0x0, 0x108(%rax)
jne 0xb8ee
movl -0x9a4(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
movq %rax, %rsi
leaq -0x9c0(%rbp), %rdi
callq 0xc70b0
jmp 0xafb9
leaq -0x9d8(%rbp), %rdi
callq 0x10280
movl $0x0, -0x9dc(%rbp)
movl -0x9dc(%rbp), %eax
movq %rax, -0xd68(%rbp)
leaq -0x9c0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x102a0
movq %rax, %rdi
callq 0x102c0
movq %rax, %rcx
movq -0xd68(%rbp), %rax
cmpq %rcx, %rax
jae 0xb3a9
movl -0x9dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9e0(%rbp)
movl -0x9e0(%rbp), %eax
movq %rax, -0xd70(%rbp)
leaq -0x9c0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x102a0
movq %rax, %rdi
callq 0x102c0
movq %rax, %rcx
movq -0xd70(%rbp), %rax
cmpq %rcx, %rax
jae 0xb393
movl -0x9a4(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
addq $0x30, %rax
movq %rax, -0xd80(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x9c0(%rbp), %rdi
callq 0x102a0
movq %rax, %rdi
movl -0x9dc(%rbp), %eax
movl %eax, %esi
callq 0x10310
movq %rax, -0xd78(%rbp)
jmp 0xb096
movq -0xd78(%rbp), %rsi
movq -0xd80(%rbp), %rdi
callq 0x102e0
movq %rax, -0xd88(%rbp)
jmp 0xb0b2
movq -0xd88(%rbp), %rax
movq %rax, -0x9f0(%rbp)
leaq -0x9f0(%rbp), %rdi
callq 0x10350
movl 0x4(%rax), %eax
movl %eax, -0x9e4(%rbp)
movl -0x9a4(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
addq $0x30, %rax
movq %rax, -0xd98(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x9c0(%rbp), %rdi
callq 0x102a0
movq %rax, %rdi
movl -0x9e0(%rbp), %eax
movl %eax, %esi
callq 0x10310
movq %rax, -0xd90(%rbp)
jmp 0xb11d
movq -0xd90(%rbp), %rsi
movq -0xd98(%rbp), %rdi
callq 0x102e0
movq %rax, -0xda0(%rbp)
jmp 0xb139
movq -0xda0(%rbp), %rax
movq %rax, -0xa00(%rbp)
leaq -0xa00(%rbp), %rdi
callq 0x10350
movl 0x4(%rax), %eax
movl %eax, -0x9f4(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x9c0(%rbp), %rdi
callq 0x102a0
movq %rax, %rdi
movl -0x9dc(%rbp), %eax
movl %eax, %esi
callq 0x10310
movq %rax, -0xda8(%rbp)
jmp 0xb185
movq -0xda8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xdb8(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x9c0(%rbp), %rdi
callq 0x102a0
movq %rax, %rdi
movl -0x9e0(%rbp), %eax
movl %eax, %esi
callq 0x10310
movq %rax, -0xdb0(%rbp)
jmp 0xb1c0
movq -0xdb8(%rbp), %rdi
movq -0xdb0(%rbp), %rsi
addq $0x8, %rsi
callq 0xeaf00
movsd %xmm0, -0xdc0(%rbp)
jmp 0xb1e1
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x9e4(%rbp), %rsi
callq 0xf090
movq %rax, -0xdc8(%rbp)
jmp 0xb201
movq -0xdc8(%rbp), %rsi
addq $0x40, %rsi
leaq -0xa20(%rbp), %rdi
callq 0x5220
jmp 0xb21a
leaq -0xa20(%rbp), %rdi
callq 0x46a20
movsd %xmm0, -0xdd0(%rbp)
jmp 0xb230
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x9f4(%rbp), %rsi
callq 0xf090
movq %rax, -0xdd8(%rbp)
jmp 0xb250
movq -0xdd8(%rbp), %rsi
addq $0x40, %rsi
leaq -0xa40(%rbp), %rdi
callq 0x5220
jmp 0xb269
leaq -0xa40(%rbp), %rdi
callq 0x46a20
movsd %xmm0, -0xde0(%rbp)
jmp 0xb27f
movsd -0xde0(%rbp), %xmm1
movsd -0xdd0(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd 0x1e6dbd(%rip), %xmm1   # 0x1f2058
addsd %xmm1, %xmm0
movsd %xmm0, -0xde8(%rbp)
leaq -0xa40(%rbp), %rdi
callq 0x5300
leaq -0xa20(%rbp), %rdi
callq 0x5300
movsd -0xdc0(%rbp), %xmm1
movsd -0xde8(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xb37d
leaq -0xa48(%rbp), %rdi
leaq -0x9dc(%rbp), %rsi
leaq -0x9e0(%rbp), %rdx
callq 0x103a0
jmp 0xb2f5
leaq -0x9d8(%rbp), %rdi
leaq -0xa48(%rbp), %rsi
callq 0x10370
jmp 0xb30a
jmp 0xb37d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xb920
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xb8d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0xb36c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xa40(%rbp), %rdi
callq 0x5300
leaq -0xa20(%rbp), %rdi
callq 0x5300
jmp 0xb8d4
jmp 0xb37f
movl -0x9e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9e0(%rbp)
jmp 0xb016
jmp 0xb395
movl -0x9dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9dc(%rbp)
jmp 0xafcf
movl $0x0, -0xa4c(%rbp)
movl -0xa4c(%rbp), %eax
movq %rax, -0xdf0(%rbp)
leaq -0x9c0(%rbp), %rdi
callq 0x103d0
movq %rax, %rcx
movq -0xdf0(%rbp), %rax
cmpq %rcx, %rax
jae 0xb8ba
leaq -0x990(%rbp), %rdi
movl -0x9a4(%rbp), %esi
callq 0x56f0
movq %rax, -0xdf8(%rbp)
jmp 0xb3fa
movq -0xdf8(%rbp), %rdi
movq 0x267b90(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0xb40f
leaq -0x990(%rbp), %rdi
leaq 0x1e6ff1(%rip), %rsi    # 0x1f240e
callq 0x5540
movq %rax, -0xe00(%rbp)
jmp 0xb42b
movq -0xe00(%rbp), %rdi
movq 0x267b5f(%rip), %rsi    # 0x272f98
callq 0x55b0
movq %rax, -0xe08(%rbp)
jmp 0xb447
movq -0xe08(%rbp), %rdi
movq 0x267b43(%rip), %rsi    # 0x272f98
callq 0x55b0
jmp 0xb45c
leaq -0x990(%rbp), %rdi
leaq 0x1e701e(%rip), %rsi    # 0x1f2488
callq 0x5540
movq %rax, -0xe10(%rbp)
jmp 0xb478
movl -0x9a4(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
movq %rax, %rdi
addq $0x30, %rdi
callq 0x10400
movq -0xe10(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, -0xe18(%rbp)
jmp 0xb4b0
movq -0xe18(%rbp), %rdi
leaq 0x1f0df0(%rip), %rsi    # 0x1fc2ae
callq 0x5540
movq %rax, -0xe20(%rbp)
jmp 0xb4cc
leaq -0x9d8(%rbp), %rdi
callq 0x10420
movq -0xe20(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, -0xe28(%rbp)
jmp 0xb4f0
movq -0xe28(%rbp), %rdi
leaq 0x1e6f1c(%rip), %rsi    # 0x1f241a
callq 0x5540
jmp 0xb505
movl $0x0, -0xa50(%rbp)
movl -0xa50(%rbp), %eax
movq %rax, -0xe30(%rbp)
movl -0x9a4(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
movq %rax, %rdi
addq $0x30, %rdi
callq 0x10400
movq %rax, %rcx
movq -0xe30(%rbp), %rax
cmpq %rcx, %rax
jae 0xb7ad
movl -0x9a4(%rbp), %eax
movl %eax, %esi
leaq -0x540(%rbp), %rdi
callq 0x10260
addq $0x30, %rax
movq %rax, -0xe40(%rbp)
movl -0xa4c(%rbp), %eax
movl %eax, %esi
leaq -0x9c0(%rbp), %rdi
callq 0x102a0
movq %rax, %rdi
movl -0xa50(%rbp), %eax
movl %eax, %esi
callq 0x10310
movq %rax, -0xe38(%rbp)
jmp 0xb59b
movq -0xe38(%rbp), %rsi
movq -0xe40(%rbp), %rdi
callq 0x102e0
movq %rax, -0xe48(%rbp)
jmp 0xb5b7
movq -0xe48(%rbp), %rax
movq %rax, -0xa60(%rbp)
leaq -0xa60(%rbp), %rdi
callq 0x10350
movl 0x4(%rax), %eax
movl %eax, -0xa54(%rbp)
leaq -0x990(%rbp), %rdi
leaq 0x1e6e9e(%rip), %rsi    # 0x1f2486
callq 0x5540
jmp 0xb5ef
leaq -0x990(%rbp), %rax
movq %rax, -0xe58(%rbp)
movl -0xa4c(%rbp), %eax
movl %eax, %esi
leaq -0x9c0(%rbp), %rdi
callq 0x102a0
movq %rax, %rdi
movl -0xa50(%rbp), %eax
movl %eax, %esi
callq 0x10310
movq %rax, -0xe50(%rbp)
jmp 0xb62a
movq -0xe58(%rbp), %rdi
movq -0xe50(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x5980
movq %rax, -0xe60(%rbp)
jmp 0xb64b
movq -0xe60(%rbp), %rdi
leaq 0x1e6e2f(%rip), %rsi    # 0x1f2488
callq 0x5540
movq %rax, -0xe68(%rbp)
jmp 0xb667
movl -0xa4c(%rbp), %eax
movl %eax, %esi
leaq -0x9c0(%rbp), %rdi
callq 0x102a0
movq %rax, %rdi
movl -0xa50(%rbp), %eax
movl %eax, %esi
callq 0x10310
movq %rax, -0xe70(%rbp)
jmp 0xb694
movq -0xe68(%rbp), %rdi
movq -0xe70(%rbp), %rax
movsd 0x10(%rax), %xmm0
callq 0x5980
movq %rax, -0xe78(%rbp)
jmp 0xb6b5
movq -0xe78(%rbp), %rdi
leaq 0x1e6dc5(%rip), %rsi    # 0x1f2488
callq 0x5540
movq %rax, -0xe80(%rbp)
jmp 0xb6d1
movl -0xa4c(%rbp), %eax
movl %eax, %esi
leaq -0x9c0(%rbp), %rdi
callq 0x102a0
movq %rax, %rdi
movl -0xa50(%rbp), %eax
movl %eax, %esi
callq 0x10310
movq %rax, -0xe88(%rbp)
jmp 0xb6fe
movq -0xe80(%rbp), %rdi
movq -0xe88(%rbp), %rax
movsd 0x18(%rax), %xmm0
callq 0x5980
movq %rax, -0xe90(%rbp)
jmp 0xb71f
movq -0xe90(%rbp), %rdi
leaq 0x1e6d5b(%rip), %rsi    # 0x1f2488
callq 0x5540
jmp 0xb734
leaq -0x990(%rbp), %rax
movq %rax, -0xea0(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0xa54(%rbp), %rsi
callq 0xf090
movq %rax, -0xe98(%rbp)
jmp 0xb762
movq -0xea0(%rbp), %rdi
movq -0xe98(%rbp), %rsi
addq $0x40, %rsi
callq 0x5480
movq %rax, -0xea8(%rbp)
jmp 0xb782
movq -0xea8(%rbp), %rdi
leaq 0x1e6cac(%rip), %rsi    # 0x1f243c
callq 0x5540
jmp 0xb797
jmp 0xb799
movl -0xa50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa50(%rbp)
jmp 0xb50f
movl $0x0, -0xa64(%rbp)
movl -0xa64(%rbp), %eax
movq %rax, -0xeb0(%rbp)
leaq -0x9d8(%rbp), %rdi
callq 0x10420
movq %rax, %rcx
movq -0xeb0(%rbp), %rax
cmpq %rcx, %rax
jae 0xb88f
leaq -0x990(%rbp), %rax
movq %rax, -0xec0(%rbp)
movl -0xa64(%rbp), %eax
movl %eax, %esi
leaq -0x9d8(%rbp), %rdi
callq 0x10440
movq -0xec0(%rbp), %rdi
movl (%rax), %esi
callq 0x58d0
movq %rax, -0xeb8(%rbp)
jmp 0xb81c
movq -0xeb8(%rbp), %rdi
leaq 0x1e6c5e(%rip), %rsi    # 0x1f2488
callq 0x5540
movq %rax, -0xec8(%rbp)
jmp 0xb838
movl -0xa64(%rbp), %eax
movl %eax, %esi
leaq -0x9d8(%rbp), %rdi
callq 0x10440
movq -0xec8(%rbp), %rdi
movl 0x4(%rax), %esi
callq 0x58d0
movq %rax, -0xed0(%rbp)
jmp 0xb864
movq -0xed0(%rbp), %rdi
leaq 0x1e6bf1(%rip), %rsi    # 0x1f2463
callq 0x5540
jmp 0xb879
jmp 0xb87b
movl -0xa64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa64(%rbp)
jmp 0xb7b7
leaq -0x990(%rbp), %rdi
leaq 0x1e6bd2(%rip), %rsi    # 0x1f246f
callq 0x5540
jmp 0xb8a4
jmp 0xb8a6
movl -0xa4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4c(%rbp)
jmp 0xb3b3
leaq -0x9d8(%rbp), %rdi
callq 0x10460
leaq -0x9c0(%rbp), %rdi
callq 0x104c0
jmp 0xb8ee
leaq -0x9d8(%rbp), %rdi
callq 0x10460
leaq -0x9c0(%rbp), %rdi
callq 0x104c0
jmp 0xb920
jmp 0xb8f0
movl -0x9a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9a4(%rbp)
jmp 0xaf47
leaq -0x9a0(%rbp), %rdi
callq 0x50a0
jmp 0xb912
leaq -0x9a0(%rbp), %rdi
callq 0x5150
jmp 0xb92e
leaq -0x9a0(%rbp), %rdi
callq 0x5150
jmp 0xb979
leaq -0x750(%rbp), %rdi
callq 0x5150
leaq -0x540(%rbp), %rdi
callq 0x10520
leaq -0x528(%rbp), %rdi
callq 0xf9b0
leaq -0x140(%rbp), %rdi
callq 0xf840
leaq -0x60(%rbp), %rdi
callq 0xf9b0
leaq -0x38(%rbp), %rdi
callq 0xec80
addq $0xed0, %rsp            # imm = 0xED0
popq %rbp
retq
leaq -0x750(%rbp), %rdi
callq 0x5150
leaq -0x540(%rbp), %rdi
callq 0x10520
leaq -0x528(%rbp), %rdi
callq 0xf9b0
leaq -0x140(%rbp), %rdi
callq 0xf840
leaq -0x60(%rbp), %rdi
callq 0xf9b0
leaq -0x38(%rbp), %rdi
callq 0xec80
movq -0x88(%rbp), %rdi
callq 0x58f0
nopw (%rax,%rax)