// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/networkstorage.cc
// Function: get_multiple_best_RMSD_fits(MOLECULE, ATOM_NETWORK*, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
vector<MOLECULE> get_multiple_best_RMSD_fits(MOLECULE mol, ATOM_NETWORK *cell, int vertex_ID, string net, string prefix, int mol_ID) {
  bool verbose = false; //for printing data to terminal
  //1) can we fit this MOLECULE to this VERTEX?
  int num_fit_sites_no_dummy = cell->vertices.at(vertex_ID).edges.size();
  int num_fit_sites_dummy = cell->vertices.at(vertex_ID).dummy_edges.size();
  int num_fit_sites = num_fit_sites_no_dummy + num_fit_sites_dummy;
  int num_mol_sites_no_dummy = mol.sites.size();
  int num_mol_sites_dummy = mol.dummy_sites.size();
  int num_mol_sites = num_mol_sites_no_dummy + num_mol_sites_dummy;
  if(num_fit_sites_dummy!=num_mol_sites_dummy || num_fit_sites_no_dummy!=num_mol_sites_no_dummy) { //we can only fit the molecule to the given vertex is the number of sites is the same in each
    printf("ERROR: cannot fit molecule with %d sites and %d dummy sites to a vertex with %d sites and %d dummy sites!\n", num_mol_sites_no_dummy, num_mol_sites_dummy, num_fit_sites_no_dummy, num_fit_sites_dummy);
    exit(EXIT_FAILURE);
  }

  //2) how many ways can we do it?
  vector<int> permute_base_no_dummy, permute_base_dummy;
  for(int i=0; i<num_fit_sites_no_dummy; i++) permute_base_no_dummy.push_back(i);
  for(int i=0; i<num_fit_sites_dummy; i++) permute_base_dummy.push_back(i+num_fit_sites_no_dummy);
  vector< vector<int> > permutations_no_dummy, permutations_dummy;

  permute(permute_base_no_dummy, 0, &permutations_no_dummy); //fills in a vector with all possible permutations by which we can try and orient our two objects, e.g. (0123), (0132), ...
  permute(permute_base_dummy, 0, &permutations_dummy);

  //2b) now collapse permutations for non-dummy and dummy together to get acceptable permutations
  vector< vector<int> > permutations;
  int num_perm_no_dummy = permutations_no_dummy.size();
  int num_perm_dummy = permutations_dummy.size();
  for(int i=0; i<num_perm_no_dummy; i++) {
    for(int j=0; j<num_perm_dummy; j++) {
      vector<int> new_perm = permutations_no_dummy.at(i);
      for(int k=0; k<num_fit_sites_dummy; k++) new_perm.push_back(permutations_dummy.at(j).at(k));
      permutations.push_back(new_perm);
    }
  }

  int num_perm = permutations.size();
  if(verbose) {
    printf("there are %d permutations of length %d:\n", num_perm, num_fit_sites);
    for(int i=0; i<num_perm; i++) {
      printf("\t");
      for(int j=0; j<permutations.at(i).size(); j++) {
        printf("%d ", permutations.at(i).at(j));
      }
      printf("\n");
    }
  }
  //3) which way gives us the lowest rmsd?
  double best_rmsd = -1; //dummy value
  int best_rmsd_ID = -1;
  vector<FIT> vector_of_fits;
  vector<MOLECULE> vector_of_centred_molecules;
  for(int p=0; p<num_perm; p++) { //try each permutation!
    vector<int> perm = permutations.at(p);
    double fixed[num_fit_sites][3], moving[num_fit_sites][3];
    XYZ fixed_CoM = origin, moving_CoM = origin;
    for(int i=0; i<num_fit_sites; i++) {
      XYZ fix(0,0,0);
      if(i<num_fit_sites_no_dummy)
        fix = cell->abc_to_xyz_returning_XYZ(cell->vertices.at(vertex_ID).edges.at(i)); //the edges are always in the same order
      else
        fix = cell->abc_to_xyz_returning_XYZ(cell->vertices.at(vertex_ID).dummy_edges.at(i-num_fit_sites_no_dummy));
      fixed[i][0] = fix.x;
      fixed[i][1] = fix.y;
      fixed[i][2] = fix.z;
      fixed_CoM = fixed_CoM+fix;
      XYZ move(0,0,0);
      if(perm.at(i)<num_fit_sites_no_dummy)
        move = mol.atoms_xyz.at(mol.sites.at(perm.at(i))); //permutation encodes in what order the sites should go to correspond to the edges
      else
//        move = mol.dummy_sites.at(perm.at(i)-num_fit_sites_no_dummy);
        move = mol.atoms_xyz.at(mol.dummy_sites.at(perm.at(i)-num_fit_sites_no_dummy));
      moving[i][0] = move.x;
      moving[i][1] = move.y;
      moving[i][2] = move.z;
      moving_CoM = moving_CoM+move;
    }

    if(verbose) {
      printf("PERMUTATION %d:\n\t", p);
      for(int i=0; i<num_fit_sites; i++) {
        printf("%d ", perm.at(i));
      }
      printf("\n");
      printf("\tfits the following positions:\n");
      for(int i=0; i<num_fit_sites; i++) {
        printf("\t\t%.3f %.3f %.3f to %.3f %.3f %.3f\n", moving[i][0], moving[i][1], moving[i][2], fixed[i][0], fixed[i][1], fixed[i][2]);
      }
    }
    //3a) evaluate this permutation
    double mov_com[3], mov_to_ref[3]; //leave these blank, they are filled in by the rmsd method
    double rotation_matrix[3][3];
    for(int i=0; i<3; i++) for(int j=0; j<3; j++) rotation_matrix[i][j] = 0; //dummy values - filled in by the rmsd method
    double rmsd = 0; //dummy value - filled in by the rmsd method
    calculate_rotation_rmsd(fixed, moving, num_fit_sites, mov_com, mov_to_ref, rotation_matrix, &rmsd); //calling rmsd code - writes the corresponding rotation matrix
    //3b) some permutations are not possible, and produce NAN
    bool valid = true;
    if(isnan(rmsd)) valid=false;
    for(int i=0; i<3 && valid; i++) for(int j=0; j<3 && valid; j++) if(isnan(rotation_matrix[i][j])) valid=false;
    if(valid) {
      FIT f;
      f.fit = rotate(mol, rotation_matrix);
      MOLECULE centred_aligned_mol = translate(f.fit, get_mol_site_CoM(&f.fit).scale(-1));
      f.fit.permutation = permutations.at(p);
      f.perm_ID = p;
      f.rmsd = rmsd;
//try and select alignments appropriately ...
      if(best_rmsd<0 || rmsd<best_rmsd) {
        best_rmsd = rmsd;
//        best_rmsd_ID = p;
        best_rmsd_ID = vector_of_fits.size();
      }
      vector_of_fits.push_back(f);
      vector_of_centred_molecules.push_back(centred_aligned_mol);
    } else if(verbose) printf("\tTHIS PERMUTATION COULD NOT PRODUCE A VALID ROTATION MATRIX\n");
  }

  //now return all molecules which are within a tolerance of the best RMSD
  int num_fits = vector_of_fits.size();
if(verbose) printf("DEBUG: num valid rotation matrices = %d; best_rmsd_ID = %d\n", num_fits, best_rmsd_ID);
  vector<MOLECULE> vec, vector_of_unique_centred_molecules;
  vector_of_unique_centred_molecules.push_back(vector_of_centred_molecules.at(best_rmsd_ID));
  FIT f0 = vector_of_fits.at(best_rmsd_ID);
  vec.push_back(f0.fit);
if(verbose) {
  string rotmol_name = prefix+"_molecule_ID_"+convertToString(mol_ID)+"_basic_vertex_ID_"+convertToString(vertex_ID)+"_permutation_"+convertToString(f0.perm_ID)+".xyz"; //write molecule to xyz file
  FILE *rotmol = fopen(rotmol_name.c_str(),"w");
  if(rotmol==NULL) {
    printf("ERROR: could not open output rotated molecule file with name %s\n", rotmol_name.c_str());
    exit(EXIT_FAILURE);
  }
  MOLECULE rotated = translate(f0.fit, get_mol_site_CoM(&f0.fit).scale(-1));
  write_molecule(rotmol, &rotated, net, vertex_ID, -1, true); //oriented to basic vertex basic_ID with symmetry "-1" (not applicable here) - this will be noted in the file - true indicates 'write out sites'
  fclose(rotmol);
  printf("\tmolecule %d oriented to basic vertex %d written to %s\n", mol_ID, vertex_ID, rotmol_name.c_str());
}
  for(int i=0; i<num_fits; i++) {
    if(i!=best_rmsd_ID) { //don't check the one we pushed already
      if(vector_of_fits.at(i).rmsd<best_rmsd*TOLERANCE_PROPORTION) { //acceptable RMSD?
        if(molecule_alignment_chemistry_is_unique(&vector_of_centred_molecules.at(i), &vector_of_unique_centred_molecules)) { //unique molecule?
          vector_of_unique_centred_molecules.push_back(vector_of_centred_molecules.at(i));
          FIT f = vector_of_fits.at(i);
          vec.push_back(f.fit);
if(verbose) {
  string rotmol_name = prefix+"_molecule_ID_"+convertToString(mol_ID)+"_basic_vertex_ID_"+convertToString(vertex_ID)+"_permutation_"+convertToString(f.perm_ID)+".xyz"; //write molecule to xyz file
  FILE *rotmol = fopen(rotmol_name.c_str(),"w");
  if(rotmol==NULL) {
    printf("ERROR: could not open output rotated molecule file with name %s\n", rotmol_name.c_str());
    exit(EXIT_FAILURE);
  }
  MOLECULE rotated = translate(f.fit, get_mol_site_CoM(&f.fit).scale(-1));
  write_molecule(rotmol, &rotated, net, vertex_ID, -1, true); //oriented to basic vertex basic_ID with symmetry "-1" (not applicable here) - this will be noted in the file - true indicates 'write out sites'
  fclose(rotmol);
  printf("\tmolecule %d oriented to basic vertex %d written to %s\n", mol_ID, vertex_ID, rotmol_name.c_str());
}
        }
      }
    }
  }
if(verbose) printf("DEBUG: of %d permutations, %d unique alignments were generated\n", num_perm, (int)(vec.size()));
  return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x588, %rsp            # imm = 0x588
movq %rsi, %r15
movq %rdi, -0x50(%rbp)
movslq %ecx, %rsi
movq 0x3c0(%rdx), %rax
movq %rdx, -0x38(%rbp)
movq 0x3c8(%rdx), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x5dc51
movq %rsi, -0xa0(%rbp)
imulq $0x70, %rsi, %rcx
movq 0x28(%rax,%rcx), %r13
movq 0x40(%rax,%rcx), %r12
subq 0x20(%rax,%rcx), %r13
sarq $0x3, %r13
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, -0x318(%rbp)
subq 0x38(%rax,%rcx), %r12
imulq %rdx, %r13
sarq $0x3, %r12
imulq %rdx, %r12
movq 0x50(%r15), %rsi
movq 0x68(%r15), %rdx
subq 0x48(%r15), %rsi
shrq $0x2, %rsi
subq 0x60(%r15), %rdx
shrq $0x2, %rdx
cmpl %esi, %r13d
jne 0x5dc5f
cmpl %edx, %r12d
jne 0x5dc5f
xorpd %xmm0, %xmm0
movapd %xmm0, -0x130(%rbp)
xorl %eax, %eax
movq %rax, -0x120(%rbp)
movq %rax, -0x100(%rbp)
movapd %xmm0, -0x110(%rbp)
movl $0x0, -0x2d0(%rbp)
testl %r13d, %r13d
jle 0x5c8d5
leaq -0x130(%rbp), %rbx
leaq -0x2d0(%rbp), %r14
movq -0x128(%rbp), %rsi
cmpq -0x120(%rbp), %rsi
je 0x5c8b7
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x128(%rbp)
jmp 0x5c8c2
movq %rbx, %rdi
movq %r14, %rdx
callq 0xf7b4
movl -0x2d0(%rbp), %eax
incl %eax
movl %eax, -0x2d0(%rbp)
cmpl %r13d, %eax
jl 0x5c898
movq %r15, -0xa8(%rbp)
movq %r12, -0x58(%rbp)
testl %r12d, %r12d
jle 0x5c937
leaq -0x110(%rbp), %rbx
leaq -0x2d0(%rbp), %r14
movl %r13d, %r15d
movq -0x58(%rbp), %rax
movl %eax, %r12d
movl %r15d, -0x2d0(%rbp)
movq -0x108(%rbp), %rsi
cmpq -0x100(%rbp), %rsi
je 0x5c924
movl %r15d, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x108(%rbp)
jmp 0x5c92f
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1422c
incl %r15d
decl %r12d
jne 0x5c8fd
xorpd %xmm0, %xmm0
movapd %xmm0, -0x310(%rbp)
xorl %eax, %eax
movq %rax, -0x300(%rbp)
movq %rax, -0x2e0(%rbp)
movapd %xmm0, -0x2f0(%rbp)
leaq -0x3d8(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0xe886
movq -0x58(%rbp), %rbx
leaq -0x3d8(%rbp), %rdi
leaq -0x310(%rbp), %rdx
xorl %esi, %esi
callq 0x9f7ef
movq -0x3d8(%rbp), %rdi
testq %rdi, %rdi
je 0x5c9a2
movq -0x3c8(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x3c0(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0xe886
leaq -0x3c0(%rbp), %rdi
leaq -0x2f0(%rbp), %rdx
xorl %esi, %esi
callq 0x9f7ef
movq -0x3c0(%rbp), %rdi
testq %rdi, %rdi
je 0x5c9e5
movq -0x3b0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
xorpd %xmm0, %xmm0
movapd %xmm0, -0xf0(%rbp)
movq -0x308(%rbp), %rcx
subq -0x310(%rbp), %rcx
movq $0x0, -0xe0(%rbp)
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rcx, -0x88(%rbp)
testl %ecx, %ecx
movq %r13, -0x60(%rbp)
jle 0x5cbc4
movq -0x2e8(%rbp), %rdx
subq -0x2f0(%rbp), %rdx
sarq $0x3, %rdx
imulq %rax, %rdx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, -0x88(%rbp)
movq %rdx, -0x48(%rbp)
andq %rax, %rdx
movq %rdx, -0x98(%rbp)
movq %rbx, %r15
andq %rax, %r15
movq $0x0, -0x30(%rbp)
cmpl $0x0, -0x48(%rbp)
jle 0x5cbac
movq -0x30(%rbp), %rax
leaq (%rax,%rax,2), %rax
movq %rax, -0x90(%rbp)
xorl %r14d, %r14d
movq -0x310(%rbp), %rax
movq -0x308(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq -0x30(%rbp), %rdx
jbe 0x5dbd7
movq -0x90(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x2d0(%rbp), %rdi
callq 0xe886
testl %ebx, %ebx
jle 0x5cb66
leaq (%r14,%r14,2), %r12
xorl %r13d, %r13d
xorl %ebx, %ebx
movq -0x2f0(%rbp), %rcx
movq -0x2e8(%rbp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %r14, %rdx
jbe 0x5dbb2
movq (%rcx,%r12,8), %rax
movq 0x8(%rcx,%r12,8), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rbx, %rdx
jbe 0x5dbaf
addq %r13, %rax
movq -0x2c8(%rbp), %rsi
cmpq -0x2c0(%rbp), %rsi
je 0x5cb47
movl (%rax), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x2c8(%rbp)
jmp 0x5cb56
leaq -0x2d0(%rbp), %rdi
movq %rax, %rdx
callq 0xf7b4
incq %rbx
addq $0x4, %r13
cmpq %rbx, %r15
jne 0x5cade
leaq -0xf0(%rbp), %rdi
leaq -0x2d0(%rbp), %rsi
callq 0xefae
movq -0x2d0(%rbp), %rdi
testq %rdi, %rdi
je 0x5cb94
movq -0x2c0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
incq %r14
cmpq -0x98(%rbp), %r14
movq -0x60(%rbp), %r13
movq -0x58(%rbp), %rbx
jne 0x5ca89
movq -0x30(%rbp), %rcx
incq %rcx
movq %rcx, -0x30(%rbp)
cmpq -0x88(%rbp), %rcx
jne 0x5ca6d
movq -0xe8(%rbp), %rcx
subq -0xf0(%rbp), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
xorl %r15d, %r15d
movq %r15, -0x70(%rbp)
xorpd %xmm0, %xmm0
movapd %xmm0, -0x80(%rbp)
movq %r15, -0xc0(%rbp)
movapd %xmm0, -0xd0(%rbp)
testl %ecx, %ecx
jle 0x5d7a8
leal (%rbx,%r13), %eax
movl %eax, -0x64(%rbp)
movl %eax, %eax
movq %rax, -0x90(%rbp)
movl $0x90, %eax
leaq -0x2d0(%rbp), %rsi
leaq (%rsi,%rax), %rdx
movq %rdx, -0x388(%rbp)
leaq -0x210(%rbp), %rdx
addq %rdx, %rax
movq %rax, -0x390(%rbp)
movslq %r13d, %rax
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq %rax, %rdx
negq %rdx
movq %rdx, -0x98(%rbp)
movq %rax, -0x58(%rbp)
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rax
negq %rax
movq %rax, -0x88(%rbp)
movsd 0xf6655(%rip), %xmm0    # 0x1532d0
movsd %xmm0, -0x40(%rbp)
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
xorl %esi, %esi
movq %rcx, -0x398(%rbp)
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rsi, %rdx
jbe 0x5dc0f
movl %r12d, -0xb4(%rbp)
movq %rsi, -0x48(%rbp)
leaq (%rsi,%rsi,2), %rcx
movq %rcx, -0x3a0(%rbp)
leaq (%rax,%rcx,8), %rsi
leaq -0x330(%rbp), %rdi
callq 0xe886
movq %rsp, -0x3a8(%rbp)
movq %rsp, %rcx
movq -0x90(%rbp), %rax
leaq (%rax,%rax,2), %rax
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, %rsp
movq %rsp, %r13
subq %rax, %r13
movq %r13, %rsp
movq 0x13a9c4(%rip), %rax    # 0x1976e0
movq %rax, -0x400(%rbp)
movupd 0x13a9a5(%rip), %xmm0   # 0x1976d0
movapd %xmm0, -0x410(%rbp)
movq %rax, -0x3e0(%rbp)
movapd %xmm0, -0x3f0(%rbp)
cmpl $0x0, -0x64(%rbp)
jle 0x5d05a
movl $0x4, %r12d
xorl %r14d, %r14d
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
leaq -0x2d0(%rbp), %rdi
callq 0x85982
movq %r14, %rsi
subq -0x58(%rbp), %rsi
jge 0x5ce09
movq -0x38(%rbp), %rax
movq 0x3c0(%rax), %rcx
movq 0x3c8(%rax), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdx
movq -0xa0(%rbp), %rsi
cmpq %rsi, %rdx
jbe 0x5dbec
movq -0x318(%rbp), %rdx
movq 0x20(%rcx,%rdx), %rax
movq 0x28(%rcx,%rdx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r14, %rdx
jbe 0x5dbe9
movsd -0x10(%rax,%r12,4), %xmm0
movsd -0x8(%rax,%r12,4), %xmm1
movsd (%rax,%r12,4), %xmm2
leaq -0x210(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x530d6
jmp 0x5cea2
movq -0x38(%rbp), %rax
movq 0x3c0(%rax), %rcx
movq 0x3c8(%rax), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdx
cmpq -0xa0(%rbp), %rdx
jbe 0x5dbfa
movq -0x98(%rbp), %rax
leaq (%rax,%r14), %rdi
movq -0x318(%rbp), %rdx
movq 0x38(%rcx,%rdx), %rax
movq 0x40(%rcx,%rdx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %rdi, %rdx
jbe 0x5dc01
addq -0x88(%rbp), %rax
movsd -0x10(%rax,%r12,4), %xmm0
movsd -0x8(%rax,%r12,4), %xmm1
movsd (%rax,%r12,4), %xmm2
leaq -0x210(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x530d6
movq -0x200(%rbp), %rax
movq %rax, -0x2c0(%rbp)
movups -0x210(%rbp), %xmm0
movaps %xmm0, -0x2d0(%rbp)
movsd -0x2d0(%rbp), %xmm0
movq -0x30(%rbp), %rax
movsd %xmm0, -0x10(%rax,%r12,4)
movsd -0x2c8(%rbp), %xmm0
movsd %xmm0, -0x8(%rax,%r12,4)
movsd -0x2c0(%rbp), %xmm0
movsd %xmm0, (%rax,%r12,4)
leaq -0x210(%rbp), %rbx
movq %rbx, %rdi
leaq -0x410(%rbp), %rsi
leaq -0x2d0(%rbp), %rdx
callq 0x85dd4
movq -0x200(%rbp), %rax
movq %rax, -0x400(%rbp)
movupd -0x210(%rbp), %xmm0
movapd %xmm0, -0x410(%rbp)
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %rbx, %rdi
callq 0x85982
movq -0x330(%rbp), %rax
movq -0x328(%rbp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r14, %rdx
jbe 0x5dbc6
movslq (%rax,%r14,4), %rax
movq -0x60(%rbp), %rcx
cmpl %ecx, %eax
jge 0x5cf78
movq -0xa8(%rbp), %rsi
movq 0x48(%rsi), %rcx
movq 0x50(%rsi), %rdx
jmp 0x5cf8b
subl %ecx, %eax
cltq
movq -0xa8(%rbp), %rsi
movq 0x60(%rsi), %rcx
movq 0x68(%rsi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x5dbc3
movslq (%rcx,%rax,4), %rax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdx
cmpq %rax, %rdx
jbe 0x5dbc3
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x210(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x200(%rbp)
movsd -0x210(%rbp), %xmm0
movsd %xmm0, -0x10(%r13,%r12,4)
movsd -0x208(%rbp), %xmm0
movsd %xmm0, -0x8(%r13,%r12,4)
movsd -0x200(%rbp), %xmm0
movsd %xmm0, (%r13,%r12,4)
leaq -0x380(%rbp), %rdi
leaq -0x3f0(%rbp), %rsi
leaq -0x210(%rbp), %rdx
callq 0x85dd4
movq -0x370(%rbp), %rax
movq %rax, -0x3e0(%rbp)
movupd -0x380(%rbp), %xmm0
movapd %xmm0, -0x3f0(%rbp)
incq %r14
addq $0x6, %r12
cmpq %r14, -0x90(%rbp)
jne 0x5cd55
movq %r15, -0x340(%rbp)
xorpd %xmm0, %xmm0
movapd %xmm0, -0x350(%rbp)
movapd %xmm0, -0x360(%rbp)
movapd %xmm0, -0x370(%rbp)
movapd %xmm0, -0x380(%rbp)
movq %r15, -0xb0(%rbp)
subq $0x8, %rsp
movq -0x30(%rbp), %rdi
movq %r13, %rsi
movl -0x64(%rbp), %edx
leaq -0x5b0(%rbp), %rcx
leaq -0x590(%rbp), %r8
leaq -0x380(%rbp), %r9
leaq -0xb0(%rbp), %rax
pushq %rax
callq 0xa3f80
addq $0x10, %rsp
movsd -0xb0(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setnp %al
movl -0xb4(%rbp), %r12d
leaq -0x1f8(%rbp), %rbx
leaq -0x2d0(%rbp), %r14
jp 0x5d126
setnp %al
leaq -0x380(%rbp), %rcx
xorl %edx, %edx
testb $0x1, %al
je 0x5d115
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
ucomisd %xmm0, %xmm0
movzbl %al, %eax
cmovpl %r15d, %eax
cmpq $0x1, %rsi
ja 0x5d115
incq %rsi
testb $0x1, %al
jne 0x5d0f8
cmpq $0x1, %rdx
ja 0x5d126
incq %rdx
addq $0x18, %rcx
testb $0x1, %al
jne 0x5d0f2
testb $0x1, %al
je 0x5d760
movq %r14, %rdi
callq 0x683dc
leaq -0x578(%rbp), %r13
movq %r13, %rdi
movq -0xa8(%rbp), %rsi
callq 0x67f48
leaq -0x210(%rbp), %rdi
movq %r13, %rsi
leaq -0x380(%rbp), %rdx
callq 0x9f2df
movq -0x2d0(%rbp), %rdi
movq -0x2c0(%rbp), %rsi
movq -0x210(%rbp), %rax
movq %rax, -0x2d0(%rbp)
movups -0x208(%rbp), %xmm0
movups %xmm0, -0x2c8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x210(%rbp)
movq $0x0, -0x200(%rbp)
testq %rdi, %rdi
je 0x5d1ae
subq %rdi, %rsi
callq 0x4470
xorps %xmm0, %xmm0
movaps %xmm0, -0x150(%rbp)
movups -0x2b8(%rbp), %xmm0
movq -0x2a8(%rbp), %rax
movups -0x1f8(%rbp), %xmm1
movups %xmm1, -0x2b8(%rbp)
movq -0x1e8(%rbp), %rcx
movq %rcx, -0x2a8(%rbp)
movaps -0x150(%rbp), %xmm1
movaps %xmm0, -0x150(%rbp)
movq %rax, -0x140(%rbp)
movups %xmm1, -0x1f8(%rbp)
movq %r15, -0x1e8(%rbp)
leaq -0x150(%rbp), %r13
movq %r13, %rdi
callq 0x2f6f0
xorps %xmm0, %xmm0
movaps %xmm0, -0x150(%rbp)
movups -0x2a0(%rbp), %xmm0
movq -0x290(%rbp), %rax
movaps -0x1e0(%rbp), %xmm1
movups %xmm1, -0x2a0(%rbp)
movq -0x1d0(%rbp), %rcx
movq %rcx, -0x290(%rbp)
movapd -0x150(%rbp), %xmm1
movaps %xmm0, -0x150(%rbp)
movq %rax, -0x140(%rbp)
movapd %xmm1, -0x1e0(%rbp)
movq %r15, -0x1d0(%rbp)
movq %r13, %rdi
callq 0x2f6f0
movq -0x288(%rbp), %rdi
movq -0x280(%rbp), %rax
movq -0x278(%rbp), %rsi
movq -0x1c8(%rbp), %rcx
movq %rcx, -0x288(%rbp)
movaps -0x1c0(%rbp), %xmm0
movups %xmm0, -0x280(%rbp)
movq %rdi, -0x1c8(%rbp)
movq %rax, -0x1c0(%rbp)
movq %rsi, -0x1b8(%rbp)
movq %r15, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
testq %rdi, %rdi
je 0x5d2d3
subq %rdi, %rsi
callq 0x4470
movq -0x270(%rbp), %rdi
movq -0x268(%rbp), %rax
movq -0x260(%rbp), %rsi
movq -0x1b0(%rbp), %rcx
movq %rcx, -0x270(%rbp)
movups -0x1a8(%rbp), %xmm0
movups %xmm0, -0x268(%rbp)
movq %rdi, -0x1b0(%rbp)
movq %rax, -0x1a8(%rbp)
movq %rsi, -0x1a0(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
testq %rdi, %rdi
je 0x5d335
subq %rdi, %rsi
callq 0x4470
movq -0x258(%rbp), %rdi
movq -0x250(%rbp), %rax
movq -0x248(%rbp), %rsi
movq -0x198(%rbp), %rcx
movq %rcx, -0x258(%rbp)
movaps -0x190(%rbp), %xmm0
movups %xmm0, -0x250(%rbp)
movq %rdi, -0x198(%rbp)
movq %rax, -0x190(%rbp)
movq %rsi, -0x188(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
testq %rdi, %rdi
je 0x5d397
subq %rdi, %rsi
callq 0x4470
movq -0x390(%rbp), %rcx
movq 0x10(%rcx), %rax
movq -0x388(%rbp), %rdx
movq %rax, 0x10(%rdx)
movupd (%rcx), %xmm0
movupd %xmm0, (%rdx)
movq -0x198(%rbp), %rdi
testq %rdi, %rdi
je 0x5d3d0
movq -0x188(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x1b0(%rbp), %rdi
testq %rdi, %rdi
je 0x5d3eb
movq -0x1a0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x1c8(%rbp), %rdi
testq %rdi, %rdi
je 0x5d406
movq -0x1b8(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x1e0(%rbp), %rdi
callq 0x2f6f0
movq %rbx, %rdi
callq 0x2f6f0
movq -0x210(%rbp), %rdi
testq %rdi, %rdi
je 0x5d435
movq -0x200(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x500(%rbp), %rdi
testq %rdi, %rdi
je 0x5d450
movq -0x4f0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x518(%rbp), %rdi
testq %rdi, %rdi
je 0x5d46b
movq -0x508(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x530(%rbp), %rdi
testq %rdi, %rdi
je 0x5d486
movq -0x520(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x548(%rbp), %rdi
callq 0x2f6f0
leaq -0x560(%rbp), %rdi
callq 0x2f6f0
movq -0x578(%rbp), %rdi
testq %rdi, %rdi
je 0x5d4b9
movq -0x568(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x4d0(%rbp), %rdi
movq %r14, %rsi
callq 0x67f48
leaq -0x150(%rbp), %rdi
movq %r14, %rsi
callq 0x9f4c6
leaq -0x428(%rbp), %rdi
leaq -0x150(%rbp), %rsi
movsd 0xf5de3(%rip), %xmm0    # 0x1532d0
callq 0x85a34
subq $0x20, %rsp
movq -0x418(%rbp), %rax
movq %rax, 0x10(%rsp)
movupd -0x428(%rbp), %xmm0
movupd %xmm0, (%rsp)
leaq -0x210(%rbp), %rdi
leaq -0x4d0(%rbp), %rsi
callq 0x9f6e4
addq $0x20, %rsp
movq -0x458(%rbp), %rdi
testq %rdi, %rdi
je 0x5d541
movq -0x448(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x470(%rbp), %rdi
testq %rdi, %rdi
je 0x5d55c
movq -0x460(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x488(%rbp), %rdi
testq %rdi, %rdi
je 0x5d577
movq -0x478(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x4a0(%rbp), %rdi
callq 0x2f6f0
leaq -0x4b8(%rbp), %rdi
callq 0x2f6f0
movq -0x4d0(%rbp), %rdi
testq %rdi, %rdi
je 0x5d5aa
movq -0x4c0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq -0x48(%rbp), %rdx
jbe 0x5dc2e
movq -0x3a0(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x258(%rbp), %rdi
callq 0x1005e
movq -0x48(%rbp), %rax
movl %eax, -0x220(%rbp)
movsd -0xb0(%rbp), %xmm0
movsd %xmm0, -0x228(%rbp)
movsd -0x40(%rbp), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
ja 0x5d61d
ucomisd %xmm0, %xmm1
jbe 0x5d634
movq -0x78(%rbp), %rax
subq -0x80(%rbp), %rax
shrq $0x3, %rax
imull $0xe9bd37a7, %eax, %r12d # imm = 0xE9BD37A7
movapd %xmm0, %xmm1
movsd %xmm1, -0x40(%rbp)
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x680e6
leaq -0xd0(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x68142
movq -0x198(%rbp), %rdi
testq %rdi, %rdi
je 0x5d673
movq -0x188(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x1b0(%rbp), %rdi
testq %rdi, %rdi
je 0x5d68e
movq -0x1a0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x1c8(%rbp), %rdi
testq %rdi, %rdi
je 0x5d6a9
movq -0x1b8(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x1e0(%rbp), %rdi
callq 0x2f6f0
leaq -0x1f8(%rbp), %rdi
callq 0x2f6f0
movq -0x210(%rbp), %rdi
testq %rdi, %rdi
je 0x5d6dc
movq -0x200(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x258(%rbp), %rdi
testq %rdi, %rdi
je 0x5d6f7
movq -0x248(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x270(%rbp), %rdi
testq %rdi, %rdi
je 0x5d712
movq -0x260(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x288(%rbp), %rdi
testq %rdi, %rdi
je 0x5d72d
movq -0x278(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x2a0(%rbp), %rdi
callq 0x2f6f0
leaq -0x2b8(%rbp), %rdi
callq 0x2f6f0
movq -0x2d0(%rbp), %rdi
testq %rdi, %rdi
je 0x5d760
movq -0x2c0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x3a8(%rbp), %rsp
movq -0x330(%rbp), %rdi
testq %rdi, %rdi
je 0x5d782
movq -0x320(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x48(%rbp), %rsi
incq %rsi
movq -0x398(%rbp), %rcx
cmpq %rcx, %rsi
jne 0x5cc8f
movsd -0x40(%rbp), %xmm0
mulsd 0xf6f42(%rip), %xmm0    # 0x1546e8
jmp 0x5d7b6
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movsd 0xf6f2a(%rip), %xmm0    # 0x1546e0
movsd %xmm0, -0x40(%rbp)
movq -0x78(%rbp), %r15
subq -0x80(%rbp), %r15
xorl %eax, %eax
movq -0x50(%rbp), %rcx
movq %rax, 0x10(%rcx)
xorpd %xmm0, %xmm0
movupd %xmm0, (%rcx)
movq %rax, -0x370(%rbp)
movapd %xmm0, -0x380(%rbp)
movslq %r12d, %rbx
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $-0x30c30c30c30c30c3, %rax # imm = 0xCF3CF3CF3CF3CF3D
imulq %rax, %rdx
cmpq %rbx, %rdx
jbe 0x5dc7d
imulq $0xa8, %rbx, %rax
addq %rax, %rsi
leaq -0x380(%rbp), %rdi
callq 0x68142
movabsq $-0x2c8590b21642c859, %rax # imm = 0xD37A6F4DE9BD37A7
movq -0x80(%rbp), %r14
movq -0x78(%rbp), %rdx
subq %r14, %rdx
sarq $0x3, %rdx
imulq %rax, %rdx
cmpq %rbx, %rdx
jbe 0x5dc8e
imulq $0xb8, %rbx, %rax
addq %rax, %r14
leaq -0x2d0(%rbp), %rdi
movq %r14, %rsi
callq 0x67f48
movl 0xb0(%r14), %eax
leaq -0x2d0(%rbp), %rsi
movl %eax, 0xb0(%rsi)
movq 0xa8(%r14), %rax
movq %rax, 0xa8(%rsi)
movq -0x50(%rbp), %rdi
callq 0x68142
movq %r15, %r8
sarq $0x3, %r8
movabsq $-0x2c8590b21642c859, %rax # imm = 0xD37A6F4DE9BD37A7
imulq %rax, %r8
testl %r8d, %r8d
movabsq $-0x30c30c30c30c30c3, %r14 # imm = 0xCF3CF3CF3CF3CF3D
jle 0x5da9d
movl %r12d, %esi
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %r12d, %r12d
xorl %r13d, %r13d
xorl %ebx, %ebx
movq %r8, -0x38(%rbp)
movq %rsi, -0x60(%rbp)
cmpq %rbx, %rsi
je 0x5da83
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x2c8590b21642c859, %rcx # imm = 0xD37A6F4DE9BD37A7
imulq %rcx, %rdx
cmpq %rbx, %rdx
jbe 0x5dc1d
movsd -0x40(%rbp), %xmm0
ucomisd 0xa8(%rax,%r12), %xmm0
jbe 0x5da83
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
cmpq %rbx, %rdx
jbe 0x5dc1d
addq %r13, %rdi
leaq -0x380(%rbp), %rsi
callq 0xa23d5
testb %al, %al
movq -0x60(%rbp), %rsi
movq -0x38(%rbp), %r8
je 0x5da83
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
cmpq %rbx, %rdx
jbe 0x5dc1d
addq %r13, %rsi
leaq -0x380(%rbp), %rdi
callq 0x68142
movq -0x80(%rbp), %r14
movq -0x78(%rbp), %rdx
subq %r14, %rdx
sarq $0x3, %rdx
movabsq $-0x2c8590b21642c859, %rax # imm = 0xD37A6F4DE9BD37A7
imulq %rax, %rdx
cmpq %rbx, %rdx
leaq -0x210(%rbp), %rdi
jbe 0x5dc40
leaq (%r14,%r12), %rsi
movq %rdi, %r15
callq 0x67f48
movl 0xb0(%r14,%r12), %eax
leaq -0x168(%rbp), %rcx
movl %eax, 0x8(%rcx)
movq 0xa8(%r14,%r12), %rax
movq %rax, (%rcx)
movq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x68142
movq -0x198(%rbp), %rdi
testq %rdi, %rdi
movabsq $-0x30c30c30c30c30c3, %r14 # imm = 0xCF3CF3CF3CF3CF3D
je 0x5da12
movq -0x188(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x1b0(%rbp), %rdi
testq %rdi, %rdi
je 0x5da2d
movq -0x1a0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x1c8(%rbp), %rdi
testq %rdi, %rdi
je 0x5da48
movq -0x1b8(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x1e0(%rbp), %rdi
callq 0x2f6f0
leaq -0x1f8(%rbp), %rdi
callq 0x2f6f0
movq -0x210(%rbp), %rdi
testq %rdi, %rdi
je 0x5da7b
movq -0x200(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x60(%rbp), %rsi
movq -0x38(%rbp), %r8
incq %rbx
addq $0xa8, %r13
addq $0xb8, %r12
cmpq %rbx, %r8
jne 0x5d8d5
movq -0x258(%rbp), %rdi
testq %rdi, %rdi
je 0x5dab8
movq -0x248(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x270(%rbp), %rdi
testq %rdi, %rdi
je 0x5dad3
movq -0x260(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x288(%rbp), %rdi
testq %rdi, %rdi
je 0x5daee
movq -0x278(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x2a0(%rbp), %rdi
callq 0x2f6f0
leaq -0x2b8(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f6f0
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5db21
movq -0x2c0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x380(%rbp), %rdi
callq 0x681e2
leaq -0xd0(%rbp), %rdi
callq 0x681e2
leaq -0x80(%rbp), %rdi
callq 0x68212
leaq -0xf0(%rbp), %rdi
callq 0xefda
leaq -0x2f0(%rbp), %rdi
callq 0xefda
leaq -0x310(%rbp), %rdi
callq 0xefda
movq -0x110(%rbp), %rdi
testq %rdi, %rdi
je 0x5db81
movq -0x100(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x130(%rbp), %rdi
testq %rdi, %rdi
je 0x5db9c
movq -0x120(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x50(%rbp), %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r14
leaq 0xf1aec(%rip), %rdi     # 0x14f6a5
movq %r14, %rsi
xorl %eax, %eax
callq 0x4630
movq %rax, %r14
leaq 0xf1ad8(%rip), %rdi     # 0x14f6a5
movq %r14, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf1ac7(%rip), %rdi     # 0x14f6a5
movq -0x30(%rbp), %rsi
xorl %eax, %eax
callq 0x4630
movq %r14, %rsi
leaq 0xf1ab2(%rip), %rdi     # 0x14f6a5
xorl %eax, %eax
callq 0x4630
movq -0xa0(%rbp), %rsi
leaq 0xf1a9d(%rip), %rdi     # 0x14f6a5
xorl %eax, %eax
callq 0x4630
leaq 0xf1a8f(%rip), %rdi     # 0x14f6a5
xorl %eax, %eax
callq 0x4630
leaq 0xf1a81(%rip), %rdi     # 0x14f6a5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf1a70(%rip), %rdi     # 0x14f6a5
movq -0x48(%rbp), %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf1a5e(%rip), %rdi     # 0x14f6a5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf1a4d(%rip), %rdi     # 0x14f6a5
xorl %eax, %eax
callq 0x4630
leaq 0xf777b(%rip), %rdi     # 0x1553e1
movl %r13d, %ecx
movl %r12d, %r8d
xorl %eax, %eax
callq 0x4060
movl $0x1, %edi
callq 0x710c
leaq 0xf1a21(%rip), %rdi     # 0x14f6a5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf1a10(%rip), %rdi     # 0x14f6a5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
jmp 0x5dd2e
movq %rax, %rbx
movq -0x3c0(%rbp), %rdi
testq %rdi, %rdi
je 0x5de00
movq -0x3b0(%rbp), %rsi
jmp 0x5dcda
movq %rax, %rbx
movq -0x3d8(%rbp), %rdi
testq %rdi, %rdi
je 0x5de00
movq -0x3c8(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
jmp 0x5de00
jmp 0x5dce9
movq %rax, %rbx
jmp 0x5dd3d
movq %rax, %rbx
jmp 0x5de00
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x68172
jmp 0x5dd31
jmp 0x5dd2e
jmp 0x5dd2e
jmp 0x5dd2e
jmp 0x5dd0f
movq %rax, %rbx
jmp 0x5de18
movq %rax, %rbx
leaq -0x578(%rbp), %rdi
jmp 0x5dd73
jmp 0x5dd9f
jmp 0x5dd5d
jmp 0x5dd29
movq %rax, %rbx
jmp 0x5dd78
movq %rax, %rbx
leaq -0x2d0(%rbp), %rdi
callq 0x68172
leaq -0x380(%rbp), %rdi
callq 0x681e2
movq -0x50(%rbp), %rdi
callq 0x681e2
jmp 0x5ddbd
jmp 0x5dd9f
jmp 0x5dd58
movq %rax, %rbx
jmp 0x5ddbd
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
jmp 0x5dd73
movq %rax, %rbx
leaq -0x4d0(%rbp), %rdi
callq 0x6804c
leaq -0x2d0(%rbp), %rdi
callq 0x68172
jmp 0x5dda2
jmp 0x5dd9f
jmp 0x5dd9f
jmp 0x5ddd6
jmp 0x5dd8e
movq %rax, %rbx
jmp 0x5ddf4
jmp 0x5dd9f
jmp 0x5dd9f
jmp 0x5dd9f
jmp 0x5dd9f
jmp 0x5dd9f
jmp 0x5dd9f
movq %rax, %rbx
movq -0x330(%rbp), %rdi
testq %rdi, %rdi
je 0x5ddbd
movq -0x320(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0xd0(%rbp), %rdi
callq 0x681e2
leaq -0x80(%rbp), %rdi
callq 0x68212
jmp 0x5ddf4
jmp 0x5ddd6
movq %rax, %rbx
movq -0x2d0(%rbp), %rdi
testq %rdi, %rdi
je 0x5ddf4
movq -0x2c0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0xf0(%rbp), %rdi
callq 0xefda
leaq -0x2f0(%rbp), %rdi
callq 0xefda
leaq -0x310(%rbp), %rdi
callq 0xefda
movq -0x110(%rbp), %rdi
testq %rdi, %rdi
je 0x5de33
movq -0x100(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x130(%rbp), %rdi
testq %rdi, %rdi
je 0x5de4e
movq -0x120(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780