void logDetFillFxy(int *nUnambig, int *nAmbig, int *nDoubleGap, char *seq,
                   int sNum1, int sNum2, int *refUnambigCountMatrix,
                   int *refAmbigCountMatrix, int *allSymbolNums, int nTax,
                   int nChar, int dim, int bigDim, double *normUnambig,
                   double *bigFxy, int *equatesArray) {
  int i, j, i1, j1;
  int firstChar, secondChar, firstIndx, secondIndx;
  int na, nSlots;
  double nUnambigD, fsum, oneOverNSlots;
  int dimSquared = dim * dim;
  nUnambig[0] = 0;
  nAmbig[0] = 0;
  nDoubleGap[0] = 0;
  for (i = 0; i < nChar; i++) {
    firstChar = (int)seq[(sNum1 * nChar) + i];
    secondChar = (int)seq[(sNum2 * nChar) + i];
    if (firstChar >= 0 && secondChar >= 0) {
      refUnambigCountMatrix[(firstChar * dim) + secondChar] += 1;
      nUnambig[0] += 1;
    } else {
      if (firstChar == -3 && secondChar == -3) {
        nDoubleGap[0] += 1;
      } else {
        firstIndx = 0;
        secondIndx = 0;
        for (j1 = 0; j1 < bigDim; j1++) {
          if (allSymbolNums[j1] == firstChar) {
            firstIndx = j1;
            break;
          }
        }
        for (j1 = 0; j1 < bigDim; j1++) {
          if (allSymbolNums[j1] == secondChar) {
            secondIndx = j1;
            break;
          }
        }
        refAmbigCountMatrix[(firstIndx * bigDim) + secondIndx] += 1;
        nAmbig[0] += 1;
      }
    }
  }
  if ((nAmbig[0] + nUnambig[0] + nDoubleGap[0]) != nChar) {
    printf("problem with Fxy\n");
    exit(0);
  }
  if (!nUnambig[0]) {
    printf("logDetFillFxy().  No unambiguous chars.\n");
    exit(0);
  }
  nUnambigD = (double)nUnambig[0];
  for (i = 0; i < dimSquared; i++) {
    normUnambig[i] = refUnambigCountMatrix[i] / nUnambigD;
  }
  if (0) {
    printf("refUnambigCountMatrix = \n");
    for (i = 0; i < dim; i++) {
      for (j = 0; j < dim; j++) {
        printf("%6i", refUnambigCountMatrix[(dim * i) + j]);
      }
      printf("\n");
    }
  }
  if (0) {
    printf("normUnambig = \n");
    for (i = 0; i < dim; i++) {
      for (j = 0; j < dim; j++) {
        printf("%6.2f", normUnambig[(dim * i) + j]);
      }
      printf("\n");
    }
  }
  if (0) {
    printf("refAmbigCountMatrix = \n");
    for (i = 0; i < bigDim; i++) {
      for (j = 0; j < bigDim; j++) {
        printf("%6i", refAmbigCountMatrix[(bigDim * i) + j]);
      }
      printf("\n");
    }
    exit(0);
  }
  for (i = 0; i < dimSquared; i++) {
    bigFxy[i] = (double)refUnambigCountMatrix[i];
  }
  if (nAmbig[0]) {
    for (i = 0; i < bigDim; i++) {
      for (j = 0; j < bigDim; j++) {
        na = refAmbigCountMatrix[(bigDim * i) + j];
        if (na) {
          fsum = 0.0;
          nSlots = 0;
          if (i < dim) {
            if (j == bigDim - 1) {
              for (j1 = 0; j1 < dim; j1++) {
                fsum += normUnambig[(dim * i) + j1];
                nSlots += 1;
              }
            } else if (j >= dim) {
              for (j1 = 0; j1 < dim; j1++) {
                if (equatesArray[(dim * (j - dim)) + j1]) {
                  fsum += normUnambig[(dim * i) + j1];
                  nSlots += 1;
                }
              }
            } else {
              printf("error in logDetFillFxy\n");
              exit(0);
            }
          } else if (i == bigDim - 1) {
            if (j < dim) {
              for (i1 = 0; i1 < dim; i1++) {
                fsum += normUnambig[(dim * i1) + j];
                nSlots += 1;
              }
            } else if (j == bigDim - 1) {
              printf("error in logDetFillFxy\n");
              exit(0);
            } else {
              for (i1 = 0; i1 < dim; i1++) {
                for (j1 = 0; j1 < dim; j1++) {
                  if (equatesArray[(dim * (j - dim)) + j1]) {
                    fsum += normUnambig[(dim * i1) + j1];
                    nSlots += 1;
                  }
                }
              }
            }
          } else {
            if (j < dim) {
              for (i1 = 0; i1 < dim; i1++) {
                if (equatesArray[(dim * (i - dim)) + i1]) {
                  fsum += normUnambig[(dim * i1) + j];
                  nSlots += 1;
                }
              }
            } else if (j == (bigDim - 1)) {
              for (i1 = 0; i1 < dim; i1++) {
                if (equatesArray[(dim * (i - dim)) + i1]) {
                  for (j1 = 0; j1 < dim; j1++) {
                    fsum += normUnambig[(dim * i1) + j1];
                    nSlots += 1;
                  }
                }
              }
            } else {
              for (i1 = 0; i1 < dim; i1++) {
                if (equatesArray[(dim * (i - dim)) + i1]) {
                  for (j1 = 0; j1 < dim; j1++) {
                    if (equatesArray[(dim * (j - dim)) + j1]) {
                      fsum += normUnambig[(dim * i1) + j1];
                      nSlots += 1;
                    }
                  }
                }
              }
            }
          }
          if (fsum < 1.e-15) {
            oneOverNSlots = 1.0 / (double)nSlots;
            if (i < dim) {
              if (j == (bigDim - 1)) {
                for (j1 = 0; j1 < dim; j1++) {
                  bigFxy[(dim * i) + j1] += na * oneOverNSlots;
                }
              } else if (j >= dim) {
                for (j1 = 0; j1 < dim; j1++) {
                  if (equatesArray[(dim * (j - dim)) + j1]) {
                    bigFxy[(dim * i) + j1] += na * oneOverNSlots;
                  }
                }
              } else {
                printf("error in logDetFillFxy\n");
                exit(0);
              }
            } else if (i == (bigDim - 1)) {
              if (j < dim) {
                for (i1 = 0; i1 < dim; i1++) {
                  bigFxy[(dim * i1) + j] += na * oneOverNSlots;
                }
              } else if (j == (bigDim - 1)) {
                printf("error in logDetFillFxy\n");
                exit(0);
              } else {
                for (i1 = 0; i1 < dim; i1++) {
                  for (j1 = 0; j1 < dim; j1++) {
                    if (equatesArray[(dim * (j - dim)) + j1]) {
                      bigFxy[(dim * i1) + j1] += na * oneOverNSlots;
                    }
                  }
                }
              }
            } else {
              if (j < dim) {
                for (i1 = 0; i1 < dim; i1++) {
                  if (equatesArray[(dim * (i - dim)) + i1]) {
                    bigFxy[(dim * i1) + j] += na * oneOverNSlots;
                  }
                }
              } else if (j == (bigDim - 1)) {
                for (i1 = 0; i1 < dim; i1++) {
                  if (equatesArray[(dim * (i - dim)) + i1]) {
                    for (j1 = 0; j1 < dim; j1++) {
                      bigFxy[(dim * i1) + j1] += na * oneOverNSlots;
                    }
                  }
                }
              } else {
                for (i1 = 0; i1 < dim; i1++) {
                  if (equatesArray[(dim * (i - dim)) + i1]) {
                    for (j1 = 0; j1 < dim; j1++) {
                      if (equatesArray[(dim * (j - dim)) + j1]) {
                        bigFxy[(dim * i1) + j1] += na * oneOverNSlots;
                      }
                    }
                  }
                }
              }
            }
          } else {
            if (i < dim) {
              if (j == (bigDim - 1)) {
                for (j1 = 0; j1 < dim; j1++) {
                  bigFxy[(dim * i) + j1] +=
                      na * normUnambig[(dim * i) + j1] / fsum;
                }
              } else if (j >= dim) {
                for (j1 = 0; j1 < dim; j1++) {
                  if (equatesArray[(dim * (j - dim)) + j1]) {
                    bigFxy[(dim * i) + j1] +=
                        na * normUnambig[(dim * i) + j1] / fsum;
                  }
                }
              } else {
                printf("error in logDetFillFxy\n");
                exit(0);
              }
            } else if (i == (bigDim - 1)) {
              if (j < dim) {
                for (i1 = 0; i1 < dim; i1++) {
                  bigFxy[(dim * i1) + j] +=
                      na * normUnambig[(dim * i1) + j] / fsum;
                }
              } else if (j == (bigDim - 1)) {
                printf("error in logDetFillFxy\n");
                exit(0);
              } else {
                for (i1 = 0; i1 < dim; i1++) {
                  for (j1 = 0; j1 < dim; j1++) {
                    if (equatesArray[(dim * (j - dim)) + j1]) {
                      bigFxy[(dim * i1) + j1] +=
                          na * normUnambig[(dim * i1) + j1] / fsum;
                    }
                  }
                }
              }
            } else {
              if (j < dim) {
                for (i1 = 0; i1 < dim; i1++) {
                  if (equatesArray[(dim * (i - dim)) + i1]) {
                    bigFxy[(dim * i1) + j] +=
                        na * normUnambig[(dim * i1) + j] / fsum;
                  }
                }
              } else if (j == (bigDim - 1)) {
                for (i1 = 0; i1 < dim; i1++) {
                  if (equatesArray[(dim * (i - dim)) + i1]) {
                    for (j1 = 0; j1 < dim; j1++) {
                      bigFxy[(dim * i1) + j1] +=
                          na * normUnambig[(dim * i1) + j1] / fsum;
                    }
                  }
                }
              } else {
                for (i1 = 0; i1 < dim; i1++) {
                  if (equatesArray[(dim * (i - dim)) + i1]) {
                    for (j1 = 0; j1 < dim; j1++) {
                      if (equatesArray[(dim * (j - dim)) + j1]) {
                        bigFxy[(dim * i1) + j1] +=
                            na * normUnambig[(dim * i1) + j1] / fsum;
                      }
                    }
                  }
                }
              }
            }
          }
          if (0) {
            printf("bigFxy, after partial ambig resolution\n");
            for (i1 = 0; i1 < dim; i1++) {
              for (j1 = 0; j1 < dim; j1++) {
                printf("%7.3f", bigFxy[(dim * i1) + j1]);
              }
              printf("\n");
            }
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<logDetFillFxy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%eax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    0x38(%rbp),%eax
imul   0x38(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x8(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x10(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x30(%rbp),%eax
jge    1306 <logDetFillFxy+0x1e6>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jl     120d <logDetFillFxy+0xed>
cmpl   $0x0,-0x40(%rbp)
jl     120d <logDetFillFxy+0xed>
mov    0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
imul   0x38(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    12f3 <logDetFillFxy+0x1d3>
cmpl   $0xfffffffd,-0x3c(%rbp)
jne    1231 <logDetFillFxy+0x111>
cmpl   $0xfffffffd,-0x40(%rbp)
jne    1231 <logDetFillFxy+0x111>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    12ee <logDetFillFxy+0x1ce>
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    1284 <logDetFillFxy+0x164>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    1271 <logDetFillFxy+0x151>
mov    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1284 <logDetFillFxy+0x164>
jmp    1276 <logDetFillFxy+0x156>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1246 <logDetFillFxy+0x126>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    12c9 <logDetFillFxy+0x1a9>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x40(%rbp),%eax
jne    12b6 <logDetFillFxy+0x196>
mov    -0x38(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    12c9 <logDetFillFxy+0x1a9>
jmp    12bb <logDetFillFxy+0x19b>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    128b <logDetFillFxy+0x16b>
mov    0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   0x40(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
jmp    12f3 <logDetFillFxy+0x1d3>
jmp    12f8 <logDetFillFxy+0x1d8>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1193 <logDetFillFxy+0x73>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
add    (%rcx),%eax
mov    -0x18(%rbp),%rcx
add    (%rcx),%eax
cmp    0x30(%rbp),%eax
je     1336 <logDetFillFxy+0x216>
lea    0x1ce8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
mov    -0x8(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1358 <logDetFillFxy+0x238>
lea    0x1cd8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
mov    -0x8(%rbp),%rax
cvtsi2sdl (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    13a5 <logDetFillFxy+0x285>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
divsd  -0x58(%rbp),%xmm0
mov    0x48(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    136c <logDetFillFxy+0x24c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    13e0 <logDetFillFxy+0x2c0>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
mov    0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13ac <logDetFillFxy+0x28c>
mov    -0x10(%rbp),%rax
cmpl   $0x0,(%rax)
je     21ee <logDetFillFxy+0x10ce>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    21e9 <logDetFillFxy+0x10c9>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    0x40(%rbp),%eax
jge    21d6 <logDetFillFxy+0x10b6>
mov    0x18(%rbp),%rax
mov    0x40(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
je     21c3 <logDetFillFxy+0x10a3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    154e <logDetFillFxy+0x42e>
mov    -0x30(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    14af <logDetFillFxy+0x38f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    14aa <logDetFillFxy+0x38a>
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1467 <logDetFillFxy+0x347>
jmp    1549 <logDetFillFxy+0x429>
mov    -0x30(%rbp),%eax
cmp    0x38(%rbp),%eax
jl     152f <logDetFillFxy+0x40f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    152a <logDetFillFxy+0x40a>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1517 <logDetFillFxy+0x3f7>
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    151c <logDetFillFxy+0x3fc>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14c2 <logDetFillFxy+0x3a2>
jmp    1544 <logDetFillFxy+0x424>
lea    0x1b15(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
jmp    1549 <logDetFillFxy+0x429>
jmp    187d <logDetFillFxy+0x75d>
mov    -0x2c(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1684 <logDetFillFxy+0x564>
mov    -0x30(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    15ba <logDetFillFxy+0x49a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    15b5 <logDetFillFxy+0x495>
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1572 <logDetFillFxy+0x452>
jmp    167f <logDetFillFxy+0x55f>
mov    -0x30(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    15e0 <logDetFillFxy+0x4c0>
lea    0x1a79(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1675 <logDetFillFxy+0x555>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1662 <logDetFillFxy+0x542>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     164f <logDetFillFxy+0x52f>
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1654 <logDetFillFxy+0x534>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15fa <logDetFillFxy+0x4da>
jmp    1667 <logDetFillFxy+0x547>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15e7 <logDetFillFxy+0x4c7>
jmp    167a <logDetFillFxy+0x55a>
jmp    167f <logDetFillFxy+0x55f>
jmp    1878 <logDetFillFxy+0x758>
mov    -0x30(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1704 <logDetFillFxy+0x5e4>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    16ff <logDetFillFxy+0x5df>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     16ec <logDetFillFxy+0x5cc>
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    16f1 <logDetFillFxy+0x5d1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1697 <logDetFillFxy+0x577>
jmp    1873 <logDetFillFxy+0x753>
mov    -0x30(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    17af <logDetFillFxy+0x68f>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    17aa <logDetFillFxy+0x68a>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1797 <logDetFillFxy+0x677>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1792 <logDetFillFxy+0x672>
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    174f <logDetFillFxy+0x62f>
jmp    1797 <logDetFillFxy+0x677>
jmp    179c <logDetFillFxy+0x67c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    171c <logDetFillFxy+0x5fc>
jmp    186e <logDetFillFxy+0x74e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1869 <logDetFillFxy+0x749>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1856 <logDetFillFxy+0x736>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1851 <logDetFillFxy+0x731>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     183e <logDetFillFxy+0x71e>
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1843 <logDetFillFxy+0x723>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17e9 <logDetFillFxy+0x6c9>
jmp    1856 <logDetFillFxy+0x736>
jmp    185b <logDetFillFxy+0x73b>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17b6 <logDetFillFxy+0x696>
jmp    186e <logDetFillFxy+0x74e>
jmp    1873 <logDetFillFxy+0x753>
jmp    1878 <logDetFillFxy+0x758>
jmp    187d <logDetFillFxy+0x75d>
movsd  0x177b(%rip),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    1d01 <logDetFillFxy+0xbe1>
cvtsi2sdl -0x50(%rbp),%xmm1
movsd  0x176b(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    19b9 <logDetFillFxy+0x899>
mov    -0x30(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1916 <logDetFillFxy+0x7f6>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1911 <logDetFillFxy+0x7f1>
cvtsi2sdl -0x4c(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    18ca <logDetFillFxy+0x7aa>
jmp    19b4 <logDetFillFxy+0x894>
mov    -0x30(%rbp),%eax
cmp    0x38(%rbp),%eax
jl     199a <logDetFillFxy+0x87a>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1995 <logDetFillFxy+0x875>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1982 <logDetFillFxy+0x862>
cvtsi2sdl -0x4c(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1987 <logDetFillFxy+0x867>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1929 <logDetFillFxy+0x809>
jmp    19af <logDetFillFxy+0x88f>
lea    0x16aa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
jmp    19b4 <logDetFillFxy+0x894>
jmp    1cfc <logDetFillFxy+0xbdc>
mov    -0x2c(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1af7 <logDetFillFxy+0x9d7>
mov    -0x30(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1a29 <logDetFillFxy+0x909>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1a24 <logDetFillFxy+0x904>
cvtsi2sdl -0x4c(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19dd <logDetFillFxy+0x8bd>
jmp    1af2 <logDetFillFxy+0x9d2>
mov    -0x30(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1a4f <logDetFillFxy+0x92f>
lea    0x160a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1ae8 <logDetFillFxy+0x9c8>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1ad5 <logDetFillFxy+0x9b5>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1ac2 <logDetFillFxy+0x9a2>
cvtsi2sdl -0x4c(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ac7 <logDetFillFxy+0x9a7>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a69 <logDetFillFxy+0x949>
jmp    1ada <logDetFillFxy+0x9ba>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a56 <logDetFillFxy+0x936>
jmp    1aed <logDetFillFxy+0x9cd>
jmp    1af2 <logDetFillFxy+0x9d2>
jmp    1cf7 <logDetFillFxy+0xbd7>
mov    -0x30(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1b7b <logDetFillFxy+0xa5b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1b76 <logDetFillFxy+0xa56>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1b63 <logDetFillFxy+0xa43>
cvtsi2sdl -0x4c(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b68 <logDetFillFxy+0xa48>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b0a <logDetFillFxy+0x9ea>
jmp    1cf2 <logDetFillFxy+0xbd2>
mov    -0x30(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1c2a <logDetFillFxy+0xb0a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1c25 <logDetFillFxy+0xb05>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1c12 <logDetFillFxy+0xaf2>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1c0d <logDetFillFxy+0xaed>
cvtsi2sdl -0x4c(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1bc6 <logDetFillFxy+0xaa6>
jmp    1c12 <logDetFillFxy+0xaf2>
jmp    1c17 <logDetFillFxy+0xaf7>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1b93 <logDetFillFxy+0xa73>
jmp    1ced <logDetFillFxy+0xbcd>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1ce8 <logDetFillFxy+0xbc8>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1cd5 <logDetFillFxy+0xbb5>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1cd0 <logDetFillFxy+0xbb0>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1cbd <logDetFillFxy+0xb9d>
cvtsi2sdl -0x4c(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1cc2 <logDetFillFxy+0xba2>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1c64 <logDetFillFxy+0xb44>
jmp    1cd5 <logDetFillFxy+0xbb5>
jmp    1cda <logDetFillFxy+0xbba>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1c31 <logDetFillFxy+0xb11>
jmp    1ced <logDetFillFxy+0xbcd>
jmp    1cf2 <logDetFillFxy+0xbd2>
jmp    1cf7 <logDetFillFxy+0xbd7>
jmp    1cfc <logDetFillFxy+0xbdc>
jmp    21be <logDetFillFxy+0x109e>
mov    -0x2c(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1e30 <logDetFillFxy+0xd10>
mov    -0x30(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1d7f <logDetFillFxy+0xc5f>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1d7a <logDetFillFxy+0xc5a>
cvtsi2sdl -0x4c(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1d25 <logDetFillFxy+0xc05>
jmp    1e2b <logDetFillFxy+0xd0b>
mov    -0x30(%rbp),%eax
cmp    0x38(%rbp),%eax
jl     1e11 <logDetFillFxy+0xcf1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1e0c <logDetFillFxy+0xcec>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1df9 <logDetFillFxy+0xcd9>
cvtsi2sdl -0x4c(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x2c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1dfe <logDetFillFxy+0xcde>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1d92 <logDetFillFxy+0xc72>
jmp    1e26 <logDetFillFxy+0xd06>
lea    0x1233(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
jmp    1e2b <logDetFillFxy+0xd0b>
jmp    21b9 <logDetFillFxy+0x1099>
mov    -0x2c(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1f8a <logDetFillFxy+0xe6a>
mov    -0x30(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1eae <logDetFillFxy+0xd8e>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1ea9 <logDetFillFxy+0xd89>
cvtsi2sdl -0x4c(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1e54 <logDetFillFxy+0xd34>
jmp    1f85 <logDetFillFxy+0xe65>
mov    -0x30(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1ed4 <logDetFillFxy+0xdb4>
lea    0x1185(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
xor    %edi,%edi
call   1040 <exit@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1f7b <logDetFillFxy+0xe5b>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    1f68 <logDetFillFxy+0xe48>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1f55 <logDetFillFxy+0xe35>
cvtsi2sdl -0x4c(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1f5a <logDetFillFxy+0xe3a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1eee <logDetFillFxy+0xdce>
jmp    1f6d <logDetFillFxy+0xe4d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1edb <logDetFillFxy+0xdbb>
jmp    1f80 <logDetFillFxy+0xe60>
jmp    1f85 <logDetFillFxy+0xe65>
jmp    21b4 <logDetFillFxy+0x1094>
mov    -0x30(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    201c <logDetFillFxy+0xefc>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    2017 <logDetFillFxy+0xef7>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     2004 <logDetFillFxy+0xee4>
cvtsi2sdl -0x4c(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2009 <logDetFillFxy+0xee9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1f9d <logDetFillFxy+0xe7d>
jmp    21af <logDetFillFxy+0x108f>
mov    -0x30(%rbp),%eax
mov    0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    20d9 <logDetFillFxy+0xfb9>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    20d4 <logDetFillFxy+0xfb4>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     20c1 <logDetFillFxy+0xfa1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    20bc <logDetFillFxy+0xf9c>
cvtsi2sdl -0x4c(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2067 <logDetFillFxy+0xf47>
jmp    20c1 <logDetFillFxy+0xfa1>
jmp    20c6 <logDetFillFxy+0xfa6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2034 <logDetFillFxy+0xf14>
jmp    21aa <logDetFillFxy+0x108a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    21a5 <logDetFillFxy+0x1085>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     2192 <logDetFillFxy+0x1072>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    0x38(%rbp),%eax
jge    218d <logDetFillFxy+0x106d>
mov    0x58(%rbp),%rax
mov    0x38(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    0x38(%rbp),%edx
imul   %edx,%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     217a <logDetFillFxy+0x105a>
cvtsi2sdl -0x4c(%rbp),%xmm0
mov    0x48(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x60(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    0x38(%rbp),%ecx
imul   -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    217f <logDetFillFxy+0x105f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    2113 <logDetFillFxy+0xff3>
jmp    2192 <logDetFillFxy+0x1072>
jmp    2197 <logDetFillFxy+0x1077>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    20e0 <logDetFillFxy+0xfc0>
jmp    21aa <logDetFillFxy+0x108a>
jmp    21af <logDetFillFxy+0x108f>
jmp    21b4 <logDetFillFxy+0x1094>
jmp    21b9 <logDetFillFxy+0x1099>
jmp    21be <logDetFillFxy+0x109e>
jmp    21c3 <logDetFillFxy+0x10a3>
jmp    21c8 <logDetFillFxy+0x10a8>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1407 <logDetFillFxy+0x2e7>
jmp    21db <logDetFillFxy+0x10bb>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13f4 <logDetFillFxy+0x2d4>
jmp    21ee <logDetFillFxy+0x10ce>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<logDetFillFxy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x168,%rsp
mov    0x1d0(%rsp),%eax
mov    0x1c8(%rsp),%r14d
mov    0x1c0(%rsp),%ebp
mov    0x1a0(%rsp),%r11
movl   $0x0,(%rdi)
movl   $0x0,(%rsi)
movl   $0x0,(%rdx)
mov    %rax,%r10
mov    %eax,%ebx
test   %ebp,%ebp
mov    %rbx,0x88(%rsp)
jle    1282 <logDetFillFxy+0x162>
mov    0x1b0(%rsp),%r15
imul   %ebp,%r8d
imul   %ebp,%r9d
movslq %r8d,%r8
movslq %r9d,%r9
mov    %ebp,%r14d
xor    %eax,%eax
jmp    11ca <logDetFillFxy+0xaa>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
imul   0x1c8(%rsp),%ebp
add    %r13d,%ebp
mov    %r11,%rbx
mov    %rdi,%r12
movslq %ebp,%rbp
addl   $0x1,(%rbx,%rbp,4)
addl   $0x1,(%r12)
add    $0x1,%rax
cmp    %r14,%rax
je     1267 <logDetFillFxy+0x147>
lea    (%rax,%r8,1),%rbx
movsbl (%rcx,%rbx,1),%ebp
lea    (%rax,%r9,1),%rbx
mov    (%rcx,%rbx,1),%bl
movsbl %bl,%r13d
test   %ebp,%ebp
js     11e5 <logDetFillFxy+0xc5>
test   %bl,%bl
jns    11a0 <logDetFillFxy+0x80>
cmp    $0xfd,%bpl
jne    11f3 <logDetFillFxy+0xd3>
mov    %rdx,%r12
cmp    $0xfd,%bl
je     11b8 <logDetFillFxy+0x98>
xor    %r12d,%r12d
test   %r10d,%r10d
jle    121d <logDetFillFxy+0xfd>
xor    %ebx,%ebx
nopl   (%rax)
cmp    %ebp,(%r15,%rbx,4)
je     1221 <logDetFillFxy+0x101>
add    $0x1,%rbx
cmp    %rbx,0x88(%rsp)
jne    1200 <logDetFillFxy+0xe0>
xor    %ebp,%ebp
test   %r10d,%r10d
jg     1228 <logDetFillFxy+0x108>
jmp    1250 <logDetFillFxy+0x130>
xor    %ebp,%ebp
jmp    1250 <logDetFillFxy+0x130>
mov    %ebx,%ebp
test   %r10d,%r10d
jle    1250 <logDetFillFxy+0x130>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
cmp    %r13d,(%r15,%rbx,4)
je     1246 <logDetFillFxy+0x126>
add    $0x1,%rbx
cmp    %rbx,0x88(%rsp)
jne    1230 <logDetFillFxy+0x110>
jmp    1250 <logDetFillFxy+0x130>
mov    %ebx,%r12d
nopl   0x0(%rax)
imul   %r10d,%ebp
add    %r12d,%ebp
mov    0x1a8(%rsp),%rbx
mov    %rsi,%r12
jmp    11b1 <logDetFillFxy+0x91>
mov    (%rdx),%eax
mov    0x1c8(%rsp),%r14d
mov    0x88(%rsp),%rbx
mov    0x1c0(%rsp),%ebp
jmp    1284 <logDetFillFxy+0x164>
xor    %eax,%eax
mov    (%rsi),%r8d
mov    (%rdi),%edx
add    %edx,%eax
add    %r8d,%eax
cmp    %ebp,%eax
jne    2c02 <logDetFillFxy+0x1ae2>
test   %edx,%edx
je     2c0b <logDetFillFxy+0x1aeb>
mov    %r10,%rdi
mov    0x1e0(%rsp),%r13
mov    0x1d8(%rsp),%r15
mov    %r14d,%eax
imul   %r14d,%eax
test   %eax,%eax
je     1469 <logDetFillFxy+0x349>
cvtsi2sd %edx,%xmm0
mov    %eax,%edx
cmp    $0x1,%eax
jne    12d2 <logDetFillFxy+0x1b2>
xor    %esi,%esi
jmp    1360 <logDetFillFxy+0x240>
mov    %edx,%esi
and    $0xfffffffe,%esi
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x2(%rsi),%rdi
mov    %rdi,%rcx
shr    %rcx
add    $0x1,%rcx
test   %rdi,%rdi
je     13fc <logDetFillFxy+0x2dc>
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebp,%ebp
nop
cvtdq2pd (%r11,%rbp,4),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r15,%rbp,8)
cvtdq2pd 0x8(%r11,%rbp,4),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,0x10(%r15,%rbp,8)
add    $0x4,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1300 <logDetFillFxy+0x1e0>
test   $0x1,%cl
je     1341 <logDetFillFxy+0x221>
cvtdq2pd (%r11,%rbp,4),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%r15,%rbp,8)
cmp    %rdx,%rsi
mov    %r10,%rdi
mov    0x1e0(%rsp),%r13
je     137c <logDetFillFxy+0x25c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sdl (%r11,%rsi,4),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1360 <logDetFillFxy+0x240>
test   %eax,%eax
je     1469 <logDetFillFxy+0x349>
cmp    $0x4,%eax
jae    1390 <logDetFillFxy+0x270>
xor    %eax,%eax
jmp    1450 <logDetFillFxy+0x330>
mov    %edx,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rsi
mov    %rsi,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     140c <logDetFillFxy+0x2ec>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edi,%edi
mov    0x1e0(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
cvtdq2pd (%r11,%rdi,4),%xmm0
cvtdq2pd 0x8(%r11,%rdi,4),%xmm1
movups %xmm0,(%rcx,%rdi,8)
movups %xmm1,0x10(%rcx,%rdi,8)
cvtdq2pd 0x10(%r11,%rdi,4),%xmm0
cvtdq2pd 0x18(%r11,%rdi,4),%xmm1
movupd %xmm0,0x20(%rcx,%rdi,8)
movupd %xmm1,0x30(%rcx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    13c0 <logDetFillFxy+0x2a0>
jmp    1416 <logDetFillFxy+0x2f6>
xor    %ebp,%ebp
test   $0x1,%cl
jne    1331 <logDetFillFxy+0x211>
jmp    1341 <logDetFillFxy+0x221>
xor    %edi,%edi
mov    0x1e0(%rsp),%rcx
test   $0x1,%bpl
mov    %rcx,%r13
je     143a <logDetFillFxy+0x31a>
cvtdq2pd (%r11,%rdi,4),%xmm0
cvtdq2pd 0x8(%r11,%rdi,4),%xmm1
movupd %xmm0,0x0(%r13,%rdi,8)
movupd %xmm1,0x10(%r13,%rdi,8)
cmp    %rdx,%rax
mov    %r10,%rdi
je     1469 <logDetFillFxy+0x349>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm0,%xmm0
cvtsi2sdl (%r11,%rax,4),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1450 <logDetFillFxy+0x330>
test   %r8d,%r8d
je     2bdd <logDetFillFxy+0x1abd>
test   %edi,%edi
jle    2bdd <logDetFillFxy+0x1abd>
mov    %rdi,%r10
add    $0xffffffff,%r10d
mov    0x1c8(%rsp),%eax
movslq %eax,%rbp
mov    %eax,%r9d
mov    %r9d,%r14d
and    $0xfffffffe,%r14d
lea    -0x2(%r14),%rax
mov    %rax,0xc8(%rsp)
mov    %rax,%rcx
shr    %rcx
add    $0x1,%rcx
mov    %r9d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xe0(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,0x70(%rsp)
mov    %rcx,%rax
mov    %rcx,0xc0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xb8(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0xf0(%rsp)
mov    %rsi,%rax
mov    %rsi,0xd8(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0xd0(%rsp)
mov    %rbp,%rax
imul   %rbp,%rax
mov    $0x1,%ecx
sub    %rax,%rcx
mov    %rbp,%rax
shl    $0x4,%rax
mov    %rax,0x58(%rsp)
mov    %rbp,%rax
shl    $0x5,%rax
mov    %rax,0x138(%rsp)
mov    0x1e8(%rsp),%rax
lea    (%rax,%rcx,4),%r11
lea    (%rax,%rcx,4),%r12
add    $0xfffffffffffffffc,%r12
movsd  0x1aa5(%rip),%xmm9
movsd  0x1aa4(%rip),%xmm8
lea    -0x1(%r9),%rcx
mov    %rcx,0x28(%rsp)
lea    0x0(,%rbp,4),%rcx
mov    %rcx,0x100(%rsp)
lea    0x8(%r15),%rax
lea    0x0(,%rbp,8),%r8
lea    0x18(%r15),%rsi
lea    (%r8,%r8,2),%rdx
mov    %rdx,0x128(%rsp)
lea    0x10(%r13),%rdx
mov    %rdx,0x120(%rsp)
lea    0x10(%r15),%rdx
mov    %rdx,0x118(%rsp)
lea    0x8(%r13),%rdx
mov    %rdx,0x98(%rsp)
lea    0x0(%r13,%rbp,8),%rdx
mov    %rdx,0x148(%rsp)
lea    (%r15,%rbp,8),%rdx
mov    %rdx,0x140(%rsp)
lea    0x30(%r13),%rdx
mov    %rdx,0x110(%rsp)
xor    %edi,%edi
mov    %r13,%rdx
mov    %r12,0x150(%rsp)
mov    %r12,0xf8(%rsp)
mov    %r15,%rcx
mov    %rsi,0x130(%rsp)
mov    %rax,0xa0(%rsp)
mov    %r11,0x158(%rsp)
mov    %r10,0x40(%rsp)
mov    %rbp,0x8(%rsp)
jmp    1686 <logDetFillFxy+0x566>
xchg   %ax,%ax
mov    0x80(%rsp),%rdi
add    $0x1,%rdi
mov    0x100(%rsp),%rdx
mov    0xa8(%rsp),%r11
add    %rdx,%r11
mov    0xb0(%rsp),%rax
add    %r8,%rax
mov    0xe8(%rsp),%rsi
add    %r8,%rsi
mov    0x78(%rsp),%rcx
add    %r8,%rcx
add    %rdx,0xf8(%rsp)
mov    0x48(%rsp),%rdx
add    %r8,%rdx
cmp    %rbx,%rdi
mov    0x1e0(%rsp),%r13
mov    0x1d8(%rsp),%r15
je     2bdd <logDetFillFxy+0x1abd>
mov    %r11,0xa8(%rsp)
mov    %rax,0xb0(%rsp)
mov    %rsi,0xe8(%rsp)
mov    %rcx,0x78(%rsp)
mov    %rdx,0x48(%rsp)
mov    %rdi,%rsi
mov    0x8(%rsp),%rax
imul   %rax,%rsi
lea    0x0(,%rsi,8),%r10
add    %r13,%r10
lea    (%rsi,%r9,1),%rcx
lea    0x0(%r13,%rcx,8),%rdx
mov    %rsi,0x50(%rsp)
lea    (%r15,%rsi,8),%rsi
lea    (%r15,%rcx,8),%rcx
mov    %rdi,%rbp
imul   %rbx,%rbp
mov    %rbp,0x160(%rsp)
mov    %rdi,0x80(%rsp)
sub    %rax,%rdi
imul   %rax,%rdi
mov    %rdi,0x30(%rsp)
cmp    %rcx,%r10
setb   %al
cmp    %rdx,%rsi
setb   %cl
and    %al,%cl
mov    %cl,0x27(%rsp)
mov    0x140(%rsp),%rax
mov    0x148(%rsp),%rcx
mov    0x150(%rsp),%r12
mov    0x158(%rsp),%rsi
xor    %edi,%edi
jmp    179d <logDetFillFxy+0x67d>
imul   0x8(%rsp),%rax
add    %rdi,%rax
mulsd  %xmm2,%xmm3
mov    0x1e0(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm3
movsd  %xmm3,(%rcx,%rax,8)
nopl   (%rax)
add    $0x1,%rdi
mov    0x100(%rsp),%rax
add    %rax,%rsi
mov    0x68(%rsp),%r15
add    $0x8,%r15
add    %rax,%r12
mov    0x60(%rsp),%r13
add    $0x8,%r13
mov    0x90(%rsp),%rcx
add    $0x8,%rcx
mov    0x108(%rsp),%rax
add    $0x8,%rax
mov    0x88(%rsp),%rbx
cmp    %rbx,%rdi
je     1620 <logDetFillFxy+0x500>
mov    %r15,0x68(%rsp)
mov    %r13,0x60(%rsp)
mov    %rcx,0x90(%rsp)
mov    %rax,0x108(%rsp)
mov    0x160(%rsp),%rax
add    %rdi,%rax
mov    0x1a8(%rsp),%rcx
mov    (%rcx,%rax,4),%edx
test   %edx,%edx
je     1750 <logDetFillFxy+0x630>
mov    0x80(%rsp),%rax
mov    0x8(%rsp),%rcx
cmp    %rcx,%rax
mov    %rdi,0x18(%rsp)
jge    1830 <logDetFillFxy+0x710>
mov    0x40(%rsp),%r15
cmp    %r15,%rdi
jne    1888 <logDetFillFxy+0x768>
mov    0x1c8(%rsp),%r11d
test   %r11d,%r11d
jle    1990 <logDetFillFxy+0x870>
mov    %edx,0x14(%rsp)
cmpq   $0x3,0x28(%rsp)
jae    1b6c <logDetFillFxy+0xa4c>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
mov    0x70(%rsp),%rdx
jmp    1bb0 <logDetFillFxy+0xa90>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%r15
mov    %rdi,%r10
cmp    %r15,%rax
jne    18fd <logDetFillFxy+0x7dd>
sub    %rcx,%r10
mov    0x1c8(%rsp),%r11d
jge    19a9 <logDetFillFxy+0x889>
test   %r11d,%r11d
mov    0x70(%rsp),%r13
jle    1b53 <logDetFillFxy+0xa33>
mov    %edx,0x14(%rsp)
cmpq   $0x3,0x28(%rsp)
mov    0x58(%rsp),%rbx
xorpd  %xmm2,%xmm2
jae    1d07 <logDetFillFxy+0xbe7>
xor    %eax,%eax
mov    0x1d8(%rsp),%r10
jmp    1d50 <logDetFillFxy+0xc30>
mov    %rdi,%rax
sub    %rcx,%rax
mov    0x1c8(%rsp),%r11d
jl     2bef <logDetFillFxy+0x1acf>
test   %r11d,%r11d
jle    1990 <logDetFillFxy+0x870>
mov    %edx,0x14(%rsp)
cmpq   $0x0,0x28(%rsp)
je     1cc3 <logDetFillFxy+0xba3>
xor    %edx,%edx
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
mov    0x1d8(%rsp),%rcx
mov    0xb0(%rsp),%rdi
jmp    18dd <logDetFillFxy+0x7bd>
nop
add    $0x2,%rdx
cmp    %rdx,%r14
je     1cd3 <logDetFillFxy+0xbb3>
cmpl   $0x0,-0x4(%rsi,%rdx,4)
je     18ed <logDetFillFxy+0x7cd>
addsd  -0x8(%rdi,%rdx,8),%xmm2
add    $0x1,%ebx
cmpl   $0x0,(%rsi,%rdx,4)
je     18d0 <logDetFillFxy+0x7b0>
addsd  (%rdi,%rdx,8),%xmm2
add    $0x1,%ebx
jmp    18d0 <logDetFillFxy+0x7b0>
sub    %rcx,%r10
mov    0x1c8(%rsp),%eax
jge    1a65 <logDetFillFxy+0x945>
test   %eax,%eax
jle    1750 <logDetFillFxy+0x630>
mov    %edx,0x14(%rsp)
cmpq   $0x0,0x28(%rsp)
je     1d82 <logDetFillFxy+0xc62>
xor    %eax,%eax
xorpd  %xmm2,%xmm2
mov    0x68(%rsp),%rdx
xor    %ebx,%ebx
mov    0x1c8(%rsp),%r11d
mov    0x1d8(%rsp),%rdi
mov    0x58(%rsp),%rcx
mov    0xa8(%rsp),%rbp
jmp    1970 <logDetFillFxy+0x850>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rax
add    %rcx,%rdx
cmp    %rax,%r14
je     1d9a <logDetFillFxy+0xc7a>
cmpl   $0x0,-0x4(%rbp,%rax,4)
je     197e <logDetFillFxy+0x85e>
addsd  (%rdx),%xmm2
add    $0x1,%ebx
cmpl   $0x0,0x0(%rbp,%rax,4)
je     1960 <logDetFillFxy+0x840>
addsd  (%rdx,%r8,1),%xmm2
add    $0x1,%ebx
jmp    1960 <logDetFillFxy+0x840>
cmp    %r15,%rdi
je     1750 <logDetFillFxy+0x630>
cmp    0x8(%rsp),%rdi
jge    1750 <logDetFillFxy+0x630>
jmp    2bef <logDetFillFxy+0x1acf>
cmp    %r15,%rdi
je     2bef <logDetFillFxy+0x1acf>
test   %r11d,%r11d
jle    1b53 <logDetFillFxy+0xa33>
mov    %edx,0x14(%rsp)
imul   %rcx,%r10
xor    %ebp,%ebp
xorpd  %xmm2,%xmm2
mov    0xa0(%rsp),%rdx
xor    %ebx,%ebx
mov    0x1d8(%rsp),%r13
jmp    19f0 <logDetFillFxy+0x8d0>
nopl   (%rax)
add    $0x1,%rbp
add    %r8,%rdx
cmp    %r9,%rbp
je     1dd0 <logDetFillFxy+0xcb0>
cmpq   $0x0,0x28(%rsp)
je     1a30 <logDetFillFxy+0x910>
xor    %eax,%eax
jmp    1a09 <logDetFillFxy+0x8e9>
nopl   0x0(%rax)
add    $0x2,%rax
cmp    %rax,%r14
je     1a32 <logDetFillFxy+0x912>
cmpl   $0x0,-0x4(%rsi,%rax,4)
je     1a19 <logDetFillFxy+0x8f9>
addsd  -0x8(%rdx,%rax,8),%xmm2
add    $0x1,%ebx
cmpl   $0x0,(%rsi,%rax,4)
je     1a00 <logDetFillFxy+0x8e0>
addsd  (%rdx,%rax,8),%xmm2
add    $0x1,%ebx
jmp    1a00 <logDetFillFxy+0x8e0>
nopl   0x0(%rax)
xor    %eax,%eax
test   $0x1,%r9b
je     19e0 <logDetFillFxy+0x8c0>
lea    (%rax,%r10,1),%rcx
mov    0x1e8(%rsp),%rdi
cmpl   $0x0,(%rdi,%rcx,4)
je     19e0 <logDetFillFxy+0x8c0>
mov    %rbp,%rcx
imul   0x8(%rsp),%rcx
add    %rcx,%rax
addsd  0x0(%r13,%rax,8),%xmm2
add    $0x1,%ebx
jmp    19e0 <logDetFillFxy+0x8c0>
cmp    %r15,%rdi
jne    1be3 <logDetFillFxy+0xac3>
test   %eax,%eax
jle    1750 <logDetFillFxy+0x630>
mov    %edx,0x14(%rsp)
xor    %r13d,%r13d
xorpd  %xmm2,%xmm2
mov    0x1d8(%rsp),%r10
mov    0x130(%rsp),%rax
xor    %ebx,%ebx
mov    0x1c8(%rsp),%r11d
mov    0x40(%rsp),%r15
mov    0x38(%rsp),%rbp
mov    0x70(%rsp),%rdx
jmp    1acb <logDetFillFxy+0x9ab>
nopl   0x0(%rax)
add    %r11d,%ebx
mov    0x40(%rsp),%r15
add    $0x1,%r13
add    %r8,%rax
add    %r8,%r10
cmp    %r9,%r13
je     1dd0 <logDetFillFxy+0xcb0>
mov    0x30(%rsp),%rcx
add    %r13,%rcx
mov    0x1e8(%rsp),%rdi
cmpl   $0x0,(%rdi,%rcx,4)
je     1ab8 <logDetFillFxy+0x998>
test   %r11d,%r11d
jle    1ab8 <logDetFillFxy+0x998>
cmpq   $0x3,0x28(%rsp)
jae    1b00 <logDetFillFxy+0x9e0>
xor    %ecx,%ecx
jmp    1b30 <logDetFillFxy+0xa10>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
addsd  -0x18(%rax,%rcx,8),%xmm2
addsd  -0x10(%rax,%rcx,8),%xmm2
addsd  -0x8(%rax,%rcx,8),%xmm2
addsd  (%rax,%rcx,8),%xmm2
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    1b10 <logDetFillFxy+0x9f0>
test   %rdx,%rdx
je     1ab0 <logDetFillFxy+0x990>
lea    (%r10,%rcx,8),%rcx
xor    %edi,%edi
nop
addsd  (%rcx,%rdi,8),%xmm2
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1b40 <logDetFillFxy+0xa20>
jmp    1ab0 <logDetFillFxy+0x990>
cmp    %rcx,%rdi
jl     1750 <logDetFillFxy+0x630>
cmp    0x40(%rsp),%rdi
jne    1750 <logDetFillFxy+0x630>
jmp    2bef <logDetFillFxy+0x1acf>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
mov    0x38(%rsp),%rcx
mov    0x70(%rsp),%rdx
mov    0xe8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
addsd  -0x18(%rdi,%rax,8),%xmm2
addsd  -0x10(%rdi,%rax,8),%xmm2
addsd  -0x8(%rdi,%rax,8),%xmm2
addsd  (%rdi,%rax,8),%xmm2
add    $0x4,%rax
cmp    %rax,%rcx
jne    1b90 <logDetFillFxy+0xa70>
mov    %r11d,%ebx
test   $0x3,%r9b
je     1dd0 <logDetFillFxy+0xcb0>
mov    0x78(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
addsd  (%rax,%rcx,8),%xmm2
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1bd0 <logDetFillFxy+0xab0>
jmp    1d7d <logDetFillFxy+0xc5d>
test   %eax,%eax
jle    1750 <logDetFillFxy+0x630>
mov    %edx,0x14(%rsp)
imul   0x8(%rsp),%r10
xor    %edx,%edx
xorpd  %xmm2,%xmm2
mov    0xa0(%rsp),%rbp
xor    %ebx,%ebx
mov    0x1c8(%rsp),%r11d
mov    0x1d8(%rsp),%r13
mov    0x40(%rsp),%r15
jmp    1c30 <logDetFillFxy+0xb10>
nopl   0x0(%rax)
add    $0x1,%rdx
add    %r8,%rbp
cmp    %r9,%rdx
je     1dd0 <logDetFillFxy+0xcb0>
mov    0x30(%rsp),%rax
add    %rdx,%rax
mov    0x1e8(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
je     1c20 <logDetFillFxy+0xb00>
test   %r11d,%r11d
jle    1c20 <logDetFillFxy+0xb00>
cmpq   $0x0,0x28(%rsp)
je     1c8a <logDetFillFxy+0xb6a>
xor    %eax,%eax
jmp    1c69 <logDetFillFxy+0xb49>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rax
cmp    %rax,%r14
je     1c8c <logDetFillFxy+0xb6c>
cmpl   $0x0,-0x4(%rsi,%rax,4)
je     1c79 <logDetFillFxy+0xb59>
addsd  -0x8(%rbp,%rax,8),%xmm2
add    $0x1,%ebx
cmpl   $0x0,(%rsi,%rax,4)
je     1c60 <logDetFillFxy+0xb40>
addsd  0x0(%rbp,%rax,8),%xmm2
add    $0x1,%ebx
jmp    1c60 <logDetFillFxy+0xb40>
xor    %eax,%eax
test   $0x1,%r9b
je     1c20 <logDetFillFxy+0xb00>
lea    (%rax,%r10,1),%rcx
mov    0x1e8(%rsp),%rdi
cmpl   $0x0,(%rdi,%rcx,4)
je     1c20 <logDetFillFxy+0xb00>
mov    %rdx,%rcx
imul   0x8(%rsp),%rcx
add    %rcx,%rax
addsd  0x0(%r13,%rax,8),%xmm2
add    $0x1,%ebx
jmp    1c20 <logDetFillFxy+0xb00>
xor    %edx,%edx
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
mov    0x1d8(%rsp),%rcx
test   $0x1,%r9b
je     1dd0 <logDetFillFxy+0xcb0>
imul   0x8(%rsp),%rax
add    %rdx,%rax
mov    0x1e8(%rsp),%rdi
cmpl   $0x0,(%rdi,%rax,4)
je     1dd0 <logDetFillFxy+0xcb0>
add    0x50(%rsp),%rdx
addsd  (%rcx,%rdx,8),%xmm2
jmp    1dcb <logDetFillFxy+0xcab>
mov    0x68(%rsp),%rcx
xor    %eax,%eax
mov    0x1d8(%rsp),%r10
mov    0x38(%rsp),%rdi
mov    0x138(%rsp),%rdx
mov    0x128(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
addsd  (%rcx),%xmm2
addsd  (%rcx,%r8,1),%xmm2
addsd  (%rcx,%rbx,1),%xmm2
addsd  (%rcx,%rbp,1),%xmm2
add    $0x4,%rax
add    %rdx,%rcx
cmp    %rax,%rdi
jne    1d30 <logDetFillFxy+0xc10>
mov    %r11d,%ebx
test   $0x3,%r9b
je     1dd0 <logDetFillFxy+0xcb0>
imul   0x8(%rsp),%rax
add    0x18(%rsp),%rax
lea    (%r10,%rax,8),%rax
mov    %r13,%rcx
nopl   0x0(%rax,%rax,1)
addsd  (%rax),%xmm2
add    %r8,%rax
add    $0xffffffffffffffff,%rcx
jne    1d70 <logDetFillFxy+0xc50>
mov    %r11d,%ebx
jmp    1dd0 <logDetFillFxy+0xcb0>
xor    %eax,%eax
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
mov    0x1c8(%rsp),%r11d
mov    0x1d8(%rsp),%rdi
test   $0x1,%r9b
mov    0x40(%rsp),%r15
je     1dd0 <logDetFillFxy+0xcb0>
mov    0x30(%rsp),%rcx
add    %rax,%rcx
mov    0x1e8(%rsp),%rdx
cmpl   $0x0,(%rdx,%rcx,4)
je     1dd0 <logDetFillFxy+0xcb0>
imul   0x8(%rsp),%rax
add    0x18(%rsp),%rax
addsd  (%rdi,%rax,8),%xmm2
add    $0x1,%ebx
xchg   %ax,%ax
ucomisd %xmm2,%xmm9
jbe    1e34 <logDetFillFxy+0xd14>
xorps  %xmm3,%xmm3
cvtsi2sd %ebx,%xmm3
movapd %xmm8,%xmm2
divsd  %xmm3,%xmm2
mov    0x8(%rsp),%rcx
mov    0x80(%rsp),%rax
cmp    %rcx,%rax
mov    0x18(%rsp),%rdi
mov    0x14(%rsp),%edx
jge    1e88 <logDetFillFxy+0xd68>
cmp    %r15,%rdi
jne    1fa1 <logDetFillFxy+0xe81>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
cmpl   $0x4,0x1c8(%rsp)
04
jae    26d6 <logDetFillFxy+0x15b6>
xor    %eax,%eax
jmp    27c0 <logDetFillFxy+0x16a0>
mov    0x8(%rsp),%rcx
mov    0x80(%rsp),%rax
cmp    %rcx,%rax
mov    0x18(%rsp),%rdi
mov    0x14(%rsp),%edx
jge    1f03 <logDetFillFxy+0xde3>
cmp    %r15,%rdi
jne    2022 <logDetFillFxy+0xf02>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
cmpl   $0x1,0x1c8(%rsp)
01
sete   %al
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
or     0x27(%rsp),%al
je     27e5 <logDetFillFxy+0x16c5>
xor    %ecx,%ecx
jmp    28b0 <logDetFillFxy+0x1790>
cmp    %r15,%rax
jne    2077 <logDetFillFxy+0xf57>
mov    %rdi,%rax
sub    %rcx,%rax
jge    2171 <logDetFillFxy+0x1051>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
cmpq   $0x0,0x28(%rsp)
je     2b20 <logDetFillFxy+0x1a00>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0x58(%rsp),%rdx
mov    0x90(%rsp),%rdi
mov    0x60(%rsp),%rbp
nop
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
movsd  0x0(%rbp,%rcx,1),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,1)
addsd  (%rdi,%rcx,1),%xmm0
movsd  %xmm0,(%rdi,%rcx,1)
add    $0x2,%rax
add    %rdx,%rcx
cmp    %rax,%r14
jne    1ed0 <logDetFillFxy+0xdb0>
jmp    2b22 <logDetFillFxy+0x1a02>
cmp    %r15,%rax
jne    2105 <logDetFillFxy+0xfe5>
cmp    %rcx,%rdi
jge    225a <logDetFillFxy+0x113a>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
cmpq   $0x0,0x28(%rsp)
je     2b36 <logDetFillFxy+0x1a16>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0x58(%rsp),%r10
mov    0x108(%rsp),%rdi
mov    0x90(%rsp),%rbp
mov    0x60(%rsp),%rbx
mov    0x68(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx,%rcx,1),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
addsd  (%rbx,%rcx,1),%xmm0
movsd  %xmm0,(%rbx,%rcx,1)
movsd  (%rdi,%rcx,1),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
addsd  0x0(%rbp,%rcx,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,1)
add    $0x2,%rax
add    %r10,%rcx
cmp    %rax,%r14
jne    1f60 <logDetFillFxy+0xe40>
jmp    2b38 <logDetFillFxy+0x1a18>
mov    %rdi,%rax
sub    %rcx,%rax
jl     2bef <logDetFillFxy+0x1acf>
cmpl   $0x0,0x1c8(%rsp)
jle    1750 <logDetFillFxy+0x630>
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
cmpq   $0x0,0x28(%rsp)
je     2ad9 <logDetFillFxy+0x19b9>
xor    %edx,%edx
mov    0x48(%rsp),%rcx
jmp    1fed <logDetFillFxy+0xecd>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rdx
cmp    %rdx,%r14
je     2adb <logDetFillFxy+0x19bb>
cmpl   $0x0,-0x4(%rsi,%rdx,4)
je     2006 <logDetFillFxy+0xee6>
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
cmpl   $0x0,(%rsi,%rdx,4)
je     1fe0 <logDetFillFxy+0xec0>
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
addsd  0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rdx,8)
jmp    1fe0 <logDetFillFxy+0xec0>
cmp    %rcx,%rdi
jl     2bef <logDetFillFxy+0x1acf>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
xor    %eax,%eax
jmp    204d <logDetFillFxy+0xf2d>
nop
add    $0x1,%rax
cmp    %rax,%r9
je     1750 <logDetFillFxy+0x630>
cmpl   $0x0,(%r12,%rax,4)
je     2040 <logDetFillFxy+0xf20>
mov    0x78(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
mov    0x48(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
jmp    2040 <logDetFillFxy+0xf20>
mov    %rdi,%rax
sub    %rcx,%rax
jge    22d9 <logDetFillFxy+0x11b9>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
cmpq   $0x0,0x28(%rsp)
je     2b66 <logDetFillFxy+0x1a46>
xor    %ecx,%ecx
xor    %eax,%eax
mov    0x58(%rsp),%rdx
mov    0xa8(%rsp),%rdi
mov    0x90(%rsp),%rbp
mov    0x60(%rsp),%rbx
jmp    20d0 <logDetFillFxy+0xfb0>
nop
add    $0x2,%rax
add    %rdx,%rcx
cmp    %rax,%r14
je     2b68 <logDetFillFxy+0x1a48>
cmpl   $0x0,-0x4(%rdi,%rax,4)
je     20e9 <logDetFillFxy+0xfc9>
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rbx,%rcx,1),%xmm0
movsd  %xmm0,(%rbx,%rcx,1)
cmpl   $0x0,(%rdi,%rax,4)
je     20c0 <logDetFillFxy+0xfa0>
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
addsd  0x0(%rbp,%rcx,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,1)
jmp    20c0 <logDetFillFxy+0xfa0>
cmp    %rcx,%rdi
jge    2467 <logDetFillFxy+0x1347>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
xor    %eax,%eax
xor    %ecx,%ecx
jmp    2140 <logDetFillFxy+0x1020>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
add    %r8,%rax
cmp    %rcx,%r9
je     1750 <logDetFillFxy+0x630>
mov    0xf8(%rsp),%rdx
cmpl   $0x0,(%rdx,%rcx,4)
je     2130 <logDetFillFxy+0x1010>
mov    0x68(%rsp),%rdx
movsd  (%rdx,%rax,1),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
mov    0x60(%rsp),%rdx
addsd  (%rdx,%rax,1),%xmm0
movsd  %xmm0,(%rdx,%rax,1)
jmp    2130 <logDetFillFxy+0x1010>
cmp    %r15,%rdi
je     2bef <logDetFillFxy+0x1acf>
cmpl   $0x0,0x1c8(%rsp)
jle    1750 <logDetFillFxy+0x630>
imul   0x8(%rsp),%rax
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
mov    0x98(%rsp),%rdx
xor    %ebp,%ebp
jmp    21c0 <logDetFillFxy+0x10a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    %r8,%rdx
cmp    %r9,%rbp
je     1750 <logDetFillFxy+0x630>
cmpq   $0x0,0x28(%rsp)
je     2210 <logDetFillFxy+0x10f0>
xor    %ebx,%ebx
jmp    21d9 <logDetFillFxy+0x10b9>
nopl   0x0(%rax)
add    $0x2,%rbx
cmp    %rbx,%r14
je     2212 <logDetFillFxy+0x10f2>
cmpl   $0x0,-0x4(%rsi,%rbx,4)
je     21f4 <logDetFillFxy+0x10d4>
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
addsd  -0x8(%rdx,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rbx,8)
cmpl   $0x0,(%rsi,%rbx,4)
je     21d0 <logDetFillFxy+0x10b0>
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
jmp    21d0 <logDetFillFxy+0x10b0>
xchg   %ax,%ax
xor    %ebx,%ebx
test   $0x1,%r9b
je     21b0 <logDetFillFxy+0x1090>
lea    (%rbx,%rax,1),%rcx
mov    0x1e8(%rsp),%rdi
cmpl   $0x0,(%rdi,%rcx,4)
mov    0x18(%rsp),%rdi
je     21b0 <logDetFillFxy+0x1090>
mov    %rbp,%rcx
imul   0x8(%rsp),%rcx
add    %rcx,%rbx
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
mov    0x1e0(%rsp),%rcx
addsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
jmp    21b0 <logDetFillFxy+0x1090>
cmp    %r15,%rdi
je     2bef <logDetFillFxy+0x1acf>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
cvtsi2sd %edx,%xmm3
mov    0x1e0(%rsp),%rax
mov    0x1d8(%rsp),%rdx
xor    %ebp,%ebp
jmp    22a3 <logDetFillFxy+0x1183>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
add    %r8,%rdx
add    %r8,%rax
cmp    %r9,%rbp
je     1750 <logDetFillFxy+0x630>
xor    %ecx,%ecx
jmp    22b9 <logDetFillFxy+0x1199>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rcx,%r9
je     2290 <logDetFillFxy+0x1170>
cmpl   $0x0,(%r12,%rcx,4)
je     22b0 <logDetFillFxy+0x1190>
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    22b0 <logDetFillFxy+0x1190>
cmp    %r15,%rdi
jne    294c <logDetFillFxy+0x182c>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
movapd %xmm3,%xmm10
unpcklpd %xmm3,%xmm10
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
mov    0x1e0(%rsp),%rdx
mov    0x110(%rsp),%rbp
xor    %ebx,%ebx
jmp    2333 <logDetFillFxy+0x1213>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    %r8,%rbp
add    %r8,%rdx
cmp    %r9,%rbx
je     1750 <logDetFillFxy+0x630>
mov    0x30(%rsp),%rax
add    %rbx,%rax
mov    0x1e8(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
mov    0x1c8(%rsp),%eax
je     2320 <logDetFillFxy+0x1200>
test   %eax,%eax
jle    2320 <logDetFillFxy+0x1200>
cmp    $0x4,%eax
jae    2360 <logDetFillFxy+0x1240>
xor    %eax,%eax
jmp    2430 <logDetFillFxy+0x1310>
cmpq   $0x0,0xe0(%rsp)
je     2450 <logDetFillFxy+0x1330>
mov    0xd0(%rsp),%rcx
xor    %eax,%eax
mov    0x38(%rsp),%rdi
xchg   %ax,%ax
movapd %xmm10,%xmm0
mulpd  %xmm5,%xmm0
movupd -0x30(%rbp,%rax,8),%xmm1
movupd -0x20(%rbp,%rax,8),%xmm6
movupd -0x10(%rbp,%rax,8),%xmm7
movupd 0x0(%rbp,%rax,8),%xmm4
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm6
movupd %xmm1,-0x30(%rbp,%rax,8)
movupd %xmm6,-0x20(%rbp,%rax,8)
addpd  %xmm0,%xmm7
addpd  %xmm0,%xmm4
movupd %xmm7,-0x10(%rbp,%rax,8)
movupd %xmm4,0x0(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2380 <logDetFillFxy+0x1260>
testb  $0x1,0xd8(%rsp)
01
je     2418 <logDetFillFxy+0x12f8>
mov    %rbx,%rcx
imul   0x8(%rsp),%rcx
add    %rcx,%rax
mov    0x1e0(%rsp),%rcx
movupd (%rcx,%rax,8),%xmm0
movupd 0x10(%rcx,%rax,8),%xmm1
movapd %xmm10,%xmm4
mulpd  %xmm5,%xmm4
addpd  %xmm4,%xmm0
addpd  %xmm1,%xmm4
movupd %xmm0,(%rcx,%rax,8)
movupd %xmm4,0x10(%rcx,%rax,8)
mov    %rdi,%rax
cmp    %r9,%rdi
mov    0x18(%rsp),%rdi
je     2320 <logDetFillFxy+0x1200>
nopl   0x0(%rax)
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    2430 <logDetFillFxy+0x1310>
jmp    2320 <logDetFillFxy+0x1200>
xor    %eax,%eax
mov    0x38(%rsp),%rdi
testb  $0x1,0xd8(%rsp)
01
jne    23dd <logDetFillFxy+0x12bd>
jmp    2418 <logDetFillFxy+0x12f8>
cmp    %r15,%rdi
jne    2a4b <logDetFillFxy+0x192b>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
cvtsi2sd %edx,%xmm3
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
mov    0x98(%rsp),%rbx
mov    0xa0(%rsp),%r10
mov    0x118(%rsp),%r13
mov    0x120(%rsp),%r15
xor    %r11d,%r11d
jmp    24d9 <logDetFillFxy+0x13b9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r11
add    %r8,%r15
add    %r8,%r13
add    %r8,%r10
add    %r8,%rbx
cmp    %r9,%r11
je     1750 <logDetFillFxy+0x630>
mov    0x30(%rsp),%rax
add    %r11,%rax
mov    0x1e8(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
je     24c0 <logDetFillFxy+0x13a0>
cmpl   $0x0,0x1c8(%rsp)
jle    24c0 <logDetFillFxy+0x13a0>
mov    %r11,%rax
imul   0x8(%rsp),%rax
cmpl   $0x2,0x1c8(%rsp)
02
jae    2520 <logDetFillFxy+0x1400>
xor    %ecx,%ecx
jmp    2630 <logDetFillFxy+0x1510>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x1e0(%rsp),%rbp
lea    0x0(,%rax,8),%rdx
add    %rbp,%rdx
lea    (%rax,%r9,1),%rcx
mov    0x1d8(%rsp),%rbp
lea    0x0(,%rcx,8),%rdi
add    %rbp,%rdi
cmp    %rdi,%rdx
mov    0x1e0(%rsp),%rdi
jae    2577 <logDetFillFxy+0x1457>
lea    (%rdi,%rcx,8),%rcx
lea    0x0(,%rax,8),%rdx
add    %rbp,%rdx
cmp    %rcx,%rdx
jae    2577 <logDetFillFxy+0x1457>
xor    %ecx,%ecx
mov    0x18(%rsp),%rdi
jmp    2630 <logDetFillFxy+0x1510>
mov    %rdi,%rbp
cmpq   $0x0,0xc8(%rsp)
mov    0x18(%rsp),%rdi
je     26c1 <logDetFillFxy+0x15a1>
mov    0xb8(%rsp),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r13,%rdx,8),%xmm0
mulpd  %xmm4,%xmm0
divpd  %xmm5,%xmm0
movupd -0x10(%r15,%rdx,8),%xmm1
addpd  %xmm0,%xmm1
movupd (%r15,%rdx,8),%xmm0
movupd %xmm1,-0x10(%r15,%rdx,8)
movupd 0x0(%r13,%rdx,8),%xmm1
mulpd  %xmm4,%xmm1
divpd  %xmm5,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%r15,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rcx
jne    25a0 <logDetFillFxy+0x1480>
testb  $0x1,0xc0(%rsp)
01
je     261c <logDetFillFxy+0x14fc>
add    %rax,%rdx
mov    0x1d8(%rsp),%rcx
movupd (%rcx,%rdx,8),%xmm0
mulpd  %xmm4,%xmm0
divpd  %xmm5,%xmm0
movupd 0x0(%rbp,%rdx,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x0(%rbp,%rdx,8)
mov    %r14,%rcx
cmp    %r9,%r14
je     24c0 <logDetFillFxy+0x13a0>
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rdx
test   $0x1,%r9b
je     266a <logDetFillFxy+0x154a>
add    %rcx,%rax
mov    0x1d8(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
mov    0x1e0(%rsp),%rdx
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
mov    %rcx,%rdx
or     $0x1,%rdx
not    %rcx
cmp    0xf0(%rsp),%rcx
je     24c0 <logDetFillFxy+0x13a0>
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r10,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
addsd  -0x8(%rbx,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rdx,8)
movsd  (%r10,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
addsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r9
jne    2680 <logDetFillFxy+0x1560>
jmp    24c0 <logDetFillFxy+0x13a0>
xor    %edx,%edx
testb  $0x1,0xc0(%rsp)
01
jne    25f4 <logDetFillFxy+0x14d4>
jmp    261c <logDetFillFxy+0x14fc>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
movapd %xmm2,%xmm10
unpcklpd %xmm2,%xmm10
cmpq   $0x0,0xe0(%rsp)
je     2b96 <logDetFillFxy+0x1a76>
mov    0xd0(%rsp),%rcx
xor    %eax,%eax
mov    0x1e0(%rsp),%rdx
mov    0x38(%rsp),%rdi
mov    0x48(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm4,%xmm6
mulpd  %xmm10,%xmm6
movupd 0x0(%rbp,%rax,8),%xmm7
movupd 0x10(%rbp,%rax,8),%xmm1
movupd 0x20(%rbp,%rax,8),%xmm0
movupd 0x30(%rbp,%rax,8),%xmm5
addpd  %xmm6,%xmm7
addpd  %xmm6,%xmm1
movupd %xmm7,0x0(%rbp,%rax,8)
movupd %xmm1,0x10(%rbp,%rax,8)
addpd  %xmm6,%xmm0
addpd  %xmm6,%xmm5
movupd %xmm0,0x20(%rbp,%rax,8)
movupd %xmm5,0x30(%rbp,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2720 <logDetFillFxy+0x1600>
testb  $0x1,0xd8(%rsp)
01
je     27a5 <logDetFillFxy+0x1685>
add    0x50(%rsp),%rax
movupd (%rdx,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
mulpd  %xmm10,%xmm4
addpd  %xmm4,%xmm0
addpd  %xmm1,%xmm4
movupd %xmm0,(%rdx,%rax,8)
movupd %xmm4,0x10(%rdx,%rax,8)
mov    %rdi,%rax
cmp    %r9,%rdi
mov    0x18(%rsp),%rdi
je     1750 <logDetFillFxy+0x630>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
mov    0x48(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    27c0 <logDetFillFxy+0x16a0>
jmp    1750 <logDetFillFxy+0x630>
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
cmpq   $0x0,0xc8(%rsp)
je     2bb8 <logDetFillFxy+0x1a98>
mov    0xb8(%rsp),%rcx
xor    %eax,%eax
mov    0x1e0(%rsp),%rdx
mov    0x1d8(%rsp),%rdi
mov    0x48(%rsp),%rbp
mov    0x78(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm0
mulpd  %xmm4,%xmm0
divpd  %xmm5,%xmm0
movupd 0x0(%rbp,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movupd 0x10(%rbp,%rax,8),%xmm0
movupd %xmm1,0x0(%rbp,%rax,8)
movupd 0x10(%rbx,%rax,8),%xmm1
mulpd  %xmm4,%xmm1
divpd  %xmm5,%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,0x10(%rbp,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rcx
jne    2830 <logDetFillFxy+0x1710>
testb  $0x1,0xc0(%rsp)
01
je     289f <logDetFillFxy+0x177f>
add    0x50(%rsp),%rax
movupd (%rdi,%rax,8),%xmm0
mulpd  %xmm4,%xmm0
divpd  %xmm5,%xmm0
movupd (%rdx,%rax,8),%xmm1
addpd  %xmm0,%xmm1
movupd %xmm1,(%rdx,%rax,8)
mov    %r14,%rcx
cmp    %r9,%r14
mov    0x18(%rsp),%rdi
je     1750 <logDetFillFxy+0x630>
mov    %rcx,%rax
test   $0x1,%r9b
je     28ef <logDetFillFxy+0x17cf>
mov    0x50(%rsp),%rax
add    %rcx,%rax
mov    0x1d8(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
mov    0x1e0(%rsp),%rdx
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rax,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xf0(%rsp),%rcx
je     1750 <logDetFillFxy+0x630>
mov    0xb0(%rsp),%rdx
movsd  -0x8(%rdx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
mov    0x48(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
addsd  0x8(%rcx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r9
jne    2900 <logDetFillFxy+0x17e0>
jmp    1750 <logDetFillFxy+0x630>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
imul   0x8(%rsp),%rax
xorps  %xmm3,%xmm3
cvtsi2sd %edx,%xmm3
mov    0x98(%rsp),%rdx
xor    %ebp,%ebp
jmp    2985 <logDetFillFxy+0x1865>
xchg   %ax,%ax
add    $0x1,%rbp
add    %r8,%rdx
cmp    %r9,%rbp
mov    0x18(%rsp),%rdi
je     1750 <logDetFillFxy+0x630>
mov    0x30(%rsp),%rcx
add    %rbp,%rcx
mov    0x1e8(%rsp),%rdi
cmpl   $0x0,(%rdi,%rcx,4)
mov    0x1c8(%rsp),%ecx
je     2970 <logDetFillFxy+0x1850>
test   %ecx,%ecx
jle    2970 <logDetFillFxy+0x1850>
cmpq   $0x0,0x28(%rsp)
je     29fe <logDetFillFxy+0x18de>
xor    %ebx,%ebx
jmp    29c9 <logDetFillFxy+0x18a9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x2,%rbx
cmp    %rbx,%r14
je     2a00 <logDetFillFxy+0x18e0>
cmpl   $0x0,-0x4(%rsi,%rbx,4)
je     29e4 <logDetFillFxy+0x18c4>
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
addsd  -0x8(%rdx,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%rdx,%rbx,8)
cmpl   $0x0,(%rsi,%rbx,4)
je     29c0 <logDetFillFxy+0x18a0>
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,(%rdx,%rbx,8)
jmp    29c0 <logDetFillFxy+0x18a0>
xor    %ebx,%ebx
test   $0x1,%r9b
je     2970 <logDetFillFxy+0x1850>
lea    (%rbx,%rax,1),%rcx
mov    0x1e8(%rsp),%rdi
cmpl   $0x0,(%rdi,%rcx,4)
je     2970 <logDetFillFxy+0x1850>
mov    %rbp,%rcx
imul   0x8(%rsp),%rcx
add    %rcx,%rbx
movapd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
mov    0x1e0(%rsp),%rcx
addsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,8)
jmp    2970 <logDetFillFxy+0x1850>
test   %r11d,%r11d
jle    1750 <logDetFillFxy+0x630>
cvtsi2sd %edx,%xmm3
mov    0x1e0(%rsp),%rax
mov    0x1d8(%rsp),%rdx
xor    %ebp,%ebp
jmp    2a88 <logDetFillFxy+0x1968>
nopl   0x0(%rax)
add    $0x1,%rbp
add    %r8,%rdx
add    %r8,%rax
cmp    %r9,%rbp
mov    0x18(%rsp),%rdi
je     1750 <logDetFillFxy+0x630>
mov    0x30(%rsp),%rcx
add    %rbp,%rcx
mov    0x1e8(%rsp),%rdi
cmpl   $0x0,(%rdi,%rcx,4)
mov    0x1c8(%rsp),%ecx
je     2a70 <logDetFillFxy+0x1950>
test   %ecx,%ecx
jle    2a70 <logDetFillFxy+0x1950>
xor    %ecx,%ecx
jmp    2ab9 <logDetFillFxy+0x1999>
nopl   (%rax)
add    $0x1,%rcx
cmp    %rcx,%r9
je     2a70 <logDetFillFxy+0x1950>
cmpl   $0x0,(%r12,%rcx,4)
je     2ab0 <logDetFillFxy+0x1990>
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm3,%xmm0
divsd  %xmm2,%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    2ab0 <logDetFillFxy+0x1990>
xor    %edx,%edx
test   $0x1,%r9b
je     1750 <logDetFillFxy+0x630>
imul   0x8(%rsp),%rax
add    %rdx,%rax
mov    0x1e8(%rsp),%rcx
cmpl   $0x0,(%rcx,%rax,4)
je     1750 <logDetFillFxy+0x630>
add    0x50(%rsp),%rdx
mulsd  %xmm2,%xmm3
mov    0x1e0(%rsp),%rax
addsd  (%rax,%rdx,8),%xmm3
movsd  %xmm3,(%rax,%rdx,8)
jmp    1750 <logDetFillFxy+0x630>
xor    %eax,%eax
test   $0x1,%r9b
mov    0x18(%rsp),%rdi
jne    172e <logDetFillFxy+0x60e>
jmp    1750 <logDetFillFxy+0x630>
xor    %eax,%eax
test   $0x1,%r9b
mov    0x18(%rsp),%rdi
je     1750 <logDetFillFxy+0x630>
imul   0x8(%rsp),%rax
add    %rdi,%rax
mov    0x1d8(%rsp),%rcx
mulsd  (%rcx,%rax,8),%xmm3
divsd  %xmm2,%xmm3
jmp    173b <logDetFillFxy+0x61b>
xor    %eax,%eax
test   $0x1,%r9b
mov    0x18(%rsp),%rdi
je     1750 <logDetFillFxy+0x630>
mov    0x30(%rsp),%rcx
add    %rax,%rcx
mov    0x1e8(%rsp),%rdx
cmpl   $0x0,(%rdx,%rcx,4)
jne    172e <logDetFillFxy+0x60e>
jmp    1750 <logDetFillFxy+0x630>
xor    %eax,%eax
mov    0x1e0(%rsp),%rdx
mov    0x38(%rsp),%rdi
testb  $0x1,0xd8(%rsp)
01
jne    277d <logDetFillFxy+0x165d>
jmp    27a5 <logDetFillFxy+0x1685>
xor    %eax,%eax
mov    0x1e0(%rsp),%rdx
mov    0x1d8(%rsp),%rdi
testb  $0x1,0xc0(%rsp)
01
jne    287f <logDetFillFxy+0x175f>
jmp    289f <logDetFillFxy+0x177f>
add    $0x168,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x442(%rip),%rdi
call   1030 <puts@plt>
xor    %edi,%edi
call   1040 <exit@plt>
lea    0x446(%rip),%rdi
jmp    2bf6 <logDetFillFxy+0x1ad6>
lea    0x3fe(%rip),%rdi
jmp    2bf6 <logDetFillFxy+0x1ad6>

LLVM IR (-O0):
@.str = [18 x i8] c"problem with Fxy\0A\00"
@.str.1 = [41 x i8] c"logDetFillFxy(). No unambiguous chars.\0A\00"
@.str.2 = [24 x i8] c"error in logDetFillFxy\0A\00"
define void @logDetFillFxy(i32* %0, i32* %1, i32* %2, i8* %3, i32 %4, i32 %5, i32* %6, i32* %7, i32* %8, i32 %9, i32 %10, i32 %11, i32 %12, double* %13, double* %14, i32* %15) {
%17 = alloca i32*
%18 = alloca i32*
%19 = alloca i32*
%20 = alloca i8*
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32*
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca double*
%31 = alloca double*
%32 = alloca i32*
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca double
%44 = alloca double
%45 = alloca double
%46 = alloca i32
store i32* %0, i32** %17
store i32* %1, i32** %18
store i32* %2, i32** %19
store i8* %3, i8** %20
store i32 %4, i32* %21
store i32 %5, i32* %22
store i32* %6, i32** %23
store i32* %7, i32** %24
store i32* %8, i32** %25
store i32 %9, i32* %26
store i32 %10, i32* %27
store i32 %11, i32* %28
store i32 %12, i32* %29
store double* %13, double** %30
store double* %14, double** %31
store i32* %15, i32** %32
%47 = load i32, i32* %28
%48 = load i32, i32* %28
%49 = mul nsw i32 %47, %48
store i32 %49, i32* %46
%50 = load i32*, i32** %17
%51 = getelementptr inbounds i32, i32* %50, i64 0
store i32 0, i32* %51
%52 = load i32*, i32** %18
%53 = getelementptr inbounds i32, i32* %52, i64 0
store i32 0, i32* %53
%54 = load i32*, i32** %19
%55 = getelementptr inbounds i32, i32* %54, i64 0
store i32 0, i32* %55
store i32 0, i32* %33
br label %56
56: ; preds = %167, %16
%57 = load i32, i32* %33
%58 = load i32, i32* %27
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %170
60: ; preds = %56
%61 = load i8*, i8** %20
%62 = load i32, i32* %21
%63 = load i32, i32* %27
%64 = mul nsw i32 %62, %63
%65 = load i32, i32* %33
%66 = add nsw i32 %64, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i8, i8* %61, i64 %67
%69 = load i8, i8* %68
%70 = sext i8 %69 to i32
store i32 %70, i32* %37
%71 = load i8*, i8** %20
%72 = load i32, i32* %22
%73 = load i32, i32* %27
%74 = mul nsw i32 %72, %73
%75 = load i32, i32* %33
%76 = add nsw i32 %74, %75
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %71, i64 %77
%79 = load i8, i8* %78
%80 = sext i8 %79 to i32
store i32 %80, i32* %38
%81 = load i32, i32* %37
%82 = icmp sge i32 %81, 0
br i1 %82, label %83, label %101
83: ; preds = %60
%84 = load i32, i32* %38
%85 = icmp sge i32 %84, 0
br i1 %85, label %86, label %101
86: ; preds = %83
%87 = load i32*, i32** %23
%88 = load i32, i32* %37
%89 = load i32, i32* %28
%90 = mul nsw i32 %88, %89
%91 = load i32, i32* %38
%92 = add nsw i32 %90, %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32, i32* %87, i64 %93
%95 = load i32, i32* %94
%96 = add nsw i32 %95, 1
store i32 %96, i32* %94
%97 = load i32*, i32** %17
%98 = getelementptr inbounds i32, i32* %97, i64 0
%99 = load i32, i32* %98
%100 = add nsw i32 %99, 1
store i32 %100, i32* %98
br label %166
101: ; preds = %83, %60
%102 = load i32, i32* %37
%103 = icmp eq i32 %102, -3
br i1 %103, label %104, label %112
104: ; preds = %101
%105 = load i32, i32* %38
%106 = icmp eq i32 %105, -3
br i1 %106, label %107, label %112
107: ; preds = %104
%108 = load i32*, i32** %19
%109 = getelementptr inbounds i32, i32* %108, i64 0
%110 = load i32, i32* %109
%111 = add nsw i32 %110, 1
store i32 %111, i32* %109
br label %165
112: ; preds = %104, %101
store i32 0, i32* %39
store i32 0, i32* %40
store i32 0, i32* %36
br label %113
113: ; preds = %128, %112
%114 = load i32, i32* %36
%115 = load i32, i32* %29
%116 = icmp slt i32 %114, %115
br i1 %116, label %117, label %131
117: ; preds = %113
%118 = load i32*, i32** %25
%119 = load i32, i32* %36
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32, i32* %118, i64 %120
%122 = load i32, i32* %121
%123 = load i32, i32* %37
%124 = icmp eq i32 %122, %123
br i1 %124, label %125, label %127
125: ; preds = %117
%126 = load i32, i32* %36
store i32 %126, i32* %39
br label %131
127: ; preds = %117
br label %128
128: ; preds = %127
%129 = load i32, i32* %36
%130 = add nsw i32 %129, 1
store i32 %130, i32* %36
br label %113
131: ; preds = %125, %113
store i32 0, i32* %36
br label %132
132: ; preds = %147, %131
%133 = load i32, i32* %36
%134 = load i32, i32* %29
%135 = icmp slt i32 %133, %134
br i1 %135, label %136, label %150
136: ; preds = %132
%137 = load i32*, i32** %25
%138 = load i32, i32* %36
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i32, i32* %137, i64 %139
%141 = load i32, i32* %140
%142 = load i32, i32* %38
%143 = icmp eq i32 %141, %142
br i1 %143, label %144, label %146
144: ; preds = %136
%145 = load i32, i32* %36
store i32 %145, i32* %40
br label %150
146: ; preds = %136
br label %147
147: ; preds = %146
%148 = load i32, i32* %36
%149 = add nsw i32 %148, 1
store i32 %149, i32* %36
br label %132
150: ; preds = %144, %132
%151 = load i32*, i32** %24
%152 = load i32, i32* %39
%153 = load i32, i32* %29
%154 = mul nsw i32 %152, %153
%155 = load i32, i32* %40
%156 = add nsw i32 %154, %155
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i32, i32* %151, i64 %157
%159 = load i32, i32* %158
%160 = add nsw i32 %159, 1
store i32 %160, i32* %158
%161 = load i32*, i32** %18
%162 = getelementptr inbounds i32, i32* %161, i64 0
%163 = load i32, i32* %162
%164 = add nsw i32 %163, 1
store i32 %164, i32* %162
br label %165
165: ; preds = %150, %107
br label %166
166: ; preds = %165, %86
br label %167
167: ; preds = %166
%168 = load i32, i32* %33
%169 = add nsw i32 %168, 1
store i32 %169, i32* %33
br label %56
170: ; preds = %56
%171 = load i32*, i32** %18
%172 = getelementptr inbounds i32, i32* %171, i64 0
%173 = load i32, i32* %172
%174 = load i32*, i32** %17
%175 = getelementptr inbounds i32, i32* %174, i64 0
%176 = load i32, i32* %175
%177 = add nsw i32 %173, %176
%178 = load i32*, i32** %19
%179 = getelementptr inbounds i32, i32* %178, i64 0
%180 = load i32, i32* %179
%181 = add nsw i32 %177, %180
%182 = load i32, i32* %27
%183 = icmp ne i32 %181, %182
br i1 %183, label %184, label %186
184: ; preds = %170
%185 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0))
unreachable
186: ; preds = %170
%187 = load i32*, i32** %17
%188 = getelementptr inbounds i32, i32* %187, i64 0
%189 = load i32, i32* %188
%190 = icmp ne i32 %189, 0
br i1 %190, label %193, label %191
191: ; preds = %186
%192 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.1, i64 0, i64 0))
unreachable
193: ; preds = %186
%194 = load i32*, i32** %17
%195 = getelementptr inbounds i32, i32* %194, i64 0
%196 = load i32, i32* %195
%197 = sitofp i32 %196 to double
store double %197, double* %43
store i32 0, i32* %33
br label %198
198: ; preds = %215, %193
%199 = load i32, i32* %33
%200 = load i32, i32* %46
%201 = icmp slt i32 %199, %200
br i1 %201, label %202, label %218
202: ; preds = %198
%203 = load i32*, i32** %23
%204 = load i32, i32* %33
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i32, i32* %203, i64 %205
%207 = load i32, i32* %206
%208 = sitofp i32 %207 to double
%209 = load double, double* %43
%210 = fdiv double %208, %209
%211 = load double*, double** %30
%212 = load i32, i32* %33
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %211, i64 %213
store double %210, double* %214
br label %215
215: ; preds = %202
%216 = load i32, i32* %33
%217 = add nsw i32 %216, 1
store i32 %217, i32* %33
br label %198
218: ; preds = %198
store i32 0, i32* %33
br label %219
219: ; preds = %234, %218
%220 = load i32, i32* %33
%221 = load i32, i32* %46
%222 = icmp slt i32 %220, %221
br i1 %222, label %223, label %237
223: ; preds = %219
%224 = load i32*, i32** %23
%225 = load i32, i32* %33
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds i32, i32* %224, i64 %226
%228 = load i32, i32* %227
%229 = sitofp i32 %228 to double
%230 = load double*, double** %31
%231 = load i32, i32* %33
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds double, double* %230, i64 %232
store double %229, double* %233
br label %234
234: ; preds = %223
%235 = load i32, i32* %33
%236 = add nsw i32 %235, 1
store i32 %236, i32* %33
br label %219
237: ; preds = %219
%238 = load i32*, i32** %18
%239 = getelementptr inbounds i32, i32* %238, i64 0
%240 = load i32, i32* %239
%241 = icmp ne i32 %240, 0
br i1 %241, label %242, label %1316
242: ; preds = %237
store i32 0, i32* %33
br label %243
243: ; preds = %1312, %242
%244 = load i32, i32* %33
%245 = load i32, i32* %29
%246 = icmp slt i32 %244, %245
br i1 %246, label %247, label %1315
247: ; preds = %243
store i32 0, i32* %34
br label %248
248: ; preds = %1308, %247
%249 = load i32, i32* %34
%250 = load i32, i32* %29
%251 = icmp slt i32 %249, %250
br i1 %251, label %252, label %1311
252: ; preds = %248
%253 = load i32*, i32** %24
%254 = load i32, i32* %29
%255 = load i32, i32* %33
%256 = mul nsw i32 %254, %255
%257 = load i32, i32* %34
%258 = add nsw i32 %256, %257
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i32, i32* %253, i64 %259
%261 = load i32, i32* %260
store i32 %261, i32* %41
%262 = load i32, i32* %41
%263 = icmp ne i32 %262, 0
br i1 %263, label %264, label %1307
264: ; preds = %252
store double 0.000000e+00, double* %44
store i32 0, i32* %42
%265 = load i32, i32* %33
%266 = load i32, i32* %28
%267 = icmp slt i32 %265, %266
br i1 %267, label %268, label %341
268: ; preds = %264
%269 = load i32, i32* %34
%270 = load i32, i32* %29
%271 = sub nsw i32 %270, 1
%272 = icmp eq i32 %269, %271
br i1 %272, label %273, label %296
273: ; preds = %268
store i32 0, i32* %36
br label %274
274: ; preds = %292, %273
%275 = load i32, i32* %36
%276 = load i32, i32* %28
%277 = icmp slt i32 %275, %276
br i1 %277, label %278, label %295
278: ; preds = %274
%279 = load double*, double** %30
%280 = load i32, i32* %28
%281 = load i32, i32* %33
%282 = mul nsw i32 %280, %281
%283 = load i32, i32* %36
%284 = add nsw i32 %282, %283
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds double, double* %279, i64 %285
%287 = load double, double* %286
%288 = load double, double* %44
%289 = fadd double %288, %287
store double %289, double* %44
%290 = load i32, i32* %42
%291 = add nsw i32 %290, 1
store i32 %291, i32* %42
br label %292
292: ; preds = %278
%293 = load i32, i32* %36
%294 = add nsw i32 %293, 1
store i32 %294, i32* %36
br label %274
295: ; preds = %274
br label %340
296: ; preds = %268
%297 = load i32, i32* %34
%298 = load i32, i32* %28
%299 = icmp sge i32 %297, %298
br i1 %299, label %300, label %337
300: ; preds = %296
store i32 0, i32* %36
br label %301
301: ; preds = %333, %300
%302 = load i32, i32* %36
%303 = load i32, i32* %28
%304 = icmp slt i32 %302, %303
br i1 %304, label %305, label %336
305: ; preds = %301
%306 = load i32*, i32** %32
%307 = load i32, i32* %28
%308 = load i32, i32* %34
%309 = load i32, i32* %28
%310 = sub nsw i32 %308, %309
%311 = mul nsw i32 %307, %310
%312 = load i32, i32* %36
%313 = add nsw i32 %311, %312
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i32, i32* %306, i64 %314
%316 = load i32, i32* %315
%317 = icmp ne i32 %316, 0
br i1 %317, label %318, label %332
318: ; preds = %305
%319 = load double*, double** %30
%320 = load i32, i32* %28
%321 = load i32, i32* %33
%322 = mul nsw i32 %320, %321
%323 = load i32, i32* %36
%324 = add nsw i32 %322, %323
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds double, double* %319, i64 %325
%327 = load double, double* %326
%328 = load double, double* %44
%329 = fadd double %328, %327
store double %329, double* %44
%330 = load i32, i32* %42
%331 = add nsw i32 %330, 1
store i32 %331, i32* %42
br label %332
332: ; preds = %318, %305
br label %333
333: ; preds = %332
%334 = load i32, i32* %36
%335 = add nsw i32 %334, 1
store i32 %335, i32* %36
br label %301
336: ; preds = %301
br label %339
337: ; preds = %296
%338 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0))
unreachable
339: ; preds = %336
br label %340
340: ; preds = %339, %295
br label %583
341: ; preds = %264
%342 = load i32, i32* %33
%343 = load i32, i32* %29
%344 = sub nsw i32 %343, 1
%345 = icmp eq i32 %342, %344
br i1 %345, label %346, label %428
346: ; preds = %341
%347 = load i32, i32* %34
%348 = load i32, i32* %28
%349 = icmp slt i32 %347, %348
br i1 %349, label %350, label %373
350: ; preds = %346
store i32 0, i32* %35
br label %351
351: ; preds = %369, %350
%352 = load i32, i32* %35
%353 = load i32, i32* %28
%354 = icmp slt i32 %352, %353
br i1 %354, label %355, label %372
355: ; preds = %351
%356 = load double*, double** %30
%357 = load i32, i32* %28
%358 = load i32, i32* %35
%359 = mul nsw i32 %357, %358
%360 = load i32, i32* %34
%361 = add nsw i32 %359, %360
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds double, double* %356, i64 %362
%364 = load double, double* %363
%365 = load double, double* %44
%366 = fadd double %365, %364
store double %366, double* %44
%367 = load i32, i32* %42
%368 = add nsw i32 %367, 1
store i32 %368, i32* %42
br label %369
369: ; preds = %355
%370 = load i32, i32* %35
%371 = add nsw i32 %370, 1
store i32 %371, i32* %35
br label %351
372: ; preds = %351
br label %427
373: ; preds = %346
%374 = load i32, i32* %34
%375 = load i32, i32* %29
%376 = sub nsw i32 %375, 1
%377 = icmp eq i32 %374, %376
br i1 %377, label %378, label %380
378: ; preds = %373
%379 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0))
unreachable
380: ; preds = %373
store i32 0, i32* %35
br label %381
381: ; preds = %422, %380
%382 = load i32, i32* %35
%383 = load i32, i32* %28
%384 = icmp slt i32 %382, %383
br i1 %384, label %385, label %425
385: ; preds = %381
store i32 0, i32* %36
br label %386
386: ; preds = %418, %385
%387 = load i32, i32* %36
%388 = load i32, i32* %28
%389 = icmp slt i32 %387, %388
br i1 %389, label %390, label %421
390: ; preds = %386
%391 = load i32*, i32** %32
%392 = load i32, i32* %28
%393 = load i32, i32* %34
%394 = load i32, i32* %28
%395 = sub nsw i32 %393, %394
%396 = mul nsw i32 %392, %395
%397 = load i32, i32* %36
%398 = add nsw i32 %396, %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds i32, i32* %391, i64 %399
%401 = load i32, i32* %400
%402 = icmp ne i32 %401, 0
br i1 %402, label %403, label %417
403: ; preds = %390
%404 = load double*, double** %30
%405 = load i32, i32* %28
%406 = load i32, i32* %35
%407 = mul nsw i32 %405, %406
%408 = load i32, i32* %36
%409 = add nsw i32 %407, %408
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds double, double* %404, i64 %410
%412 = load double, double* %411
%413 = load double, double* %44
%414 = fadd double %413, %412
store double %414, double* %44
%415 = load i32, i32* %42
%416 = add nsw i32 %415, 1
store i32 %416, i32* %42
br label %417
417: ; preds = %403, %390
br label %418
418: ; preds = %417
%419 = load i32, i32* %36
%420 = add nsw i32 %419, 1
store i32 %420, i32* %36
br label %386
421: ; preds = %386
br label %422
422: ; preds = %421
%423 = load i32, i32* %35
%424 = add nsw i32 %423, 1
store i32 %424, i32* %35
br label %381
425: ; preds = %381
br label %426
426: ; preds = %425
br label %427
427: ; preds = %426, %372
br label %582
428: ; preds = %341
%429 = load i32, i32* %34
%430 = load i32, i32* %28
%431 = icmp slt i32 %429, %430
br i1 %431, label %432, label %469
432: ; preds = %428
store i32 0, i32* %35
br label %433
433: ; preds = %465, %432
%434 = load i32, i32* %35
%435 = load i32, i32* %28
%436 = icmp slt i32 %434, %435
br i1 %436, label %437, label %468
437: ; preds = %433
%438 = load i32*, i32** %32
%439 = load i32, i32* %28
%440 = load i32, i32* %33
%441 = load i32, i32* %28
%442 = sub nsw i32 %440, %441
%443 = mul nsw i32 %439, %442
%444 = load i32, i32* %35
%445 = add nsw i32 %443, %444
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i32, i32* %438, i64 %446
%448 = load i32, i32* %447
%449 = icmp ne i32 %448, 0
br i1 %449, label %450, label %464
450: ; preds = %437
%451 = load double*, double** %30
%452 = load i32, i32* %28
%453 = load i32, i32* %35
%454 = mul nsw i32 %452, %453
%455 = load i32, i32* %34
%456 = add nsw i32 %454, %455
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds double, double* %451, i64 %457
%459 = load double, double* %458
%460 = load double, double* %44
%461 = fadd double %460, %459
store double %461, double* %44
%462 = load i32, i32* %42
%463 = add nsw i32 %462, 1
store i32 %463, i32* %42
br label %464
464: ; preds = %450, %437
br label %465
465: ; preds = %464
%466 = load i32, i32* %35
%467 = add nsw i32 %466, 1
store i32 %467, i32* %35
br label %433
468: ; preds = %433
br label %581
469: ; preds = %428
%470 = load i32, i32* %34
%471 = load i32, i32* %29
%472 = sub nsw i32 %471, 1
%473 = icmp eq i32 %470, %472
br i1 %473, label %474, label %520
474: ; preds = %469
store i32 0, i32* %35
br label %475
475: ; preds = %516, %474
%476 = load i32, i32* %35
%477 = load i32, i32* %28
%478 = icmp slt i32 %476, %477
br i1 %478, label %479, label %519
479: ; preds = %475
%480 = load i32*, i32** %32
%481 = load i32, i32* %28
%482 = load i32, i32* %33
%483 = load i32, i32* %28
%484 = sub nsw i32 %482, %483
%485 = mul nsw i32 %481, %484
%486 = load i32, i32* %35
%487 = add nsw i32 %485, %486
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds i32, i32* %480, i64 %488
%490 = load i32, i32* %489
%491 = icmp ne i32 %490, 0
br i1 %491, label %492, label %515
492: ; preds = %479
store i32 0, i32* %36
br label %493
493: ; preds = %511, %492
%494 = load i32, i32* %36
%495 = load i32, i32* %28
%496 = icmp slt i32 %494, %495
br i1 %496, label %497, label %514
497: ; preds = %493
%498 = load double*, double** %30
%499 = load i32, i32* %28
%500 = load i32, i32* %35
%501 = mul nsw i32 %499, %500
%502 = load i32, i32* %36
%503 = add nsw i32 %501, %502
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds double, double* %498, i64 %504
%506 = load double, double* %505
%507 = load double, double* %44
%508 = fadd double %507, %506
store double %508, double* %44
%509 = load i32, i32* %42
%510 = add nsw i32 %509, 1
store i32 %510, i32* %42
br label %511
511: ; preds = %497
%512 = load i32, i32* %36
%513 = add nsw i32 %512, 1
store i32 %513, i32* %36
br label %493
514: ; preds = %493
br label %515
515: ; preds = %514, %479
br label %516
516: ; preds = %515
%517 = load i32, i32* %35
%518 = add nsw i32 %517, 1
store i32 %518, i32* %35
br label %475
519: ; preds = %475
br label %580
520: ; preds = %469
store i32 0, i32* %35
br label %521
521: ; preds = %576, %520
%522 = load i32, i32* %35
%523 = load i32, i32* %28
%524 = icmp slt i32 %522, %523
br i1 %524, label %525, label %579
525: ; preds = %521
%526 = load i32*, i32** %32
%527 = load i32, i32* %28
%528 = load i32, i32* %33
%529 = load i32, i32* %28
%530 = sub nsw i32 %528, %529
%531 = mul nsw i32 %527, %530
%532 = load i32, i32* %35
%533 = add nsw i32 %531, %532
%534 = sext i32 %533 to i64
%535 = getelementptr inbounds i32, i32* %526, i64 %534
%536 = load i32, i32* %535
%537 = icmp ne i32 %536, 0
br i1 %537, label %538, label %575
538: ; preds = %525
store i32 0, i32* %36
br label %539
539: ; preds = %571, %538
%540 = load i32, i32* %36
%541 = load i32, i32* %28
%542 = icmp slt i32 %540, %541
br i1 %542, label %543, label %574
543: ; preds = %539
%544 = load i32*, i32** %32
%545 = load i32, i32* %28
%546 = load i32, i32* %34
%547 = load i32, i32* %28
%548 = sub nsw i32 %546, %547
%549 = mul nsw i32 %545, %548
%550 = load i32, i32* %36
%551 = add nsw i32 %549, %550
%552 = sext i32 %551 to i64
%553 = getelementptr inbounds i32, i32* %544, i64 %552
%554 = load i32, i32* %553
%555 = icmp ne i32 %554, 0
br i1 %555, label %556, label %570
556: ; preds = %543
%557 = load double*, double** %30
%558 = load i32, i32* %28
%559 = load i32, i32* %35
%560 = mul nsw i32 %558, %559
%561 = load i32, i32* %36
%562 = add nsw i32 %560, %561
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds double, double* %557, i64 %563
%565 = load double, double* %564
%566 = load double, double* %44
%567 = fadd double %566, %565
store double %567, double* %44
%568 = load i32, i32* %42
%569 = add nsw i32 %568, 1
store i32 %569, i32* %42
br label %570
570: ; preds = %556, %543
br label %571
571: ; preds = %570
%572 = load i32, i32* %36
%573 = add nsw i32 %572, 1
store i32 %573, i32* %36
br label %539
574: ; preds = %539
br label %575
575: ; preds = %574, %525
br label %576
576: ; preds = %575
%577 = load i32, i32* %35
%578 = add nsw i32 %577, 1
store i32 %578, i32* %35
br label %521
579: ; preds = %521
br label %580
580: ; preds = %579, %519
br label %581
581: ; preds = %580, %468
br label %582
582: ; preds = %581, %427
br label %583
583: ; preds = %582, %340
%584 = load double, double* %44
%585 = fcmp olt double %584, 1.000000e-15
br i1 %585, label %586, label %909
586: ; preds = %583
%587 = load i32, i32* %42
%588 = sitofp i32 %587 to double
%589 = fdiv double 1.000000e+00, %588
store double %589, double* %45
%590 = load i32, i32* %33
%591 = load i32, i32* %28
%592 = icmp slt i32 %590, %591
br i1 %592, label %593, label %666
593: ; preds = %586
%594 = load i32, i32* %34
%595 = load i32, i32* %29
%596 = sub nsw i32 %595, 1
%597 = icmp eq i32 %594, %596
br i1 %597, label %598, label %621
598: ; preds = %593
store i32 0, i32* %36
br label %599
599: ; preds = %617, %598
%600 = load i32, i32* %36
%601 = load i32, i32* %28
%602 = icmp slt i32 %600, %601
br i1 %602, label %603, label %620
603: ; preds = %599
%604 = load i32, i32* %41
%605 = sitofp i32 %604 to double
%606 = load double, double* %45
%607 = load double*, double** %31
%608 = load i32, i32* %28
%609 = load i32, i32* %33
%610 = mul nsw i32 %608, %609
%611 = load i32, i32* %36
%612 = add nsw i32 %610, %611
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds double, double* %607, i64 %613
%615 = load double, double* %614
%616 = call double @llvm.fmuladd.f64(double %605, double %606, double %615)
store double %616, double* %614
br label %617
617: ; preds = %603
%618 = load i32, i32* %36
%619 = add nsw i32 %618, 1
store i32 %619, i32* %36
br label %599
620: ; preds = %599
br label %665
621: ; preds = %593
%622 = load i32, i32* %34
%623 = load i32, i32* %28
%624 = icmp sge i32 %622, %623
br i1 %624, label %625, label %662
625: ; preds = %621
store i32 0, i32* %36
br label %626
626: ; preds = %658, %625
%627 = load i32, i32* %36
%628 = load i32, i32* %28
%629 = icmp slt i32 %627, %628
br i1 %629, label %630, label %661
630: ; preds = %626
%631 = load i32*, i32** %32
%632 = load i32, i32* %28
%633 = load i32, i32* %34
%634 = load i32, i32* %28
%635 = sub nsw i32 %633, %634
%636 = mul nsw i32 %632, %635
%637 = load i32, i32* %36
%638 = add nsw i32 %636, %637
%639 = sext i32 %638 to i64
%640 = getelementptr inbounds i32, i32* %631, i64 %639
%641 = load i32, i32* %640
%642 = icmp ne i32 %641, 0
br i1 %642, label %643, label %657
643: ; preds = %630
%644 = load i32, i32* %41
%645 = sitofp i32 %644 to double
%646 = load double, double* %45
%647 = load double*, double** %31
%648 = load i32, i32* %28
%649 = load i32, i32* %33
%650 = mul nsw i32 %648, %649
%651 = load i32, i32* %36
%652 = add nsw i32 %650, %651
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds double, double* %647, i64 %653
%655 = load double, double* %654
%656 = call double @llvm.fmuladd.f64(double %645, double %646, double %655)
store double %656, double* %654
br label %657
657: ; preds = %643, %630
br label %658
658: ; preds = %657
%659 = load i32, i32* %36
%660 = add nsw i32 %659, 1
store i32 %660, i32* %36
br label %626
661: ; preds = %626
br label %664
662: ; preds = %621
%663 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0))
unreachable
664: ; preds = %661
br label %665
665: ; preds = %664, %620
br label %908
666: ; preds = %586
%667 = load i32, i32* %33
%668 = load i32, i32* %29
%669 = sub nsw i32 %668, 1
%670 = icmp eq i32 %667, %669
br i1 %670, label %671, label %753
671: ; preds = %666
%672 = load i32, i32* %34
%673 = load i32, i32* %28
%674 = icmp slt i32 %672, %673
br i1 %674, label %675, label %698
675: ; preds = %671
store i32 0, i32* %35
br label %676
676: ; preds = %694, %675
%677 = load i32, i32* %35
%678 = load i32, i32* %28
%679 = icmp slt i32 %677, %678
br i1 %679, label %680, label %697
680: ; preds = %676
%681 = load i32, i32* %41
%682 = sitofp i32 %681 to double
%683 = load double, double* %45
%684 = load double*, double** %31
%685 = load i32, i32* %28
%686 = load i32, i32* %35
%687 = mul nsw i32 %685, %686
%688 = load i32, i32* %34
%689 = add nsw i32 %687, %688
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds double, double* %684, i64 %690
%692 = load double, double* %691
%693 = call double @llvm.fmuladd.f64(double %682, double %683, double %692)
store double %693, double* %691
br label %694
694: ; preds = %680
%695 = load i32, i32* %35
%696 = add nsw i32 %695, 1
store i32 %696, i32* %35
br label %676
697: ; preds = %676
br label %752
698: ; preds = %671
%699 = load i32, i32* %34
%700 = load i32, i32* %29
%701 = sub nsw i32 %700, 1
%702 = icmp eq i32 %699, %701
br i1 %702, label %703, label %705
703: ; preds = %698
%704 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0))
unreachable
705: ; preds = %698
store i32 0, i32* %35
br label %706
706: ; preds = %747, %705
%707 = load i32, i32* %35
%708 = load i32, i32* %28
%709 = icmp slt i32 %707, %708
br i1 %709, label %710, label %750
710: ; preds = %706
store i32 0, i32* %36
br label %711
711: ; preds = %743, %710
%712 = load i32, i32* %36
%713 = load i32, i32* %28
%714 = icmp slt i32 %712, %713
br i1 %714, label %715, label %746
715: ; preds = %711
%716 = load i32*, i32** %32
%717 = load i32, i32* %28
%718 = load i32, i32* %34
%719 = load i32, i32* %28
%720 = sub nsw i32 %718, %719
%721 = mul nsw i32 %717, %720
%722 = load i32, i32* %36
%723 = add nsw i32 %721, %722
%724 = sext i32 %723 to i64
%725 = getelementptr inbounds i32, i32* %716, i64 %724
%726 = load i32, i32* %725
%727 = icmp ne i32 %726, 0
br i1 %727, label %728, label %742
728: ; preds = %715
%729 = load i32, i32* %41
%730 = sitofp i32 %729 to double
%731 = load double, double* %45
%732 = load double*, double** %31
%733 = load i32, i32* %28
%734 = load i32, i32* %35
%735 = mul nsw i32 %733, %734
%736 = load i32, i32* %36
%737 = add nsw i32 %735, %736
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds double, double* %732, i64 %738
%740 = load double, double* %739
%741 = call double @llvm.fmuladd.f64(double %730, double %731, double %740)
store double %741, double* %739
br label %742
742: ; preds = %728, %715
br label %743
743: ; preds = %742
%744 = load i32, i32* %36
%745 = add nsw i32 %744, 1
store i32 %745, i32* %36
br label %711
746: ; preds = %711
br label %747
747: ; preds = %746
%748 = load i32, i32* %35
%749 = add nsw i32 %748, 1
store i32 %749, i32* %35
br label %706
750: ; preds = %706
br label %751
751: ; preds = %750
br label %752
752: ; preds = %751, %697
br label %907
753: ; preds = %666
%754 = load i32, i32* %34
%755 = load i32, i32* %28
%756 = icmp slt i32 %754, %755
br i1 %756, label %757, label %794
757: ; preds = %753
store i32 0, i32* %35
br label %758
758: ; preds = %790, %757
%759 = load i32, i32* %35
%760 = load i32, i32* %28
%761 = icmp slt i32 %759, %760
br i1 %761, label %762, label %793
762: ; preds = %758
%763 = load i32*, i32** %32
%764 = load i32, i32* %28
%765 = load i32, i32* %33
%766 = load i32, i32* %28
%767 = sub nsw i32 %765, %766
%768 = mul nsw i32 %764, %767
%769 = load i32, i32* %35
%770 = add nsw i32 %768, %769
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds i32, i32* %763, i64 %771
%773 = load i32, i32* %772
%774 = icmp ne i32 %773, 0
br i1 %774, label %775, label %789
775: ; preds = %762
%776 = load i32, i32* %41
%777 = sitofp i32 %776 to double
%778 = load double, double* %45
%779 = load double*, double** %31
%780 = load i32, i32* %28
%781 = load i32, i32* %35
%782 = mul nsw i32 %780, %781
%783 = load i32, i32* %34
%784 = add nsw i32 %782, %783
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds double, double* %779, i64 %785
%787 = load double, double* %786
%788 = call double @llvm.fmuladd.f64(double %777, double %778, double %787)
store double %788, double* %786
br label %789
789: ; preds = %775, %762
br label %790
790: ; preds = %789
%791 = load i32, i32* %35
%792 = add nsw i32 %791, 1
store i32 %792, i32* %35
br label %758
793: ; preds = %758
br label %906
794: ; preds = %753
%795 = load i32, i32* %34
%796 = load i32, i32* %29
%797 = sub nsw i32 %796, 1
%798 = icmp eq i32 %795, %797
br i1 %798, label %799, label %845
799: ; preds = %794
store i32 0, i32* %35
br label %800
800: ; preds = %841, %799
%801 = load i32, i32* %35
%802 = load i32, i32* %28
%803 = icmp slt i32 %801, %802
br i1 %803, label %804, label %844
804: ; preds = %800
%805 = load i32*, i32** %32
%806 = load i32, i32* %28
%807 = load i32, i32* %33
%808 = load i32, i32* %28
%809 = sub nsw i32 %807, %808
%810 = mul nsw i32 %806, %809
%811 = load i32, i32* %35
%812 = add nsw i32 %810, %811
%813 = sext i32 %812 to i64
%814 = getelementptr inbounds i32, i32* %805, i64 %813
%815 = load i32, i32* %814
%816 = icmp ne i32 %815, 0
br i1 %816, label %817, label %840
817: ; preds = %804
store i32 0, i32* %36
br label %818
818: ; preds = %836, %817
%819 = load i32, i32* %36
%820 = load i32, i32* %28
%821 = icmp slt i32 %819, %820
br i1 %821, label %822, label %839
822: ; preds = %818
%823 = load i32, i32* %41
%824 = sitofp i32 %823 to double
%825 = load double, double* %45
%826 = load double*, double** %31
%827 = load i32, i32* %28
%828 = load i32, i32* %35
%829 = mul nsw i32 %827, %828
%830 = load i32, i32* %36
%831 = add nsw i32 %829, %830
%832 = sext i32 %831 to i64
%833 = getelementptr inbounds double, double* %826, i64 %832
%834 = load double, double* %833
%835 = call double @llvm.fmuladd.f64(double %824, double %825, double %834)
store double %835, double* %833
br label %836
836: ; preds = %822
%837 = load i32, i32* %36
%838 = add nsw i32 %837, 1
store i32 %838, i32* %36
br label %818
839: ; preds = %818
br label %840
840: ; preds = %839, %804
br label %841
841: ; preds = %840
%842 = load i32, i32* %35
%843 = add nsw i32 %842, 1
store i32 %843, i32* %35
br label %800
844: ; preds = %800
br label %905
845: ; preds = %794
store i32 0, i32* %35
br label %846
846: ; preds = %901, %845
%847 = load i32, i32* %35
%848 = load i32, i32* %28
%849 = icmp slt i32 %847, %848
br i1 %849, label %850, label %904
850: ; preds = %846
%851 = load i32*, i32** %32
%852 = load i32, i32* %28
%853 = load i32, i32* %33
%854 = load i32, i32* %28
%855 = sub nsw i32 %853, %854
%856 = mul nsw i32 %852, %855
%857 = load i32, i32* %35
%858 = add nsw i32 %856, %857
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds i32, i32* %851, i64 %859
%861 = load i32, i32* %860
%862 = icmp ne i32 %861, 0
br i1 %862, label %863, label %900
863: ; preds = %850
store i32 0, i32* %36
br label %864
864: ; preds = %896, %863
%865 = load i32, i32* %36
%866 = load i32, i32* %28
%867 = icmp slt i32 %865, %866
br i1 %867, label %868, label %899
868: ; preds = %864
%869 = load i32*, i32** %32
%870 = load i32, i32* %28
%871 = load i32, i32* %34
%872 = load i32, i32* %28
%873 = sub nsw i32 %871, %872
%874 = mul nsw i32 %870, %873
%875 = load i32, i32* %36
%876 = add nsw i32 %874, %875
%877 = sext i32 %876 to i64
%878 = getelementptr inbounds i32, i32* %869, i64 %877
%879 = load i32, i32* %878
%880 = icmp ne i32 %879, 0
br i1 %880, label %881, label %895
881: ; preds = %868
%882 = load i32, i32* %41
%883 = sitofp i32 %882 to double
%884 = load double, double* %45
%885 = load double*, double** %31
%886 = load i32, i32* %28
%887 = load i32, i32* %35
%888 = mul nsw i32 %886, %887
%889 = load i32, i32* %36
%890 = add nsw i32 %888, %889
%891 = sext i32 %890 to i64
%892 = getelementptr inbounds double, double* %885, i64 %891
%893 = load double, double* %892
%894 = call double @llvm.fmuladd.f64(double %883, double %884, double %893)
store double %894, double* %892
br label %895
895: ; preds = %881, %868
br label %896
896: ; preds = %895
%897 = load i32, i32* %36
%898 = add nsw i32 %897, 1
store i32 %898, i32* %36
br label %864
899: ; preds = %864
br label %900
900: ; preds = %899, %850
br label %901
901: ; preds = %900
%902 = load i32, i32* %35
%903 = add nsw i32 %902, 1
store i32 %903, i32* %35
br label %846
904: ; preds = %846
br label %905
905: ; preds = %904, %844
br label %906
906: ; preds = %905, %793
br label %907
907: ; preds = %906, %752
br label %908
908: ; preds = %907, %665
br label %1306
909: ; preds = %583
%910 = load i32, i32* %33
%911 = load i32, i32* %28
%912 = icmp slt i32 %910, %911
br i1 %912, label %913, label %1008
913: ; preds = %909
%914 = load i32, i32* %34
%915 = load i32, i32* %29
%916 = sub nsw i32 %915, 1
%917 = icmp eq i32 %914, %916
br i1 %917, label %918, label %952
918: ; preds = %913
store i32 0, i32* %36
br label %919
919: ; preds = %948, %918
%920 = load i32, i32* %36
%921 = load i32, i32* %28
%922 = icmp slt i32 %920, %921
br i1 %922, label %923, label %951
923: ; preds = %919
%924 = load i32, i32* %41
%925 = sitofp i32 %924 to double
%926 = load double*, double** %30
%927 = load i32, i32* %28
%928 = load i32, i32* %33
%929 = mul nsw i32 %927, %928
%930 = load i32, i32* %36
%931 = add nsw i32 %929, %930
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds double, double* %926, i64 %932
%934 = load double, double* %933
%935 = fmul double %925, %934
%936 = load double, double* %44
%937 = fdiv double %935, %936
%938 = load double*, double** %31
%939 = load i32, i32* %28
%940 = load i32, i32* %33
%941 = mul nsw i32 %939, %940
%942 = load i32, i32* %36
%943 = add nsw i32 %941, %942
%944 = sext i32 %943 to i64
%945 = getelementptr inbounds double, double* %938, i64 %944
%946 = load double, double* %945
%947 = fadd double %946, %937
store double %947, double* %945
br label %948
948: ; preds = %923
%949 = load i32, i32* %36
%950 = add nsw i32 %949, 1
store i32 %950, i32* %36
br label %919
951: ; preds = %919
br label %1007
952: ; preds = %913
%953 = load i32, i32* %34
%954 = load i32, i32* %28
%955 = icmp sge i32 %953, %954
br i1 %955, label %956, label %1004
956: ; preds = %952
store i32 0, i32* %36
br label %957
957: ; preds = %1000, %956
%958 = load i32, i32* %36
%959 = load i32, i32* %28
%960 = icmp slt i32 %958, %959
br i1 %960, label %961, label %1003
961: ; preds = %957
%962 = load i32*, i32** %32
%963 = load i32, i32* %28
%964 = load i32, i32* %34
%965 = load i32, i32* %28
%966 = sub nsw i32 %964, %965
%967 = mul nsw i32 %963, %966
%968 = load i32, i32* %36
%969 = add nsw i32 %967, %968
%970 = sext i32 %969 to i64
%971 = getelementptr inbounds i32, i32* %962, i64 %970
%972 = load i32, i32* %971
%973 = icmp ne i32 %972, 0
br i1 %973, label %974, label %999
974: ; preds = %961
%975 = load i32, i32* %41
%976 = sitofp i32 %975 to double
%977 = load double*, double** %30
%978 = load i32, i32* %28
%979 = load i32, i32* %33
%980 = mul nsw i32 %978, %979
%981 = load i32, i32* %36
%982 = add nsw i32 %980, %981
%983 = sext i32 %982 to i64
%984 = getelementptr inbounds double, double* %977, i64 %983
%985 = load double, double* %984
%986 = fmul double %976, %985
%987 = load double, double* %44
%988 = fdiv double %986, %987
%989 = load double*, double** %31
%990 = load i32, i32* %28
%991 = load i32, i32* %33
%992 = mul nsw i32 %990, %991
%993 = load i32, i32* %36
%994 = add nsw i32 %992, %993
%995 = sext i32 %994 to i64
%996 = getelementptr inbounds double, double* %989, i64 %995
%997 = load double, double* %996
%998 = fadd double %997, %988
store double %998, double* %996
br label %999
999: ; preds = %974, %961
br label %1000
1000: ; preds = %999
%1001 = load i32, i32* %36
%1002 = add nsw i32 %1001, 1
store i32 %1002, i32* %36
br label %957
1003: ; preds = %957
br label %1006
1004: ; preds = %952
%1005 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0))
unreachable
1006: ; preds = %1003
br label %1007
1007: ; preds = %1006, %951
br label %1305
1008: ; preds = %909
%1009 = load i32, i32* %33
%1010 = load i32, i32* %29
%1011 = sub nsw i32 %1010, 1
%1012 = icmp eq i32 %1009, %1011
br i1 %1012, label %1013, label %1117
1013: ; preds = %1008
%1014 = load i32, i32* %34
%1015 = load i32, i32* %28
%1016 = icmp slt i32 %1014, %1015
br i1 %1016, label %1017, label %1051
1017: ; preds = %1013
store i32 0, i32* %35
br label %1018
1018: ; preds = %1047, %1017
%1019 = load i32, i32* %35
%1020 = load i32, i32* %28
%1021 = icmp slt i32 %1019, %1020
br i1 %1021, label %1022, label %1050
1022: ; preds = %1018
%1023 = load i32, i32* %41
%1024 = sitofp i32 %1023 to double
%1025 = load double*, double** %30
%1026 = load i32, i32* %28
%1027 = load i32, i32* %35
%1028 = mul nsw i32 %1026, %1027
%1029 = load i32, i32* %34
%1030 = add nsw i32 %1028, %1029
%1031 = sext i32 %1030 to i64
%1032 = getelementptr inbounds double, double* %1025, i64 %1031
%1033 = load double, double* %1032
%1034 = fmul double %1024, %1033
%1035 = load double, double* %44
%1036 = fdiv double %1034, %1035
%1037 = load double*, double** %31
%1038 = load i32, i32* %28
%1039 = load i32, i32* %35
%1040 = mul nsw i32 %1038, %1039
%1041 = load i32, i32* %34
%1042 = add nsw i32 %1040, %1041
%1043 = sext i32 %1042 to i64
%1044 = getelementptr inbounds double, double* %1037, i64 %1043
%1045 = load double, double* %1044
%1046 = fadd double %1045, %1036
store double %1046, double* %1044
br label %1047
1047: ; preds = %1022
%1048 = load i32, i32* %35
%1049 = add nsw i32 %1048, 1
store i32 %1049, i32* %35
br label %1018
1050: ; preds = %1018
br label %1116
1051: ; preds = %1013
%1052 = load i32, i32* %34
%1053 = load i32, i32* %29
%1054 = sub nsw i32 %1053, 1
%1055 = icmp eq i32 %1052, %1054
br i1 %1055, label %1056, label %1058
1056: ; preds = %1051
%1057 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.2, i64 0, i64 0))
unreachable
1058: ; preds = %1051
store i32 0, i32* %35
br label %1059
1059: ; preds = %1111, %1058
%1060 = load i32, i32* %35
%1061 = load i32, i32* %28
%1062 = icmp slt i32 %1060, %1061
br i1 %1062, label %1063, label %1114
1063: ; preds = %1059
store i32 0, i32* %36
br label %1064
1064: ; preds = %1107, %1063
%1065 = load i32, i32* %36
%1066 = load i32, i32* %28
%1067 = icmp slt i32 %1065, %1066
br i1 %1067, label %1068, label %1110
1068: ; preds = %1064
%1069 = load i32*, i32** %32
%1070 = load i32, i32* %28
%1071 = load i32, i32* %34
%1072 = load i32, i32* %28
%1073 = sub nsw i32 %1071, %1072
%1074 = mul nsw i32 %1070, %1073
%1075 = load i32, i32* %36
%1076 = add nsw i32 %1074, %1075
%1077 = sext i32 %1076 to i64
%1078 = getelementptr inbounds i32, i32* %1069, i64 %1077
%1079 = load i32, i32* %1078
%1080 = icmp ne i32 %1079, 0
br i1 %1080, label %1081, label %1106
1081: ; preds = %1068
%1082 = load i32, i32* %41
%1083 = sitofp i32 %1082 to double
%1084 = load double*, double** %30
%1085 = load i32, i32* %28
%1086 = load i32, i32* %35
%1087 = mul nsw i32 %1085, %1086
%1088 = load i32, i32* %36
%1089 = add nsw i32 %1087, %1088
%1090 = sext i32 %1089 to i64
%1091 = getelementptr inbounds double, double* %1084, i64 %1090
%1092 = load double, double* %1091
%1093 = fmul double %1083, %1092
%1094 = load double, double* %44
%1095 = fdiv double %1093, %1094
%1096 = load double*, double** %31
%1097 = load i32, i32* %28
%1098 = load i32, i32* %35
%1099 = mul nsw i32 %1097, %1098
%1100 = load i32, i32* %36
%1101 = add nsw i32 %1099, %1100
%1102 = sext i32 %1101 to i64
%1103 = getelementptr inbounds double, double* %1096, i64 %1102
%1104 = load double, double* %1103
%1105 = fadd double %1104, %1095
store double %1105, double* %1103
br label %1106
1106: ; preds = %1081, %1068
br label %1107
1107: ; preds = %1106
%1108 = load i32, i32* %36
%1109 = add nsw i32 %1108, 1
store i32 %1109, i32* %36
br label %1064
1110: ; preds = %1064
br label %1111
1111: ; preds = %1110
%1112 = load i32, i32* %35
%1113 = add nsw i32 %1112, 1
store i32 %1113, i32* %35
br label %1059
1114: ; preds = %1059
br label %1115
1115: ; preds = %1114
br label %1116
1116: ; preds = %1115, %1050
br label %1304
1117: ; preds = %1008
%1118 = load i32, i32* %34
%1119 = load i32, i32* %28
%1120 = icmp slt i32 %1118, %1119
br i1 %1120, label %1121, label %1169
1121: ; preds = %1117
store i32 0, i32* %35
br label %1122
1122: ; preds = %1165, %1121
%1123 = load i32, i32* %35
%1124 = load i32, i32* %28
%1125 = icmp slt i32 %1123, %1124
br i1 %1125, label %1126, label %1168
1126: ; preds = %1122
%1127 = load i32*, i32** %32
%1128 = load i32, i32* %28
%1129 = load i32, i32* %33
%1130 = load i32, i32* %28
%1131 = sub nsw i32 %1129, %1130
%1132 = mul nsw i32 %1128, %1131
%1133 = load i32, i32* %35
%1134 = add nsw i32 %1132, %1133
%1135 = sext i32 %1134 to i64
%1136 = getelementptr inbounds i32, i32* %1127, i64 %1135
%1137 = load i32, i32* %1136
%1138 = icmp ne i32 %1137, 0
br i1 %1138, label %1139, label %1164
1139: ; preds = %1126
%1140 = load i32, i32* %41
%1141 = sitofp i32 %1140 to double
%1142 = load double*, double** %30
%1143 = load i32, i32* %28
%1144 = load i32, i32* %35
%1145 = mul nsw i32 %1143, %1144
%1146 = load i32, i32* %34
%1147 = add nsw i32 %1145, %1146
%1148 = sext i32 %1147 to i64
%1149 = getelementptr inbounds double, double* %1142, i64 %1148
%1150 = load double, double* %1149
%1151 = fmul double %1141, %1150
%1152 = load double, double* %44
%1153 = fdiv double %1151, %1152
%1154 = load double*, double** %31
%1155 = load i32, i32* %28
%1156 = load i32, i32* %35
%1157 = mul nsw i32 %1155, %1156
%1158 = load i32, i32* %34
%1159 = add nsw i32 %1157, %1158
%1160 = sext i32 %1159 to i64
%1161 = getelementptr inbounds double, double* %1154, i64 %1160
%1162 = load double, double* %1161
%1163 = fadd double %1162, %1153
store double %1163, double* %1161
br label %1164
1164: ; preds = %1139, %1126
br label %1165
1165: ; preds = %1164
%1166 = load i32, i32* %35
%1167 = add nsw i32 %1166, 1
store i32 %1167, i32* %35
br label %1122
1168: ; preds = %1122
br label %1303
1169: ; preds = %1117
%1170 = load i32, i32* %34
%1171 = load i32, i32* %29
%1172 = sub nsw i32 %1171, 1
%1173 = icmp eq i32 %1170, %1172
br i1 %1173, label %1174, label %1231
1174: ; preds = %1169
store i32 0, i32* %35
br label %1175
1175: ; preds = %1227, %1174
%1176 = load i32, i32* %35
%1177 = load i32, i32* %28
%1178 = icmp slt i32 %1176, %1177
br i1 %1178, label %1179, label %1230
1179: ; preds = %1175
%1180 = load i32*, i32** %32
%1181 = load i32, i32* %28
%1182 = load i32, i32* %33
%1183 = load i32, i32* %28
%1184 = sub nsw i32 %1182, %1183
%1185 = mul nsw i32 %1181, %1184
%1186 = load i32, i32* %35
%1187 = add nsw i32 %1185, %1186
%1188 = sext i32 %1187 to i64
%1189 = getelementptr inbounds i32, i32* %1180, i64 %1188
%1190 = load i32, i32* %1189
%1191 = icmp ne i32 %1190, 0
br i1 %1191, label %1192, label %1226
1192: ; preds = %1179
store i32 0, i32* %36
br label %1193
1193: ; preds = %1222, %1192
%1194 = load i32, i32* %36
%1195 = load i32, i32* %28
%1196 = icmp slt i32 %1194, %1195
br i1 %1196, label %1197, label %1225
1197: ; preds = %1193
%1198 = load i32, i32* %41
%1199 = sitofp i32 %1198 to double
%1200 = load double*, double** %30
%1201 = load i32, i32* %28
%1202 = load i32, i32* %35
%1203 = mul nsw i32 %1201, %1202
%1204 = load i32, i32* %36
%1205 = add nsw i32 %1203, %1204
%1206 = sext i32 %1205 to i64
%1207 = getelementptr inbounds double, double* %1200, i64 %1206
%1208 = load double, double* %1207
%1209 = fmul double %1199, %1208
%1210 = load double, double* %44
%1211 = fdiv double %1209, %1210
%1212 = load double*, double** %31
%1213 = load i32, i32* %28
%1214 = load i32, i32* %35
%1215 = mul nsw i32 %1213, %1214
%1216 = load i32, i32* %36
%1217 = add nsw i32 %1215, %1216
%1218 = sext i32 %1217 to i64
%1219 = getelementptr inbounds double, double* %1212, i64 %1218
%1220 = load double, double* %1219
%1221 = fadd double %1220, %1211
store double %1221, double* %1219
br label %1222
1222: ; preds = %1197
%1223 = load i32, i32* %36
%1224 = add nsw i32 %1223, 1
store i32 %1224, i32* %36
br label %1193
1225: ; preds = %1193
br label %1226
1226: ; preds = %1225, %1179
br label %1227
1227: ; preds = %1226
%1228 = load i32, i32* %35
%1229 = add nsw i32 %1228, 1
store i32 %1229, i32* %35
br label %1175
1230: ; preds = %1175
br label %1302
1231: ; preds = %1169
store i32 0, i32* %35
br label %1232
1232: ; preds = %1298, %1231
%1233 = load i32, i32* %35
%1234 = load i32, i32* %28
%1235 = icmp slt i32 %1233, %1234
br i1 %1235, label %1236, label %1301
1236: ; preds = %1232
%1237 = load i32*, i32** %32
%1238 = load i32, i32* %28
%1239 = load i32, i32* %33
%1240 = load i32, i32* %28
%1241 = sub nsw i32 %1239, %1240
%1242 = mul nsw i32 %1238, %1241
%1243 = load i32, i32* %35
%1244 = add nsw i32 %1242, %1243
%1245 = sext i32 %1244 to i64
%1246 = getelementptr inbounds i32, i32* %1237, i64 %1245
%1247 = load i32, i32* %1246
%1248 = icmp ne i32 %1247, 0
br i1 %1248, label %1249, label %1297
1249: ; preds = %1236
store i32 0, i32* %36
br label %1250
1250: ; preds = %1293, %1249
%1251 = load i32, i32* %36
%1252 = load i32, i32* %28
%1253 = icmp slt i32 %1251, %1252
br i1 %1253, label %1254, label %1296
1254: ; preds = %1250
%1255 = load i32*, i32** %32
%1256 = load i32, i32* %28
%1257 = load i32, i32* %34
%1258 = load i32, i32* %28
%1259 = sub nsw i32 %1257, %1258
%1260 = mul nsw i32 %1256, %1259
%1261 = load i32, i32* %36
%1262 = add nsw i32 %1260, %1261
%1263 = sext i32 %1262 to i64
%1264 = getelementptr inbounds i32, i32* %1255, i64 %1263
%1265 = load i32, i32* %1264
%1266 = icmp ne i32 %1265, 0
br i1 %1266, label %1267, label %1292
1267: ; preds = %1254
%1268 = load i32, i32* %41
%1269 = sitofp i32 %1268 to double
%1270 = load double*, double** %30
%1271 = load i32, i32* %28
%1272 = load i32, i32* %35
%1273 = mul nsw i32 %1271, %1272
%1274 = load i32, i32* %36
%1275 = add nsw i32 %1273, %1274
%1276 = sext i32 %1275 to i64
%1277 = getelementptr inbounds double, double* %1270, i64 %1276
%1278 = load double, double* %1277
%1279 = fmul double %1269, %1278
%1280 = load double, double* %44
%1281 = fdiv double %1279, %1280
%1282 = load double*, double** %31
%1283 = load i32, i32* %28
%1284 = load i32, i32* %35
%1285 = mul nsw i32 %1283, %1284
%1286 = load i32, i32* %36
%1287 = add nsw i32 %1285, %1286
%1288 = sext i32 %1287 to i64
%1289 = getelementptr inbounds double, double* %1282, i64 %1288
%1290 = load double, double* %1289
%1291 = fadd double %1290, %1281
store double %1291, double* %1289
br label %1292
1292: ; preds = %1267, %1254
br label %1293
1293: ; preds = %1292
%1294 = load i32, i32* %36
%1295 = add nsw i32 %1294, 1
store i32 %1295, i32* %36
br label %1250
1296: ; preds = %1250
br label %1297
1297: ; preds = %1296, %1236
br label %1298
1298: ; preds = %1297
%1299 = load i32, i32* %35
%1300 = add nsw i32 %1299, 1
store i32 %1300, i32* %35
br label %1232
1301: ; preds = %1232
br label %1302
1302: ; preds = %1301, %1230
br label %1303
1303: ; preds = %1302, %1168
br label %1304
1304: ; preds = %1303, %1116
br label %1305
1305: ; preds = %1304, %1007
br label %1306
1306: ; preds = %1305, %908
br label %1307
1307: ; preds = %1306, %252
br label %1308
1308: ; preds = %1307
%1309 = load i32, i32* %34
%1310 = add nsw i32 %1309, 1
store i32 %1310, i32* %34
br label %248
1311: ; preds = %248
br label %1312
1312: ; preds = %1311
%1313 = load i32, i32* %33
%1314 = add nsw i32 %1313, 1
store i32 %1314, i32* %33
br label %243
1315: ; preds = %243
br label %1316
1316: ; preds = %1315, %237
ret void
}

LLVM IR (-O2):
@str = [40 x i8] c"logDetFillFxy(). No unambiguous chars.\00"
@str.8 = [23 x i8] c"error in logDetFillFxy\00"
@str.9 = [17 x i8] c"problem with Fxy\00"
define void @logDetFillFxy(i32* nocapture %0, i32* nocapture %1, i32* nocapture %2, i8* nocapture %3, i32 %4, i32 %5, i32* nocapture %6, i32* nocapture %7, i32* nocapture %8, i32 %9, i32 %10, i32 %11, i32 %12, double* nocapture %13, double* nocapture %14, i32* nocapture %15) {
%17 = mul i32 %11, %11
store i32 0, i32* %0
store i32 0, i32* %1
store i32 0, i32* %2
%18 = icmp sgt i32 %10, 0
br i1 %18, label %19, label %92
19: ; preds = %16
%20 = mul nsw i32 %10, %4
%21 = mul nsw i32 %10, %5
%22 = icmp sgt i32 %12, 0
%23 = sext i32 %20 to i64
%24 = sext i32 %21 to i64
%25 = zext i32 %10 to i64
%26 = zext i32 %12 to i64
%27 = zext i32 %12 to i64
br label %28
28: ; preds = %19, %84
%29 = phi i64 [ 0, %19 ], [ %88, %84 ]
%30 = add nsw i64 %29, %23
%31 = getelementptr inbounds i8, i8* %3, i64 %30
%32 = load i8, i8* %31
%33 = sext i8 %32 to i32
%34 = add nsw i64 %29, %24
%35 = getelementptr inbounds i8, i8* %3, i64 %34
%36 = load i8, i8* %35
%37 = sext i8 %36 to i32
%38 = icmp sgt i8 %32, -1
%39 = icmp sgt i8 %36, -1
%40 = select i1 %38, i1 %39, i1 false
br i1 %40, label %41, label %44
41: ; preds = %28
%42 = mul nsw i32 %33, %11
%43 = add nsw i32 %42, %37
br label %76
44: ; preds = %28
%45 = icmp eq i8 %32, -3
%46 = icmp eq i8 %36, -3
%47 = select i1 %45, i1 %46, i1 false
br i1 %47, label %84, label %48
48: ; preds = %44
br i1 %22, label %49, label %71
49: ; preds = %48, %54
%50 = phi i64 [ %55, %54 ], [ 0, %48 ]
%51 = getelementptr inbounds i32, i32* %8, i64 %50
%52 = load i32, i32* %51
%53 = icmp eq i32 %52, %33
br i1 %53, label %57, label %54
54: ; preds = %49
%55 = add nuw nsw i64 %50, 1
%56 = icmp eq i64 %55, %26
br i1 %56, label %59, label %49
57: ; preds = %49
%58 = trunc i64 %50 to i32
br label %59
59: ; preds = %54, %57
%60 = phi i32 [ %58, %57 ], [ 0, %54 ]
br i1 %22, label %61, label %71
61: ; preds = %59, %66
%62 = phi i64 [ %67, %66 ], [ 0, %59 ]
%63 = getelementptr inbounds i32, i32* %8, i64 %62
%64 = load i32, i32* %63
%65 = icmp eq i32 %64, %37
br i1 %65, label %69, label %66
66: ; preds = %61
%67 = add nuw nsw i64 %62, 1
%68 = icmp eq i64 %67, %27
br i1 %68, label %71, label %61
69: ; preds = %61
%70 = trunc i64 %62 to i32
br label %71
71: ; preds = %66, %69, %48, %59
%72 = phi i32 [ %60, %59 ], [ 0, %48 ], [ %60, %69 ], [ %60, %66 ]
%73 = phi i32 [ 0, %59 ], [ 0, %48 ], [ %70, %69 ], [ 0, %66 ]
%74 = mul nsw i32 %72, %12
%75 = add nsw i32 %73, %74
br label %76
76: ; preds = %71, %41
%77 = phi i32 [ %75, %71 ], [ %43, %41 ]
%78 = phi i32* [ %7, %71 ], [ %6, %41 ]
%79 = phi i32* [ %1, %71 ], [ %0, %41 ]
%80 = sext i32 %77 to i64
%81 = getelementptr inbounds i32, i32* %78, i64 %80
%82 = load i32, i32* %81
%83 = add nsw i32 %82, 1
store i32 %83, i32* %81
br label %84
84: ; preds = %76, %44
%85 = phi i32* [ %2, %44 ], [ %79, %76 ]
%86 = load i32, i32* %85
%87 = add nsw i32 %86, 1
store i32 %87, i32* %85
%88 = add nuw nsw i64 %29, 1
%89 = icmp eq i64 %88, %25
br i1 %89, label %90, label %28
90: ; preds = %84
%91 = load i32, i32* %2
br label %92
92: ; preds = %90, %16
%93 = phi i32 [ %91, %90 ], [ 0, %16 ]
%94 = load i32, i32* %1
%95 = load i32, i32* %0
%96 = add nsw i32 %95, %94
%97 = add nsw i32 %96, %93
%98 = icmp eq i32 %97, %10
br i1 %98, label %101, label %99
99: ; preds = %92
%100 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str.9, i64 0, i64 0))
tail call void @exit(i32 0)
unreachable
101: ; preds = %92
%102 = icmp eq i32 %95, 0
br i1 %102, label %103, label %105
103: ; preds = %101
%104 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str, i64 0, i64 0))
tail call void @exit(i32 0)
unreachable
105: ; preds = %101
%106 = sitofp i32 %95 to double
%107 = icmp eq i32 %17, 0
br i1 %107, label %239, label %108
108: ; preds = %105
%109 = zext i32 %17 to i64
%110 = icmp eq i32 %17, 1
br i1 %110, label %156, label %111
111: ; preds = %108
%112 = and i64 %109, 4294967294
%113 = insertelement <2 x double> poison, double %106, i64 0
%114 = shufflevector <2 x double> %113, <2 x double> poison, <2 x i32> zeroinitializer
%115 = add nsw i64 %112, -2
%116 = lshr exact i64 %115, 1
%117 = add nuw i64 %116, 1
%118 = and i64 %117, 1
%119 = icmp eq i64 %115, 0
br i1 %119, label %143, label %120
120: ; preds = %111
%121 = and i64 %117, -2
br label %122
122: ; preds = %122, %120
%123 = phi i64 [ 0, %120 ], [ %140, %122 ]
%124 = phi i64 [ 0, %120 ], [ %141, %122 ]
%125 = getelementptr inbounds i32, i32* %6, i64 %123
%126 = bitcast i32* %125 to <2 x i32>*
%127 = load <2 x i32>, <2 x i32>* %126
%128 = sitofp <2 x i32> %127 to <2 x double>
%129 = fdiv <2 x double> %128, %114
%130 = getelementptr inbounds double, double* %13, i64 %123
%131 = bitcast double* %130 to <2 x double>*
store <2 x double> %129, <2 x double>* %131
%132 = or i64 %123, 2
%133 = getelementptr inbounds i32, i32* %6, i64 %132
%134 = bitcast i32* %133 to <2 x i32>*
%135 = load <2 x i32>, <2 x i32>* %134
%136 = sitofp <2 x i32> %135 to <2 x double>
%137 = fdiv <2 x double> %136, %114
%138 = getelementptr inbounds double, double* %13, i64 %132
%139 = bitcast double* %138 to <2 x double>*
store <2 x double> %137, <2 x double>* %139
%140 = add nuw i64 %123, 4
%141 = add nuw i64 %124, 2
%142 = icmp eq i64 %141, %121
br i1 %142, label %143, label %122
143: ; preds = %122, %111
%144 = phi i64 [ 0, %111 ], [ %140, %122 ]
%145 = icmp eq i64 %118, 0
br i1 %145, label %154, label %146
146: ; preds = %143
%147 = getelementptr inbounds i32, i32* %6, i64 %144
%148 = bitcast i32* %147 to <2 x i32>*
%149 = load <2 x i32>, <2 x i32>* %148
%150 = sitofp <2 x i32> %149 to <2 x double>
%151 = fdiv <2 x double> %150, %114
%152 = getelementptr inbounds double, double* %13, i64 %144
%153 = bitcast double* %152 to <2 x double>*
store <2 x double> %151, <2 x double>* %153
br label %154
154: ; preds = %143, %146
%155 = icmp eq i64 %112, %109
br i1 %155, label %158, label %156
156: ; preds = %108, %154
%157 = phi i64 [ 0, %108 ], [ %112, %154 ]
br label %222
158: ; preds = %222, %154
br i1 %107, label %239, label %159
159: ; preds = %158
%160 = zext i32 %17 to i64
%161 = icmp ult i32 %17, 4
br i1 %161, label %220, label %162
162: ; preds = %159
%163 = and i64 %109, 4294967292
%164 = add nsw i64 %163, -4
%165 = lshr exact i64 %164, 2
%166 = add nuw nsw i64 %165, 1
%167 = and i64 %166, 1
%168 = icmp eq i64 %164, 0
br i1 %168, label %202, label %169
169: ; preds = %162
%170 = and i64 %166, 9223372036854775806
br label %171
171: ; preds = %171, %169
%172 = phi i64 [ 0, %169 ], [ %199, %171 ]
%173 = phi i64 [ 0, %169 ], [ %200, %171 ]
%174 = getelementptr inbounds i32, i32* %6, i64 %172
%175 = bitcast i32* %174 to <2 x i32>*
%176 = load <2 x i32>, <2 x i32>* %175
%177 = getelementptr inbounds i32, i32* %174, i64 2
%178 = bitcast i32* %177 to <2 x i32>*
%179 = load <2 x i32>, <2 x i32>* %178
%180 = sitofp <2 x i32> %176 to <2 x double>
%181 = sitofp <2 x i32> %179 to <2 x double>
%182 = getelementptr inbounds double, double* %14, i64 %172
%183 = bitcast double* %182 to <2 x double>*
store <2 x double> %180, <2 x double>* %183
%184 = getelementptr inbounds double, double* %182, i64 2
%185 = bitcast double* %184 to <2 x double>*
store <2 x double> %181, <2 x double>* %185
%186 = or i64 %172, 4
%187 = getelementptr inbounds i32, i32* %6, i64 %186
%188 = bitcast i32* %187 to <2 x i32>*
%189 = load <2 x i32>, <2 x i32>* %188
%190 = getelementptr inbounds i32, i32* %187, i64 2
%191 = bitcast i32* %190 to <2 x i32>*
%192 = load <2 x i32>, <2 x i32>* %191
%193 = sitofp <2 x i32> %189 to <2 x double>
%194 = sitofp <2 x i32> %192 to <2 x double>
%195 = getelementptr inbounds double, double* %14, i64 %186
%196 = bitcast double* %195 to <2 x double>*
store <2 x double> %193, <2 x double>* %196
%197 = getelementptr inbounds double, double* %195, i64 2
%198 = bitcast double* %197 to <2 x double>*
store <2 x double> %194, <2 x double>* %198
%199 = add nuw i64 %172, 8
%200 = add i64 %173, 2
%201 = icmp eq i64 %200, %170
br i1 %201, label %202, label %171
202: ; preds = %171, %162
%203 = phi i64 [ 0, %162 ], [ %199, %171 ]
%204 = icmp eq i64 %167, 0
br i1 %204, label %218, label %205
205: ; preds = %202
%206 = getelementptr inbounds i32, i32* %6, i64 %203
%207 = bitcast i32* %206 to <2 x i32>*
%208 = load <2 x i32>, <2 x i32>* %207
%209 = getelementptr inbounds i32, i32* %206, i64 2
%210 = bitcast i32* %209 to <2 x i32>*
%211 = load <2 x i32>, <2 x i32>* %210
%212 = sitofp <2 x i32> %208 to <2 x double>
%213 = sitofp <2 x i32> %211 to <2 x double>
%214 = getelementptr inbounds double, double* %14, i64 %203
%215 = bitcast double* %214 to <2 x double>*
store <2 x double> %212, <2 x double>* %215
%216 = getelementptr inbounds double, double* %214, i64 2
%217 = bitcast double* %216 to <2 x double>*
store <2 x double> %213, <2 x double>* %217
br label %218
218: ; preds = %202, %205
%219 = icmp eq i64 %163, %109
br i1 %219, label %239, label %220
220: ; preds = %159, %218
%221 = phi i64 [ 0, %159 ], [ %163, %218 ]
br label %231
222: ; preds = %156, %222
%223 = phi i64 [ %229, %222 ], [ %157, %156 ]
%224 = getelementptr inbounds i32, i32* %6, i64 %223
%225 = load i32, i32* %224
%226 = sitofp i32 %225 to double
%227 = fdiv double %226, %106
%228 = getelementptr inbounds double, double* %13, i64 %223
store double %227, double* %228
%229 = add nuw nsw i64 %223, 1
%230 = icmp eq i64 %229, %109
br i1 %230, label %158, label %222
231: ; preds = %220, %231
%232 = phi i64 [ %237, %231 ], [ %221, %220 ]
%233 = getelementptr inbounds i32, i32* %6, i64 %232
%234 = load i32, i32* %233
%235 = sitofp i32 %234 to double
%236 = getelementptr inbounds double, double* %14, i64 %232
store double %235, double* %236
%237 = add nuw nsw i64 %232, 1
%238 = icmp eq i64 %237, %160
br i1 %238, label %239, label %231
239: ; preds = %231, %218, %105, %158
%240 = icmp ne i32 %94, 0
%241 = icmp sgt i32 %12, 0
%242 = and i1 %240, %241
br i1 %242, label %243, label %1573
243: ; preds = %239
%244 = add nsw i32 %12, -1
%245 = icmp sgt i32 %11, 0
%246 = icmp slt i32 %11, 1
%247 = sext i32 %11 to i64
%248 = zext i32 %244 to i64
%249 = zext i32 %12 to i64
%250 = zext i32 %12 to i64
%251 = zext i32 %11 to i64
%252 = zext i32 %11 to i64
%253 = zext i32 %11 to i64
%254 = zext i32 %11 to i64
%255 = zext i32 %11 to i64
%256 = zext i32 %11 to i64
%257 = zext i32 %11 to i64
%258 = zext i32 %11 to i64
%259 = zext i32 %11 to i64
%260 = zext i32 %11 to i64
%261 = zext i32 %11 to i64
%262 = zext i32 %11 to i64
%263 = zext i32 %11 to i64
%264 = add nsw i64 %255, -1
%265 = and i64 %255, 4294967294
%266 = add nsw i64 %265, -2
%267 = lshr exact i64 %266, 1
%268 = add nuw i64 %267, 1
%269 = and i64 %255, 4294967292
%270 = add nsw i64 %269, -4
%271 = lshr exact i64 %270, 2
%272 = add nuw nsw i64 %271, 1
%273 = and i64 %255, 1
%274 = icmp eq i64 %264, 0
%275 = and i64 %255, 4294967294
%276 = icmp eq i64 %273, 0
%277 = and i64 %255, 3
%278 = icmp ult i64 %264, 3
%279 = and i64 %255, 4294967292
%280 = icmp eq i64 %277, 0
%281 = and i64 %255, 1
%282 = icmp eq i64 %264, 0
%283 = and i64 %255, 4294967294
%284 = icmp eq i64 %281, 0
%285 = and i64 %255, 1
%286 = icmp eq i64 %264, 0
%287 = and i64 %255, 4294967294
%288 = icmp eq i64 %285, 0
%289 = and i64 %255, 3
%290 = icmp ult i64 %264, 3
%291 = and i64 %255, 4294967292
%292 = icmp eq i64 %289, 0
%293 = and i64 %255, 1
%294 = icmp eq i64 %264, 0
%295 = and i64 %255, 4294967294
%296 = icmp eq i64 %293, 0
%297 = and i64 %255, 3
%298 = icmp ult i64 %264, 3
%299 = and i64 %255, 4294967292
%300 = icmp eq i64 %297, 0
%301 = icmp ult i32 %11, 2
%302 = and i64 %251, 4294967294
%303 = and i64 %268, 1
%304 = icmp eq i64 %266, 0
%305 = and i64 %268, -2
%306 = icmp eq i64 %303, 0
%307 = icmp eq i64 %302, %251
%308 = and i64 %255, 1
%309 = icmp eq i64 %308, 0
%310 = sub nsw i64 0, %255
%311 = and i64 %255, 1
%312 = icmp eq i64 %264, 0
%313 = and i64 %255, 4294967294
%314 = icmp eq i64 %311, 0
%315 = icmp eq i32 %11, 1
%316 = and i64 %251, 4294967294
%317 = and i64 %268, 1
%318 = icmp eq i64 %266, 0
%319 = and i64 %268, -2
%320 = icmp eq i64 %317, 0
%321 = icmp eq i64 %316, %251
%322 = and i64 %255, 1
%323 = icmp eq i64 %322, 0
%324 = sub nsw i64 0, %255
%325 = and i64 %255, 1
%326 = icmp eq i64 %264, 0
%327 = and i64 %255, 4294967294
%328 = icmp eq i64 %325, 0
%329 = icmp ult i32 %11, 4
%330 = and i64 %251, 4294967292
%331 = and i64 %272, 1
%332 = icmp eq i64 %270, 0
%333 = and i64 %272, 9223372036854775806
%334 = icmp eq i64 %331, 0
%335 = icmp eq i64 %330, %251
%336 = and i64 %255, 1
%337 = icmp eq i64 %264, 0
%338 = and i64 %255, 4294967294
%339 = icmp eq i64 %336, 0
%340 = and i64 %255, 1
%341 = icmp eq i64 %264, 0
%342 = and i64 %255, 4294967294
%343 = icmp eq i64 %340, 0
%344 = and i64 %255, 1
%345 = icmp eq i64 %264, 0
%346 = and i64 %255, 4294967294
%347 = icmp eq i64 %344, 0
%348 = and i64 %255, 1
%349 = icmp eq i64 %264, 0
%350 = and i64 %255, 4294967294
%351 = icmp eq i64 %348, 0
%352 = icmp ult i32 %11, 4
%353 = and i64 %251, 4294967292
%354 = and i64 %272, 1
%355 = icmp eq i64 %270, 0
%356 = and i64 %272, 9223372036854775806
%357 = icmp eq i64 %354, 0
%358 = icmp eq i64 %353, %251
br label %359
359: ; preds = %1570, %243
%360 = phi i64 [ 0, %243 ], [ %1571, %1570 ]
%361 = mul i64 %360, %247
%362 = getelementptr double, double* %14, i64 %361
%363 = add i64 %361, %251
%364 = getelementptr double, double* %14, i64 %363
%365 = getelementptr double, double* %13, i64 %361
%366 = getelementptr double, double* %13, i64 %363
%367 = mul nsw i64 %360, %249
%368 = icmp slt i64 %360, %247
%369 = icmp eq i64 %360, %248
%370 = sub nsw i64 %360, %247
%371 = mul nsw i64 %370, %247
%372 = mul nsw i64 %360, %247
%373 = icmp ult double* %362, %366
%374 = icmp ult double* %365, %364
%375 = and i1 %373, %374
br label %376
376: ; preds = %359, %1567
%377 = phi i64 [ 0, %359 ], [ %1568, %1567 ]
%378 = add nuw nsw i64 %377, %367
%379 = getelementptr inbounds i32, i32* %7, i64 %378
%380 = load i32, i32* %379
%381 = icmp eq i32 %380, 0
br i1 %381, label %1567, label %382
382: ; preds = %376
br i1 %368, label %383, label %456
383: ; preds = %382
%384 = icmp eq i64 %377, %248
br i1 %384, label %385, label %413
385: ; preds = %383
br i1 %245, label %386, label %811
386: ; preds = %385
br i1 %298, label %736, label %387
387: ; preds = %386, %387
%388 = phi i64 [ %410, %387 ], [ 0, %386 ]
%389 = phi double [ %409, %387 ], [ 0.000000e+00, %386 ]
%390 = phi i64 [ %411, %387 ], [ 0, %386 ]
%391 = add nsw i64 %388, %372
%392 = getelementptr inbounds double, double* %13, i64 %391
%393 = load double, double* %392
%394 = fadd double %389, %393
%395 = or i64 %388, 1
%396 = add nsw i64 %395, %372
%397 = getelementptr inbounds double, double* %13, i64 %396
%398 = load double, double* %397
%399 = fadd double %394, %398
%400 = or i64 %388, 2
%401 = add nsw i64 %400, %372
%402 = getelementptr inbounds double, double* %13, i64 %401
%403 = load double, double* %402
%404 = fadd double %399, %403
%405 = or i64 %388, 3
%406 = add nsw i64 %405, %372
%407 = getelementptr inbounds double, double* %13, i64 %406
%408 = load double, double* %407
%409 = fadd double %404, %408
%410 = add nuw nsw i64 %388, 4
%411 = add i64 %390, 4
%412 = icmp eq i64 %411, %299
br i1 %412, label %736, label %387
413: ; preds = %383
%414 = icmp slt i64 %377, %247
br i1 %414, label %454, label %415
415: ; preds = %413
br i1 %245, label %416, label %811
416: ; preds = %415
%417 = sub nsw i64 %377, %247
%418 = mul nsw i64 %417, %247
br i1 %294, label %751, label %419
419: ; preds = %416, %448
%420 = phi i64 [ %451, %448 ], [ 0, %416 ]
%421 = phi double [ %450, %448 ], [ 0.000000e+00, %416 ]
%422 = phi i32 [ %449, %448 ], [ 0, %416 ]
%423 = phi i64 [ %452, %448 ], [ 0, %416 ]
%424 = add nsw i64 %420, %418
%425 = getelementptr inbounds i32, i32* %15, i64 %424
%426 = load i32, i32* %425
%427 = icmp eq i32 %426, 0
br i1 %427, label %434, label %428
428: ; preds = %419
%429 = add nsw i64 %420, %372
%430 = getelementptr inbounds double, double* %13, i64 %429
%431 = load double, double* %430
%432 = fadd double %421, %431
%433 = add nsw i32 %422, 1
br label %434
434: ; preds = %419, %428
%435 = phi i32 [ %433, %428 ], [ %422, %419 ]
%436 = phi double [ %432, %428 ], [ %421, %419 ]
%437 = or i64 %420, 1
%438 = add nsw i64 %437, %418
%439 = getelementptr inbounds i32, i32* %15, i64 %438
%440 = load i32, i32* %439
%441 = icmp eq i32 %440, 0
br i1 %441, label %448, label %442
442: ; preds = %434
%443 = add nsw i64 %437, %372
%444 = getelementptr inbounds double, double* %13, i64 %443
%445 = load double, double* %444
%446 = fadd double %436, %445
%447 = add nsw i32 %435, 1
br label %448
448: ; preds = %442, %434
%449 = phi i32 [ %447, %442 ], [ %435, %434 ]
%450 = phi double [ %446, %442 ], [ %436, %434 ]
%451 = add nuw nsw i64 %420, 2
%452 = add i64 %423, 2
%453 = icmp eq i64 %452, %295
br i1 %453, label %751, label %419
454: ; preds = %413
%455 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str.8, i64 0, i64 0))
tail call void @exit(i32 0)
unreachable
456: ; preds = %382
%457 = icmp slt i64 %377, %247
br i1 %369, label %458, label %561
458: ; preds = %456
br i1 %457, label %459, label %491
459: ; preds = %458
br i1 %245, label %460, label %920
460: ; preds = %459
br i1 %290, label %768, label %461
461: ; preds = %460, %461
%462 = phi i64 [ %488, %461 ], [ 0, %460 ]
%463 = phi double [ %487, %461 ], [ 0.000000e+00, %460 ]
%464 = phi i64 [ %489, %461 ], [ 0, %460 ]
%465 = mul nsw i64 %462, %247
%466 = add nsw i64 %465, %377
%467 = getelementptr inbounds double, double* %13, i64 %466
%468 = load double, double* %467
%469 = fadd double %463, %468
%470 = or i64 %462, 1
%471 = mul nsw i64 %470, %247
%472 = add nsw i64 %471, %377
%473 = getelementptr inbounds double, double* %13, i64 %472
%474 = load double, double* %473
%475 = fadd double %469, %474
%476 = or i64 %462, 2
%477 = mul nsw i64 %476, %247
%478 = add nsw i64 %477, %377
%479 = getelementptr inbounds double, double* %13, i64 %478
%480 = load double, double* %479
%481 = fadd double %475, %480
%482 = or i64 %462, 3
%483 = mul nsw i64 %482, %247
%484 = add nsw i64 %483, %377
%485 = getelementptr inbounds double, double* %13, i64 %484
%486 = load double, double* %485
%487 = fadd double %481, %486
%488 = add nuw nsw i64 %462, 4
%489 = add i64 %464, 4
%490 = icmp eq i64 %489, %291
br i1 %490, label %768, label %461
491: ; preds = %458
%492 = icmp eq i64 %377, %248
br i1 %492, label %497, label %493
493: ; preds = %491
br i1 %245, label %494, label %920
494: ; preds = %493
%495 = sub nsw i64 %377, %247
%496 = mul nsw i64 %495, %247
br label %499
497: ; preds = %491
%498 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str.8, i64 0, i64 0))
tail call void @exit(i32 0)
unreachable
499: ; preds = %556, %494
%500 = phi i64 [ 0, %494 ], [ %559, %556 ]
%501 = phi double [ 0.000000e+00, %494 ], [ %558, %556 ]
%502 = phi i32 [ 0, %494 ], [ %557, %556 ]
%503 = mul nsw i64 %500, %247
br i1 %286, label %539, label %504
504: ; preds = %499, %533
%505 = phi i64 [ %536, %533 ], [ 0, %499 ]
%506 = phi double [ %535, %533 ], [ %501, %499 ]
%507 = phi i32 [ %534, %533 ], [ %502, %499 ]
%508 = phi i64 [ %537, %533 ], [ 0, %499 ]
%509 = add nsw i64 %505, %496
%510 = getelementptr inbounds i32, i32* %15, i64 %509
%511 = load i32, i32* %510
%512 = icmp eq i32 %511, 0
br i1 %512, label %519, label %513
513: ; preds = %504
%514 = add nsw i64 %505, %503
%515 = getelementptr inbounds double, double* %13, i64 %514
%516 = load double, double* %515
%517 = fadd double %506, %516
%518 = add nsw i32 %507, 1
br label %519
519: ; preds = %504, %513
%520 = phi i32 [ %518, %513 ], [ %507, %504 ]
%521 = phi double [ %517, %513 ], [ %506, %504 ]
%522 = or i64 %505, 1
%523 = add nsw i64 %522, %496
%524 = getelementptr inbounds i32, i32* %15, i64 %523
%525 = load i32, i32* %524
%526 = icmp eq i32 %525, 0
br i1 %526, label %533, label %527
527: ; preds = %519
%528 = add nsw i64 %522, %503
%529 = getelementptr inbounds double, double* %13, i64 %528
%530 = load double, double* %529
%531 = fadd double %521, %530
%532 = add nsw i32 %520, 1
br label %533
533: ; preds = %527, %519
%534 = phi i32 [ %532, %527 ], [ %520, %519 ]
%535 = phi double [ %531, %527 ], [ %521, %519 ]
%536 = add nuw nsw i64 %505, 2
%537 = add i64 %508, 2
%538 = icmp eq i64 %537, %287
br i1 %538, label %539, label %504
539: ; preds = %533, %499
%540 = phi i32 [ undef, %499 ], [ %534, %533 ]
%541 = phi double [ undef, %499 ], [ %535, %533 ]
%542 = phi i64 [ 0, %499 ], [ %536, %533 ]
%543 = phi double [ %501, %499 ], [ %535, %533 ]
%544 = phi i32 [ %502, %499 ], [ %534, %533 ]
br i1 %288, label %556, label %545
545: ; preds = %539
%546 = add nsw i64 %542, %496
%547 = getelementptr inbounds i32, i32* %15, i64 %546
%548 = load i32, i32* %547
%549 = icmp eq i32 %548, 0
br i1 %549, label %556, label %550
550: ; preds = %545
%551 = add nsw i64 %542, %503
%552 = getelementptr inbounds double, double* %13, i64 %551
%553 = load double, double* %552
%554 = fadd double %543, %553
%555 = add nsw i32 %544, 1
br label %556
556: ; preds = %545, %550, %539
%557 = phi i32 [ %540, %539 ], [ %555, %550 ], [ %544, %545 ]
%558 = phi double [ %541, %539 ], [ %554, %550 ], [ %543, %545 ]
%559 = add nuw nsw i64 %500, 1
%560 = icmp eq i64 %559, %253
br i1 %560, label %802, label %499
561: ; preds = %456
br i1 %457, label %562, label %601
562: ; preds = %561
br i1 %245, label %563, label %1567
563: ; preds = %562
br i1 %282, label %784, label %564
564: ; preds = %563, %595
%565 = phi i64 [ %598, %595 ], [ 0, %563 ]
%566 = phi double [ %597, %595 ], [ 0.000000e+00, %563 ]
%567 = phi i32 [ %596, %595 ], [ 0, %563 ]
%568 = phi i64 [ %599, %595 ], [ 0, %563 ]
%569 = add nsw i64 %565, %371
%570 = getelementptr inbounds i32, i32* %15, i64 %569
%571 = load i32, i32* %570
%572 = icmp eq i32 %571, 0
br i1 %572, label %580, label %573
573: ; preds = %564
%574 = mul nsw i64 %565, %247
%575 = add nsw i64 %574, %377
%576 = getelementptr inbounds double, double* %13, i64 %575
%577 = load double, double* %576
%578 = fadd double %566, %577
%579 = add nsw i32 %567, 1
br label %580
580: ; preds = %564, %573
%581 = phi i32 [ %579, %573 ], [ %567, %564 ]
%582 = phi double [ %578, %573 ], [ %566, %564 ]
%583 = or i64 %565, 1
%584 = add nsw i64 %583, %371
%585 = getelementptr inbounds i32, i32* %15, i64 %584
%586 = load i32, i32* %585
%587 = icmp eq i32 %586, 0
br i1 %587, label %595, label %588
588: ; preds = %580
%589 = mul nsw i64 %583, %247
%590 = add nsw i64 %589, %377
%591 = getelementptr inbounds double, double* %13, i64 %590
%592 = load double, double* %591
%593 = fadd double %582, %592
%594 = add nsw i32 %581, 1
br label %595
595: ; preds = %588, %580
%596 = phi i32 [ %594, %588 ], [ %581, %580 ]
%597 = phi double [ %593, %588 ], [ %582, %580 ]
%598 = add nuw nsw i64 %565, 2
%599 = add i64 %568, 2
%600 = icmp eq i64 %599, %283
br i1 %600, label %784, label %564
601: ; preds = %561
%602 = icmp eq i64 %377, %248
br i1 %602, label %607, label %603
603: ; preds = %601
br i1 %245, label %604, label %1567
604: ; preds = %603
%605 = sub nsw i64 %377, %247
%606 = mul nsw i64 %605, %247
br label %668
607: ; preds = %601
br i1 %245, label %608, label %1567
608: ; preds = %607, %663
%609 = phi i64 [ %666, %663 ], [ 0, %607 ]
%610 = phi double [ %665, %663 ], [ 0.000000e+00, %607 ]
%611 = phi i32 [ %664, %663 ], [ 0, %607 ]
%612 = add nsw i64 %609, %371
%613 = getelementptr inbounds i32, i32* %15, i64 %612
%614 = load i32, i32* %613
%615 = icmp eq i32 %614, 0
%616 = or i1 %615, %246
br i1 %616, label %663, label %617
617: ; preds = %608
%618 = mul nsw i64 %609, %247
br i1 %278, label %645, label %619
619: ; preds = %617, %619
%620 = phi i64 [ %642, %619 ], [ 0, %617 ]
%621 = phi double [ %641, %619 ], [ %610, %617 ]
%622 = phi i64 [ %643, %619 ], [ 0, %617 ]
%623 = add nsw i64 %620, %618
%624 = getelementptr inbounds double, double* %13, i64 %623
%625 = load double, double* %624
%626 = fadd double %621, %625
%627 = or i64 %620, 1
%628 = add nsw i64 %627, %618
%629 = getelementptr inbounds double, double* %13, i64 %628
%630 = load double, double* %629
%631 = fadd double %626, %630
%632 = or i64 %620, 2
%633 = add nsw i64 %632, %618
%634 = getelementptr inbounds double, double* %13, i64 %633
%635 = load double, double* %634
%636 = fadd double %631, %635
%637 = or i64 %620, 3
%638 = add nsw i64 %637, %618
%639 = getelementptr inbounds double, double* %13, i64 %638
%640 = load double, double* %639
%641 = fadd double %636, %640
%642 = add nuw nsw i64 %620, 4
%643 = add i64 %622, 4
%644 = icmp eq i64 %643, %279
br i1 %644, label %645, label %619
645: ; preds = %619, %617
%646 = phi double [ undef, %617 ], [ %641, %619 ]
%647 = phi i64 [ 0, %617 ], [ %642, %619 ]
%648 = phi double [ %610, %617 ], [ %641, %619 ]
br i1 %280, label %660, label %649
649: ; preds = %645, %649
%650 = phi i64 [ %657, %649 ], [ %647, %645 ]
%651 = phi double [ %656, %649 ], [ %648, %645 ]
%652 = phi i64 [ %658, %649 ], [ 0, %645 ]
%653 = add nsw i64 %650, %618
%654 = getelementptr inbounds double, double* %13, i64 %653
%655 = load double, double* %654
%656 = fadd double %651, %655
%657 = add nuw nsw i64 %650, 1
%658 = add i64 %652, 1
%659 = icmp eq i64 %658, %277
br i1 %659, label %660, label %649
660: ; preds = %649, %645
%661 = phi double [ %646, %645 ], [ %656, %649 ]
%662 = add i32 %611, %11
br label %663
663: ; preds = %660, %608
%664 = phi i32 [ %611, %608 ], [ %662, %660 ]
%665 = phi double [ %610, %608 ], [ %661, %660 ]
%666 = add nuw nsw i64 %609, 1
%667 = icmp eq i64 %666, %252
br i1 %667, label %802, label %608
668: ; preds = %604, %731
%669 = phi i64 [ 0, %604 ], [ %734, %731 ]
%670 = phi double [ 0.000000e+00, %604 ], [ %733, %731 ]
%671 = phi i32 [ 0, %604 ], [ %732, %731 ]
%672 = add nsw i64 %669, %371
%673 = getelementptr inbounds i32, i32* %15, i64 %672
%674 = load i32, i32* %673
%675 = icmp eq i32 %674, 0
%676 = or i1 %675, %246
br i1 %676, label %731, label %677
677: ; preds = %668
%678 = mul nsw i64 %669, %247
br i1 %274, label %714, label %679
679: ; preds = %677, %708
%680 = phi i64 [ %711, %708 ], [ 0, %677 ]
%681 = phi double [ %710, %708 ], [ %670, %677 ]
%682 = phi i32 [ %709, %708 ], [ %671, %677 ]
%683 = phi i64 [ %712, %708 ], [ 0, %677 ]
%684 = add nsw i64 %680, %606
%685 = getelementptr inbounds i32, i32* %15, i64 %684
%686 = load i32, i32* %685
%687 = icmp eq i32 %686, 0
br i1 %687, label %694, label %688
688: ; preds = %679
%689 = add nsw i64 %680, %678
%690 = getelementptr inbounds double, double* %13, i64 %689
%691 = load double, double* %690
%692 = fadd double %681, %691
%693 = add nsw i32 %682, 1
br label %694
694: ; preds = %679, %688
%695 = phi i32 [ %693, %688 ], [ %682, %679 ]
%696 = phi double [ %692, %688 ], [ %681, %679 ]
%697 = or i64 %680, 1
%698 = add nsw i64 %697, %606
%699 = getelementptr inbounds i32, i32* %15, i64 %698
%700 = load i32, i32* %699
%701 = icmp eq i32 %700, 0
br i1 %701, label %708, label %702
702: ; preds = %694
%703 = add nsw i64 %697, %678
%704 = getelementptr inbounds double, double* %13, i64 %703
%705 = load double, double* %704
%706 = fadd double %696, %705
%707 = add nsw i32 %695, 1
br label %708
708: ; preds = %702, %694
%709 = phi i32 [ %707, %702 ], [ %695, %694 ]
%710 = phi double [ %706, %702 ], [ %696, %694 ]
%711 = add nuw nsw i64 %680, 2
%712 = add i64 %683, 2
%713 = icmp eq i64 %712, %275
br i1 %713, label %714, label %679
714: ; preds = %708, %677
%715 = phi i32 [ undef, %677 ], [ %709, %708 ]
%716 = phi double [ undef, %677 ], [ %710, %708 ]
%717 = phi i64 [ 0, %677 ], [ %711, %708 ]
%718 = phi double [ %670, %677 ], [ %710, %708 ]
%719 = phi i32 [ %671, %677 ], [ %709, %708 ]
br i1 %276, label %731, label %720
720: ; preds = %714
%721 = add nsw i64 %717, %606
%722 = getelementptr inbounds i32, i32* %15, i64 %721
%723 = load i32, i32* %722
%724 = icmp eq i32 %723, 0
br i1 %724, label %731, label %725
725: ; preds = %720
%726 = add nsw i64 %717, %678
%727 = getelementptr inbounds double, double* %13, i64 %726
%728 = load double, double* %727
%729 = fadd double %718, %728
%730 = add nsw i32 %719, 1
br label %731
731: ; preds = %714, %725, %720, %668
%732 = phi i32 [ %671, %668 ], [ %715, %714 ], [ %730, %725 ], [ %719, %720 ]
%733 = phi double [ %670, %668 ], [ %716, %714 ], [ %729, %725 ], [ %718, %720 ]
%734 = add nuw nsw i64 %669, 1
%735 = icmp eq i64 %734, %251
br i1 %735, label %802, label %668
736: ; preds = %387, %386
%737 = phi double [ undef, %386 ], [ %409, %387 ]
%738 = phi i64 [ 0, %386 ], [ %410, %387 ]
%739 = phi double [ 0.000000e+00, %386 ], [ %409, %387 ]
br i1 %300, label %802, label %740
740: ; preds = %736, %740
%741 = phi i64 [ %748, %740 ], [ %738, %736 ]
%742 = phi double [ %747, %740 ], [ %739, %736 ]
%743 = phi i64 [ %749, %740 ], [ 0, %736 ]
%744 = add nsw i64 %741, %372
%745 = getelementptr inbounds double, double* %13, i64 %744
%746 = load double, double* %745
%747 = fadd double %742, %746
%748 = add nuw nsw i64 %741, 1
%749 = add i64 %743, 1
%750 = icmp eq i64 %749, %297
br i1 %750, label %802, label %740
751: ; preds = %448, %416
%752 = phi i32 [ undef, %416 ], [ %449, %448 ]
%753 = phi double [ undef, %416 ], [ %450, %448 ]
%754 = phi i64 [ 0, %416 ], [ %451, %448 ]
%755 = phi double [ 0.000000e+00, %416 ], [ %450, %448 ]
%756 = phi i32 [ 0, %416 ], [ %449, %448 ]
br i1 %296, label %802, label %757
757: ; preds = %751
%758 = add nsw i64 %754, %418
%759 = getelementptr inbounds i32, i32* %15, i64 %758
%760 = load i32, i32* %759
%761 = icmp eq i32 %760, 0
br i1 %761, label %802, label %762
762: ; preds = %757
%763 = add nsw i64 %754, %372
%764 = getelementptr inbounds double, double* %13, i64 %763
%765 = load double, double* %764
%766 = fadd double %755, %765
%767 = add nsw i32 %756, 1
br label %802
768: ; preds = %461, %460
%769 = phi double [ undef, %460 ], [ %487, %461 ]
%770 = phi i64 [ 0, %460 ], [ %488, %461 ]
%771 = phi double [ 0.000000e+00, %460 ], [ %487, %461 ]
br i1 %292, label %802, label %772
772: ; preds = %768, %772
%773 = phi i64 [ %781, %772 ], [ %770, %768 ]
%774 = phi double [ %780, %772 ], [ %771, %768 ]
%775 = phi i64 [ %782, %772 ], [ 0, %768 ]
%776 = mul nsw i64 %773, %247
%777 = add nsw i64 %776, %377
%778 = getelementptr inbounds double, double* %13, i64 %777
%779 = load double, double* %778
%780 = fadd double %774, %779
%781 = add nuw nsw i64 %773, 1
%782 = add i64 %775, 1
%783 = icmp eq i64 %782, %289
br i1 %783, label %802, label %772
784: ; preds = %595, %563
%785 = phi i32 [ undef, %563 ], [ %596, %595 ]
%786 = phi double [ undef, %563 ], [ %597, %595 ]
%787 = phi i64 [ 0, %563 ], [ %598, %595 ]
%788 = phi double [ 0.000000e+00, %563 ], [ %597, %595 ]
%789 = phi i32 [ 0, %563 ], [ %596, %595 ]
br i1 %284, label %802, label %790
790: ; preds = %784
%791 = add nsw i64 %787, %371
%792 = getelementptr inbounds i32, i32* %15, i64 %791
%793 = load i32, i32* %792
%794 = icmp eq i32 %793, 0
br i1 %794, label %802, label %795
795: ; preds = %790
%796 = mul nsw i64 %787, %247
%797 = add nsw i64 %796, %377
%798 = getelementptr inbounds double, double* %13, i64 %797
%799 = load double, double* %798
%800 = fadd double %788, %799
%801 = add nsw i32 %789, 1
br label %802
802: ; preds = %731, %663, %784, %795, %790, %556, %768, %772, %751, %762, %757, %736, %740
%803 = phi i32 [ %11, %740 ], [ %11, %736 ], [ %752, %751 ], [ %767, %762 ], [ %756, %757 ], [ %11, %772 ], [ %11, %768 ], [ %557, %556 ], [ %785, %784 ], [ %801, %795 ], [ %789, %790 ], [ %664, %663 ], [ %732, %731 ]
%804 = phi double [ %737, %736 ], [ %747, %740 ], [ %753, %751 ], [ %766, %762 ], [ %755, %757 ], [ %769, %768 ], [ %780, %772 ], [ %558, %556 ], [ %786, %784 ], [ %800, %795 ], [ %788, %790 ], [ %665, %663 ], [ %733, %731 ]
%805 = fcmp olt double %804, 1.000000e-15
br i1 %805, label %806, label %1167
806: ; preds = %802
%807 = sitofp i32 %803 to double
%808 = fdiv double 1.000000e+00, %807
br i1 %368, label %809, label %917
809: ; preds = %806
%810 = icmp eq i64 %377, %248
br i1 %810, label %815, label %881
811: ; preds = %385, %415
%812 = icmp ne i64 %377, %248
%813 = icmp slt i64 %377, %247
%814 = and i1 %812, %813
br i1 %814, label %915, label %1567
815: ; preds = %809
br i1 %245, label %816, label %1567
816: ; preds = %815
%817 = sitofp i32 %380 to double
br i1 %352, label %871, label %818
818: ; preds = %816
%819 = insertelement <2 x double> poison, double %817, i64 0
%820 = shufflevector <2 x double> %819, <2 x double> poison, <2 x i32> zeroinitializer
%821 = insertelement <2 x double> poison, double %808, i64 0
%822 = shufflevector <2 x double> %821, <2 x double> poison, <2 x i32> zeroinitializer
%823 = insertelement <2 x double> poison, double %817, i64 0
%824 = shufflevector <2 x double> %823, <2 x double> poison, <2 x i32> zeroinitializer
%825 = insertelement <2 x double> poison, double %808, i64 0
%826 = shufflevector <2 x double> %825, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %355, label %856, label %827
827: ; preds = %818, %827
%828 = phi i64 [ %853, %827 ], [ 0, %818 ]
%829 = phi i64 [ %854, %827 ], [ 0, %818 ]
%830 = add nsw i64 %828, %372
%831 = getelementptr inbounds double, double* %14, i64 %830
%832 = bitcast double* %831 to <2 x double>*
%833 = load <2 x double>, <2 x double>* %832
%834 = getelementptr inbounds double, double* %831, i64 2
%835 = bitcast double* %834 to <2 x double>*
%836 = load <2 x double>, <2 x double>* %835
%837 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %820, <2 x double> %822, <2 x double> %833)
%838 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %824, <2 x double> %826, <2 x double> %836)
%839 = bitcast double* %831 to <2 x double>*
store <2 x double> %837, <2 x double>* %839
%840 = bitcast double* %834 to <2 x double>*
store <2 x double> %838, <2 x double>* %840
%841 = or i64 %828, 4
%842 = add nsw i64 %841, %372
%843 = getelementptr inbounds double, double* %14, i64 %842
%844 = bitcast double* %843 to <2 x double>*
%845 = load <2 x double>, <2 x double>* %844
%846 = getelementptr inbounds double, double* %843, i64 2
%847 = bitcast double* %846 to <2 x double>*
%848 = load <2 x double>, <2 x double>* %847
%849 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %820, <2 x double> %822, <2 x double> %845)
%850 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %824, <2 x double> %826, <2 x double> %848)
%851 = bitcast double* %843 to <2 x double>*
store <2 x double> %849, <2 x double>* %851
%852 = bitcast double* %846 to <2 x double>*
store <2 x double> %850, <2 x double>* %852
%853 = add nuw i64 %828, 8
%854 = add i64 %829, 2
%855 = icmp eq i64 %854, %356
br i1 %855, label %856, label %827
856: ; preds = %827, %818
%857 = phi i64 [ 0, %818 ], [ %853, %827 ]
br i1 %357, label %870, label %858
858: ; preds = %856
%859 = add nsw i64 %857, %372
%860 = getelementptr inbounds double, double* %14, i64 %859
%861 = bitcast double* %860 to <2 x double>*
%862 = load <2 x double>, <2 x double>* %861
%863 = getelementptr inbounds double, double* %860, i64 2
%864 = bitcast double* %863 to <2 x double>*
%865 = load <2 x double>, <2 x double>* %864
%866 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %820, <2 x double> %822, <2 x double> %862)
%867 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %824, <2 x double> %826, <2 x double> %865)
%868 = bitcast double* %860 to <2 x double>*
store <2 x double> %866, <2 x double>* %868
%869 = bitcast double* %863 to <2 x double>*
store <2 x double> %867, <2 x double>* %869
br label %870
870: ; preds = %856, %858
br i1 %358, label %1567, label %871
871: ; preds = %816, %870
%872 = phi i64 [ 0, %816 ], [ %353, %870 ]
br label %873
873: ; preds = %871, %873
%874 = phi i64 [ %879, %873 ], [ %872, %871 ]
%875 = add nsw i64 %874, %372
%876 = getelementptr inbounds double, double* %14, i64 %875
%877 = load double, double* %876
%878 = tail call double @llvm.fmuladd.f64(double %817, double %808, double %877)
store double %878, double* %876
%879 = add nuw nsw i64 %874, 1
%880 = icmp eq i64 %879, %263
br i1 %880, label %1567, label %873
881: ; preds = %809
%882 = icmp slt i64 %377, %247
br i1 %882, label %915, label %883
883: ; preds = %881
br i1 %245, label %884, label %1567
884: ; preds = %883
%885 = sub nsw i64 %377, %247
%886 = mul nsw i64 %885, %247
%887 = sitofp i32 %380 to double
br i1 %349, label %1522, label %888
888: ; preds = %884, %911
%889 = phi i64 [ %912, %911 ], [ 0, %884 ]
%890 = phi i64 [ %913, %911 ], [ 0, %884 ]
%891 = add nsw i64 %889, %886
%892 = getelementptr inbounds i32, i32* %15, i64 %891
%893 = load i32, i32* %892
%894 = icmp eq i32 %893, 0
br i1 %894, label %900, label %895
895: ; preds = %888
%896 = add nsw i64 %889, %372
%897 = getelementptr inbounds double, double* %14, i64 %896
%898 = load double, double* %897
%899 = tail call double @llvm.fmuladd.f64(double %887, double %808, double %898)
store double %899, double* %897
br label %900
900: ; preds = %888, %895
%901 = or i64 %889, 1
%902 = add nsw i64 %901, %886
%903 = getelementptr inbounds i32, i32* %15, i64 %902
%904 = load i32, i32* %903
%905 = icmp eq i32 %904, 0
br i1 %905, label %911, label %906
906: ; preds = %900
%907 = add nsw i64 %901, %372
%908 = getelementptr inbounds double, double* %14, i64 %907
%909 = load double, double* %908
%910 = tail call double @llvm.fmuladd.f64(double %887, double %808, double %909)
store double %910, double* %908
br label %911
911: ; preds = %906, %900
%912 = add nuw nsw i64 %889, 2
%913 = add i64 %890, 2
%914 = icmp eq i64 %913, %350
br i1 %914, label %1522, label %888
915: ; preds = %811, %881
%916 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str.8, i64 0, i64 0))
tail call void @exit(i32 0)
unreachable
917: ; preds = %806
%918 = icmp slt i64 %377, %247
br i1 %369, label %919, label %998
919: ; preds = %917
br i1 %918, label %924, label %944
920: ; preds = %493, %459
%921 = icmp sge i64 %377, %247
%922 = icmp eq i64 %377, %248
%923 = select i1 %921, i1 %922, i1 false
br i1 %923, label %951, label %1567
924: ; preds = %919
br i1 %245, label %925, label %1567
925: ; preds = %924
%926 = sitofp i32 %380 to double
br i1 %345, label %1534, label %927
927: ; preds = %925, %927
%928 = phi i64 [ %941, %927 ], [ 0, %925 ]
%929 = phi i64 [ %942, %927 ], [ 0, %925 ]
%930 = mul nsw i64 %928, %247
%931 = add nsw i64 %930, %377
%932 = getelementptr inbounds double, double* %14, i64 %931
%933 = load double, double* %932
%934 = tail call double @llvm.fmuladd.f64(double %926, double %808, double %933)
store double %934, double* %932
%935 = or i64 %928, 1
%936 = mul nsw i64 %935, %247
%937 = add nsw i64 %936, %377
%938 = getelementptr inbounds double, double* %14, i64 %937
%939 = load double, double* %938
%940 = tail call double @llvm.fmuladd.f64(double %926, double %808, double %939)
store double %940, double* %938
%941 = add nuw nsw i64 %928, 2
%942 = add i64 %929, 2
%943 = icmp eq i64 %942, %346
br i1 %943, label %1534, label %927
944: ; preds = %919
%945 = icmp eq i64 %377, %248
br i1 %945, label %951, label %946
946: ; preds = %944
br i1 %245, label %947, label %1567
947: ; preds = %946
%948 = sub nsw i64 %377, %247
%949 = mul nsw i64 %948, %247
%950 = sitofp i32 %380 to double
br label %953
951: ; preds = %920, %944
%952 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str.8, i64 0, i64 0))
tail call void @exit(i32 0)
unreachable
953: ; preds = %995, %947
%954 = phi i64 [ 0, %947 ], [ %996, %995 ]
%955 = mul nsw i64 %954, %247
br i1 %341, label %983, label %956
956: ; preds = %953, %979
%957 = phi i64 [ %980, %979 ], [ 0, %953 ]
%958 = phi i64 [ %981, %979 ], [ 0, %953 ]
%959 = add nsw i64 %957, %949
%960 = getelementptr inbounds i32, i32* %15, i64 %959
%961 = load i32, i32* %960
%962 = icmp eq i32 %961, 0
br i1 %962, label %968, label %963
963: ; preds = %956
%964 = add nsw i64 %957, %955
%965 = getelementptr inbounds double, double* %14, i64 %964
%966 = load double, double* %965
%967 = tail call double @llvm.fmuladd.f64(double %950, double %808, double %966)
store double %967, double* %965
br label %968
968: ; preds = %956, %963
%969 = or i64 %957, 1
%970 = add nsw i64 %969, %949
%971 = getelementptr inbounds i32, i32* %15, i64 %970
%972 = load i32, i32* %971
%973 = icmp eq i32 %972, 0
br i1 %973, label %979, label %974
974: ; preds = %968
%975 = add nsw i64 %969, %955
%976 = getelementptr inbounds double, double* %14, i64 %975
%977 = load double, double* %976
%978 = tail call double @llvm.fmuladd.f64(double %950, double %808, double %977)
store double %978, double* %976
br label %979
979: ; preds = %974, %968
%980 = add nuw nsw i64 %957, 2
%981 = add i64 %958, 2
%982 = icmp eq i64 %981, %342
br i1 %982, label %983, label %956
983: ; preds = %979, %953
%984 = phi i64 [ 0, %953 ], [ %980, %979 ]
br i1 %343, label %995, label %985
985: ; preds = %983
%986 = add nsw i64 %984, %949
%987 = getelementptr inbounds i32, i32* %15, i64 %986
%988 = load i32, i32* %987
%989 = icmp eq i32 %988, 0
br i1 %989, label %995, label %990
990: ; preds = %985
%991 = add nsw i64 %984, %955
%992 = getelementptr inbounds double, double* %14, i64 %991
%993 = load double, double* %992
%994 = tail call double @llvm.fmuladd.f64(double %950, double %808, double %993)
store double %994, double* %992
br label %995
995: ; preds = %985, %990, %983
%996 = add nuw nsw i64 %954, 1
%997 = icmp eq i64 %996, %262
br i1 %997, label %1567, label %953
998: ; preds = %917
br i1 %918, label %999, label %1031
999: ; preds = %998
br i1 %245, label %1000, label %1567
1000: ; preds = %999
%1001 = sitofp i32 %380 to double
br i1 %337, label %1542, label %1002
1002: ; preds = %1000, %1027
%1003 = phi i64 [ %1028, %1027 ], [ 0, %1000 ]
%1004 = phi i64 [ %1029, %1027 ], [ 0, %1000 ]
%1005 = add nsw i64 %1003, %371
%1006 = getelementptr inbounds i32, i32* %15, i64 %1005
%1007 = load i32, i32* %1006
%1008 = icmp eq i32 %1007, 0
br i1 %1008, label %1015, label %1009
1009: ; preds = %1002
%1010 = mul nsw i64 %1003, %247
%1011 = add nsw i64 %1010, %377
%1012 = getelementptr inbounds double, double* %14, i64 %1011
%1013 = load double, double* %1012
%1014 = tail call double @llvm.fmuladd.f64(double %1001, double %808, double %1013)
store double %1014, double* %1012
br label %1015
1015: ; preds = %1002, %1009
%1016 = or i64 %1003, 1
%1017 = add nsw i64 %1016, %371
%1018 = getelementptr inbounds i32, i32* %15, i64 %1017
%1019 = load i32, i32* %1018
%1020 = icmp eq i32 %1019, 0
br i1 %1020, label %1027, label %1021
1021: ; preds = %1015
%1022 = mul nsw i64 %1016, %247
%1023 = add nsw i64 %1022, %377
%1024 = getelementptr inbounds double, double* %14, i64 %1023
%1025 = load double, double* %1024
%1026 = tail call double @llvm.fmuladd.f64(double %1001, double %808, double %1025)
store double %1026, double* %1024
br label %1027
1027: ; preds = %1021, %1015
%1028 = add nuw nsw i64 %1003, 2
%1029 = add i64 %1004, 2
%1030 = icmp eq i64 %1029, %338
br i1 %1030, label %1542, label %1002
1031: ; preds = %998
%1032 = icmp eq i64 %377, %248
br i1 %1032, label %1038, label %1033
1033: ; preds = %1031
br i1 %245, label %1034, label %1567
1034: ; preds = %1033
%1035 = sub nsw i64 %377, %247
%1036 = mul nsw i64 %1035, %247
%1037 = sitofp i32 %380 to double
br label %1116
1038: ; preds = %1031
br i1 %245, label %1039, label %1567
1039: ; preds = %1038
%1040 = sitofp i32 %380 to double
%1041 = insertelement <2 x double> poison, double %1040, i64 0
%1042 = shufflevector <2 x double> %1041, <2 x double> poison, <2 x i32> zeroinitializer
%1043 = insertelement <2 x double> poison, double %808, i64 0
%1044 = shufflevector <2 x double> %1043, <2 x double> poison, <2 x i32> zeroinitializer
%1045 = insertelement <2 x double> poison, double %1040, i64 0
%1046 = shufflevector <2 x double> %1045, <2 x double> poison, <2 x i32> zeroinitializer
%1047 = insertelement <2 x double> poison, double %808, i64 0
%1048 = shufflevector <2 x double> %1047, <2 x double> poison, <2 x i32> zeroinitializer
br label %1049
1049: ; preds = %1039, %1113
%1050 = phi i64 [ 0, %1039 ], [ %1114, %1113 ]
%1051 = add nsw i64 %1050, %371
%1052 = getelementptr inbounds i32, i32* %15, i64 %1051
%1053 = load i32, i32* %1052
%1054 = icmp eq i32 %1053, 0
%1055 = or i1 %1054, %246
br i1 %1055, label %1113, label %1056
1056: ; preds = %1049
%1057 = mul nsw i64 %1050, %247
br i1 %329, label %1103, label %1058
1058: ; preds = %1056
br i1 %332, label %1088, label %1059
1059: ; preds = %1058, %1059
%1060 = phi i64 [ %1085, %1059 ], [ 0, %1058 ]
%1061 = phi i64 [ %1086, %1059 ], [ 0, %1058 ]
%1062 = add nsw i64 %1060, %1057
%1063 = getelementptr inbounds double, double* %14, i64 %1062
%1064 = bitcast double* %1063 to <2 x double>*
%1065 = load <2 x double>, <2 x double>* %1064
%1066 = getelementptr inbounds double, double* %1063, i64 2
%1067 = bitcast double* %1066 to <2 x double>*
%1068 = load <2 x double>, <2 x double>* %1067
%1069 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1042, <2 x double> %1044, <2 x double> %1065)
%1070 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1046, <2 x double> %1048, <2 x double> %1068)
%1071 = bitcast double* %1063 to <2 x double>*
store <2 x double> %1069, <2 x double>* %1071
%1072 = bitcast double* %1066 to <2 x double>*
store <2 x double> %1070, <2 x double>* %1072
%1073 = or i64 %1060, 4
%1074 = add nsw i64 %1073, %1057
%1075 = getelementptr inbounds double, double* %14, i64 %1074
%1076 = bitcast double* %1075 to <2 x double>*
%1077 = load <2 x double>, <2 x double>* %1076
%1078 = getelementptr inbounds double, double* %1075, i64 2
%1079 = bitcast double* %1078 to <2 x double>*
%1080 = load <2 x double>, <2 x double>* %1079
%1081 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1042, <2 x double> %1044, <2 x double> %1077)
%1082 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1046, <2 x double> %1048, <2 x double> %1080)
%1083 = bitcast double* %1075 to <2 x double>*
store <2 x double> %1081, <2 x double>* %1083
%1084 = bitcast double* %1078 to <2 x double>*
store <2 x double> %1082, <2 x double>* %1084
%1085 = add nuw i64 %1060, 8
%1086 = add i64 %1061, 2
%1087 = icmp eq i64 %1086, %333
br i1 %1087, label %1088, label %1059
1088: ; preds = %1059, %1058
%1089 = phi i64 [ 0, %1058 ], [ %1085, %1059 ]
br i1 %334, label %1102, label %1090
1090: ; preds = %1088
%1091 = add nsw i64 %1089, %1057
%1092 = getelementptr inbounds double, double* %14, i64 %1091
%1093 = bitcast double* %1092 to <2 x double>*
%1094 = load <2 x double>, <2 x double>* %1093
%1095 = getelementptr inbounds double, double* %1092, i64 2
%1096 = bitcast double* %1095 to <2 x double>*
%1097 = load <2 x double>, <2 x double>* %1096
%1098 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1042, <2 x double> %1044, <2 x double> %1094)
%1099 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1046, <2 x double> %1048, <2 x double> %1097)
%1100 = bitcast double* %1092 to <2 x double>*
store <2 x double> %1098, <2 x double>* %1100
%1101 = bitcast double* %1095 to <2 x double>*
store <2 x double> %1099, <2 x double>* %1101
br label %1102
1102: ; preds = %1088, %1090
br i1 %335, label %1113, label %1103
1103: ; preds = %1056, %1102
%1104 = phi i64 [ 0, %1056 ], [ %330, %1102 ]
br label %1105
1105: ; preds = %1103, %1105
%1106 = phi i64 [ %1111, %1105 ], [ %1104, %1103 ]
%1107 = add nsw i64 %1106, %1057
%1108 = getelementptr inbounds double, double* %14, i64 %1107
%1109 = load double, double* %1108
%1110 = tail call double @llvm.fmuladd.f64(double %1040, double %808, double %1109)
store double %1110, double* %1108
%1111 = add nuw nsw i64 %1106, 1
%1112 = icmp eq i64 %1111, %261
br i1 %1112, label %1113, label %1105
1113: ; preds = %1105, %1102, %1049
%1114 = add nuw nsw i64 %1050, 1
%1115 = icmp eq i64 %1114, %261
br i1 %1115, label %1567, label %1049
1116: ; preds = %1034, %1164
%1117 = phi i64 [ 0, %1034 ], [ %1165, %1164 ]
%1118 = add nsw i64 %1117, %371
%1119 = getelementptr inbounds i32, i32* %15, i64 %1118
%1120 = load i32, i32* %1119
%1121 = icmp eq i32 %1120, 0
%1122 = or i1 %1121, %246
br i1 %1122, label %1164, label %1123
1123: ; preds = %1116
%1124 = mul nsw i64 %1117, %247
br i1 %326, label %1152, label %1125
1125: ; preds = %1123, %1148
%1126 = phi i64 [ %1149, %1148 ], [ 0, %1123 ]
%1127 = phi i64 [ %1150, %1148 ], [ 0, %1123 ]
%1128 = add nsw i64 %1126, %1036
%1129 = getelementptr inbounds i32, i32* %15, i64 %1128
%1130 = load i32, i32* %1129
%1131 = icmp eq i32 %1130, 0
br i1 %1131, label %1137, label %1132
1132: ; preds = %1125
%1133 = add nsw i64 %1126, %1124
%1134 = getelementptr inbounds double, double* %14, i64 %1133
%1135 = load double, double* %1134
%1136 = tail call double @llvm.fmuladd.f64(double %1037, double %808, double %1135)
store double %1136, double* %1134
br label %1137
1137: ; preds = %1125, %1132
%1138 = or i64 %1126, 1
%1139 = add nsw i64 %1138, %1036
%1140 = getelementptr inbounds i32, i32* %15, i64 %1139
%1141 = load i32, i32* %1140
%1142 = icmp eq i32 %1141, 0
br i1 %1142, label %1148, label %1143
1143: ; preds = %1137
%1144 = add nsw i64 %1138, %1124
%1145 = getelementptr inbounds double, double* %14, i64 %1144
%1146 = load double, double* %1145
%1147 = tail call double @llvm.fmuladd.f64(double %1037, double %808, double %1146)
store double %1147, double* %1145
br label %1148
1148: ; preds = %1143, %1137
%1149 = add nuw nsw i64 %1126, 2
%1150 = add i64 %1127, 2
%1151 = icmp eq i64 %1150, %327
br i1 %1151, label %1152, label %1125
1152: ; preds = %1148, %1123
%1153 = phi i64 [ 0, %1123 ], [ %1149, %1148 ]
br i1 %328, label %1164, label %1154
1154: ; preds = %1152
%1155 = add nsw i64 %1153, %1036
%1156 = getelementptr inbounds i32, i32* %15, i64 %1155
%1157 = load i32, i32* %1156
%1158 = icmp eq i32 %1157, 0
br i1 %1158, label %1164, label %1159
1159: ; preds = %1154
%1160 = add nsw i64 %1153, %1124
%1161 = getelementptr inbounds double, double* %14, i64 %1160
%1162 = load double, double* %1161
%1163 = tail call double @llvm.fmuladd.f64(double %1037, double %808, double %1162)
store double %1163, double* %1161
br label %1164
1164: ; preds = %1152, %1159, %1154, %1116
%1165 = add nuw nsw i64 %1117, 1
%1166 = icmp eq i64 %1165, %260
br i1 %1166, label %1567, label %1116
1167: ; preds = %802
br i1 %368, label %1168, label %1287
1168: ; preds = %1167
%1169 = icmp eq i64 %377, %248
br i1 %1169, label %1170, label %1260
1170: ; preds = %1168
br i1 %245, label %1171, label %1567
1171: ; preds = %1170
%1172 = sitofp i32 %380 to double
%1173 = select i1 %315, i1 true, i1 %375
br i1 %1173, label %1223, label %1174
1174: ; preds = %1171
%1175 = insertelement <2 x double> poison, double %1172, i64 0
%1176 = shufflevector <2 x double> %1175, <2 x double> poison, <2 x i32> zeroinitializer
%1177 = insertelement <2 x double> poison, double %804, i64 0
%1178 = shufflevector <2 x double> %1177, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %318, label %1208, label %1179
1179: ; preds = %1174, %1179
%1180 = phi i64 [ %1205, %1179 ], [ 0, %1174 ]
%1181 = phi i64 [ %1206, %1179 ], [ 0, %1174 ]
%1182 = add nsw i64 %1180, %372
%1183 = getelementptr inbounds double, double* %13, i64 %1182
%1184 = bitcast double* %1183 to <2 x double>*
%1185 = load <2 x double>, <2 x double>* %1184
%1186 = fmul <2 x double> %1185, %1176
%1187 = fdiv <2 x double> %1186, %1178
%1188 = getelementptr inbounds double, double* %14, i64 %1182
%1189 = bitcast double* %1188 to <2 x double>*
%1190 = load <2 x double>, <2 x double>* %1189
%1191 = fadd <2 x double> %1190, %1187
%1192 = bitcast double* %1188 to <2 x double>*
store <2 x double> %1191, <2 x double>* %1192
%1193 = or i64 %1180, 2
%1194 = add nsw i64 %1193, %372
%1195 = getelementptr inbounds double, double* %13, i64 %1194
%1196 = bitcast double* %1195 to <2 x double>*
%1197 = load <2 x double>, <2 x double>* %1196
%1198 = fmul <2 x double> %1197, %1176
%1199 = fdiv <2 x double> %1198, %1178
%1200 = getelementptr inbounds double, double* %14, i64 %1194
%1201 = bitcast double* %1200 to <2 x double>*
%1202 = load <2 x double>, <2 x double>* %1201
%1203 = fadd <2 x double> %1202, %1199
%1204 = bitcast double* %1200 to <2 x double>*
store <2 x double> %1203, <2 x double>* %1204
%1205 = add nuw i64 %1180, 4
%1206 = add nuw i64 %1181, 2
%1207 = icmp eq i64 %1206, %319
br i1 %1207, label %1208, label %1179
1208: ; preds = %1179, %1174
%1209 = phi i64 [ 0, %1174 ], [ %1205, %1179 ]
br i1 %320, label %1222, label %1210
1210: ; preds = %1208
%1211 = add nsw i64 %1209, %372
%1212 = getelementptr inbounds double, double* %13, i64 %1211
%1213 = bitcast double* %1212 to <2 x double>*
%1214 = load <2 x double>, <2 x double>* %1213
%1215 = fmul <2 x double> %1214, %1176
%1216 = fdiv <2 x double> %1215, %1178
%1217 = getelementptr inbounds double, double* %14, i64 %1211
%1218 = bitcast double* %1217 to <2 x double>*
%1219 = load <2 x double>, <2 x double>* %1218
%1220 = fadd <2 x double> %1219, %1216
%1221 = bitcast double* %1217 to <2 x double>*
store <2 x double> %1220, <2 x double>* %1221
br label %1222
1222: ; preds = %1208, %1210
br i1 %321, label %1567, label %1223
1223: ; preds = %1171, %1222
%1224 = phi i64 [ 0, %1171 ], [ %316, %1222 ]
%1225 = xor i64 %1224, -1
br i1 %323, label %1236, label %1226
1226: ; preds = %1223
%1227 = add nsw i64 %1224, %372
%1228 = getelementptr inbounds double, double* %13, i64 %1227
%1229 = load double, double* %1228
%1230 = fmul double %1229, %1172
%1231 = fdiv double %1230, %804
%1232 = getelementptr inbounds double, double* %14, i64 %1227
%1233 = load double, double* %1232
%1234 = fadd double %1233, %1231
store double %1234, double* %1232
%1235 = or i64 %1224, 1
br label %1236
1236: ; preds = %1226, %1223
%1237 = phi i64 [ %1224, %1223 ], [ %1235, %1226 ]
%1238 = icmp eq i64 %1225, %324
br i1 %1238, label %1567, label %1239
1239: ; preds = %1236, %1239
%1240 = phi i64 [ %1258, %1239 ], [ %1237, %1236 ]
%1241 = add nsw i64 %1240, %372
%1242 = getelementptr inbounds double, double* %13, i64 %1241
%1243 = load double, double* %1242
%1244 = fmul double %1243, %1172
%1245 = fdiv double %1244, %804
%1246 = getelementptr inbounds double, double* %14, i64 %1241
%1247 = load double, double* %1246
%1248 = fadd double %1247, %1245
store double %1248, double* %1246
%1249 = add nuw nsw i64 %1240, 1
%1250 = add nsw i64 %1249, %372
%1251 = getelementptr inbounds double, double* %13, i64 %1250
%1252 = load double, double* %1251
%1253 = fmul double %1252, %1172
%1254 = fdiv double %1253, %804
%1255 = getelementptr inbounds double, double* %14, i64 %1250
%1256 = load double, double* %1255
%1257 = fadd double %1256, %1254
store double %1257, double* %1255
%1258 = add nuw nsw i64 %1240, 2
%1259 = icmp eq i64 %1258, %259
br i1 %1259, label %1567, label %1239
1260: ; preds = %1168
%1261 = icmp slt i64 %377, %247
br i1 %1261, label %1285, label %1262
1262: ; preds = %1260
br i1 %245, label %1263, label %1567
1263: ; preds = %1262
%1264 = sub nsw i64 %377, %247
%1265 = mul nsw i64 %1264, %247
%1266 = sitofp i32 %380 to double
br label %1267
1267: ; preds = %1263, %1282
%1268 = phi i64 [ 0, %1263 ], [ %1283, %1282 ]
%1269 = add nsw i64 %1268, %1265
%1270 = getelementptr inbounds i32, i32* %15, i64 %1269
%1271 = load i32, i32* %1270
%1272 = icmp eq i32 %1271, 0
br i1 %1272, label %1282, label %1273
1273: ; preds = %1267
%1274 = add nsw i64 %1268, %372
%1275 = getelementptr inbounds double, double* %13, i64 %1274
%1276 = load double, double* %1275
%1277 = fmul double %1276, %1266
%1278 = fdiv double %1277, %804
%1279 = getelementptr inbounds double, double* %14, i64 %1274
%1280 = load double, double* %1279
%1281 = fadd double %1280, %1278
store double %1281, double* %1279
br label %1282
1282: ; preds = %1267, %1273
%1283 = add nuw nsw i64 %1268, 1
%1284 = icmp eq i64 %1283, %258
br i1 %1284, label %1567, label %1267
1285: ; preds = %1260
%1286 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str.8, i64 0, i64 0))
tail call void @exit(i32 0)
unreachable
1287: ; preds = %1167
%1288 = icmp slt i64 %377, %247
br i1 %369, label %1289, label %1351
1289: ; preds = %1287
br i1 %1288, label %1290, label %1318
1290: ; preds = %1289
br i1 %245, label %1291, label %1567
1291: ; preds = %1290
%1292 = sitofp i32 %380 to double
br i1 %312, label %1555, label %1293
1293: ; preds = %1291, %1293
%1294 = phi i64 [ %1315, %1293 ], [ 0, %1291 ]
%1295 = phi i64 [ %1316, %1293 ], [ 0, %1291 ]
%1296 = mul nsw i64 %1294, %247
%1297 = add nsw i64 %1296, %377
%1298 = getelementptr inbounds double, double* %13, i64 %1297
%1299 = load double, double* %1298
%1300 = fmul double %1299, %1292
%1301 = fdiv double %1300, %804
%1302 = getelementptr inbounds double, double* %14, i64 %1297
%1303 = load double, double* %1302
%1304 = fadd double %1303, %1301
store double %1304, double* %1302
%1305 = or i64 %1294, 1
%1306 = mul nsw i64 %1305, %247
%1307 = add nsw i64 %1306, %377
%1308 = getelementptr inbounds double, double* %13, i64 %1307
%1309 = load double, double* %1308
%1310 = fmul double %1309, %1292
%1311 = fdiv double %1310, %804
%1312 = getelementptr inbounds double, double* %14, i64 %1307
%1313 = load double, double* %1312
%1314 = fadd double %1313, %1311
store double %1314, double* %1312
%1315 = add nuw nsw i64 %1294, 2
%1316 = add i64 %1295, 2
%1317 = icmp eq i64 %1316, %313
br i1 %1317, label %1555, label %1293
1318: ; preds = %1289
%1319 = icmp eq i64 %377, %248
br i1 %1319, label %1325, label %1320
1320: ; preds = %1318
br i1 %245, label %1321, label %1567
1321: ; preds = %1320
%1322 = sub nsw i64 %377, %247
%1323 = mul nsw i64 %1322, %247
%1324 = sitofp i32 %380 to double
br label %1327
1325: ; preds = %1318
%1326 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str.8, i64 0, i64 0))
tail call void @exit(i32 0)
unreachable
1327: ; preds = %1348, %1321
%1328 = phi i64 [ 0, %1321 ], [ %1349, %1348 ]
%1329 = mul nsw i64 %1328, %247
br label %1330
1330: ; preds = %1327, %1345
%1331 = phi i64 [ 0, %1327 ], [ %1346, %1345 ]
%1332 = add nsw i64 %1331, %1323
%1333 = getelementptr inbounds i32, i32* %15, i64 %1332
%1334 = load i32, i32* %1333
%1335 = icmp eq i32 %1334, 0
br i1 %1335, label %1345, label %1336
1336: ; preds = %1330
%1337 = add nsw i64 %1331, %1329
%1338 = getelementptr inbounds double, double* %13, i64 %1337
%1339 = load double, double* %1338
%1340 = fmul double %1339, %1324
%1341 = fdiv double %1340, %804
%1342 = getelementptr inbounds double, double* %14, i64 %1337
%1343 = load double, double* %1342
%1344 = fadd double %1343, %1341
store double %1344, double* %1342
br label %1345
1345: ; preds = %1330, %1336
%1346 = add nuw nsw i64 %1331, 1
%1347 = icmp eq i64 %1346, %257
br i1 %1347, label %1348, label %1330
1348: ; preds = %1345
%1349 = add nuw nsw i64 %1328, 1
%1350 = icmp eq i64 %1349, %257
br i1 %1350, label %1567, label %1327
1351: ; preds = %1287
br i1 %1288, label %1352, label %1374
1352: ; preds = %1351
br i1 %245, label %1353, label %1567
1353: ; preds = %1352
%1354 = sitofp i32 %380 to double
br label %1355
1355: ; preds = %1353, %1371
%1356 = phi i64 [ 0, %1353 ], [ %1372, %1371 ]
%1357 = add nsw i64 %1356, %371
%1358 = getelementptr inbounds i32, i32* %15, i64 %1357
%1359 = load i32, i32* %1358
%1360 = icmp eq i32 %1359, 0
br i1 %1360, label %1371, label %1361
1361: ; preds = %1355
%1362 = mul nsw i64 %1356, %247
%1363 = add nsw i64 %1362, %377
%1364 = getelementptr inbounds double, double* %13, i64 %1363
%1365 = load double, double* %1364
%1366 = fmul double %1365, %1354
%1367 = fdiv double %1366, %804
%1368 = getelementptr inbounds double, double* %14, i64 %1363
%1369 = load double, double* %1368
%1370 = fadd double %1369, %1367
store double %1370, double* %1368
br label %1371
1371: ; preds = %1355, %1361
%1372 = add nuw nsw i64 %1356, 1
%1373 = icmp eq i64 %1372, %256
br i1 %1373, label %1567, label %1355
1374: ; preds = %1351
%1375 = icmp eq i64 %377, %248
br i1 %1375, label %1381, label %1376
1376: ; preds = %1374
br i1 %245, label %1377, label %1567
1377: ; preds = %1376
%1378 = sub nsw i64 %377, %247
%1379 = mul nsw i64 %1378, %247
%1380 = sitofp i32 %380 to double
br label %1492
1381: ; preds = %1374
br i1 %245, label %1382, label %1567
1382: ; preds = %1381
%1383 = sitofp i32 %380 to double
%1384 = insertelement <2 x double> poison, double %1383, i64 0
%1385 = shufflevector <2 x double> %1384, <2 x double> poison, <2 x i32> zeroinitializer
%1386 = insertelement <2 x double> poison, double %804, i64 0
%1387 = shufflevector <2 x double> %1386, <2 x double> poison, <2 x i32> zeroinitializer
br label %1388
1388: ; preds = %1382, %1489
%1389 = phi i64 [ 0, %1382 ], [ %1490, %1489 ]
%1390 = mul i64 %1389, %247
%1391 = getelementptr double, double* %14, i64 %1390
%1392 = add i64 %1390, %251
%1393 = getelementptr double, double* %14, i64 %1392
%1394 = getelementptr double, double* %13, i64 %1390
%1395 = getelementptr double, double* %13, i64 %1392
%1396 = add nsw i64 %1389, %371
%1397 = getelementptr inbounds i32, i32* %15, i64 %1396
%1398 = load i32, i32* %1397
%1399 = icmp eq i32 %1398, 0
%1400 = or i1 %1399, %246
br i1 %1400, label %1489, label %1401
1401: ; preds = %1388
%1402 = mul nsw i64 %1389, %247
br i1 %301, label %1452, label %1403
1403: ; preds = %1401
%1404 = icmp ult double* %1391, %1395
%1405 = icmp ult double* %1394, %1393
%1406 = and i1 %1404, %1405
br i1 %1406, label %1452, label %1407
1407: ; preds = %1403
br i1 %304, label %1437, label %1408
1408: ; preds = %1407, %1408
%1409 = phi i64 [ %1434, %1408 ], [ 0, %1407 ]
%1410 = phi i64 [ %1435, %1408 ], [ 0, %1407 ]
%1411 = add nsw i64 %1409, %1402
%1412 = getelementptr inbounds double, double* %13, i64 %1411
%1413 = bitcast double* %1412 to <2 x double>*
%1414 = load <2 x double>, <2 x double>* %1413
%1415 = fmul <2 x double> %1414, %1385
%1416 = fdiv <2 x double> %1415, %1387
%1417 = getelementptr inbounds double, double* %14, i64 %1411
%1418 = bitcast double* %1417 to <2 x double>*
%1419 = load <2 x double>, <2 x double>* %1418
%1420 = fadd <2 x double> %1419, %1416
%1421 = bitcast double* %1417 to <2 x double>*
store <2 x double> %1420, <2 x double>* %1421
%1422 = or i64 %1409, 2
%1423 = add nsw i64 %1422, %1402
%1424 = getelementptr inbounds double, double* %13, i64 %1423
%1425 = bitcast double* %1424 to <2 x double>*
%1426 = load <2 x double>, <2 x double>* %1425
%1427 = fmul <2 x double> %1426, %1385
%1428 = fdiv <2 x double> %1427, %1387
%1429 = getelementptr inbounds double, double* %14, i64 %1423
%1430 = bitcast double* %1429 to <2 x double>*
%1431 = load <2 x double>, <2 x double>* %1430
%1432 = fadd <2 x double> %1431, %1428
%1433 = bitcast double* %1429 to <2 x double>*
store <2 x double> %1432, <2 x double>* %1433
%1434 = add nuw i64 %1409, 4
%1435 = add nuw i64 %1410, 2
%1436 = icmp eq i64 %1435, %305
br i1 %1436, label %1437, label %1408
1437: ; preds = %1408, %1407
%1438 = phi i64 [ 0, %1407 ], [ %1434, %1408 ]
br i1 %306, label %1451, label %1439
1439: ; preds = %1437
%1440 = add nsw i64 %1438, %1402
%1441 = getelementptr inbounds double, double* %13, i64 %1440
%1442 = bitcast double* %1441 to <2 x double>*
%1443 = load <2 x double>, <2 x double>* %1442
%1444 = fmul <2 x double> %1443, %1385
%1445 = fdiv <2 x double> %1444, %1387
%1446 = getelementptr inbounds double, double* %14, i64 %1440
%1447 = bitcast double* %1446 to <2 x double>*
%1448 = load <2 x double>, <2 x double>* %1447
%1449 = fadd <2 x double> %1448, %1445
%1450 = bitcast double* %1446 to <2 x double>*
store <2 x double> %1449, <2 x double>* %1450
br label %1451
1451: ; preds = %1437, %1439
br i1 %307, label %1489, label %1452
1452: ; preds = %1403, %1401, %1451
%1453 = phi i64 [ 0, %1403 ], [ 0, %1401 ], [ %302, %1451 ]
%1454 = xor i64 %1453, -1
br i1 %309, label %1465, label %1455
1455: ; preds = %1452
%1456 = add nsw i64 %1453, %1402
%1457 = getelementptr inbounds double, double* %13, i64 %1456
%1458 = load double, double* %1457
%1459 = fmul double %1458, %1383
%1460 = fdiv double %1459, %804
%1461 = getelementptr inbounds double, double* %14, i64 %1456
%1462 = load double, double* %1461
%1463 = fadd double %1462, %1460
store double %1463, double* %1461
%1464 = or i64 %1453, 1
br label %1465
1465: ; preds = %1455, %1452
%1466 = phi i64 [ %1453, %1452 ], [ %1464, %1455 ]
%1467 = icmp eq i64 %1454, %310
br i1 %1467, label %1489, label %1468
1468: ; preds = %1465, %1468
%1469 = phi i64 [ %1487, %1468 ], [ %1466, %1465 ]
%1470 = add nsw i64 %1469, %1402
%1471 = getelementptr inbounds double, double* %13, i64 %1470
%1472 = load double, double* %1471
%1473 = fmul double %1472, %1383
%1474 = fdiv double %1473, %804
%1475 = getelementptr inbounds double, double* %14, i64 %1470
%1476 = load double, double* %1475
%1477 = fadd double %1476, %1474
store double %1477, double* %1475
%1478 = add nuw nsw i64 %1469, 1
%1479 = add nsw i64 %1478, %1402
%1480 = getelementptr inbounds double, double* %13, i64 %1479
%1481 = load double, double* %1480
%1482 = fmul double %1481, %1383
%1483 = fdiv double %1482, %804
%1484 = getelementptr inbounds double, double* %14, i64 %1479
%1485 = load double, double* %1484
%1486 = fadd double %1485, %1483
store double %1486, double* %1484
%1487 = add nuw nsw i64 %1469, 2
%1488 = icmp eq i64 %1487, %255
br i1 %1488, label %1489, label %1468
1489: ; preds = %1465, %1468, %1451, %1388
%1490 = add nuw nsw i64 %1389, 1
%1491 = icmp eq i64 %1490, %255
br i1 %1491, label %1567, label %1388
1492: ; preds = %1377, %1519
%1493 = phi i64 [ 0, %1377 ], [ %1520, %1519 ]
%1494 = add nsw i64 %1493, %371
%1495 = getelementptr inbounds i32, i32* %15, i64 %1494
%1496 = load i32, i32* %1495
%1497 = icmp eq i32 %1496, 0
%1498 = or i1 %1497, %246
br i1 %1498, label %1519, label %1499
1499: ; preds = %1492
%1500 = mul nsw i64 %1493, %247
br label %1501
1501: ; preds = %1499, %1516
%1502 = phi i64 [ 0, %1499 ], [ %1517, %1516 ]
%1503 = add nsw i64 %1502, %1379
%1504 = getelementptr inbounds i32, i32* %15, i64 %1503
%1505 = load i32, i32* %1504
%1506 = icmp eq i32 %1505, 0
br i1 %1506, label %1516, label %1507
1507: ; preds = %1501
%1508 = add nsw i64 %1502, %1500
%1509 = getelementptr inbounds double, double* %13, i64 %1508
%1510 = load double, double* %1509
%1511 = fmul double %1510, %1380
%1512 = fdiv double %1511, %804
%1513 = getelementptr inbounds double, double* %14, i64 %1508
%1514 = load double, double* %1513
%1515 = fadd double %1514, %1512
store double %1515, double* %1513
br label %1516
1516: ; preds = %1501, %1507
%1517 = add nuw nsw i64 %1502, 1
%1518 = icmp eq i64 %1517, %254
br i1 %1518, label %1519, label %1501
1519: ; preds = %1516, %1492
%1520 = add nuw nsw i64 %1493, 1
%1521 = icmp eq i64 %1520, %254
br i1 %1521, label %1567, label %1492
1522: ; preds = %911, %884
%1523 = phi i64 [ 0, %884 ], [ %912, %911 ]
br i1 %351, label %1567, label %1524
1524: ; preds = %1522
%1525 = add nsw i64 %1523, %886
%1526 = getelementptr inbounds i32, i32* %15, i64 %1525
%1527 = load i32, i32* %1526
%1528 = icmp eq i32 %1527, 0
br i1 %1528, label %1567, label %1529
1529: ; preds = %1524
%1530 = add nsw i64 %1523, %372
%1531 = getelementptr inbounds double, double* %14, i64 %1530
%1532 = load double, double* %1531
%1533 = tail call double @llvm.fmuladd.f64(double %887, double %808, double %1532)
store double %1533, double* %1531
br label %1567
1534: ; preds = %927, %925
%1535 = phi i64 [ 0, %925 ], [ %941, %927 ]
br i1 %347, label %1567, label %1536
1536: ; preds = %1534
%1537 = mul nsw i64 %1535, %247
%1538 = add nsw i64 %1537, %377
%1539 = getelementptr inbounds double, double* %14, i64 %1538
%1540 = load double, double* %1539
%1541 = tail call double @llvm.fmuladd.f64(double %926, double %808, double %1540)
store double %1541, double* %1539
br label %1567
1542: ; preds = %1027, %1000
%1543 = phi i64 [ 0, %1000 ], [ %1028, %1027 ]
br i1 %339, label %1567, label %1544
1544: ; preds = %1542
%1545 = add nsw i64 %1543, %371
%1546 = getelementptr inbounds i32, i32* %15, i64 %1545
%1547 = load i32, i32* %1546
%1548 = icmp eq i32 %1547, 0
br i1 %1548, label %1567, label %1549
1549: ; preds = %1544
%1550 = mul nsw i64 %1543, %247
%1551 = add nsw i64 %1550, %377
%1552 = getelementptr inbounds double, double* %14, i64 %1551
%1553 = load double, double* %1552
%1554 = tail call double @llvm.fmuladd.f64(double %1001, double %808, double %1553)
store double %1554, double* %1552
br label %1567
1555: ; preds = %1293, %1291
%1556 = phi i64 [ 0, %1291 ], [ %1315, %1293 ]
br i1 %314, label %1567, label %1557
1557: ; preds = %1555
%1558 = mul nsw i64 %1556, %247
%1559 = add nsw i64 %1558, %377
%1560 = getelementptr inbounds double, double* %13, i64 %1559
%1561 = load double, double* %1560
%1562 = fmul double %1561, %1292
%1563 = fdiv double %1562, %804
%1564 = getelementptr inbounds double, double* %14, i64 %1559
%1565 = load double, double* %1564
%1566 = fadd double %1565, %1563
store double %1566, double* %1564
br label %1567
1567: ; preds = %1519, %1489, %1371, %1348, %1557, %1555, %1282, %1236, %1239, %1164, %1113, %1542, %1549, %1544, %995, %1536, %1534, %1522, %1529, %1524, %873, %1222, %870, %562, %607, %603, %920, %811, %1376, %1381, %1352, %1320, %1290, %1262, %1170, %1033, %1038, %999, %946, %924, %883, %815, %376
%1568 = add nuw nsw i64 %377, 1
%1569 = icmp eq i64 %1568, %250
br i1 %1569, label %1570, label %376
1570: ; preds = %1567
%1571 = add nuw nsw i64 %360, 1
%1572 = icmp eq i64 %1571, %250
br i1 %1572, label %1573, label %359
1573: ; preds = %1570, %239
ret void
}