// File: /workspace/github_cpp_makefile_star2_O1/Luthaf[P]zeopp/net.cc
// Function: try_unit_cell_vector_assign(int, int, int, XYZ, std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*, std::vector<XYZ, std::allocator<XYZ>>*, std::vector<int, std::allocator<int>>*, std::vector<XYZ, std::allocator<XYZ>>*, int)
bool try_unit_cell_vector_assign(int a, int b, int c, XYZ xyz, vector<int> *loops_a, vector<int> *loops_b, vector<int> *loops_c, vector<XYZ> *loops_xyz, vector<int> *unit_cell_vector_IDs, vector<XYZ> *unit_cell_vectors, int num_uc_vectors_required) {
  bool verbose = false;
  int num_uc_vectors_assigned = unit_cell_vectors->size();
  for(int uc=0; uc<3 && num_uc_vectors_assigned<num_uc_vectors_required; uc++) {
    //is this unit cell vector assigned already?
    bool this_uc_assigned = false;
    for(int i=0; i<num_uc_vectors_assigned && !this_uc_assigned; i++) {
      if(unit_cell_vector_IDs->at(i)==uc) this_uc_assigned = true;
    }
    if(!this_uc_assigned) {
      //if not assigned already, can we assign it based on this loop alone?
      if(
(uc==0 && a!=0 && b==0 && c==0) ||
(uc==1 && a==0 && b!=0 && c==0) ||
(uc==2 && a==0 && b==0 && c!=0)
      ) {
        XYZ vec(0,0,0);
        if(uc==0) vec=xyz.scale(1.0/a); else if(uc==1) vec=xyz.scale(1.0/b); else vec=xyz.scale(1.0/c);
if(verbose) printf("DEBUG: we can assign unit cell vector %c as %.3f %.3f %.3f\n", 'a'+uc, vec.x, vec.y, vec.z);
        unit_cell_vector_IDs->push_back(uc);
        unit_cell_vectors->push_back(vec);
        this_uc_assigned = true;
        num_uc_vectors_assigned++;
      } else {
        //we could not assign it based on this loop alone - but we might be able to based on other loops ...
        int num_loops = loops_xyz->size();
        for(int i=0; i<num_loops && !this_uc_assigned; i++) {
          XYZ other_xyz = loops_xyz->at(i);
          int other_a = loops_a->at(i);
          int other_b = loops_b->at(i);
          int other_c = loops_c->at(i);
if(verbose) printf("DEBUG: comparing to previous loop (%d %d %d) %.3f %.3f %.3f to try and isolate vector %c\n", other_a, other_b, other_c, other_xyz.x, other_xyz.y, other_xyz.z, 'a'+uc);
          //can we isolate this unit cell vector with a linear combination of these two loops?
          //bool can_isolate = true;
          if(
(uc!=0 && a!=0 && other_a==0) ||
(uc!=1 && b!=0 && other_b==0) ||
(uc!=2 && c!=0 && other_c==0)
          ) {
if(verbose) printf("DEBUG: cannot isolate vector %c because some other unit cell vector cannot be reduced to zero\n", 'a'+uc);
          } else if(
(uc==0 && a==0 && other_a==0) ||
(uc==1 && b==0 && other_b==0) ||
(uc==2 && c==0 && other_c==0)
          ) {
if(verbose) printf("DEBUG: cannot isolate vector %c because both coefficients of this vector are zero\n", 'a'+uc);
          } else { //there is another way it might not be possible - if the ratios of the two other unit cell vector coefficients are not equal
if(verbose) printf("DEBUG: may be able to isolate vector %c\n", 'a'+uc);
            vector<double> amounts_of_other_loop_to_subtract;
            vector<double> amount_of_other_loop_that_would_reduce_uc_to_zero;
            if(!(a==0 && other_a==0)) {double r = ((double)(a))/other_a; if(uc!=0) amounts_of_other_loop_to_subtract.push_back(r); else amount_of_other_loop_that_would_reduce_uc_to_zero.push_back(r);}
            if(!(b==0 && other_b==0)) {double r = ((double)(b))/other_b; if(uc!=1) amounts_of_other_loop_to_subtract.push_back(r); else amount_of_other_loop_that_would_reduce_uc_to_zero.push_back(r);}
            if(!(c==0 && other_c==0)) {double r = ((double)(c))/other_c; if(uc!=2) amounts_of_other_loop_to_subtract.push_back(r); else amount_of_other_loop_that_would_reduce_uc_to_zero.push_back(r);}
            int num_amounts = amounts_of_other_loop_to_subtract.size();
            if(num_amounts==0) {
              printf("ERROR: detected that unit cell vector has already been determined in determination routine\n");
              exit(EXIT_FAILURE);
            } else if(num_amounts>2) {
              printf("ERROR: pushed too many solutions to unit cell vector determination routine\n");
              exit(EXIT_FAILURE);
            } else {
              bool can_isolate = true;
              if(num_amounts==2) {
                if(fabs(amounts_of_other_loop_to_subtract.at(0)-amounts_of_other_loop_to_subtract.at(1))>DISTANCE_TOLERANCE) {
                  can_isolate = false;
if(verbose) printf("DEBUG: cannot isolate vector %c because no linear combination will isolate this vector\n", 'a'+uc);
                }
              }
              if(can_isolate) { //we should be able to isolate it - but are we reducing to zero?
                double ratio = amounts_of_other_loop_to_subtract.at(0);
                bool can_isolate_nonzero = true;
                if(amount_of_other_loop_that_would_reduce_uc_to_zero.size()!=0) {
                  if(fabs(ratio-amount_of_other_loop_that_would_reduce_uc_to_zero.at(0))<DISTANCE_TOLERANCE) {
                    can_isolate_nonzero = false;
if(verbose) printf("DEBUG: cannot isolate vector %c because this linear combination reveals that the two vectors are multiples of each other\n", 'a'+uc);
                  }
                }
                if(can_isolate_nonzero) {
                  XYZ pre_scale_vector = xyz-(other_xyz.scale(ratio));
if(verbose) printf("DEBUG: this loop %.3f %.3f %.3f, minus %.3f times other loop %.3f %.3f %.3f, gives isolated %c loop %.3f %.3f %.3f\n", xyz.x, xyz.y, xyz.z, ratio, other_xyz.x, other_xyz.y, other_xyz.z, 'a'+uc, pre_scale_vector.x, pre_scale_vector.y, pre_scale_vector.z);
                  XYZ vec(0,0,0);
                  if(uc==0) vec=pre_scale_vector.scale(1.0/(a-(other_a*ratio))); else if(uc==1) vec=pre_scale_vector.scale(1.0/(b-(other_b*ratio))); else vec=pre_scale_vector.scale(1.0/(c-(other_c*ratio)));
if(verbose) printf("DEBUG: we can assign unit cell vector %c as %.3f %.3f %.3f based on a linear combination with a previous loop\n", 'a'+uc, vec.x, vec.y, vec.z);
                  unit_cell_vector_IDs->push_back(uc);
                  unit_cell_vectors->push_back(vec);
                  this_uc_assigned = true;
                  num_uc_vectors_assigned++;
                  //also push this new loop so we can refer to it for subsequent linear combinations - only if it is unique!
                  int new_a=0, new_b=0, new_c=0;
                  if(uc==0) new_a=1; else if(uc==1) new_b=1; else new_c=1;
                  if(loop_is_unique(new_a, new_b, new_c, loops_a, loops_b, loops_c)) {
if(verbose) printf("DEBUG: pushing the newly defined, unique loop\n");
                    loops_a->push_back(new_a);
                    loops_b->push_back(new_b);
                    loops_c->push_back(new_c);
                    loops_xyz->push_back(vec);
                    num_loops++;
                  }
                }
              }
            }
          } 
        }
      }
    }
  }
  return (num_uc_vectors_assigned==num_uc_vectors_required);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq 0x188(%rsp), %r10
movq 0x8(%r10), %rax
subq (%r10), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %ebx # imm = 0xAAAAAAAB
movl $0x0, (%rsp)
cmpl 0x190(%rsp), %ebx
jge 0xa1f8f
movq %rcx, 0xc8(%rsp)
movq %r8, 0xc0(%rsp)
movq %r9, 0x108(%rsp)
movq 0x180(%rsp), %r15
movl %edx, %eax
orl %esi, %eax
movl %eax, 0xd4(%rsp)
movl %esi, %eax
orl %edi, %eax
movl %eax, 0xd0(%rsp)
movl %edi, 0xc(%rsp)
cvtsi2sd %edi, %xmm0
movl %esi, 0x14(%rsp)
cvtsi2sd %esi, %xmm1
movl %edx, 0x4(%rsp)
cvtsi2sd %edx, %xmm2
movsd 0xad98f(%rip), %xmm3    # 0x14f058
movapd %xmm3, %xmm4
movsd %xmm1, 0xf8(%rsp)
divsd %xmm1, %xmm4
movsd %xmm4, 0x120(%rsp)
movapd %xmm3, %xmm1
movsd %xmm0, 0x100(%rsp)
divsd %xmm0, %xmm1
movsd %xmm1, 0x118(%rsp)
movsd %xmm2, 0xf0(%rsp)
divsd %xmm2, %xmm3
movsd %xmm3, 0x110(%rsp)
movl $0x1, %r13d
xorl %eax, %eax
testl %ebx, %ebx
jle 0xa1769
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movl %ebx, %esi
movq %rdx, %rdi
negq %rdi
movl $0x1, %r8d
xorl %r14d, %r14d
leaq (%rdi,%r8), %r9
cmpq $0x1, %r9
je 0xa1fab
cmpl %eax, -0x4(%rcx,%r8,4)
movzbl %r14b, %r14d
cmovel %r13d, %r14d
cmpq %rsi, %r8
jae 0xa176c
incq %r8
testb $0x1, %r14b
je 0xa173e
jmp 0xa176c
xorl %r14d, %r14d
testb $0x1, %r14b
jne 0xa18d4
cmpl $0x0, 0xc(%rsp)
je 0xa1788
movl 0xd4(%rsp), %ecx
orl %eax, %ecx
je 0xa17c4
cmpl $0x0, 0x4(%rsp)
jne 0xa17a2
cmpl $0x0, 0x14(%rsp)
je 0xa17a2
cmpl $0x0, 0xc(%rsp)
jne 0xa17a2
cmpl $0x1, %eax
je 0xa17c4
cmpl $0x0, 0x4(%rsp)
je 0xa1908
cmpl $0x0, 0xd0(%rsp)
jne 0xa1908
cmpl $0x2, %eax
jne 0xa1908
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
leaq 0xa0(%rsp), %rdi
callq 0x85982
movl (%rsp), %eax
cmpl $0x1, %eax
je 0xa1809
testl %eax, %eax
movq 0x188(%rsp), %r14
leaq 0x20(%rsp), %rdi
leaq 0x160(%rsp), %rsi
jne 0xa184a
movsd 0x118(%rsp), %xmm0
jmp 0xa1853
leaq 0x20(%rsp), %rdi
leaq 0x160(%rsp), %rsi
movsd 0x120(%rsp), %xmm0
callq 0x85a34
movq 0x30(%rsp), %rax
movq %rax, 0xb0(%rsp)
movupd 0x20(%rsp), %xmm0
movapd %xmm0, 0xa0(%rsp)
movq 0x188(%rsp), %r14
jmp 0xa1874
movsd 0x110(%rsp), %xmm0
callq 0x85a34
movq 0x30(%rsp), %rax
movq %rax, 0xb0(%rsp)
movupd 0x20(%rsp), %xmm0
movapd %xmm0, 0xa0(%rsp)
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0xa188d
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r15)
jmp 0xa1898
movq %r15, %rdi
movq %rsp, %rdx
callq 0xf7b4
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xa18c2
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsi)
movapd 0xa0(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x8(%r14)
jmp 0xa18d2
movq %r14, %rdi
leaq 0xa0(%rsp), %rdx
callq 0x6a5be
incl %ebx
movl %ebx, 0x10(%rsp)
movl (%rsp), %ecx
leal 0x1(%rcx), %eax
movl %eax, (%rsp)
cmpl $0x1, %ecx
jg 0xa1f8b
movl 0x10(%rsp), %ebx
cmpl 0x190(%rsp), %ebx
movq 0x180(%rsp), %r15
jl 0xa171b
jmp 0xa1f8f
movl %ebx, 0x10(%rsp)
movq 0x178(%rsp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x64(%rsp)
testl %eax, %eax
jle 0xa18d8
testb $0x1, %r14b
jne 0xa18d8
xorl %ebx, %ebx
xorl %r12d, %r12d
movq 0x178(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq %r12, %rdx
jbe 0xa1fbc
movq 0x10(%rax,%rbx), %rcx
movq %rcx, 0xb0(%rsp)
movupd (%rax,%rbx), %xmm0
movapd %xmm0, 0xa0(%rsp)
movq 0xc8(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
jbe 0xa1fbc
movq 0xc0(%rsp), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
jbe 0xa1fbc
movq 0x108(%rsp), %rdx
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
subq %rsi, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
jbe 0xa1fbc
movl (%rax,%r12,4), %r15d
movl (%rcx,%r12,4), %ebp
movl (%rsi,%r12,4), %eax
movl %eax, 0x8(%rsp)
movl (%rsp), %eax
cmpl $0x0, 0xc(%rsp)
je 0xa1a04
testl %eax, %eax
je 0xa1a04
testl %r15d, %r15d
je 0xa1f67
cmpl $0x0, 0x14(%rsp)
je 0xa1a18
cmpl $0x1, %eax
je 0xa1a18
testl %ebp, %ebp
je 0xa1f67
cmpl $0x0, 0x4(%rsp)
je 0xa1a2f
cmpl $0x2, %eax
je 0xa1a2f
cmpl $0x0, 0x8(%rsp)
je 0xa1f67
movl %eax, %ecx
orl 0xc(%rsp), %ecx
orl %r15d, %ecx
je 0xa1f67
cmpl $0x0, 0x14(%rsp)
jne 0xa1a52
cmpl $0x1, %eax
jne 0xa1a52
testl %ebp, %ebp
je 0xa1f67
cmpl $0x0, 0x4(%rsp)
jne 0xa1a69
cmpl $0x2, %eax
jne 0xa1a69
cmpl $0x0, 0x8(%rsp)
je 0xa1f67
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq %rcx, 0x50(%rsp)
movapd %xmm0, 0x40(%rsp)
movl 0xc(%rsp), %ecx
orl %r15d, %ecx
je 0xa1afc
cvtsi2sd %r15d, %xmm1
movsd 0x100(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0xd8(%rsp)
testl %eax, %eax
je 0xa1ad9
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rsi
je 0xa1aef
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, (%rax)
jmp 0xa1afc
movq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq 0x50(%rsp), %rsi
jne 0xa1acc
leaq 0xd8(%rsp), %rdx
callq 0x148c4
movl 0x14(%rsp), %eax
orl %ebp, %eax
je 0xa1b6d
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movsd 0xf8(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0xd8(%rsp)
cmpl $0x1, (%rsp)
jne 0xa1b4a
movq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq 0x50(%rsp), %rsi
je 0xa1b60
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, (%rax)
jmp 0xa1b6d
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rsi
jne 0xa1b3d
leaq 0xd8(%rsp), %rdx
callq 0x148c4
movl 0x4(%rsp), %eax
orl 0x8(%rsp), %eax
je 0xa1be2
xorps %xmm1, %xmm1
cvtsi2sdl 0x8(%rsp), %xmm1
movsd 0xf0(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0xd8(%rsp)
cmpl $0x2, (%rsp)
jne 0xa1bbf
movq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq 0x50(%rsp), %rsi
je 0xa1bd5
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, (%rax)
jmp 0xa1be2
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rsi
jne 0xa1bb2
leaq 0xd8(%rsp), %rdx
callq 0x148c4
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
testl %edx, %edx
je 0xa1fd1
cmpl $0x3, %edx
jge 0xa1fc8
cmpl $0x2, %edx
jne 0xa1c3e
cmpq %rax, %rcx
je 0xa2001
cmpq $0x1, %rdx
jbe 0xa1ff7
movsd (%rax), %xmm0
subsd 0x8(%rax), %xmm0
andpd 0xad460(%rip), %xmm0    # 0x14f090
ucomisd 0xb2a78(%rip), %xmm0    # 0x1546b0
ja 0xa1f39
cmpq %rax, %rcx
je 0xa1fe7
movsd (%rax), %xmm0
movq 0x40(%rsp), %rax
cmpq %rax, 0x48(%rsp)
je 0xa1c7d
movapd %xmm0, %xmm2
subsd (%rax), %xmm0
andpd 0xad429(%rip), %xmm0    # 0x14f090
movsd 0xb2a41(%rip), %xmm1    # 0x1546b0
ucomisd %xmm0, %xmm1
movapd %xmm2, %xmm0
ja 0xa1f39
leaq 0x80(%rsp), %r14
movq %r14, %rdi
leaq 0xa0(%rsp), %rsi
movsd %xmm0, 0x38(%rsp)
callq 0x85a34
leaq 0xd8(%rsp), %rdi
leaq 0x160(%rsp), %rsi
movq %r14, %rdx
callq 0x85da6
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %r14, %rdi
callq 0x85982
movq 0x108(%rsp), %r14
movl (%rsp), %eax
cmpl $0x1, %eax
je 0xa1d16
testl %eax, %eax
jne 0xa1d50
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
mulsd 0x38(%rsp), %xmm0
movsd 0x100(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0xad35a(%rip), %xmm0    # 0x14f058
divsd %xmm1, %xmm0
leaq 0x68(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x85a34
jmp 0xa1d8a
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
mulsd 0x38(%rsp), %xmm0
movsd 0xf8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0xad320(%rip), %xmm0    # 0x14f058
divsd %xmm1, %xmm0
leaq 0x68(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x85a34
jmp 0xa1d8a
xorps %xmm0, %xmm0
cvtsi2sdl 0x8(%rsp), %xmm0
mulsd 0x38(%rsp), %xmm0
movsd 0xf0(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0xad2e4(%rip), %xmm0    # 0x14f058
divsd %xmm1, %xmm0
leaq 0x68(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x85a34
movq 0x78(%rsp), %rax
movq %rax, 0x90(%rsp)
movupd 0x68(%rsp), %xmm0
movapd %xmm0, 0x80(%rsp)
movq 0x180(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa1dc7
movl (%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xa1dcf
movq %rsp, %rdx
callq 0xf7b4
movq 0x188(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa1e01
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsi)
movapd 0x80(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x8(%rdi)
jmp 0xa1e0e
leaq 0x80(%rsp), %rdx
callq 0x6a5be
xorl %eax, %eax
movl %eax, 0x68(%rsp)
movl %eax, 0x1c(%rsp)
movl %eax, 0x18(%rsp)
movl (%rsp), %eax
cmpl $0x1, %eax
je 0xa1e32
testl %eax, %eax
jne 0xa1e3c
movl $0x1, 0x68(%rsp)
jmp 0xa1e44
movl $0x1, 0x1c(%rsp)
jmp 0xa1e44
movl $0x1, 0x18(%rsp)
movl 0x68(%rsp), %edi
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %edx
movq 0xc8(%rsp), %rcx
movq 0xc0(%rsp), %r8
movq %r14, %r9
callq 0xa122c
testb %al, %al
je 0xa1f32
movq 0xc8(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa1e92
movl 0x68(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xa1e9c
leaq 0x68(%rsp), %rdx
callq 0xf7b4
movq 0xc0(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa1ebe
movl 0x1c(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xa1ec8
leaq 0x1c(%rsp), %rdx
callq 0xf7b4
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xa1ee2
movl 0x18(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xa1eef
movq %r14, %rdi
leaq 0x18(%rsp), %rdx
callq 0xf7b4
movq 0x178(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa1f21
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsi)
movapd 0x80(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x8(%rdi)
jmp 0xa1f2e
leaq 0x80(%rsp), %rdx
callq 0x6a5be
incl 0x64(%rsp)
incl 0x10(%rsp)
movb $0x1, %r14b
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xa1f50
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xa1f67
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
incq %r12
movslq 0x64(%rsp), %rax
cmpq %rax, %r12
jge 0xa18d8
addq $0x18, %rbx
testb $0x1, %r14b
je 0xa1938
jmp 0xa18d8
movl 0x10(%rsp), %ebx
cmpl 0x190(%rsp), %ebx
sete %al
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xad6f3(%rip), %rdi     # 0x14f6a5
movq %rdx, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xad6e2(%rip), %rdi     # 0x14f6a5
movq %r12, %rsi
jmp 0xa1fb5
leaq 0xb6658(%rip), %rdi     # 0x158627
jmp 0xa1fd8
leaq 0xb669a(%rip), %rdi     # 0x158672
callq 0x4660
movl $0x1, %edi
callq 0x710c
leaq 0xad6b7(%rip), %rdi     # 0x14f6a5
xorl %esi, %esi
xorl %eax, %eax
callq 0x4630
movl $0x1, %eax
movq %rax, 0x38(%rsp)
leaq 0xad69d(%rip), %rdi     # 0x14f6a5
movq 0x38(%rsp), %rsi
xorl %eax, %eax
callq 0x4630
jmp 0xa2028
jmp 0xa2028
jmp 0xa2028
jmp 0xa2028
jmp 0xa2028
jmp 0xa2028
jmp 0xa2028
jmp 0xa2028
jmp 0xa2028
jmp 0xa2028
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xa2042
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xa2059
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780