// File: Luthaf[P]zeopp/networkstorage.cc
// Function: add_missing_edges(ATOM_NETWORK*)
void add_missing_edges(ATOM_NETWORK *cell) { //this function is called when the vertices in a cell do not have the correct number of edges, due to edges not being provided exhaustively in the input file - we need to add them in by looking at symmetry!
  bool verbose = false;
  int num_vertices = cell->vertices.size();
  for(int i=0; i<num_vertices; i++) {
    VERTEX v = cell->vertices.at(i);
    XYZ vertex_xyz = cell->abc_to_xyz_returning_XYZ(v.abc);
    int num_edges = (int)(v.edges.size());
    int num_expect_edges = v.expected_edges;
if(verbose) printf("\n");
if(verbose) printf("DEBUG: vertex ID %d at %.3f %.3f %.3f [%.3f %.3f %.3f] has %d edges, %d were expected\n", i, v.abc.x, v.abc.y, v.abc.z, vertex_xyz.x, vertex_xyz.y, vertex_xyz.z, num_edges, num_expect_edges);
    vector<double> read_edge_lengths;
    if(num_edges<num_expect_edges) {
if(verbose) printf("DEBUG: BASIC VERTEX ID %d has fewer edges than expected - filling in missing edges by symmetry operations\n", i);
if(verbose) printf("\tDEBUG: edges read were as follows:\n");
      vector<XYZ> new_edges_abc, new_edges_xyz; //a new vector of edges - fill it up and hopefully it will be the right length, once duplicates are removed
      for(int j=0; j<num_edges; j++) {
        XYZ this_read_edge = v.edges.at(j); //the jth edge that was read - add it to the new vector if it is not a duplicate of one already added
        XYZ edge_xyz = cell->abc_to_xyz_returning_XYZ(this_read_edge);
        double read_edge_length = (edge_xyz-vertex_xyz).magnitude();
if(verbose) printf("\tDEBUG: %.3f %.3f %.3f [%.3f %.3f %.3f], length = %.3f\n", this_read_edge.x, this_read_edge.y, this_read_edge.z, edge_xyz.x, edge_xyz.y, edge_xyz.z, read_edge_length);
        int num_read_edge_lengths = read_edge_lengths.size();
        bool may_be_new_edge_length = true;
        for(int k=0; k<num_read_edge_lengths && may_be_new_edge_length; k++) {
          if(fabs(read_edge_length-read_edge_lengths.at(k))>DISTANCE_TOLERANCE) may_be_new_edge_length = false;
        }
        if(may_be_new_edge_length) read_edge_lengths.push_back(read_edge_length);
        bool this_read_edge_is_dupe = false;
        int num_new_edges = new_edges_abc.size();
        for(int k=0; k<num_new_edges && !this_read_edge_is_dupe; k++) {
          if(overlaps_xyz(edge_xyz, new_edges_xyz.at(k))) this_read_edge_is_dupe = true; //we should not reject edges because their end points overlap periodically - think pcu! they are valid unless they overlap in xyz!
        }
        if(!this_read_edge_is_dupe) { //the jth read edge is not a duplicate - add it to the vector
          new_edges_abc.push_back(this_read_edge);
          new_edges_xyz.push_back(edge_xyz);
        }
        //now, identify all the images of the jth edge by symmetry, and periodic images thereof (!), and 1) check that the length is correct, and 2) perform the same duplication check - note that even if j was a dupe, we are checking its images here - it should be redundant but just in case...
        vector<XYZ> equiv = GetEquivalentPositions(cell->sym_ID,&this_read_edge);
        int num_sym_images = equiv.size();
if(verbose) printf("\tDEBUG: num_sym_images of this edge = %d\n", num_sym_images);
        for(int k=0; k<num_sym_images; k++) {
          XYZ this_base_sym_edge = trans_to_origuc(equiv.at(k)); //the kth symmetry image of the jth edge that was read, translated to the unit cell - look at each periodic image, and add them to the new vector if they are not a duplicate of one already added
          vector<XYZ> periodic_images = get_periodic_images_of_uc_abc_position(this_base_sym_edge);
          int num_periodic_images = periodic_images.size();
          for(int im=0; im<num_periodic_images; im++) {
            XYZ this_sym_edge = periodic_images.at(im);
            XYZ sym_edge_xyz = cell->abc_to_xyz_returning_XYZ(this_sym_edge);
            double sym_edge_length = (sym_edge_xyz-vertex_xyz).magnitude();
            bool length_ok = false;
            if(fabs(sym_edge_length-read_edge_length)<DISTANCE_TOLERANCE) length_ok = true;
            if(length_ok) {
              bool this_sym_edge_is_dupe = false;
              num_new_edges = new_edges_abc.size();
if(verbose) printf("\t\tDEBUG: edge at %.3f %.3f %.3f [%.3f %.3f %.3f] length is ok - checking for overlap against the existing %d edges...\n", this_sym_edge.x, this_sym_edge.y, this_sym_edge.z, sym_edge_xyz.x, sym_edge_xyz.y, sym_edge_xyz.z, num_new_edges);
              for(int l=0; l<num_new_edges && !this_sym_edge_is_dupe; l++) {
                //if(overlaps_abc(this_sym_edge, new_edges.at(l), cell)) this_sym_edge_is_dupe = true;
if(verbose) printf("\t\t\tDEBUG: checking against existing edge %d at %.3f %.3f %.3f [%.3f %.3f %.3f]...\n", l, new_edges_abc.at(l).x, new_edges_abc.at(l).y, new_edges_abc.at(l).z, new_edges_xyz.at(l).x, new_edges_xyz.at(l).y, new_edges_xyz.at(l).z);
                if(overlaps_xyz(sym_edge_xyz, new_edges_xyz.at(l))) this_sym_edge_is_dupe = true; //we should not reject edges because their end points overlap periodically - think pcu! they are valid unless they overlap in xyz!
              }
              if(!this_sym_edge_is_dupe) { //the kth symmetry image of the jth read edge is not a duplicate - add it to the vector
                new_edges_abc.push_back(this_sym_edge);
                new_edges_xyz.push_back(sym_edge_xyz);
if(verbose) printf("\t\t\tDEBUG: this sym edge is unique\n");
              } else {
if(verbose) printf("\t\t\tDEBUG: this sym edge is a duplicate!\n");
              }
            }
          }
        }
      }
      int num_new_edges = new_edges_abc.size();
if(verbose) printf("\tDEBUG: after examining symmetry, the following %d edges were identified:\n", num_new_edges);
      for(int j=0; j<num_new_edges; j++) {
        XYZ this_new_edge_abc = new_edges_abc.at(j);
        XYZ this_new_edge_xyz = new_edges_xyz.at(j);
if(verbose) printf("\t\tDEBUG: %.3f %.3f %.3f [%.3f %.3f %.3f]\n", this_new_edge_abc.x, this_new_edge_abc.y, this_new_edge_abc.z, this_new_edge_xyz.x, this_new_edge_xyz.y, this_new_edge_xyz.z);
      }
      if(num_new_edges==num_expect_edges) {
if(verbose) printf("DEBUG: the correct number of edges, %d, have been identified from symmetry and periodic operations\n", num_new_edges);
        v.edges = new_edges_abc;
        cell->vertices.at(i) = v;
      } else {
if(verbose) printf("DEBUG: %d edges were expected but after examining edges by symmetry, %d were identified - can not complete the net with just this information - need to consider any orphan vertices\n", num_expect_edges, num_new_edges);
        //this is where we need the orphan edges - they may start at symmetry images of this vertex, and if they do, we can use the orphan edge here
        int num_orphan_edges = cell->orphan_edge_starts.size();
        int num_orphan_edges_check = cell->orphan_edge_ends.size();
        if(num_orphan_edges_check!=num_orphan_edges) {
          printf("ERROR: attempting to interpret orphan edges in order to complete the basic net, but the number of start points (%d) is not equal to the number of end points (%d)\n", num_orphan_edges, num_orphan_edges_check);
          exit(EXIT_FAILURE);
        }
if(verbose) printf("DEBUG: there are %d orphan edges to consider!\n", num_orphan_edges);
        for(int j=0; j<num_orphan_edges; j++) {
          XYZ orphan_vertex = cell->orphan_edge_starts.at(j); //the start is treated as a vertex here
          vector<XYZ> equiv_orphan_vertices = GetEquivalentPositions(cell->sym_ID,&orphan_vertex);
          int num_equiv_orphan_vertices = equiv_orphan_vertices.size();
          for(int k=0; k<num_equiv_orphan_vertices; k++) { //this orphan vertex does not overlap with this basic vertex - however, it might be equivalent by symmetry, and if it is, we need to check the edge end points by symmetry too, in order to complete the basic cell
            XYZ this_sym_orphan_vertex = equiv_orphan_vertices.at(k);
            if(overlaps_abc(this_sym_orphan_vertex, v.abc, cell)) { //this image of the orphan vertex overlaps with the basic vertex - it is a candidate for a missing edge
if(verbose) printf("DEBUG: orphan vertex ID %d at %.3f %.3f %.3f has a symmetry image at %.3f %.3f %.3f which overlaps with this basic vertex at %.3f %.3f %.3f\n", j, orphan_vertex.x, orphan_vertex.y, orphan_vertex.z, this_sym_orphan_vertex.x, this_sym_orphan_vertex.y, this_sym_orphan_vertex.z, v.abc.x, v.abc.y, v.abc.z);
              XYZ orphan_edge = cell->orphan_edge_ends.at(j);
              vector<XYZ> equiv_orphan_edges = GetEquivalentPositions(cell->sym_ID,&orphan_edge); //get all the symmetry positions of this orphan edge, but we only need to look at the particular symmetry operation in question, hopefully
              XYZ this_sym_orphan_edge = equiv_orphan_edges.at(k);
if(verbose) printf("\tDEBUG: the corresponding edge end symmetry image is at %.3f %.3f %.3f\n", this_sym_orphan_edge.x, this_sym_orphan_edge.y, this_sym_orphan_edge.z);
              XYZ sym_orphan_edge_xyz = cell->abc_to_xyz_returning_XYZ(this_sym_orphan_edge);
              double sym_orphan_edge_length = (sym_orphan_edge_xyz-vertex_xyz).magnitude();
              bool length_ok = false;
              int num_read_edge_lengths = read_edge_lengths.size();
              for(int l=0; l<num_read_edge_lengths && !length_ok; l++) {
                if(fabs(sym_orphan_edge_length-read_edge_lengths.at(l))<DISTANCE_TOLERANCE) {
                  length_ok = true;
if(verbose) printf("\t\tDEBUG: length is ok - %.3f is similar to desired %.3f\n", sym_orphan_edge_length, read_edge_lengths.at(l));
                }
              }
              if(length_ok) {
                bool this_sym_orphan_edge_is_dupe = false;
                int num_new_edges = new_edges_abc.size();
                for(int l=0; l<num_new_edges && !this_sym_orphan_edge_is_dupe; l++) {
                  if(overlaps_xyz(sym_orphan_edge_xyz, new_edges_xyz.at(l))) this_sym_orphan_edge_is_dupe = true; //we should not reject edges because their end points overlap periodically - think pcu! they are valid unless they overlap in xyz!
                }
                if(!this_sym_orphan_edge_is_dupe) { //the kth symmetry image of the jth orphan edge is not a duplicate - add it to the vector
if(verbose) printf("\t\t\tDEBUG: this orphan edge is unique\n");
                  new_edges_abc.push_back(this_sym_orphan_edge);
                  new_edges_xyz.push_back(sym_orphan_edge_xyz);
                } else {
if(verbose) printf("\t\t\tDEBUG: this orphan edge is a duplicate!\n");
                }
              }
            }
          }
        }
        //now we have exhausted the orphan edges too - if the cell is not complete now, then there has to be a problem
        num_new_edges = new_edges_abc.size();
if(verbose) printf("DEBUG: after examining symmetry AND orphan edges, the following %d edges were identified:\n", num_new_edges);
        for(int j=0; j<num_new_edges; j++) {
          XYZ this_new_edge_abc = new_edges_abc.at(j);
          XYZ this_new_edge_xyz = new_edges_xyz.at(j);
if(verbose) printf("\tDEBUG: %.3f %.3f %.3f [%.3f %.3f %.3f]\n", this_new_edge_abc.x, this_new_edge_abc.y, this_new_edge_abc.z, this_new_edge_xyz.x, this_new_edge_xyz.y, this_new_edge_xyz.z);
        }
        if(num_new_edges==num_expect_edges) {
if(verbose) printf("DEBUG: the correct number of edges, %d, have been identified from symmetry and periodic operations, and orphan vertices\n", num_new_edges);
          v.edges = new_edges_abc;
          cell->vertices.at(i) = v;
        } else {
          printf("ERROR: %d edges were expected but after examining edges by symmetry AND orphan edges, %d were identified - can not complete the net\n", num_expect_edges, num_new_edges);
          exit(EXIT_FAILURE);
        }
      }
    } else if(num_edges==num_expect_edges) {
if(verbose) printf("DEBUG: the correct number of edges, %d, have been identified - no action required for this vertex\n", num_edges);
    } else {
      printf("ERROR: more edges than expected - error case in file parsing, probably a bug!\n");
      exit(EXIT_FAILURE);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp            # imm = 0x670
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
callq 0xae470
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xa9e87
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
movslq -0x14(%rbp), %rsi
callq 0xae4a0
movq %rax, %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0x4d0(%rbp)
callq 0xae4e0
movq -0x4d0(%rbp), %rdx
movq -0x8(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x97310
jmp 0xa896c
leaq -0x88(%rbp), %rdi
addq $0x20, %rdi
callq 0xae590
movl %eax, -0xb0(%rbp)
movl -0x70(%rbp), %eax
movl %eax, -0xb4(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa89ba
leaq 0x150c8d(%rip), %rdi    # 0x1f9625
xorl %eax, %eax
callq 0x5070
jmp 0xa89a1
jmp 0xa89ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa9e79
testb $0x1, -0x9(%rbp)
je 0xa8a0b
movl -0x14(%rbp), %esi
movsd -0x88(%rbp), %xmm0
movsd -0x80(%rbp), %xmm1
movsd -0x78(%rbp), %xmm2
movsd -0xa0(%rbp), %xmm3
movsd -0x98(%rbp), %xmm4
movsd -0x90(%rbp), %xmm5
movl -0xb0(%rbp), %edx
movl -0xb4(%rbp), %ecx
leaq 0x1511db(%rip), %rdi    # 0x1f9bdb
movb $0x6, %al
callq 0x5070
jmp 0xa8a09
jmp 0xa8a0b
leaq -0xd0(%rbp), %rdi
callq 0xf650
movl -0xb0(%rbp), %eax
cmpl -0xb4(%rbp), %eax
jge 0xa9dfd
testb $0x1, -0x9(%rbp)
je 0xa8a5b
movl -0x14(%rbp), %esi
leaq 0x1511f9(%rip), %rdi    # 0x1f9c32
xorl %eax, %eax
callq 0x5070
jmp 0xa8a42
jmp 0xa8a5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa9e6d
testb $0x1, -0x9(%rbp)
je 0xa8a73
leaq 0x151235(%rip), %rdi    # 0x1f9c9d
xorl %eax, %eax
callq 0x5070
jmp 0xa8a71
jmp 0xa8a73
leaq -0xe8(%rbp), %rdi
callq 0xada60
leaq -0x100(%rbp), %rdi
callq 0xada60
movl $0x0, -0x104(%rbp)
movl -0x104(%rbp), %eax
cmpl -0xb0(%rbp), %eax
jge 0xa93a7
leaq -0x68(%rbp), %rdi
movslq -0x104(%rbp), %rsi
callq 0xae5c0
movq %rax, -0x4d8(%rbp)
jmp 0xa8ac0
movq -0x4d8(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x110(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x120(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x138(%rbp), %rdi
leaq -0x120(%rbp), %rdx
callq 0x97310
jmp 0xa8af5
leaq -0x158(%rbp), %rdi
leaq -0x138(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0xeadf0
jmp 0xa8b11
leaq -0x158(%rbp), %rdi
callq 0xe9240
movsd %xmm0, -0x4e0(%rbp)
jmp 0xa8b27
movsd -0x4e0(%rbp), %xmm0
movsd %xmm0, -0x140(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa8b9e
movsd -0x120(%rbp), %xmm0
movsd -0x118(%rbp), %xmm1
movsd -0x110(%rbp), %xmm2
movsd -0x138(%rbp), %xmm3
movsd -0x130(%rbp), %xmm4
movsd -0x128(%rbp), %xmm5
movsd -0x140(%rbp), %xmm6
leaq 0x151146(%rip), %rdi    # 0x1f9cc2
movb $0x7, %al
callq 0x5070
jmp 0xa8b85
jmp 0xa8b9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa9de3
leaq -0xd0(%rbp), %rdi
callq 0xf990
movl %eax, -0x15c(%rbp)
movb $0x1, -0x15d(%rbp)
movl $0x0, -0x164(%rbp)
movl -0x164(%rbp), %ecx
xorl %eax, %eax
cmpl -0x15c(%rbp), %ecx
movb %al, -0x4e1(%rbp)
jge 0xa8be3
movb -0x15d(%rbp), %al
movb %al, -0x4e1(%rbp)
movb -0x4e1(%rbp), %al
testb $0x1, %al
jne 0xa8bef
jmp 0xa8c64
movsd -0x140(%rbp), %xmm0
movsd %xmm0, -0x4f8(%rbp)
movslq -0x164(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0xfc80
movq %rax, -0x4f0(%rbp)
jmp 0xa8c1b
movq -0x4f0(%rbp), %rax
movsd -0x4f8(%rbp), %xmm0
subsd (%rax), %xmm0
movaps 0x14944b(%rip), %xmm1   # 0x1f2080
pand %xmm1, %xmm0
movsd 0x14ec27(%rip), %xmm1   # 0x1f7868
ucomisd %xmm1, %xmm0
jbe 0xa8c4e
movb $0x0, -0x15d(%rbp)
jmp 0xa8c50
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
jmp 0xa8bc1
testb $0x1, -0x15d(%rbp)
je 0xa8c84
leaq -0xd0(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x105c0
jmp 0xa8c82
jmp 0xa8c84
movb $0x0, -0x165(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0xae590
movl %eax, -0x16c(%rbp)
movl $0x0, -0x170(%rbp)
movl -0x170(%rbp), %ecx
xorl %eax, %eax
cmpl -0x16c(%rbp), %ecx
movb %al, -0x4f9(%rbp)
jge 0xa8ccb
movb -0x165(%rbp), %al
xorb $-0x1, %al
movb %al, -0x4f9(%rbp)
movb -0x4f9(%rbp), %al
testb $0x1, %al
jne 0xa8cda
jmp 0xa8d92
movq -0x128(%rbp), %rax
movq %rax, -0x180(%rbp)
movups -0x138(%rbp), %xmm0
movaps %xmm0, -0x190(%rbp)
movslq -0x170(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x508(%rbp)
jmp 0xa8d12
movq -0x508(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x1a0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x1b0(%rbp)
movq -0x1a0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x28(%rax)
movaps -0x1b0(%rbp), %xmm0
movups %xmm0, 0x18(%rax)
movq -0x180(%rbp), %rcx
movq %rcx, 0x10(%rax)
movaps -0x190(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x110ea0
movb %al, -0x509(%rbp)
jmp 0xa8d69
movb -0x509(%rbp), %al
testb $0x1, %al
jne 0xa8d75
jmp 0xa8d7c
movb $0x1, -0x165(%rbp)
jmp 0xa8d7e
movl -0x170(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x170(%rbp)
jmp 0xa8ca7
testb $0x1, -0x165(%rbp)
jne 0xa8dc7
leaq -0xe8(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0xafc20
jmp 0xa8db0
leaq -0x100(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0xafc20
jmp 0xa8dc5
jmp 0xa8dc7
movq -0x8(%rbp), %rax
movl 0x438(%rax), %esi
leaq -0x1c8(%rbp), %rdi
leaq -0x120(%rbp), %rdx
callq 0x117c50
jmp 0xa8de6
leaq -0x1c8(%rbp), %rdi
callq 0xae590
movl %eax, -0x1cc(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa8e2d
movl -0x1cc(%rbp), %esi
leaq 0x150eef(%rip), %rdi    # 0x1f9cfa
xorl %eax, %eax
callq 0x5070
jmp 0xa8e14
jmp 0xa8e2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa9396
movl $0x0, -0x1d0(%rbp)
movl -0x1d0(%rbp), %eax
cmpl -0x1cc(%rbp), %eax
jge 0xa9376
movslq -0x1d0(%rbp), %rsi
leaq -0x1c8(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x518(%rbp)
jmp 0xa8e65
movq -0x518(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x1f0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x200(%rbp)
movq -0x1f0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x200(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x1e8(%rbp), %rdi
callq 0xe9320
jmp 0xa8ea7
movq -0x1d8(%rbp), %rax
movq %rax, -0x220(%rbp)
movups -0x1e8(%rbp), %xmm0
movaps %xmm0, -0x230(%rbp)
movq -0x220(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movaps -0x230(%rbp), %xmm0
movups %xmm0, (%rax)
leaq -0x218(%rbp), %rdi
callq 0x114e60
jmp 0xa8ee9
leaq -0x218(%rbp), %rdi
callq 0xae590
movl %eax, -0x234(%rbp)
movl $0x0, -0x238(%rbp)
movl -0x238(%rbp), %eax
cmpl -0x234(%rbp), %eax
jge 0xa9356
movslq -0x238(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x520(%rbp)
jmp 0xa8f33
movq -0x520(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x240(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x250(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x268(%rbp), %rdi
leaq -0x250(%rbp), %rdx
callq 0x97310
jmp 0xa8f68
leaq -0x288(%rbp), %rdi
leaq -0x268(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0xeadf0
jmp 0xa8f84
leaq -0x288(%rbp), %rdi
callq 0xe9240
movsd %xmm0, -0x528(%rbp)
jmp 0xa8f9a
movsd -0x528(%rbp), %xmm0
movsd %xmm0, -0x270(%rbp)
movb $0x0, -0x289(%rbp)
movsd -0x270(%rbp), %xmm1
subsd -0x140(%rbp), %xmm1
movaps 0x1490b8(%rip), %xmm0   # 0x1f2080
pand %xmm0, %xmm1
movsd 0x14e894(%rip), %xmm0   # 0x1f7868
ucomisd %xmm1, %xmm0
jbe 0xa9006
movb $0x1, -0x289(%rbp)
jmp 0xa9006
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x12210
jmp 0xa9396
testb $0x1, -0x289(%rbp)
je 0xa9340
movb $0x0, -0x28a(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0xae590
movl %eax, -0x16c(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa907a
movsd -0x250(%rbp), %xmm0
movsd -0x248(%rbp), %xmm1
movsd -0x240(%rbp), %xmm2
movsd -0x268(%rbp), %xmm3
movsd -0x260(%rbp), %xmm4
movsd -0x258(%rbp), %xmm5
movl -0x16c(%rbp), %esi
leaq 0x150cb5(%rip), %rdi    # 0x1f9d24
movb $0x6, %al
callq 0x5070
jmp 0xa9078
jmp 0xa907a
movl $0x0, -0x290(%rbp)
movl -0x290(%rbp), %ecx
xorl %eax, %eax
cmpl -0x16c(%rbp), %ecx
movb %al, -0x529(%rbp)
jge 0xa90a8
movb -0x28a(%rbp), %al
xorb $-0x1, %al
movb %al, -0x529(%rbp)
movb -0x529(%rbp), %al
testb $0x1, %al
jne 0xa90b7
jmp 0xa92d7
testb $0x1, -0x9(%rbp)
je 0xa921f
movl -0x290(%rbp), %eax
movl %eax, -0x53c(%rbp)
movslq %eax, %rsi
leaq -0xe8(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x538(%rbp)
jmp 0xa90e5
movq -0x538(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x550(%rbp)
movslq -0x290(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x548(%rbp)
jmp 0xa9114
movq -0x548(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x560(%rbp)
movslq -0x290(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x558(%rbp)
jmp 0xa9144
movq -0x558(%rbp), %rax
movsd 0x10(%rax), %xmm0
movsd %xmm0, -0x570(%rbp)
movslq -0x290(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x568(%rbp)
jmp 0xa9174
movq -0x568(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x580(%rbp)
movslq -0x290(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x578(%rbp)
jmp 0xa91a3
movq -0x578(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, -0x590(%rbp)
movslq -0x290(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x588(%rbp)
jmp 0xa91d3
movsd -0x590(%rbp), %xmm4
movsd -0x580(%rbp), %xmm3
movsd -0x570(%rbp), %xmm2
movsd -0x560(%rbp), %xmm1
movsd -0x550(%rbp), %xmm0
movl -0x53c(%rbp), %esi
movq -0x588(%rbp), %rax
movsd 0x10(%rax), %xmm5
leaq 0x150b87(%rip), %rdi    # 0x1f9d9b
movb $0x6, %al
callq 0x5070
jmp 0xa921d
jmp 0xa921f
movq -0x258(%rbp), %rax
movq %rax, -0x2a0(%rbp)
movups -0x268(%rbp), %xmm0
movaps %xmm0, -0x2b0(%rbp)
movslq -0x290(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x598(%rbp)
jmp 0xa9257
movq -0x598(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x2c0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x2d0(%rbp)
movq -0x2c0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x28(%rax)
movaps -0x2d0(%rbp), %xmm0
movups %xmm0, 0x18(%rax)
movq -0x2a0(%rbp), %rcx
movq %rcx, 0x10(%rax)
movaps -0x2b0(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x110ea0
movb %al, -0x599(%rbp)
jmp 0xa92ae
movb -0x599(%rbp), %al
testb $0x1, %al
jne 0xa92ba
jmp 0xa92c1
movb $0x1, -0x28a(%rbp)
jmp 0xa92c3
movl -0x290(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x290(%rbp)
jmp 0xa9084
testb $0x1, -0x28a(%rbp)
jne 0xa9324
leaq -0xe8(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0xafc20
jmp 0xa92f5
leaq -0x100(%rbp), %rdi
leaq -0x268(%rbp), %rsi
callq 0xafc20
jmp 0xa930a
testb $0x1, -0x9(%rbp)
je 0xa9322
leaq 0x150ad7(%rip), %rdi    # 0x1f9dee
xorl %eax, %eax
callq 0x5070
jmp 0xa9320
jmp 0xa9322
jmp 0xa933e
testb $0x1, -0x9(%rbp)
je 0xa933c
leaq 0x150ae0(%rip), %rdi    # 0x1f9e11
xorl %eax, %eax
callq 0x5070
jmp 0xa933a
jmp 0xa933c
jmp 0xa933e
jmp 0xa9340
jmp 0xa9342
movl -0x238(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x238(%rbp)
jmp 0xa8f05
leaq -0x218(%rbp), %rdi
callq 0x12210
movl -0x1d0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d0(%rbp)
jmp 0xa8e37
leaq -0x1c8(%rbp), %rdi
callq 0x12210
movl -0x104(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x104(%rbp)
jmp 0xa8a95
leaq -0x1c8(%rbp), %rdi
callq 0x12210
jmp 0xa9de3
leaq -0xe8(%rbp), %rdi
callq 0xae590
movl %eax, -0x2d4(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa93d7
movl -0x2d4(%rbp), %esi
leaq 0x150a6e(%rip), %rdi    # 0x1f9e3a
xorl %eax, %eax
callq 0x5070
jmp 0xa93d5
jmp 0xa93d7
movl $0x0, -0x2d8(%rbp)
movl -0x2d8(%rbp), %eax
cmpl -0x2d4(%rbp), %eax
jge 0xa94cc
movslq -0x2d8(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x5a8(%rbp)
jmp 0xa940f
movq -0x5a8(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x2e0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x2f0(%rbp)
movslq -0x2d8(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x5b0(%rbp)
jmp 0xa9447
movq -0x5b0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x308(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x300(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x2f8(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa94b6
movsd -0x2f0(%rbp), %xmm0
movsd -0x2e8(%rbp), %xmm1
movsd -0x2e0(%rbp), %xmm2
movsd -0x308(%rbp), %xmm3
movsd -0x300(%rbp), %xmm4
movsd -0x2f8(%rbp), %xmm5
leaq 0x1509da(%rip), %rdi    # 0x1f9e85
movb $0x6, %al
callq 0x5070
jmp 0xa94b4
jmp 0xa94b6
jmp 0xa94b8
movl -0x2d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2d8(%rbp)
jmp 0xa93e1
movl -0x2d4(%rbp), %eax
cmpl -0xb4(%rbp), %eax
jne 0xa9541
testb $0x1, -0x9(%rbp)
je 0xa94f8
movl -0x2d4(%rbp), %esi
leaq 0x1509c2(%rip), %rdi    # 0x1f9eaf
xorl %eax, %eax
callq 0x5070
jmp 0xa94f6
jmp 0xa94f8
leaq -0x68(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xadfe0
jmp 0xa950a
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
movslq -0x14(%rbp), %rsi
callq 0xae4a0
movq %rax, -0x5b8(%rbp)
jmp 0xa9527
movq -0x5b8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xafd00
jmp 0xa953c
jmp 0xa9dc9
testb $0x1, -0x9(%rbp)
je 0xa9565
movl -0xb4(%rbp), %esi
movl -0x2d4(%rbp), %edx
leaq 0x1509b9(%rip), %rdi    # 0x1f9f13
xorl %eax, %eax
callq 0x5070
jmp 0xa9563
jmp 0xa9565
movq -0x8(%rbp), %rdi
addq $0x3d8, %rdi            # imm = 0x3D8
callq 0xae590
movl %eax, -0x30c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0xae590
movl %eax, -0x310(%rbp)
movl -0x310(%rbp), %eax
cmpl -0x30c(%rbp), %eax
je 0xa95c5
movl -0x30c(%rbp), %esi
movl -0x310(%rbp), %edx
leaq 0x150a17(%rip), %rdi    # 0x1f9fc9
xorl %eax, %eax
callq 0x5070
jmp 0xa95bb
movl $0x1, %edi
callq 0x67c0
testb $0x1, -0x9(%rbp)
je 0xa95e3
movl -0x30c(%rbp), %esi
leaq 0x150a94(%rip), %rdi    # 0x1fa06c
xorl %eax, %eax
callq 0x5070
jmp 0xa95e1
jmp 0xa95e3
movl $0x0, -0x314(%rbp)
movl -0x314(%rbp), %eax
cmpl -0x30c(%rbp), %eax
jge 0xa9c0a
movq -0x8(%rbp), %rdi
addq $0x3d8, %rdi            # imm = 0x3D8
movslq -0x314(%rbp), %rsi
callq 0xae5c0
movq %rax, -0x5c0(%rbp)
jmp 0xa961f
movq -0x5c0(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x320(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x330(%rbp)
movq -0x8(%rbp), %rax
movl 0x438(%rax), %esi
leaq -0x348(%rbp), %rdi
leaq -0x330(%rbp), %rdx
callq 0x117c50
jmp 0xa965a
leaq -0x348(%rbp), %rdi
callq 0xae590
movl %eax, -0x34c(%rbp)
movl $0x0, -0x350(%rbp)
movl -0x350(%rbp), %eax
cmpl -0x34c(%rbp), %eax
jge 0xa9bd9
movslq -0x350(%rbp), %rsi
leaq -0x348(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x5c8(%rbp)
jmp 0xa96a4
movq -0x5c8(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x360(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x370(%rbp)
movq -0x360(%rbp), %rax
movq %rax, -0x380(%rbp)
movaps -0x370(%rbp), %xmm0
movaps %xmm0, -0x390(%rbp)
movq -0x78(%rbp), %rax
movq %rax, -0x3a0(%rbp)
movups -0x88(%rbp), %xmm0
movaps %xmm0, -0x3b0(%rbp)
movq -0x8(%rbp), %rdi
movq -0x3a0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x28(%rax)
movaps -0x3b0(%rbp), %xmm0
movups %xmm0, 0x18(%rax)
movq -0x380(%rbp), %rcx
movq %rcx, 0x10(%rax)
movaps -0x390(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x9f840
movb %al, -0x5c9(%rbp)
jmp 0xa9734
movb -0x5c9(%rbp), %al
testb $0x1, %al
jne 0xa9743
jmp 0xa9bc3
testb $0x1, -0x9(%rbp)
je 0xa97c3
movl -0x314(%rbp), %esi
movsd -0x330(%rbp), %xmm0
movsd -0x328(%rbp), %xmm1
movsd -0x320(%rbp), %xmm2
movsd -0x370(%rbp), %xmm3
movsd -0x368(%rbp), %xmm4
movsd -0x360(%rbp), %xmm5
movsd -0x88(%rbp), %xmm6
movsd -0x80(%rbp), %xmm7
movsd -0x78(%rbp), %xmm8
movq %rsp, %rax
movsd %xmm8, (%rax)
leaq 0x1508fa(%rip), %rdi    # 0x1fa09b
movb $0x8, %al
callq 0x5070
jmp 0xa97aa
jmp 0xa97c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
jmp 0xa9bf9
movq -0x8(%rbp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
movslq -0x314(%rbp), %rsi
callq 0xae5c0
movq %rax, -0x5d8(%rbp)
jmp 0xa97e3
movq -0x5d8(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x3c0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x3d0(%rbp)
movq -0x8(%rbp), %rax
movl 0x438(%rax), %esi
leaq -0x3e8(%rbp), %rdi
leaq -0x3d0(%rbp), %rdx
callq 0x117c50
jmp 0xa981e
movslq -0x350(%rbp), %rsi
leaq -0x3e8(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x5e0(%rbp)
jmp 0xa983a
movq -0x5e0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x400(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x3f8(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x3f0(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa98b4
movsd -0x400(%rbp), %xmm0
movsd -0x3f8(%rbp), %xmm1
movsd -0x3f0(%rbp), %xmm2
leaq 0x1508a2(%rip), %rdi    # 0x1fa128
movb $0x3, %al
callq 0x5070
jmp 0xa988f
jmp 0xa98b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0x3e8(%rbp), %rdi
callq 0x12210
jmp 0xa9bf9
movq -0x8(%rbp), %rsi
leaq -0x418(%rbp), %rdi
leaq -0x400(%rbp), %rdx
callq 0x97310
jmp 0xa98cd
leaq -0x438(%rbp), %rdi
leaq -0x418(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0xeadf0
jmp 0xa98e9
leaq -0x438(%rbp), %rdi
callq 0xe9240
movsd %xmm0, -0x5e8(%rbp)
jmp 0xa98ff
movsd -0x5e8(%rbp), %xmm0
movsd %xmm0, -0x420(%rbp)
movb $0x0, -0x439(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0xf990
movl %eax, -0x440(%rbp)
movl $0x0, -0x444(%rbp)
movl -0x444(%rbp), %ecx
xorl %eax, %eax
cmpl -0x440(%rbp), %ecx
movb %al, -0x5e9(%rbp)
jge 0xa9956
movb -0x439(%rbp), %al
xorb $-0x1, %al
movb %al, -0x5e9(%rbp)
movb -0x5e9(%rbp), %al
testb $0x1, %al
jne 0xa9965
jmp 0xa9a33
movsd -0x420(%rbp), %xmm0
movsd %xmm0, -0x600(%rbp)
movslq -0x444(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0xfc80
movq %rax, -0x5f8(%rbp)
jmp 0xa9991
movq -0x5f8(%rbp), %rax
movsd -0x600(%rbp), %xmm1
subsd (%rax), %xmm1
movaps 0x1486d5(%rip), %xmm0   # 0x1f2080
pand %xmm0, %xmm1
movsd 0x14deb1(%rip), %xmm0   # 0x1f7868
ucomisd %xmm1, %xmm0
jbe 0xa9a1d
movb $0x1, -0x439(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa9a1b
movsd -0x420(%rbp), %xmm0
movsd %xmm0, -0x610(%rbp)
movslq -0x444(%rbp), %rsi
leaq -0xd0(%rbp), %rdi
callq 0xfc80
movq %rax, -0x608(%rbp)
jmp 0xa99f6
movsd -0x610(%rbp), %xmm0
movq -0x608(%rbp), %rax
movsd (%rax), %xmm1
leaq 0x150760(%rip), %rdi    # 0x1fa170
movb $0x2, %al
callq 0x5070
jmp 0xa9a19
jmp 0xa9a1b
jmp 0xa9a1d
jmp 0xa9a1f
movl -0x444(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x444(%rbp)
jmp 0xa9932
testb $0x1, -0x439(%rbp)
je 0xa9bb7
movb $0x0, -0x445(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0xae590
movl %eax, -0x44c(%rbp)
movl $0x0, -0x450(%rbp)
movl -0x450(%rbp), %ecx
xorl %eax, %eax
cmpl -0x44c(%rbp), %ecx
movb %al, -0x611(%rbp)
jge 0xa9a87
movb -0x445(%rbp), %al
xorb $-0x1, %al
movb %al, -0x611(%rbp)
movb -0x611(%rbp), %al
testb $0x1, %al
jne 0xa9a96
jmp 0xa9b4e
movq -0x408(%rbp), %rax
movq %rax, -0x460(%rbp)
movups -0x418(%rbp), %xmm0
movaps %xmm0, -0x470(%rbp)
movslq -0x450(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x620(%rbp)
jmp 0xa9ace
movq -0x620(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x480(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x490(%rbp)
movq -0x480(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x28(%rax)
movaps -0x490(%rbp), %xmm0
movups %xmm0, 0x18(%rax)
movq -0x460(%rbp), %rcx
movq %rcx, 0x10(%rax)
movaps -0x470(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x110ea0
movb %al, -0x621(%rbp)
jmp 0xa9b25
movb -0x621(%rbp), %al
testb $0x1, %al
jne 0xa9b31
jmp 0xa9b38
movb $0x1, -0x445(%rbp)
jmp 0xa9b3a
movl -0x450(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x450(%rbp)
jmp 0xa9a63
testb $0x1, -0x445(%rbp)
jne 0xa9b9b
testb $0x1, -0x9(%rbp)
je 0xa9b6f
leaq 0x150645(%rip), %rdi    # 0x1fa1a9
xorl %eax, %eax
callq 0x5070
jmp 0xa9b6d
jmp 0xa9b6f
leaq -0xe8(%rbp), %rdi
leaq -0x400(%rbp), %rsi
callq 0xafc20
jmp 0xa9b84
leaq -0x100(%rbp), %rdi
leaq -0x418(%rbp), %rsi
callq 0xafc20
jmp 0xa9b99
jmp 0xa9bb5
testb $0x1, -0x9(%rbp)
je 0xa9bb3
leaq 0x150627(%rip), %rdi    # 0x1fa1cf
xorl %eax, %eax
callq 0x5070
jmp 0xa9bb1
jmp 0xa9bb3
jmp 0xa9bb5
jmp 0xa9bb7
leaq -0x3e8(%rbp), %rdi
callq 0x12210
jmp 0xa9bc5
movl -0x350(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x350(%rbp)
jmp 0xa9676
leaq -0x348(%rbp), %rdi
callq 0x12210
movl -0x314(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x314(%rbp)
jmp 0xa95ed
leaq -0x348(%rbp), %rdi
callq 0x12210
jmp 0xa9de3
leaq -0xe8(%rbp), %rdi
callq 0xae590
movl %eax, -0x2d4(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa9c3a
movl -0x2d4(%rbp), %esi
leaq 0x1505cc(%rip), %rdi    # 0x1fa1fb
xorl %eax, %eax
callq 0x5070
jmp 0xa9c38
jmp 0xa9c3a
movl $0x0, -0x494(%rbp)
movl -0x494(%rbp), %eax
cmpl -0x2d4(%rbp), %eax
jge 0xa9d2f
movslq -0x494(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x630(%rbp)
jmp 0xa9c72
movq -0x630(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x4a0(%rbp)
movups (%rax), %xmm0
movaps %xmm0, -0x4b0(%rbp)
movslq -0x494(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0xae5c0
movq %rax, -0x638(%rbp)
jmp 0xa9caa
movq -0x638(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x4c8(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x4c0(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x4b8(%rbp)
testb $0x1, -0x9(%rbp)
je 0xa9d19
movsd -0x4b0(%rbp), %xmm0
movsd -0x4a8(%rbp), %xmm1
movsd -0x4a0(%rbp), %xmm2
movsd -0x4c8(%rbp), %xmm3
movsd -0x4c0(%rbp), %xmm4
movsd -0x4b8(%rbp), %xmm5
leaq 0x150178(%rip), %rdi    # 0x1f9e86
movb $0x6, %al
callq 0x5070
jmp 0xa9d17
jmp 0xa9d19
jmp 0xa9d1b
movl -0x494(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x494(%rbp)
jmp 0xa9c44
movl -0x2d4(%rbp), %eax
cmpl -0xb4(%rbp), %eax
jne 0xa9da1
testb $0x1, -0x9(%rbp)
je 0xa9d5b
movl -0x2d4(%rbp), %esi
leaq 0x150506(%rip), %rdi    # 0x1fa256
xorl %eax, %eax
callq 0x5070
jmp 0xa9d59
jmp 0xa9d5b
leaq -0x68(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0xadfe0
jmp 0xa9d6d
movq -0x8(%rbp), %rdi
addq $0x3c0, %rdi            # imm = 0x3C0
movslq -0x14(%rbp), %rsi
callq 0xae4a0
movq %rax, -0x640(%rbp)
jmp 0xa9d8a
movq -0x640(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xafd00
jmp 0xa9d9f
jmp 0xa9dc7
movl -0xb4(%rbp), %esi
movl -0x2d4(%rbp), %edx
leaq 0x15051b(%rip), %rdi    # 0x1fa2cf
xorl %eax, %eax
callq 0x5070
jmp 0xa9dbd
movl $0x1, %edi
callq 0x67c0
jmp 0xa9dc9
leaq -0x100(%rbp), %rdi
callq 0x12210
leaq -0xe8(%rbp), %rdi
callq 0x12210
jmp 0xa9e47
leaq -0x100(%rbp), %rdi
callq 0x12210
leaq -0xe8(%rbp), %rdi
callq 0x12210
jmp 0xa9e6d
movl -0xb0(%rbp), %eax
cmpl -0xb4(%rbp), %eax
jne 0xa9e2b
testb $0x1, -0x9(%rbp)
je 0xa9e29
movl -0xb0(%rbp), %esi
leaq 0x150536(%rip), %rdi    # 0x1fa354
xorl %eax, %eax
callq 0x5070
jmp 0xa9e27
jmp 0xa9e29
jmp 0xa9e45
leaq 0x150585(%rip), %rdi    # 0x1fa3b7
xorl %eax, %eax
callq 0x5070
jmp 0xa9e3b
movl $0x1, %edi
callq 0x67c0
jmp 0xa9e47
leaq -0xd0(%rbp), %rdi
callq 0xf9d0
leaq -0x88(%rbp), %rdi
callq 0x12650
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa891d
leaq -0xd0(%rbp), %rdi
callq 0xf9d0
leaq -0x88(%rbp), %rdi
callq 0x12650
jmp 0xa9e90
addq $0x670, %rsp            # imm = 0x670
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x58f0
nopl (%rax)