// File: /workspace/github_cpp_makefile_star2_O3/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 $0x578, %rsp            # imm = 0x578
movq %rdi, -0x58(%rbp)
movslq %ecx, %rbx
movq 0x3c0(%rdx), %rax
movq %rdx, -0x90(%rbp)
movq 0x3c8(%rdx), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rcx, %rdx
cmpq %rbx, %rdx
jbe 0x5d6b8
movq %rsi, %r8
imulq $0x70, %rbx, %rdx
movq 0x28(%rax,%rdx), %rcx
movq 0x40(%rax,%rdx), %r13
subq 0x20(%rax,%rdx), %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
movq %rdx, -0x308(%rbp)
subq 0x38(%rax,%rdx), %r13
imulq %rsi, %rcx
sarq $0x3, %r13
imulq %rsi, %r13
movq 0x50(%r8), %rsi
movq 0x68(%r8), %rdx
subq 0x48(%r8), %rsi
shrq $0x2, %rsi
movq %r8, -0xc0(%rbp)
subq 0x60(%r8), %rdx
shrq $0x2, %rdx
movq %rcx, -0x40(%rbp)
cmpl %esi, %ecx
jne 0x5d6c9
cmpl %edx, %r13d
jne 0x5d6c9
xorpd %xmm0, %xmm0
movapd %xmm0, -0x130(%rbp)
xorl %eax, %eax
movq %rax, -0x120(%rbp)
movq %rax, -0x100(%rbp)
movapd %xmm0, -0x110(%rbp)
movl $0x0, -0x1f0(%rbp)
cmpl $0x0, -0x40(%rbp)
jle 0x5c39f
leaq -0x130(%rbp), %r12
leaq -0x1f0(%rbp), %r15
movq -0x128(%rbp), %rsi
cmpq -0x120(%rbp), %rsi
je 0x5c381
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x128(%rbp)
jmp 0x5c38c
movq %r12, %rdi
movq %r15, %rdx
callq 0xf864
movl -0x1f0(%rbp), %eax
incl %eax
movl %eax, -0x1f0(%rbp)
cmpl -0x40(%rbp), %eax
jl 0x5c362
movq %rbx, -0x60(%rbp)
testl %r13d, %r13d
jle 0x5c3f6
leaq -0x110(%rbp), %r12
leaq -0x1f0(%rbp), %r15
movq -0x40(%rbp), %rax
movl %eax, %ebx
movl %r13d, %r14d
movl %ebx, -0x1f0(%rbp)
movq -0x108(%rbp), %rsi
cmpq -0x100(%rbp), %rsi
je 0x5c3e4
movl %ebx, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x108(%rbp)
jmp 0x5c3ef
movq %r12, %rdi
movq %r15, %rdx
callq 0x14198
incl %ebx
decl %r14d
jne 0x5c3bf
xorpd %xmm0, %xmm0
movapd %xmm0, -0x2f0(%rbp)
xorl %eax, %eax
movq %rax, -0x2e0(%rbp)
movq %rax, -0x2c0(%rbp)
movapd %xmm0, -0x2d0(%rbp)
leaq -0x3c8(%rbp), %rdi
leaq -0x130(%rbp), %rsi
callq 0xe8f8
movq -0x40(%rbp), %rbx
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
leaq -0x3c8(%rbp), %rdi
leaq -0x2f0(%rbp), %rdx
xorl %esi, %esi
callq 0x9dc03
movq -0x3c8(%rbp), %rdi
testq %rdi, %rdi
je 0x5c46b
movq -0x3b8(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x3b0(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0xe8f8
leaq -0x3b0(%rbp), %rdi
leaq -0x2d0(%rbp), %rdx
xorl %esi, %esi
callq 0x9dc03
movq -0x3b0(%rbp), %rdi
testq %rdi, %rdi
je 0x5c4ae
movq -0x3a0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
xorpd %xmm0, %xmm0
movapd %xmm0, -0xf0(%rbp)
movq -0x2e8(%rbp), %rcx
subq -0x2f0(%rbp), %rcx
movq $0x0, -0xe0(%rbp)
sarq $0x3, %rcx
imulq %r14, %rcx
testl %ecx, %ecx
jle 0x5d224
movq -0x2c8(%rbp), %rdx
subq -0x2d0(%rbp), %rdx
leal (%rbx,%r13), %eax
movl %eax, -0x44(%rbp)
sarq $0x3, %rdx
imulq %r14, %rdx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
andq %rax, %rcx
movq %rcx, -0x50(%rbp)
movq %rdx, -0xb8(%rbp)
andq %rax, %rdx
movq %rdx, -0xc8(%rbp)
movq %r13, -0xd0(%rbp)
andq %rax, %r13
movq $0x0, -0x30(%rbp)
leaq -0x1f0(%rbp), %r15
cmpl $0x0, -0xb8(%rbp)
jle 0x5c674
movq -0x30(%rbp), %rax
leaq (%rax,%rax,2), %rax
movq %rax, -0x88(%rbp)
xorl %ebx, %ebx
movq -0x2f0(%rbp), %rax
movq -0x2e8(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
cmpq -0x30(%rbp), %rdx
jbe 0x5d63c
movq -0x88(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r15, %rdi
callq 0xe8f8
cmpl $0x0, -0xd0(%rbp)
jle 0x5c629
leaq (%rbx,%rbx,2), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq -0x2d0(%rbp), %rcx
movq -0x2c8(%rbp), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rdx
cmpq %rbx, %rdx
jbe 0x5d617
movq (%rcx,%r14,8), %rax
movq 0x8(%rcx,%r14,8), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
jbe 0x5d614
addq %r15, %rax
movq -0x1e8(%rbp), %rsi
cmpq -0x1e0(%rbp), %rsi
je 0x5c60a
movl (%rax), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x1e8(%rbp)
jmp 0x5c619
leaq -0x1f0(%rbp), %rdi
movq %rax, %rdx
callq 0xf864
incq %r12
addq $0x4, %r15
cmpq %r12, %r13
jne 0x5c5a1
leaq -0xf0(%rbp), %rdi
leaq -0x1f0(%rbp), %r15
movq %r15, %rsi
callq 0xf03a
movq -0x1f0(%rbp), %rdi
testq %rdi, %rdi
je 0x5c65a
movq -0x1e0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
incq %rbx
cmpq -0xc8(%rbp), %rbx
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
jne 0x5c554
movq -0x30(%rbp), %rcx
incq %rcx
movq %rcx, -0x30(%rbp)
cmpq -0x50(%rbp), %rcx
jne 0x5c536
movq -0xe8(%rbp), %rcx
subq -0xf0(%rbp), %rcx
sarq $0x3, %rcx
imulq %r14, %rcx
xorl %edx, %edx
movq %rdx, -0x70(%rbp)
xorpd %xmm0, %xmm0
movapd %xmm0, -0x80(%rbp)
movq %rdx, -0xa0(%rbp)
movapd %xmm0, -0xb0(%rbp)
testl %ecx, %ecx
jle 0x5d255
movl -0x44(%rbp), %eax
movq %rax, -0x88(%rbp)
movl $0x90, %eax
leaq (%r15,%rax), %rdx
movq %rdx, -0x2f8(%rbp)
leaq -0x2b0(%rbp), %rdx
addq %rdx, %rax
movq %rax, -0x300(%rbp)
movslq -0x40(%rbp), %rax
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq %rax, %rdx
negq %rdx
movq %rdx, -0xc8(%rbp)
movq %rax, -0xd0(%rbp)
leaq (,%rax,8), %rax
leaq (%rax,%rax,2), %rax
negq %rax
movq %rax, -0xb8(%rbp)
movsd 0xf4c34(%rip), %xmm0    # 0x151360
movsd %xmm0, -0x38(%rbp)
movl $0xffffffff, -0x64(%rbp) # imm = 0xFFFFFFFF
xorl %r12d, %r12d
leaq -0x4c0(%rbp), %rbx
xorl %esi, %esi
movq %rcx, -0x388(%rbp)
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
cmpq %rsi, %rdx
jbe 0x5d687
movq %rsi, -0x50(%rbp)
leaq (%rsi,%rsi,2), %rcx
movq %rcx, -0x390(%rbp)
leaq (%rax,%rcx,8), %rsi
leaq -0x338(%rbp), %rdi
callq 0xe8f8
movq %rsp, -0x398(%rbp)
movq %rsp, %rcx
movq -0x88(%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, %r14
subq %rax, %r14
movq %r14, %rsp
movq 0x138f19(%rip), %rax    # 0x1956e0
movq %rax, -0x3f0(%rbp)
movupd 0x138efa(%rip), %xmm0   # 0x1956d0
movapd %xmm0, -0x400(%rbp)
movq %rax, -0x3d0(%rbp)
movapd %xmm0, -0x3e0(%rbp)
cmpl $0x0, -0x44(%rbp)
jle 0x5caef
movl $0x4, %r13d
xorl %r15d, %r15d
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
leaq -0x1f0(%rbp), %rdi
callq 0x84364
movq %r15, %rsi
subq -0xd0(%rbp), %rsi
jge 0x5c8b7
movq -0x90(%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 -0x60(%rbp), %rdx
jbe 0x5d652
movq -0x308(%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 %r15, %rdx
jbe 0x5d64e
movsd -0x10(%rax,%r13,4), %xmm0
movsd -0x8(%rax,%r13,4), %xmm1
movsd (%rax,%r13,4), %xmm2
leaq -0x2b0(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x52dd8
jmp 0x5c953
movq -0x90(%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 -0x60(%rbp), %rdx
jbe 0x5d664
movq -0xc8(%rbp), %rax
leaq (%rax,%r15), %rdi
movq -0x308(%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 0x5d668
addq -0xb8(%rbp), %rax
movsd -0x10(%rax,%r13,4), %xmm0
movsd -0x8(%rax,%r13,4), %xmm1
movsd (%rax,%r13,4), %xmm2
leaq -0x2b0(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x52dd8
movq -0x2a0(%rbp), %rax
movq %rax, -0x1e0(%rbp)
movups -0x2b0(%rbp), %xmm0
movaps %xmm0, -0x1f0(%rbp)
movaps -0x1f0(%rbp), %xmm0
movq -0x30(%rbp), %rax
movups %xmm0, -0x10(%rax,%r13,4)
movsd -0x1e0(%rbp), %xmm0
movsd %xmm0, (%rax,%r13,4)
leaq -0x2b0(%rbp), %rbx
movq %rbx, %rdi
leaq -0x400(%rbp), %rsi
leaq -0x1f0(%rbp), %rdx
callq 0x84642
movq -0x2a0(%rbp), %rax
movq %rax, -0x3f0(%rbp)
movupd -0x2b0(%rbp), %xmm0
movapd %xmm0, -0x400(%rbp)
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %rbx, %rdi
callq 0x84364
movq -0x338(%rbp), %rax
movq -0x330(%rbp), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r15, %rdx
jbe 0x5d62b
movslq (%rax,%r15,4), %rax
movq -0x40(%rbp), %rcx
cmpl %ecx, %eax
jge 0x5ca18
movq -0xc0(%rbp), %rsi
movq 0x48(%rsi), %rcx
movq 0x50(%rsi), %rdx
jmp 0x5ca2b
subl %ecx, %eax
cltq
movq -0xc0(%rbp), %rsi
movq 0x60(%rsi), %rcx
movq 0x68(%rsi), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
leaq -0x4c0(%rbp), %rbx
jbe 0x5d628
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 0x5d628
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x2b0(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x2a0(%rbp)
movaps -0x2b0(%rbp), %xmm0
movups %xmm0, -0x10(%r14,%r13,4)
movsd -0x2a0(%rbp), %xmm0
movsd %xmm0, (%r14,%r13,4)
leaq -0x380(%rbp), %rdi
leaq -0x3e0(%rbp), %rsi
leaq -0x2b0(%rbp), %rdx
callq 0x84642
movq -0x370(%rbp), %rax
movq %rax, -0x3d0(%rbp)
movupd -0x380(%rbp), %xmm0
movapd %xmm0, -0x3e0(%rbp)
incq %r15
addq $0x6, %r13
cmpq %r15, -0x88(%rbp)
jne 0x5c800
movq %r12, -0x340(%rbp)
xorpd %xmm0, %xmm0
movapd %xmm0, -0x350(%rbp)
movapd %xmm0, -0x360(%rbp)
movapd %xmm0, -0x370(%rbp)
movapd %xmm0, -0x380(%rbp)
movq %r12, -0xd8(%rbp)
subq $0x8, %rsp
movq -0x30(%rbp), %rdi
movq %r14, %rsi
movl -0x44(%rbp), %edx
leaq -0x5a0(%rbp), %rcx
leaq -0x580(%rbp), %r8
leaq -0x380(%rbp), %r9
leaq -0xd8(%rbp), %rax
pushq %rax
callq 0xa21ad
addq $0x10, %rsp
movsd -0xd8(%rbp), %xmm0
ucomisd %xmm0, %xmm0
movabsq $-0x5555555555555555, %r14 # imm = 0xAAAAAAAAAAAAAAAB
jp 0x5d1b2
movb $0x1, %al
leaq -0x380(%rbp), %rcx
xorl %edx, %edx
testb $0x1, %al
je 0x5d1b2
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
ucomisd %xmm0, %xmm0
movzbl %al, %eax
cmovpl %r12d, %eax
cmpq $0x1, %rsi
ja 0x5cba3
incq %rsi
testb $0x1, %al
jne 0x5cb86
cmpq $0x1, %rdx
ja 0x5cbb4
incq %rdx
addq $0x18, %rcx
testb $0x1, %al
jne 0x5cb7c
testb $0x1, %al
je 0x5d1b2
leaq -0x1f0(%rbp), %rdi
callq 0x67a70
movq %rbx, %rdi
movq -0xc0(%rbp), %rsi
callq 0x67616
leaq -0x2b0(%rbp), %rdi
movq %rbx, %rsi
leaq -0x380(%rbp), %rdx
callq 0x9d6f3
movq -0x1f0(%rbp), %rdi
movq -0x1e0(%rbp), %rsi
movaps -0x2b0(%rbp), %xmm0
movaps %xmm0, -0x1f0(%rbp)
movq -0x2a0(%rbp), %rax
movq %rax, -0x1e0(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x2b0(%rbp)
movq $0x0, -0x2a0(%rbp)
testq %rdi, %rdi
je 0x5cc39
subq %rdi, %rsi
callq 0x4470
movq -0x1c8(%rbp), %rax
movups -0x298(%rbp), %xmm0
movq -0x288(%rbp), %rcx
movq %rcx, -0x1c8(%rbp)
movups -0x1d8(%rbp), %xmm1
movups %xmm0, -0x1d8(%rbp)
movaps %xmm1, -0x320(%rbp)
movq %rax, -0x310(%rbp)
leaq -0x298(%rbp), %r15
movq %r12, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
leaq -0x320(%rbp), %r13
movq %r13, %rdi
callq 0x2f4c2
movq -0x1b0(%rbp), %rax
movaps -0x280(%rbp), %xmm0
movq -0x270(%rbp), %rcx
movq %rcx, -0x1b0(%rbp)
movapd -0x1c0(%rbp), %xmm1
movaps %xmm0, -0x1c0(%rbp)
movapd %xmm1, -0x320(%rbp)
movq %rax, -0x310(%rbp)
leaq -0x280(%rbp), %rax
movq %r12, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %r13, %rdi
callq 0x2f4c2
movq -0x1a8(%rbp), %rdi
movq -0x198(%rbp), %rsi
movups -0x268(%rbp), %xmm0
movups %xmm0, -0x1a8(%rbp)
movq -0x258(%rbp), %rax
movq %rax, -0x198(%rbp)
movq %r12, 0x40(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r15)
testq %rdi, %rdi
je 0x5cd28
subq %rdi, %rsi
callq 0x4470
movq -0x190(%rbp), %rdi
movq -0x180(%rbp), %rsi
movaps -0x250(%rbp), %xmm0
movaps %xmm0, -0x190(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0x180(%rbp)
xorps %xmm0, %xmm0
leaq -0x298(%rbp), %rax
movaps %xmm0, 0x48(%rax)
movq $0x0, 0x58(%rax)
testq %rdi, %rdi
je 0x5cd75
subq %rdi, %rsi
callq 0x4470
movq -0x178(%rbp), %rdi
movq -0x168(%rbp), %rsi
movups -0x238(%rbp), %xmm0
movups %xmm0, -0x178(%rbp)
movq -0x228(%rbp), %rax
movq %rax, -0x168(%rbp)
xorps %xmm0, %xmm0
leaq -0x298(%rbp), %rax
movups %xmm0, 0x60(%rax)
movq $0x0, 0x70(%rax)
testq %rdi, %rdi
je 0x5cdfd
subq %rdi, %rsi
callq 0x4470
movq -0x238(%rbp), %rdi
movq -0x300(%rbp), %rcx
movq 0x10(%rcx), %rax
movq -0x2f8(%rbp), %rdx
movq %rax, 0x10(%rdx)
movapd (%rcx), %xmm0
movapd %xmm0, (%rdx)
testq %rdi, %rdi
je 0x5ce1b
movq -0x228(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
jmp 0x5ce1b
movq -0x300(%rbp), %rcx
movq 0x10(%rcx), %rax
movq -0x2f8(%rbp), %rdx
movq %rax, 0x10(%rdx)
movapd (%rcx), %xmm0
movapd %xmm0, (%rdx)
movq -0x250(%rbp), %rdi
testq %rdi, %rdi
je 0x5ce36
movq -0x240(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x268(%rbp), %rdi
testq %rdi, %rdi
je 0x5ce51
movq -0x258(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x280(%rbp), %rdi
callq 0x2f4c2
leaq -0x298(%rbp), %rdi
callq 0x2f4c2
movq -0x2b0(%rbp), %rdi
testq %rdi, %rdi
je 0x5ce84
movq -0x2a0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x448(%rbp), %rdi
testq %rdi, %rdi
je 0x5ce9f
movq -0x438(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x460(%rbp), %rdi
testq %rdi, %rdi
je 0x5ceba
movq -0x450(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x478(%rbp), %rdi
testq %rdi, %rdi
je 0x5ced5
movq -0x468(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x490(%rbp), %rdi
callq 0x2f4c2
leaq -0x4a8(%rbp), %rdi
callq 0x2f4c2
movq -0x4c0(%rbp), %rdi
testq %rdi, %rdi
je 0x5cf08
movq -0x4b0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x568(%rbp), %rdi
leaq -0x1f0(%rbp), %r15
movq %r15, %rsi
callq 0x67616
leaq -0x320(%rbp), %rdi
movq %r15, %rsi
callq 0x9d8da
leaq -0x418(%rbp), %rdi
leaq -0x320(%rbp), %rsi
movsd 0xf441d(%rip), %xmm0    # 0x151360
callq 0x84416
subq $0x20, %rsp
movq -0x408(%rbp), %rax
movq %rax, 0x10(%rsp)
movupd -0x418(%rbp), %xmm0
movupd %xmm0, (%rsp)
leaq -0x2b0(%rbp), %rdi
leaq -0x568(%rbp), %rsi
callq 0x9daf8
addq $0x20, %rsp
movq -0x4f0(%rbp), %rdi
testq %rdi, %rdi
je 0x5cf97
movq -0x4e0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x508(%rbp), %rdi
testq %rdi, %rdi
je 0x5cfb2
movq -0x4f8(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x520(%rbp), %rdi
testq %rdi, %rdi
je 0x5cfcd
movq -0x510(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x538(%rbp), %rdi
callq 0x2f4c2
leaq -0x550(%rbp), %rdi
callq 0x2f4c2
movq -0x568(%rbp), %rdi
testq %rdi, %rdi
je 0x5d000
movq -0x558(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0xf0(%rbp), %rax
movq -0xe8(%rbp), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
imulq %r14, %rdx
cmpq -0x50(%rbp), %rdx
jbe 0x5d695
movq -0x390(%rbp), %rcx
leaq (%rax,%rcx,8), %rsi
leaq -0x178(%rbp), %rdi
callq 0x100d2
movq -0x50(%rbp), %rax
movl %eax, -0x140(%rbp)
movsd -0xd8(%rbp), %xmm0
movsd %xmm0, -0x148(%rbp)
movsd -0x38(%rbp), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm1, %xmm2
ja 0x5d069
ucomisd %xmm0, %xmm1
jbe 0x5d082
movq -0x78(%rbp), %rax
subq -0x80(%rbp), %rax
shrq $0x3, %rax
imull $0xe9bd37a7, %eax, %eax # imm = 0xE9BD37A7
movl %eax, -0x64(%rbp)
movapd %xmm0, %xmm1
movsd %xmm1, -0x38(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x677b4
leaq -0xb0(%rbp), %rdi
leaq -0x2b0(%rbp), %rsi
callq 0x67810
movq -0x238(%rbp), %rdi
testq %rdi, %rdi
je 0x5d0c5
movq -0x228(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x250(%rbp), %rdi
testq %rdi, %rdi
je 0x5d0e0
movq -0x240(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x268(%rbp), %rdi
testq %rdi, %rdi
je 0x5d0fb
movq -0x258(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x280(%rbp), %rdi
callq 0x2f4c2
leaq -0x298(%rbp), %rdi
callq 0x2f4c2
movq -0x2b0(%rbp), %rdi
testq %rdi, %rdi
je 0x5d12e
movq -0x2a0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x178(%rbp), %rdi
testq %rdi, %rdi
je 0x5d149
movq -0x168(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x190(%rbp), %rdi
testq %rdi, %rdi
je 0x5d164
movq -0x180(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x1a8(%rbp), %rdi
testq %rdi, %rdi
je 0x5d17f
movq -0x198(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x1c0(%rbp), %rdi
callq 0x2f4c2
leaq -0x1d8(%rbp), %rdi
callq 0x2f4c2
movq -0x1f0(%rbp), %rdi
testq %rdi, %rdi
je 0x5d1b2
movq -0x1e0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x398(%rbp), %rsp
movq -0x338(%rbp), %rdi
testq %rdi, %rdi
je 0x5d1d4
movq -0x328(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x50(%rbp), %rsi
incq %rsi
movq -0x388(%rbp), %rcx
cmpq %rcx, %rsi
jne 0x5c74b
movq -0x78(%rbp), %rax
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
subq -0x80(%rbp), %rax
shrq $0x3, %rax
imull $0xe9bd37a7, %eax, %r12d # imm = 0xE9BD37A7
movsd -0x38(%rbp), %xmm0
mulsd 0xf5577(%rip), %xmm0    # 0x152790
movsd %xmm0, -0x38(%rbp)
movl -0x64(%rbp), %r15d
jmp 0x5d26d
movapd %xmm0, -0x80(%rbp)
xorl %esi, %esi
movq %rsi, -0x70(%rbp)
movq %rsi, -0xa0(%rbp)
movapd %xmm0, -0xb0(%rbp)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movsd 0xf553c(%rip), %xmm0    # 0x152788
movsd %xmm0, -0x38(%rbp)
xorl %edx, %edx
jmp 0x5d26a
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movsd 0xf5525(%rip), %xmm0    # 0x152788
movsd %xmm0, -0x38(%rbp)
xorl %esi, %esi
xorl %r12d, %r12d
xorpd %xmm0, %xmm0
movq -0x58(%rbp), %rcx
movupd %xmm0, (%rcx)
xorl %eax, %eax
movq %rax, 0x10(%rcx)
movq %rax, -0x370(%rbp)
movapd %xmm0, -0x380(%rbp)
movslq %r15d, %rbx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $-0x30c30c30c30c30c3, %rax # imm = 0xCF3CF3CF3CF3CF3D
imulq %rax, %rdx
cmpq %rbx, %rdx
jbe 0x5d6e8
imulq $0xa8, %rbx, %rax
addq %rax, %rsi
leaq -0x380(%rbp), %rdi
callq 0x67810
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
jbe 0x5d6f9
imulq $0xb8, %rbx, %rax
addq %rax, %r14
leaq -0x1f0(%rbp), %rdi
movq %r14, %rsi
callq 0x67616
movl 0xb0(%r14), %eax
leaq -0x1f0(%rbp), %rsi
movl %eax, 0xb0(%rsi)
movq 0xa8(%r14), %rax
movq %rax, 0xa8(%rsi)
movq -0x58(%rbp), %rdi
callq 0x67810
testl %r12d, %r12d
jle 0x5d502
movl %r15d, %r15d
movl %r12d, %r12d
xorl %ebx, %ebx
cmpq %r15, %rbx
je 0x5d4f6
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 0x5d676
imulq $0xb8, %rbx, %r13
movsd -0x38(%rbp), %xmm0
ucomisd 0xa8(%rax,%r13), %xmm0
jbe 0x5d4f6
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
movabsq $-0x30c30c30c30c30c3, %rax # imm = 0xCF3CF3CF3CF3CF3D
imulq %rax, %rdx
cmpq %rbx, %rdx
jbe 0x5d676
imulq $0xa8, %rbx, %r14
addq %r14, %rdi
leaq -0x380(%rbp), %rsi
callq 0xa0703
testb %al, %al
je 0x5d4f6
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
movabsq $-0x30c30c30c30c30c3, %rax # imm = 0xCF3CF3CF3CF3CF3D
imulq %rax, %rdx
cmpq %rbx, %rdx
jbe 0x5d676
addq %r14, %rsi
leaq -0x380(%rbp), %rdi
callq 0x67810
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
jbe 0x5d6a7
addq %r13, %r14
leaq -0x2b0(%rbp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x67616
movl 0xb0(%r14), %eax
leaq -0x208(%rbp), %rcx
movl %eax, 0x8(%rcx)
movq 0xa8(%r14), %rax
movq %rax, (%rcx)
movq -0x58(%rbp), %rdi
movq %r13, %rsi
callq 0x67810
movq -0x238(%rbp), %rdi
testq %rdi, %rdi
je 0x5d48d
movq -0x228(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x250(%rbp), %rdi
testq %rdi, %rdi
je 0x5d4a8
movq -0x240(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x268(%rbp), %rdi
testq %rdi, %rdi
je 0x5d4c3
movq -0x258(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x280(%rbp), %rdi
callq 0x2f4c2
leaq -0x298(%rbp), %rdi
callq 0x2f4c2
movq -0x2b0(%rbp), %rdi
testq %rdi, %rdi
je 0x5d4f6
movq -0x2a0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
incq %rbx
cmpq %r12, %rbx
jne 0x5d340
movq -0x178(%rbp), %rdi
testq %rdi, %rdi
je 0x5d51d
movq -0x168(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x190(%rbp), %rdi
testq %rdi, %rdi
je 0x5d538
movq -0x180(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x1a8(%rbp), %rdi
testq %rdi, %rdi
je 0x5d553
movq -0x198(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x1c0(%rbp), %rdi
callq 0x2f4c2
leaq -0x1d8(%rbp), %rbx
movq %rbx, %rdi
callq 0x2f4c2
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x5d586
movq -0x1e0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0x380(%rbp), %rdi
callq 0x678b0
leaq -0xb0(%rbp), %rdi
callq 0x678b0
leaq -0x80(%rbp), %rdi
callq 0x678e0
leaq -0xf0(%rbp), %rdi
callq 0xf066
leaq -0x2d0(%rbp), %rdi
callq 0xf066
leaq -0x2f0(%rbp), %rdi
callq 0xf066
movq -0x110(%rbp), %rdi
testq %rdi, %rdi
je 0x5d5e6
movq -0x100(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x130(%rbp), %rdi
testq %rdi, %rdi
je 0x5d601
movq -0x120(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x58(%rbp), %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rbx
leaq 0xf00d7(%rip), %rdi     # 0x14d6f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
movq %rax, %r15
leaq 0xf00c3(%rip), %rdi     # 0x14d6f5
movq %r15, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf00b2(%rip), %rdi     # 0x14d6f5
movq -0x30(%rbp), %rsi
xorl %eax, %eax
callq 0x4630
movq %r15, -0x60(%rbp)
leaq 0xf009c(%rip), %rdi     # 0x14d6f5
movq -0x60(%rbp), %rsi
xorl %eax, %eax
callq 0x4630
movq -0x60(%rbp), %rsi
leaq 0xf0086(%rip), %rdi     # 0x14d6f5
xorl %eax, %eax
callq 0x4630
leaq 0xf0078(%rip), %rdi     # 0x14d6f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf0067(%rip), %rdi     # 0x14d6f5
xorl %eax, %eax
callq 0x4630
leaq 0xf0059(%rip), %rdi     # 0x14d6f5
movq -0x50(%rbp), %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf0047(%rip), %rdi     # 0x14d6f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf0036(%rip), %rdi     # 0x14d6f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xf5e01(%rip), %rdi     # 0x1534d1
movq -0x40(%rbp), %rcx
movl %r13d, %r8d
xorl %eax, %eax
callq 0x4060
movl $0x1, %edi
callq 0x72bc
leaq 0xf0006(%rip), %rdi     # 0x14d6f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xefff5(%rip), %rdi     # 0x14d6f5
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4630
jmp 0x5d7ce
movq %rax, %rbx
movq -0x3b0(%rbp), %rdi
testq %rdi, %rdi
je 0x5d86e
movq -0x3a0(%rbp), %rsi
jmp 0x5d745
movq %rax, %rbx
movq -0x3c8(%rbp), %rdi
testq %rdi, %rdi
je 0x5d86e
movq -0x3b8(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
jmp 0x5d86e
jmp 0x5d754
movq %rax, %rbx
jmp 0x5d7dd
movq %rax, %rbx
jmp 0x5d86e
movq %rax, %rbx
leaq -0x2b0(%rbp), %rdi
callq 0x67840
jmp 0x5d7d1
jmp 0x5d7ce
jmp 0x5d7ce
jmp 0x5d787
movq %rax, %rbx
leaq -0x4c0(%rbp), %rdi
jmp 0x5d7b2
movq %rax, %rbx
jmp 0x5d7b7
jmp 0x5d80d
jmp 0x5d79c
jmp 0x5d7ce
jmp 0x5d794
movq %rax, %rbx
jmp 0x5d886
movq %rax, %rbx
leaq -0x2b0(%rbp), %rdi
jmp 0x5d7b2
movq %rax, %rbx
leaq -0x568(%rbp), %rdi
callq 0x6771a
leaq -0x1f0(%rbp), %rdi
callq 0x67840
jmp 0x5d810
jmp 0x5d80d
jmp 0x5d7c9
movq %rax, %rbx
jmp 0x5d82b
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x67840
leaq -0x380(%rbp), %rdi
callq 0x678b0
movq -0x58(%rbp), %rdi
callq 0x678b0
jmp 0x5d82b
jmp 0x5d80d
jmp 0x5d80d
jmp 0x5d80d
jmp 0x5d80d
jmp 0x5d80d
jmp 0x5d80d
jmp 0x5d80d
jmp 0x5d80d
jmp 0x5d844
jmp 0x5d808
movq %rax, %rbx
jmp 0x5d862
movq %rax, %rbx
movq -0x338(%rbp), %rdi
testq %rdi, %rdi
je 0x5d82b
movq -0x328(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0xb0(%rbp), %rdi
callq 0x678b0
leaq -0x80(%rbp), %rdi
callq 0x678e0
jmp 0x5d862
jmp 0x5d844
movq %rax, %rbx
movq -0x1f0(%rbp), %rdi
testq %rdi, %rdi
je 0x5d862
movq -0x1e0(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
leaq -0xf0(%rbp), %rdi
callq 0xf066
leaq -0x2d0(%rbp), %rdi
callq 0xf066
leaq -0x2f0(%rbp), %rdi
callq 0xf066
movq -0x110(%rbp), %rdi
testq %rdi, %rdi
je 0x5d8a1
movq -0x100(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq -0x130(%rbp), %rdi
testq %rdi, %rdi
je 0x5d8bc
movq -0x120(%rbp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780