// File: /workspace/github_cpp_makefile_star2_O3/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, 0x8(%rsp)
cmpl 0x190(%rsp), %ebx
jge 0xa02c1
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, 0x18(%rsp)
cvtsi2sd %edi, %xmm0
movl %esi, 0x1c(%rsp)
cvtsi2sd %esi, %xmm1
movl %edx, 0xc(%rsp)
cvtsi2sd %edx, %xmm2
movsd 0xad658(%rip), %xmm3    # 0x14d058
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 0x9faa9
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 0xa02dd
cmpl %eax, -0x4(%rcx,%r8,4)
movzbl %r14b, %r14d
cmovel %r13d, %r14d
cmpq %rsi, %r8
jae 0x9fa9e
incq %r8
testb $0x1, %r14b
je 0x9fa75
testb $0x1, %r14b
je 0x9faac
jmp 0x9fc0e
xorl %r14d, %r14d
cmpl $0x0, 0x18(%rsp)
je 0x9fabe
movl 0xd4(%rsp), %ecx
orl %eax, %ecx
je 0x9fafa
cmpl $0x0, 0xc(%rsp)
jne 0x9fad8
cmpl $0x0, 0x1c(%rsp)
je 0x9fad8
cmpl $0x0, 0x18(%rsp)
jne 0x9fad8
cmpl $0x1, %eax
je 0x9fafa
cmpl $0x0, 0xc(%rsp)
je 0x9fc44
cmpl $0x0, 0xd0(%rsp)
jne 0x9fc44
cmpl $0x2, %eax
jne 0x9fc44
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
leaq 0x90(%rsp), %rdi
callq 0x84364
movl 0x8(%rsp), %eax
cmpl $0x1, %eax
je 0x9fb40
testl %eax, %eax
movq 0x188(%rsp), %r14
leaq 0x20(%rsp), %rdi
leaq 0x160(%rsp), %rsi
jne 0x9fb81
movsd 0x118(%rsp), %xmm0
jmp 0x9fb8a
leaq 0x20(%rsp), %rdi
leaq 0x160(%rsp), %rsi
movsd 0x120(%rsp), %xmm0
callq 0x84416
movq 0x30(%rsp), %rax
movq %rax, 0xa0(%rsp)
movupd 0x20(%rsp), %xmm0
movapd %xmm0, 0x90(%rsp)
movq 0x188(%rsp), %r14
jmp 0x9fbab
movsd 0x110(%rsp), %xmm0
callq 0x84416
movq 0x30(%rsp), %rax
movq %rax, 0xa0(%rsp)
movupd 0x20(%rsp), %xmm0
movapd %xmm0, 0x90(%rsp)
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x9fbc5
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r15)
jmp 0x9fbd2
movq %r15, %rdi
leaq 0x8(%rsp), %rdx
callq 0xf864
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x9fbfc
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsi)
movapd 0x90(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x8(%r14)
jmp 0x9fc0c
movq %r14, %rdi
leaq 0x90(%rsp), %rdx
callq 0x69b82
incl %ebx
movl %ebx, 0x14(%rsp)
movl 0x8(%rsp), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x8(%rsp)
cmpl $0x1, %ecx
jg 0xa02bd
movl 0x14(%rsp), %ebx
cmpl 0x190(%rsp), %ebx
movq 0x180(%rsp), %r15
jl 0x9fa52
jmp 0xa02c1
movl %ebx, 0x14(%rsp)
movq 0x178(%rsp), %rcx
movq 0x8(%rcx), %rax
subq (%rcx), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0x4c(%rsp)
testl %eax, %eax
jle 0x9fc12
testb $0x1, %r14b
jne 0x9fc12
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 0xa02e9
movq 0x10(%rax,%rbx), %rcx
movq %rcx, 0xa0(%rsp)
movupd (%rax,%rbx), %xmm0
movapd %xmm0, 0x90(%rsp)
movq 0xc8(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
jbe 0xa02e9
movq 0xc0(%rsp), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
jbe 0xa02e9
movq 0x108(%rsp), %rdx
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
subq %rsi, %rdx
sarq $0x2, %rdx
cmpq %r12, %rdx
jbe 0xa02e9
movl (%rax,%r12,4), %r15d
movl (%rcx,%r12,4), %ebp
movl (%rsi,%r12,4), %eax
movl %eax, 0x10(%rsp)
movl 0x8(%rsp), %eax
cmpl $0x0, 0x18(%rsp)
je 0x9fd41
testl %eax, %eax
je 0x9fd41
testl %r15d, %r15d
je 0xa0299
cmpl $0x0, 0x1c(%rsp)
je 0x9fd55
cmpl $0x1, %eax
je 0x9fd55
testl %ebp, %ebp
je 0xa0299
cmpl $0x0, 0xc(%rsp)
je 0x9fd6c
cmpl $0x2, %eax
je 0x9fd6c
cmpl $0x0, 0x10(%rsp)
je 0xa0299
movl %eax, %ecx
orl 0x18(%rsp), %ecx
orl %r15d, %ecx
je 0xa0299
cmpl $0x0, 0x1c(%rsp)
jne 0x9fd8f
cmpl $0x1, %eax
jne 0x9fd8f
testl %ebp, %ebp
je 0xa0299
cmpl $0x0, 0xc(%rsp)
jne 0x9fda6
cmpl $0x2, %eax
jne 0x9fda6
cmpl $0x0, 0x10(%rsp)
je 0xa0299
xorpd %xmm0, %xmm0
movapd %xmm0, 0x20(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq %rcx, 0x60(%rsp)
movapd %xmm0, 0x50(%rsp)
movl 0x18(%rsp), %ecx
orl %r15d, %ecx
je 0x9fe11
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd 0x100(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0xd8(%rsp)
testl %eax, %eax
leaq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmoveq %rax, %rdi
xorl %esi, %esi
leaq 0xd8(%rsp), %rdx
callq 0x1481e
movl 0x1c(%rsp), %eax
orl %ebp, %eax
je 0x9fe83
xorps %xmm1, %xmm1
cvtsi2sd %ebp, %xmm1
movsd 0xf8(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0xd8(%rsp)
cmpl $0x1, 0x8(%rsp)
jne 0x9fe60
movq 0x58(%rsp), %rsi
leaq 0x50(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq 0x60(%rsp), %rsi
je 0x9fe76
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, (%rax)
jmp 0x9fe83
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rsi
jne 0x9fe53
leaq 0xd8(%rsp), %rdx
callq 0x1481e
movl 0xc(%rsp), %eax
orl 0x10(%rsp), %eax
je 0x9fef9
xorps %xmm1, %xmm1
cvtsi2sdl 0x10(%rsp), %xmm1
movsd 0xf0(%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0xd8(%rsp)
cmpl $0x2, 0x8(%rsp)
jne 0x9fed6
movq 0x58(%rsp), %rsi
leaq 0x50(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq 0x60(%rsp), %rsi
je 0x9feec
movsd %xmm0, (%rsi)
addq $0x8, %rsi
movq %rsi, (%rax)
jmp 0x9fef9
movq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq 0x30(%rsp), %rsi
jne 0x9fec9
leaq 0xd8(%rsp), %rdx
callq 0x1481e
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
testl %edx, %edx
je 0xa0303
cmpl $0x3, %edx
jge 0xa02fa
cmpl $0x2, %edx
jne 0x9ff55
cmpq %rax, %rcx
je 0xa0333
cmpq $0x1, %rdx
jbe 0xa0329
movsd (%rax), %xmm0
subsd 0x8(%rax), %xmm0
andpd 0xad159(%rip), %xmm0    # 0x14d0a0
ucomisd 0xb2809(%rip), %xmm0    # 0x152758
ja 0xa026b
cmpq %rax, %rcx
je 0xa0319
movsd (%rax), %xmm0
movq 0x50(%rsp), %rax
cmpq %rax, 0x58(%rsp)
je 0x9ff94
movapd %xmm0, %xmm2
subsd (%rax), %xmm0
andpd 0xad122(%rip), %xmm0    # 0x14d0a0
movsd 0xb27d2(%rip), %xmm1    # 0x152758
ucomisd %xmm0, %xmm1
movapd %xmm2, %xmm0
ja 0xa026b
leaq 0x70(%rsp), %r14
movq %r14, %rdi
leaq 0x90(%rsp), %rsi
movsd %xmm0, 0x40(%rsp)
callq 0x84416
leaq 0xd8(%rsp), %rdi
leaq 0x160(%rsp), %rsi
movq %r14, %rdx
callq 0x8461e
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movq %r14, %rdi
callq 0x84364
movq 0x108(%rsp), %r14
movl 0x8(%rsp), %eax
cmpl $0x1, %eax
je 0xa002e
testl %eax, %eax
jne 0xa006b
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
mulsd 0x40(%rsp), %xmm0
movsd 0x100(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0xad045(%rip), %xmm0    # 0x14d058
divsd %xmm1, %xmm0
leaq 0xa8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x84416
jmp 0xa00a8
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
mulsd 0x40(%rsp), %xmm0
movsd 0xf8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0xad008(%rip), %xmm0    # 0x14d058
divsd %xmm1, %xmm0
leaq 0xa8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x84416
jmp 0xa00a8
xorps %xmm0, %xmm0
cvtsi2sdl 0x10(%rsp), %xmm0
mulsd 0x40(%rsp), %xmm0
movsd 0xf0(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0xacfc9(%rip), %xmm0    # 0x14d058
divsd %xmm1, %xmm0
leaq 0xa8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x84416
movq 0xb8(%rsp), %rax
movq %rax, 0x80(%rsp)
movupd 0xa8(%rsp), %xmm0
movapd %xmm0, 0x70(%rsp)
movq 0x180(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa00e9
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xa00f3
leaq 0x8(%rsp), %rdx
callq 0xf864
movq 0x188(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa0122
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsi)
movapd 0x70(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x8(%rdi)
jmp 0xa012c
leaq 0x70(%rsp), %rdx
callq 0x69b82
xorl %eax, %eax
movl %eax, 0xa8(%rsp)
movl %eax, 0x3c(%rsp)
movl %eax, 0x38(%rsp)
movl 0x8(%rsp), %eax
cmpl $0x1, %eax
je 0xa0160
testl %eax, %eax
jne 0xa0171
movl $0x1, 0xa8(%rsp)
movl $0x1, %edi
xorl %edx, %edx
xorl %esi, %esi
jmp 0xa0182
movl $0x1, 0x3c(%rsp)
movl $0x1, %esi
xorl %edx, %edx
jmp 0xa0180
movl $0x1, 0x38(%rsp)
xorl %esi, %esi
movl $0x1, %edx
xorl %edi, %edi
movq 0xc8(%rsp), %rcx
movq 0xc0(%rsp), %r8
movq %r14, %r9
callq 0x9f5d3
testb %al, %al
je 0xa0264
movq 0xc8(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa01c7
movl 0xa8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xa01d4
leaq 0xa8(%rsp), %rdx
callq 0xf864
movq 0xc0(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa01f6
movl 0x3c(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0xa0200
leaq 0x3c(%rsp), %rdx
callq 0xf864
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0xa021a
movl 0x38(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0xa0227
movq %r14, %rdi
leaq 0x38(%rsp), %rdx
callq 0xf864
movq 0x178(%rsp), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xa0256
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsi)
movapd 0x70(%rsp), %xmm0
movupd %xmm0, (%rsi)
addq $0x18, 0x8(%rdi)
jmp 0xa0260
leaq 0x70(%rsp), %rdx
callq 0x69b82
incl 0x4c(%rsp)
incl 0x14(%rsp)
movb $0x1, %r14b
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xa0282
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xa0299
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
incq %r12
movslq 0x4c(%rsp), %rax
cmpq %rax, %r12
jge 0x9fc12
addq $0x18, %rbx
testb $0x1, %r14b
je 0x9fc74
jmp 0x9fc12
movl 0x14(%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 0xad411(%rip), %rdi     # 0x14d6f5
movq %rdx, %rsi
jmp 0xa02f3
leaq 0xad405(%rip), %rdi     # 0x14d6f5
movq %r12, %rsi
xorl %eax, %eax
callq 0x4630
leaq 0xb64e6(%rip), %rdi     # 0x1567e7
jmp 0xa030a
leaq 0xb6528(%rip), %rdi     # 0x156832
callq 0x4660
movl $0x1, %edi
callq 0x72bc
leaq 0xad3d5(%rip), %rdi     # 0x14d6f5
xorl %esi, %esi
xorl %eax, %eax
callq 0x4630
movl $0x1, %eax
movq %rax, 0x40(%rsp)
leaq 0xad3bb(%rip), %rdi     # 0x14d6f5
movq 0x40(%rsp), %rsi
xorl %eax, %eax
callq 0x4630
jmp 0xa035a
jmp 0xa035a
jmp 0xa035a
jmp 0xa035a
jmp 0xa035a
jmp 0xa035a
jmp 0xa035a
jmp 0xa035a
jmp 0xa035a
jmp 0xa035a
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0xa0374
movq 0x60(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xa038b
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x4470
movq %rbx, %rdi
callq 0x4780