#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double distaa3(double *, double *, double *, int, int, int, int, int, int);
double edgedf(double, double, double);
void edtaa3(double *img, double *gx, double *gy, int w, int h, short *distx,
            short *disty, double *dist) {
  int x, y, i, c;
  int offset_u, offset_ur, offset_r, offset_rd, offset_d, offset_dl, offset_l,
      offset_lu;
  double olddist, newdist;
  int cdistx, cdisty, newdistx, newdisty;
  int changed;
  double epsilon = 1e-3;
  offset_u = -w;
  offset_ur = -w + 1;
  offset_r = 1;
  offset_rd = w + 1;
  offset_d = w;
  offset_dl = w - 1;
  offset_l = -1;
  offset_lu = -w - 1;
  for (i = 0; i < w * h; i++) {
    distx[i] = 0;
    disty[i] = 0;
    if (img[i] <= 0.0) {
      dist[i] = 1000000.0;
    } else if (img[i] < 1.0) {
      dist[i] = edgedf(gx[i], gy[i], img[i]);
    } else {
      dist[i] = 0.0;
    }
  }
  do {
    changed = 0;
    for (y = 1; y < h; y++) {
      i = y * w;
      olddist = dist[i];
      if (olddist > 0) {
        c = i + offset_u;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx;
        newdisty = cdisty + 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_ur;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx - 1;
        newdisty = cdisty + 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          changed = 1;
        }
      }
      i++;
      for (x = 1; x < w - 1; x++, i++) {
        olddist = dist[i];
        if (olddist <= 0)
          continue;
        c = i + offset_l;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx + 1;
        newdisty = cdisty;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_lu;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx + 1;
        newdisty = cdisty + 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_u;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx;
        newdisty = cdisty + 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_ur;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx - 1;
        newdisty = cdisty + 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          changed = 1;
        }
      }
      olddist = dist[i];
      if (olddist > 0) {
        c = i + offset_l;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx + 1;
        newdisty = cdisty;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_lu;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx + 1;
        newdisty = cdisty + 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_u;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx;
        newdisty = cdisty + 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          changed = 1;
        }
      }
      i = y * w + w - 2;
      for (x = w - 2; x >= 0; x--, i--) {
        olddist = dist[i];
        if (olddist <= 0)
          continue;
        c = i + offset_r;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx - 1;
        newdisty = cdisty;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          changed = 1;
        }
      }
    }
    for (y = h - 2; y >= 0; y--) {
      i = y * w + w - 1;
      olddist = dist[i];
      if (olddist > 0) {
        c = i + offset_d;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx;
        newdisty = cdisty - 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_dl;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx + 1;
        newdisty = cdisty - 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          changed = 1;
        }
      }
      i--;
      for (x = w - 2; x > 0; x--, i--) {
        olddist = dist[i];
        if (olddist <= 0)
          continue;
        c = i + offset_r;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx - 1;
        newdisty = cdisty;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_rd;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx - 1;
        newdisty = cdisty - 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_d;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx;
        newdisty = cdisty - 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_dl;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx + 1;
        newdisty = cdisty - 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          changed = 1;
        }
      }
      olddist = dist[i];
      if (olddist > 0) {
        c = i + offset_r;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx - 1;
        newdisty = cdisty;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_rd;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx - 1;
        newdisty = cdisty - 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          olddist = newdist;
          changed = 1;
        }
        c = i + offset_d;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx;
        newdisty = cdisty - 1;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          changed = 1;
        }
      }
      i = y * w + 1;
      for (x = 1; x < w; x++, i++) {
        olddist = dist[i];
        if (olddist <= 0)
          continue;
        c = i + offset_l;
        cdistx = distx[c];
        cdisty = disty[c];
        newdistx = cdistx + 1;
        newdisty = cdisty;
        newdist =
            (distaa3(img, gx, gy, w, c, cdistx, cdisty, newdistx, newdisty));
        if (newdist < olddist - epsilon) {
          distx[i] = newdistx;
          disty[i] = newdisty;
          dist[i] = newdist;
          changed = 1;
        }
      }
    }
  } while (changed);
}


x86 assembly (clang, -O0):
<edtaa3>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  0x1eae(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
movl   $0xffffffff,-0x54(%rbp)
xor    %eax,%eax
sub    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x1c(%rbp),%ecx
imul   -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    1284 <edtaa3+0x164>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jb     1203 <edtaa3+0xe3>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  0x1e17(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1271 <edtaa3+0x151>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  0x1df5(%rip),%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    125c <edtaa3+0x13c>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
call   1030 <edgedf@plt>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    126c <edtaa3+0x14c>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1271 <edtaa3+0x151>
jmp    1276 <edtaa3+0x156>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11a5 <edtaa3+0x85>
jmp    1289 <edtaa3+0x169>
movl   $0x0,-0x7c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1bf0 <edtaa3+0xad0>
mov    -0x30(%rbp),%eax
imul   -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1473 <edtaa3+0x353>
mov    -0x34(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    13a3 <edtaa3+0x283>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    146e <edtaa3+0x34e>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x7c(%rbp)
jmp    1473 <edtaa3+0x353>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1819 <edtaa3+0x6f9>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     14b9 <edtaa3+0x399>
jmp    1802 <edtaa3+0x6e2>
mov    -0x34(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    158b <edtaa3+0x46b>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1660 <edtaa3+0x540>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1732 <edtaa3+0x612>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    17fd <edtaa3+0x6dd>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x7c(%rbp)
jmp    1802 <edtaa3+0x6e2>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1483 <edtaa3+0x363>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ab1 <edtaa3+0x991>
mov    -0x34(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    190f <edtaa3+0x7ef>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    19e4 <edtaa3+0x8c4>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1aac <edtaa3+0x98c>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x7c(%rbp)
jmp    1ab1 <edtaa3+0x991>
mov    -0x30(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     1bdd <edtaa3+0xabd>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     1af9 <edtaa3+0x9d9>
jmp    1bc6 <edtaa3+0xaa6>
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1bc1 <edtaa3+0xaa1>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x7c(%rbp)
jmp    1bc6 <edtaa3+0xaa6>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1aca <edtaa3+0x9aa>
jmp    1be2 <edtaa3+0xac2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1297 <edtaa3+0x177>
mov    -0x20(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jl     254e <edtaa3+0x142e>
mov    -0x30(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1dd9 <edtaa3+0xcb9>
mov    -0x34(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1d09 <edtaa3+0xbe9>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1dd4 <edtaa3+0xcb4>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x7c(%rbp)
jmp    1dd9 <edtaa3+0xcb9>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jle    217a <edtaa3+0x105a>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     1e1a <edtaa3+0xcfa>
jmp    2163 <edtaa3+0x1043>
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1eec <edtaa3+0xdcc>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1fc1 <edtaa3+0xea1>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    2093 <edtaa3+0xf73>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    215e <edtaa3+0x103e>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x7c(%rbp)
jmp    2163 <edtaa3+0x1043>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1deb <edtaa3+0xccb>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2412 <edtaa3+0x12f2>
mov    -0x34(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    2270 <edtaa3+0x1150>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    2345 <edtaa3+0x1225>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    240d <edtaa3+0x12ed>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x7c(%rbp)
jmp    2412 <edtaa3+0x12f2>
mov    -0x30(%rbp),%eax
imul   -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    253b <edtaa3+0x141b>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jb     2457 <edtaa3+0x1337>
jmp    2524 <edtaa3+0x1404>
mov    -0x34(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x6c(%rbp)
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x38(%rbp),%r8d
mov    -0x6c(%rbp),%r9d
mov    -0x70(%rbp),%r11d
mov    -0x74(%rbp),%r10d
mov    -0x78(%rbp),%eax
mov    %r11d,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
call   1040 <distaa3@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
subsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    251f <edtaa3+0x13ff>
mov    -0x74(%rbp),%eax
mov    %ax,%dx
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x78(%rbp),%eax
mov    %ax,%dx
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x7c(%rbp)
jmp    2524 <edtaa3+0x1404>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2426 <edtaa3+0x1306>
jmp    2540 <edtaa3+0x1420>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1bf9 <edtaa3+0xad9>
jmp    2553 <edtaa3+0x1433>
cmpl   $0x0,-0x7c(%rbp)
jne    1289 <edtaa3+0x169>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<edtaa3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,%r12
mov    %ecx,%r13d
mov    %rdx,0x10(%rsp)
mov    %rsi,0x8(%rsp)
mov    %rdi,0x18(%rsp)
mov    0x1c0(%rsp),%r14
mov    %r8,%rax
mov    %r8,0x68(%rsp)
imul   %ecx,%r8d
mov    %r8,%r15
test   %r8d,%r8d
jle    1201 <edtaa3+0xe1>
mov    %r15d,%ebx
xor    %ebp,%ebp
movsd  0x1e8d(%rip),%xmm1
xorpd  %xmm3,%xmm3
movsd  0x1e89(%rip),%xmm4
jmp    11a6 <edtaa3+0x86>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%rbx
je     1201 <edtaa3+0xe1>
movw   $0x0,(%r12,%rbp,2)
movw   $0x0,(%r14,%rbp,2)
mov    0x18(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm2
ucomisd %xmm2,%xmm3
movapd %xmm1,%xmm0
jae    1190 <edtaa3+0x70>
xorpd  %xmm0,%xmm0
ucomisd %xmm2,%xmm4
jbe    1190 <edtaa3+0x70>
mov    0x8(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm0
mov    0x10(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm1
call   1030 <edgedf@plt>
movsd  0x1e15(%rip),%xmm4
xorpd  %xmm3,%xmm3
movsd  0x1e01(%rip),%xmm1
jmp    1190 <edtaa3+0x70>
mov    %r12,0x20(%rsp)
cmpl   $0x2,0x68(%rsp)
jl     22d2 <edtaa3+0x11b2>
mov    $0x1,%ecx
sub    %r13d,%ecx
lea    0x1(%r13),%ebx
lea    -0x1(%r13),%edx
mov    0x68(%rsp),%rbp
lea    -0x2(%rbp),%esi
lea    -0x1(%rbp),%eax
imul   %r13d,%eax
lea    -0x2(%rax),%r8d
movslq %esi,%rdi
mov    %rdi,0x100(%rsp)
imul   %r13d,%esi
mov    %r13d,%edi
neg    %edi
movslq %ecx,%r9
lea    -0x2(%r13,%r13,1),%r10d
movslq %edx,%r11
movslq %esi,%rcx
movslq %edi,%rsi
add    $0xffffffff,%eax
mov    %rax,0x108(%rsp)
lea    -0x1(%r15),%eax
mov    %rax,0xf8(%rsp)
lea    -0x2(%r15),%eax
mov    %rax,0xf0(%rsp)
add    $0xfffffffd,%r15d
mov    %r15,0x110(%rsp)
mov    %r8d,%eax
mov    %rax,0xe8(%rsp)
mov    %ecx,%eax
mov    %rax,0xe0(%rsp)
mov    0x20(%rsp),%rdi
lea    0x2(%rdi,%rcx,2),%rax
mov    %rax,0xd8(%rsp)
lea    (%rsi,%rsi,1),%rax
mov    %rax,0x138(%rsp)
mov    0x1c0(%rsp),%rdx
lea    0x2(%rdx,%rcx,2),%rax
mov    %rax,0xd0(%rsp)
mov    0x1c8(%rsp),%rax
lea    (%rax,%rcx,8),%rax
add    $0x8,%rax
mov    %rax,0xc8(%rsp)
shl    $0x3,%rsi
mov    %rsi,0x140(%rsp)
xorpd  %xmm1,%xmm1
movslq %r13d,%r15
movslq %ebx,%rax
mov    %rax,0x130(%rsp)
mov    %ebp,%eax
mov    %rax,0x128(%rsp)
mov    %r9,%rax
mov    %r9,0xa8(%rsp)
lea    -0x1(%r9),%eax
mov    %rax,0xc0(%rsp)
lea    -0x2(%r15),%eax
mov    %rax,0x150(%rsp)
lea    0x2(%rdi),%rax
mov    %rax,0x120(%rsp)
lea    0x2(%rdx),%rax
mov    %rax,0x118(%rsp)
mov    %r11,0xb8(%rsp)
mov    %r11d,%eax
mov    %rax,0x98(%rsp)
xor    %r12d,%r12d
mov    $0x1,%r14d
mov    %r10d,0xa4(%rsp)
mov    %r10d,%ecx
mov    %rbx,%rax
mov    %rbx,0xb0(%rsp)
mov    %rbx,0x38(%rsp)
mov    %r13,0x50(%rsp)
mov    %r15,0x70(%rsp)
nopl   0x0(%rax)
mov    %rcx,0x60(%rsp)
mov    %r14,0x78(%rsp)
imul   %r15,%r14
mov    0x1c8(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    14d0 <edtaa3+0x3b0>
mov    %r14d,%eax
sub    %r13d,%eax
movslq %eax,%r8
mov    0x20(%rsp),%r15
movzwl (%r15,%r8,2),%eax
mov    %ax,0x30(%rsp)
movswl %ax,%r9d
mov    0x1c0(%rsp),%rbx
movswl (%rbx,%r8,2),%eax
lea    0x1(%rax),%ebp
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbp
push   %r9
push   %rax
movsd  %xmm0,0x20(%rsp)
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
addsd  0x1bf7(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    144e <edtaa3+0x32e>
movzwl 0x30(%rsp),%eax
mov    %ax,(%r15,%r14,2)
mov    %bp,(%rbx,%r14,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%r14,8)
addsd  0x1bcc(%rip),%xmm0
mov    $0x1,%r12d
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0xa8(%rsp),%rax
lea    (%r14,%rax,1),%r8
movswl (%r15,%r8,2),%r9d
movswl (%rbx,%r8,2),%eax
lea    -0x1(%r9),%ebp
lea    0x1(%rax),%r15d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %r15
push   %rbp
push   %rax
call   1040 <distaa3@plt>
add    $0x20,%rsp
movsd  (%rsp),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm1,%xmm1
jbe    14d8 <edtaa3+0x3b8>
mov    0x20(%rsp),%rax
mov    %bp,(%rax,%r14,2)
mov    %r15w,(%rbx,%r14,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%r14,8)
mov    $0x1,%r12d
jmp    14d8 <edtaa3+0x3b8>
nopl   0x0(%rax,%rax,1)
mov    0x1c0(%rsp),%rbx
cmp    $0x3,%r13d
mov    %r12,0x28(%rsp)
jl     17c0 <edtaa3+0x6a0>
mov    0x38(%rsp),%rcx
movslq %ecx,%r12
mov    %ecx,%eax
mov    %rax,0x58(%rsp)
mov    0xc0(%rsp),%rax
add    %ecx,%eax
mov    %rax,0x30(%rsp)
mov    0xa8(%rsp),%rax
lea    (%rax,%r12,1),%rax
mov    0x20(%rsp),%rcx
lea    (%rcx,%rax,2),%rdx
mov    %rdx,0x88(%rsp)
lea    (%rbx,%rax,2),%rax
mov    %rax,0x80(%rsp)
mov    %rcx,%rax
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%r12,8),%r15
lea    (%rax,%r12,2),%rax
mov    %rax,0x48(%rsp)
lea    (%rbx,%r12,2),%rax
mov    %rax,0x40(%rsp)
xor    %ebp,%ebp
jmp    157e <edtaa3+0x45e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x58(%rsp),%rax
lea    (%rax,%rbp,1),%r14d
add    $0x1,%r12
add    $0x1,%rbp
cmp    %ebp,0x150(%rsp)
je     17d0 <edtaa3+0x6b0>
movsd  (%r15,%rbp,8),%xmm0
ucomisd %xmm0,%xmm1
jae    1560 <edtaa3+0x440>
movslq %r14d,%r8
mov    0x20(%rsp),%rax
movswl (%rax,%r8,2),%r9d
mov    0x1c0(%rsp),%rax
movswl (%rax,%r8,2),%ebx
mov    %r13,%rcx
lea    0x1(%r9),%r13d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
push   %rbx
push   %r13
push   %rbx
movsd  %xmm0,0x20(%rsp)
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
addsd  0x1a31(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1614 <edtaa3+0x4f4>
mov    0x48(%rsp),%rax
mov    %r13w,(%rax,%rbp,2)
mov    0x40(%rsp),%rax
mov    %bx,(%rax,%rbp,2)
movsd  %xmm0,(%r15,%rbp,8)
addsd  0x1a0a(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0x50(%rsp),%r13
sub    %r13d,%r14d
movslq %r14d,%r8
mov    0x20(%rsp),%rax
movswl (%rax,%r8,2),%r9d
mov    0x1c0(%rsp),%rax
movswl (%rax,%r8,2),%eax
lea    0x1(%r9),%r14d
lea    0x1(%rax),%ebx
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbx
push   %r14
push   %rax
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
ucomisd %xmm0,%xmm1
jbe    16a0 <edtaa3+0x580>
mov    0x48(%rsp),%rax
mov    %r14w,(%rax,%rbp,2)
mov    0x40(%rsp),%rax
mov    %bx,(%rax,%rbp,2)
movsd  %xmm0,(%r15,%rbp,8)
addsd  0x197e(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0x30(%rsp),%rax
add    %rbp,%rax
movslq %eax,%r8
mov    0x20(%rsp),%rax
movzwl (%rax,%r8,2),%r14d
movswl %r14w,%r9d
mov    0x1c0(%rsp),%rax
movswl (%rax,%r8,2),%eax
lea    0x1(%rax),%ebx
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbx
push   %r9
push   %rax
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
ucomisd %xmm0,%xmm1
jbe    172c <edtaa3+0x60c>
mov    0x48(%rsp),%rax
mov    %r14w,(%rax,%rbp,2)
mov    0x40(%rsp),%rax
mov    %bx,(%rax,%rbp,2)
movsd  %xmm0,(%r15,%rbp,8)
addsd  0x18f2(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0x88(%rsp),%rax
movswl (%rax,%rbp,2),%r9d
mov    0x80(%rsp),%rax
movswl (%rax,%rbp,2),%eax
lea    -0x1(%r9),%r14d
lea    0x1(%rax),%ebx
mov    0x30(%rsp),%rcx
lea    (%rcx,%rbp,1),%r8d
add    $0x1,%r8d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbx
push   %r14
push   %rax
call   1040 <distaa3@plt>
add    $0x20,%rsp
movsd  (%rsp),%xmm1
ucomisd %xmm0,%xmm1
jbe    17af <edtaa3+0x68f>
mov    0x48(%rsp),%rax
mov    %r14w,(%rax,%rbp,2)
mov    0x40(%rsp),%rax
mov    %bx,(%rax,%rbp,2)
movsd  %xmm0,(%r15,%rbp,8)
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
mov    %r12d,%r14d
xorpd  %xmm1,%xmm1
jmp    1569 <edtaa3+0x449>
nopl   0x0(%rax,%rax,1)
mov    %r14d,%ebp
add    $0x1,%ebp
jmp    17dc <edtaa3+0x6bc>
nopl   0x0(%rax,%rax,1)
add    0x38(%rsp),%ebp
mov    0x1c0(%rsp),%rbx
movslq %ebp,%r15
mov    0x1c8(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    197e <edtaa3+0x85e>
movslq %r14d,%r8
mov    %r13,%rcx
mov    0x20(%rsp),%rax
movswl (%rax,%r8,2),%r9d
movswl (%rbx,%r8,2),%r13d
lea    0x1(%r9),%r12d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
push   %r13
push   %r12
push   %r13
movsd  %xmm0,0x20(%rsp)
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
addsd  0x17ca(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    187f <edtaa3+0x75f>
mov    0x20(%rsp),%rax
mov    %r12w,(%rax,%r15,2)
mov    %r13w,(%rbx,%r15,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
addsd  0x179f(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0x50(%rsp),%rcx
sub    %ecx,%r14d
movslq %r14d,%r8
mov    %rbx,%r12
mov    0x20(%rsp),%rbx
movswl (%rbx,%r8,2),%r9d
movswl (%r12,%r8,2),%eax
lea    0x1(%r9),%r14d
lea    0x1(%rax),%r13d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
push   %r13
push   %r14
push   %rax
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
ucomisd %xmm0,%xmm1
jbe    1904 <edtaa3+0x7e4>
mov    %r14w,(%rbx,%r15,2)
mov    %r13w,(%r12,%r15,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
addsd  0x171a(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0x50(%rsp),%r13
sub    %r13d,%ebp
movslq %ebp,%r8
movzwl (%rbx,%r8,2),%ebx
movswl %bx,%r9d
movswl (%r12,%r8,2),%eax
lea    0x1(%rax),%ebp
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbp
push   %r9
push   %rax
call   1040 <distaa3@plt>
add    $0x20,%rsp
movsd  (%rsp),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm1,%xmm1
jbe    197e <edtaa3+0x85e>
mov    0x20(%rsp),%rax
mov    %bx,(%rax,%r15,2)
mov    %bp,(%r12,%r15,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
cmp    $0x2,%r13d
jl     1a60 <edtaa3+0x940>
mov    0x60(%rsp),%rdx
movslq %edx,%rax
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%rax,8),%r13
mov    0x120(%rsp),%rcx
lea    (%rcx,%rax,2),%r14
mov    0x118(%rsp),%rcx
lea    (%rcx,%rax,2),%r12
lea    0x1(%rdx),%eax
mov    %rax,0x30(%rsp)
xor    %ebp,%ebp
jmp    19d6 <edtaa3+0x8b6>
add    $0xffffffffffffffff,%rbp
mov    0x98(%rsp),%rax
add    %ebp,%eax
test   %eax,%eax
jle    1a60 <edtaa3+0x940>
movsd  0x0(%r13,%rbp,8),%xmm0
ucomisd %xmm0,%xmm1
jae    19c0 <edtaa3+0x8a0>
movswl (%r14,%rbp,2),%r9d
movswl (%r12,%rbp,2),%ebx
lea    -0x1(%r9),%r15d
mov    0x30(%rsp),%rax
lea    (%rax,%rbp,1),%r8d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    0x58(%rsp),%rcx
push   %rbx
push   %r15
push   %rbx
movsd  %xmm0,0x20(%rsp)
call   1040 <distaa3@plt>
xorpd  %xmm1,%xmm1
add    $0x20,%rsp
movsd  (%rsp),%xmm2
addsd  0x15da(%rip),%xmm2
ucomisd %xmm0,%xmm2
jbe    19c0 <edtaa3+0x8a0>
mov    %r15w,-0x2(%r14,%rbp,2)
mov    %bx,-0x2(%r12,%rbp,2)
movsd  %xmm0,0x0(%r13,%rbp,8)
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
jmp    19c0 <edtaa3+0x8a0>
xchg   %ax,%ax
mov    0x78(%rsp),%r14
add    $0x1,%r14
mov    0x50(%rsp),%r13
mov    0x38(%rsp),%rax
add    %r13d,%eax
mov    %rax,0x38(%rsp)
mov    0x60(%rsp),%rcx
add    %r13d,%ecx
cmp    0x128(%rsp),%r14
mov    0x70(%rsp),%r15
mov    0x28(%rsp),%r12
jne    1390 <edtaa3+0x270>
cmpl   $0x2,0x68(%rsp)
jl     22a0 <edtaa3+0x1180>
mov    0xc8(%rsp),%rdx
mov    0xd0(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0xd8(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0xe0(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    0xe8(%rsp),%rax
mov    %rax,0x90(%rsp)
mov    0x110(%rsp),%rax
mov    %rax,0x80(%rsp)
mov    0xf0(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0xf8(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x108(%rsp),%rax
mov    %rax,0x78(%rsp)
mov    0x100(%rsp),%rax
jmp    1b93 <edtaa3+0xa73>
nopl   0x0(%rax)
mov    0x70(%rsp),%r15
mov    0x148(%rsp),%rsi
lea    -0x1(%rsi),%rax
mov    0xc0(%rsp),%rcx
add    %rcx,0x90(%rsp)
add    %rcx,0x78(%rsp)
add    %rcx,0x60(%rsp)
add    %rcx,0x38(%rsp)
add    %rcx,0x80(%rsp)
add    %rcx,0x88(%rsp)
mov    0x138(%rsp),%rcx
add    %rcx,0x40(%rsp)
add    %rcx,0x48(%rsp)
add    0x140(%rsp),%rdx
test   %rsi,%rsi
jle    22a0 <edtaa3+0x1180>
mov    %r12,0x28(%rsp)
mov    %rax,0x148(%rsp)
imul   %r15,%rax
lea    (%rax,%r15,1),%r12
mov    0x1c8(%rsp),%rcx
movsd  -0x8(%rcx,%r12,8),%xmm0
ucomisd %xmm1,%xmm0
mov    %rdx,0x58(%rsp)
jbe    1cf6 <edtaa3+0xbd6>
lea    (%rax,%r15,1),%r14
add    $0xffffffffffffffff,%r14
lea    (%r14,%r15,1),%r8
mov    0x20(%rsp),%rbx
movzwl (%rbx,%r8,2),%eax
mov    %ax,0x30(%rsp)
movswl %ax,%r9d
mov    0x1c0(%rsp),%r15
movswl (%r15,%r8,2),%eax
lea    -0x1(%rax),%ebp
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbp
push   %r9
push   %rax
movsd  %xmm0,0x20(%rsp)
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
addsd  0x13e4(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1c68 <edtaa3+0xb48>
movzwl 0x30(%rsp),%eax
mov    %ax,-0x2(%rbx,%r12,2)
mov    %bp,-0x2(%r15,%r12,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,-0x8(%rax,%r12,8)
addsd  0x13b6(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
add    0xb8(%rsp),%r14
movswl (%rbx,%r14,2),%r9d
movswl (%r15,%r14,2),%eax
lea    0x1(%r9),%ebp
lea    -0x1(%rax),%ebx
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
mov    %r14d,%r8d
push   %rbx
push   %rbp
push   %rax
call   1040 <distaa3@plt>
add    $0x20,%rsp
movsd  (%rsp),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm1,%xmm1
mov    0x70(%rsp),%r15
mov    0x58(%rsp),%rdx
jbe    1cf6 <edtaa3+0xbd6>
mov    0x20(%rsp),%rax
mov    %bp,-0x2(%rax,%r12,2)
mov    0x1c0(%rsp),%rax
mov    %bx,-0x2(%rax,%r12,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,-0x8(%rax,%r12,8)
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
cmp    $0x3,%r13d
jl     1ff0 <edtaa3+0xed0>
movslq 0x90(%rsp),%rax
mov    0x130(%rsp),%rcx
add    %rax,%rcx
lea    (%r15,%rax,1),%rdx
mov    0xb8(%rsp),%rsi
lea    (%rsi,%rax,1),%rsi
mov    0x1c8(%rsp),%rdi
lea    (%rdi,%rax,8),%r14
mov    0x20(%rsp),%rdi
lea    (%rdi,%rax,2),%rbp
mov    %rbp,0x30(%rsp)
mov    0x1c0(%rsp),%rbp
lea    0x0(%rbp,%rax,2),%r15
lea    (%rdi,%rcx,2),%rax
mov    %rax,0x180(%rsp)
lea    0x0(%rbp,%rcx,2),%rax
mov    %rax,0x178(%rsp)
lea    (%rdi,%rdx,2),%rax
mov    %rax,0x170(%rsp)
lea    0x0(%rbp,%rdx,2),%rax
mov    %rax,0x168(%rsp)
lea    (%rdi,%rsi,2),%rax
mov    %rax,0x160(%rsp)
lea    0x0(,%rsi,2),%rax
add    %rbp,%rax
mov    %rax,0x158(%rsp)
xor    %r12d,%r12d
jmp    1db8 <edtaa3+0xc98>
add    $0xffffffffffffffff,%r12
mov    0x98(%rsp),%rax
add    %r12d,%eax
cmp    $0x1,%eax
jle    2000 <edtaa3+0xee0>
movsd  (%r14,%r12,8),%xmm0
ucomisd %xmm0,%xmm1
jae    1da0 <edtaa3+0xc80>
mov    0x30(%rsp),%rax
movswl 0x2(%rax,%r12,2),%r9d
mov    %r13,%rcx
movswl 0x2(%r15,%r12,2),%r13d
lea    -0x1(%r9),%ebx
mov    0x78(%rsp),%rax
lea    (%rax,%r12,1),%r8d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
push   %r13
push   %rbx
push   %r13
movsd  %xmm0,0x20(%rsp)
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
addsd  0x11f6(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    1e4b <edtaa3+0xd2b>
mov    0x30(%rsp),%rax
mov    %bx,(%rax,%r12,2)
mov    %r13w,(%r15,%r12,2)
movsd  %xmm0,(%r14,%r12,8)
addsd  0x11d3(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0x180(%rsp),%rax
movswl (%rax,%r12,2),%r9d
mov    0x178(%rsp),%rax
movswl (%rax,%r12,2),%eax
lea    -0x1(%r9),%ebp
lea    -0x1(%rax),%ebx
mov    0x60(%rsp),%rcx
lea    (%rcx,%r12,1),%r8d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    0x58(%rsp),%r13
mov    %r13d,%ecx
push   %rbx
push   %rbp
push   %rax
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
ucomisd %xmm0,%xmm1
jbe    1ed8 <edtaa3+0xdb8>
mov    0x30(%rsp),%rax
mov    %bp,(%rax,%r12,2)
mov    %bx,(%r15,%r12,2)
movsd  %xmm0,(%r14,%r12,8)
addsd  0x1146(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0x170(%rsp),%rax
movzwl (%rax,%r12,2),%ebx
movswl %bx,%r9d
mov    0x168(%rsp),%rax
movswl (%rax,%r12,2),%eax
lea    -0x1(%rax),%ebp
mov    0x38(%rsp),%rcx
lea    (%rcx,%r12,1),%r8d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbp
push   %r9
push   %rax
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
ucomisd %xmm0,%xmm1
jbe    1f61 <edtaa3+0xe41>
mov    0x30(%rsp),%rax
mov    %bx,(%rax,%r12,2)
mov    %bp,(%r15,%r12,2)
movsd  %xmm0,(%r14,%r12,8)
addsd  0x10bd(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0x160(%rsp),%rax
movswl (%rax,%r12,2),%r9d
mov    0x158(%rsp),%rax
movswl (%rax,%r12,2),%eax
lea    0x1(%r9),%ebp
lea    -0x1(%rax),%ebx
mov    0x80(%rsp),%rcx
lea    (%rcx,%r12,1),%r8d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbx
push   %rbp
push   %rax
call   1040 <distaa3@plt>
add    $0x20,%rsp
movsd  (%rsp),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm1,%xmm1
jbe    1da0 <edtaa3+0xc80>
mov    0x30(%rsp),%rax
mov    %bp,(%rax,%r12,2)
mov    %bx,(%r15,%r12,2)
movsd  %xmm0,(%r14,%r12,8)
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
jmp    1da0 <edtaa3+0xc80>
nopl   0x0(%rax)
add    $0xfffffffe,%r12d
jmp    200d <edtaa3+0xeed>
cs nopw 0x0(%rax,%rax,1)
add    0x90(%rsp),%r12d
mov    0x58(%rsp),%rdx
movslq %r12d,%rbx
mov    0x1c8(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    21d0 <edtaa3+0x10b0>
lea    0x1(%rbx),%r8d
mov    0x20(%rsp),%rax
movswl 0x2(%rax,%rbx,2),%r9d
mov    0x1c0(%rsp),%r15
movswl 0x2(%r15,%rbx,2),%ebp
lea    -0x1(%r9),%r14d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbp
push   %r14
push   %rbp
movsd  %xmm0,0x20(%rsp)
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
addsd  0xf91(%rip),%xmm1
ucomisd %xmm0,%xmm1
jbe    20b7 <edtaa3+0xf97>
mov    0x20(%rsp),%rax
mov    %r14w,(%rax,%rbx,2)
mov    %bp,(%r15,%rbx,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
addsd  0xf67(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
mov    0xb0(%rsp),%rax
add    %r12d,%eax
movslq %eax,%r8
mov    0x20(%rsp),%rax
movswl (%rax,%r8,2),%r9d
movswl (%r15,%r8,2),%eax
lea    -0x1(%r9),%r14d
lea    -0x1(%rax),%ebp
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbp
push   %r14
push   %rax
call   1040 <distaa3@plt>
movsd  0x20(%rsp),%xmm1
add    $0x20,%rsp
ucomisd %xmm0,%xmm1
jbe    2141 <edtaa3+0x1021>
mov    0x20(%rsp),%rax
mov    %r14w,(%rax,%rbx,2)
mov    %bp,(%r15,%rbx,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
addsd  0xedd(%rip),%xmm0
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
movapd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
add    %r13d,%r12d
movslq %r12d,%r8
mov    0x20(%rsp),%rax
movzwl (%rax,%r8,2),%r14d
movswl %r14w,%r9d
movswl (%r15,%r8,2),%eax
lea    -0x1(%rax),%ebp
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbp
push   %r9
push   %rax
call   1040 <distaa3@plt>
add    $0x20,%rsp
movsd  (%rsp),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm1,%xmm1
mov    0x28(%rsp),%r12
mov    0x58(%rsp),%rdx
jbe    21d5 <edtaa3+0x10b5>
mov    0x20(%rsp),%rax
mov    %r14w,(%rax,%rbx,2)
mov    %bp,(%r15,%rbx,2)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    $0x1,%r12d
jmp    21d5 <edtaa3+0x10b5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%r12
cmp    $0x2,%r13d
jl     1b30 <edtaa3+0xa10>
xor    %ebx,%ebx
mov    0x70(%rsp),%r15
jmp    2201 <edtaa3+0x10e1>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %ebx,0x98(%rsp)
je     1b35 <edtaa3+0xa15>
movsd  (%rdx,%rbx,8),%xmm0
ucomisd %xmm0,%xmm1
jae    21f0 <edtaa3+0x10d0>
mov    0x40(%rsp),%rax
movswl -0x2(%rax,%rbx,2),%r9d
mov    0x48(%rsp),%rax
movswl -0x2(%rax,%rbx,2),%ebp
lea    0x1(%r9),%r14d
mov    0x88(%rsp),%rax
lea    (%rax,%rbx,1),%r8d
sub    $0x8,%rsp
mov    0x20(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %r13d,%ecx
push   %rbp
push   %r14
push   %rbp
movsd  %xmm0,0x20(%rsp)
call   1040 <distaa3@plt>
mov    0x78(%rsp),%rdx
xorpd  %xmm1,%xmm1
add    $0x20,%rsp
movsd  (%rsp),%xmm2
addsd  0xda0(%rip),%xmm2
ucomisd %xmm0,%xmm2
jbe    21f0 <edtaa3+0x10d0>
mov    0x40(%rsp),%rax
mov    %r14w,(%rax,%rbx,2)
mov    0x48(%rsp),%rax
mov    %bp,(%rax,%rbx,2)
movsd  %xmm0,(%rdx,%rbx,8)
mov    $0x1,%r12d
jmp    21f0 <edtaa3+0x10d0>
nopl   (%rax)
cmpl   $0x2,0x68(%rsp)
jl     22d2 <edtaa3+0x11b2>
mov    $0x1,%r14d
mov    0xa4(%rsp),%eax
mov    %eax,%ecx
mov    0xb0(%rsp),%rax
mov    %rax,0x38(%rsp)
test   %r12d,%r12d
mov    $0x0,%r12d
jne    1390 <edtaa3+0x270>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @edtaa3(double* %0, double* %1, double* %2, i32 %3, i32 %4, i16* %5, i16* %6, double* nocapture %7) {
%9 = sub i32 1, %3
%10 = add i32 %3, 1
%11 = add i32 %3, -1
%12 = mul i32 %4, %3
%13 = icmp sgt i32 %12, 0
br i1 %13, label %14, label %16
14: ; preds = %8
%15 = zext i32 %12 to i64
br label %37
16: ; preds = %52, %8
%17 = icmp sgt i32 %4, 1
%18 = icmp sgt i32 %3, 2
%19 = add nsw i32 %3, -2
%20 = icmp sgt i32 %3, 1
%21 = add i32 %4, -2
%22 = sext i32 %9 to i64
%23 = shl i32 %3, 1
%24 = add i32 %23, -2
%25 = sext i32 %3 to i64
%26 = add i32 %4, -1
%27 = mul i32 %26, %3
%28 = add i32 %27, -2
%29 = sext i32 %11 to i64
%30 = sext i32 %10 to i64
%31 = mul i32 %21, %3
%32 = sext i32 %31 to i64
%33 = sub i32 0, %3
%34 = sext i32 %33 to i64
%35 = sext i32 %21 to i64
%36 = zext i32 %4 to i64
br i1 %17, label %57, label %564
37: ; preds = %14, %52
%38 = phi i64 [ 0, %14 ], [ %55, %52 ]
%39 = getelementptr inbounds i16, i16* %5, i64 %38
store i16 0, i16* %39
%40 = getelementptr inbounds i16, i16* %6, i64 %38
store i16 0, i16* %40
%41 = getelementptr inbounds double, double* %0, i64 %38
%42 = load double, double* %41
%43 = fcmp ugt double %42, 0.000000e+00
br i1 %43, label %44, label %52
44: ; preds = %37
%45 = fcmp olt double %42, 1.000000e+00
br i1 %45, label %46, label %52
46: ; preds = %44
%47 = getelementptr inbounds double, double* %1, i64 %38
%48 = load double, double* %47
%49 = getelementptr inbounds double, double* %2, i64 %38
%50 = load double, double* %49
%51 = tail call double @edgedf(double %48, double %50, double %42)
br label %52
52: ; preds = %44, %37, %46
%53 = phi double [ %51, %46 ], [ 1.000000e+06, %37 ], [ 0.000000e+00, %44 ]
%54 = getelementptr inbounds double, double* %7, i64 %38
store double %53, double* %54
%55 = add nuw nsw i64 %38, 1
%56 = icmp eq i64 %55, %15
br i1 %56, label %16, label %37
57: ; preds = %16, %308
%58 = phi i64 [ %309, %308 ], [ 1, %16 ]
%59 = phi i32 [ %310, %308 ], [ %24, %16 ]
%60 = phi i32 [ %311, %308 ], [ %10, %16 ]
%61 = phi i32 [ %312, %308 ], [ 0, %16 ]
%62 = sext i32 %59 to i64
%63 = sext i32 %60 to i64
%64 = mul nsw i64 %58, %25
%65 = getelementptr inbounds double, double* %7, i64 %64
%66 = load double, double* %65
%67 = fcmp ogt double %66, 0.000000e+00
%68 = trunc i64 %64 to i32
br i1 %67, label %69, label %107
69: ; preds = %57
%70 = sub i32 %68, %3
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i16, i16* %5, i64 %71
%73 = load i16, i16* %72
%74 = sext i16 %73 to i32
%75 = getelementptr inbounds i16, i16* %6, i64 %71
%76 = load i16, i16* %75
%77 = sext i16 %76 to i32
%78 = add nsw i32 %77, 1
%79 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %70, i32 %74, i32 %77, i32 %74, i32 %78)
%80 = fadd double %66, -1.000000e-03
%81 = fcmp olt double %79, %80
br i1 %81, label %82, label %87
82: ; preds = %69
%83 = getelementptr inbounds i16, i16* %5, i64 %64
store i16 %73, i16* %83
%84 = trunc i32 %78 to i16
%85 = getelementptr inbounds i16, i16* %6, i64 %64
store i16 %84, i16* %85
store double %79, double* %65
%86 = fadd double %79, -1.000000e-03
br label %87
87: ; preds = %82, %69
%88 = phi double [ %86, %82 ], [ %80, %69 ]
%89 = phi i32 [ 1, %82 ], [ %61, %69 ]
%90 = add nsw i64 %64, %22
%91 = getelementptr inbounds i16, i16* %5, i64 %90
%92 = load i16, i16* %91
%93 = sext i16 %92 to i32
%94 = getelementptr inbounds i16, i16* %6, i64 %90
%95 = load i16, i16* %94
%96 = sext i16 %95 to i32
%97 = add nsw i32 %93, -1
%98 = add nsw i32 %96, 1
%99 = trunc i64 %90 to i32
%100 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %99, i32 %93, i32 %96, i32 %97, i32 %98)
%101 = fcmp olt double %100, %88
br i1 %101, label %102, label %107
102: ; preds = %87
%103 = trunc i32 %97 to i16
%104 = getelementptr inbounds i16, i16* %5, i64 %64
store i16 %103, i16* %104
%105 = trunc i32 %98 to i16
%106 = getelementptr inbounds i16, i16* %6, i64 %64
store i16 %105, i16* %106
store double %100, double* %65
br label %107
107: ; preds = %57, %87, %102
%108 = phi i32 [ %89, %87 ], [ 1, %102 ], [ %61, %57 ]
%109 = trunc i64 %64 to i32
%110 = add i32 %109, 1
br i1 %18, label %111, label %207
111: ; preds = %107, %199
%112 = phi i64 [ %203, %199 ], [ %63, %107 ]
%113 = phi i32 [ %202, %199 ], [ 1, %107 ]
%114 = phi i32 [ %201, %199 ], [ %108, %107 ]
%115 = phi i32 [ %200, %199 ], [ %68, %107 ]
%116 = getelementptr inbounds double, double* %7, i64 %112
%117 = load double, double* %116
%118 = fcmp ugt double %117, 0.000000e+00
br i1 %118, label %121, label %119
119: ; preds = %111
%120 = trunc i64 %112 to i32
br label %199
121: ; preds = %111
%122 = sext i32 %115 to i64
%123 = getelementptr inbounds i16, i16* %5, i64 %122
%124 = load i16, i16* %123
%125 = sext i16 %124 to i32
%126 = getelementptr inbounds i16, i16* %6, i64 %122
%127 = load i16, i16* %126
%128 = sext i16 %127 to i32
%129 = add nsw i32 %125, 1
%130 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %115, i32 %125, i32 %128, i32 %129, i32 %128)
%131 = fadd double %117, -1.000000e-03
%132 = fcmp olt double %130, %131
br i1 %132, label %133, label %138
133: ; preds = %121
%134 = trunc i32 %129 to i16
%135 = getelementptr inbounds i16, i16* %5, i64 %112
store i16 %134, i16* %135
%136 = getelementptr inbounds i16, i16* %6, i64 %112
store i16 %127, i16* %136
store double %130, double* %116
%137 = fadd double %130, -1.000000e-03
br label %138
138: ; preds = %133, %121
%139 = phi double [ %137, %133 ], [ %131, %121 ]
%140 = phi i32 [ 1, %133 ], [ %114, %121 ]
%141 = sub i32 %115, %3
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds i16, i16* %5, i64 %142
%144 = load i16, i16* %143
%145 = sext i16 %144 to i32
%146 = getelementptr inbounds i16, i16* %6, i64 %142
%147 = load i16, i16* %146
%148 = sext i16 %147 to i32
%149 = add nsw i32 %145, 1
%150 = add nsw i32 %148, 1
%151 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %141, i32 %145, i32 %148, i32 %149, i32 %150)
%152 = fcmp olt double %151, %139
br i1 %152, label %153, label %159
153: ; preds = %138
%154 = trunc i32 %149 to i16
%155 = getelementptr inbounds i16, i16* %5, i64 %112
store i16 %154, i16* %155
%156 = trunc i32 %150 to i16
%157 = getelementptr inbounds i16, i16* %6, i64 %112
store i16 %156, i16* %157
store double %151, double* %116
%158 = fadd double %151, -1.000000e-03
br label %159
159: ; preds = %153, %138
%160 = phi double [ %158, %153 ], [ %139, %138 ]
%161 = phi i32 [ 1, %153 ], [ %140, %138 ]
%162 = trunc i64 %112 to i32
%163 = sub i32 %162, %3
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i16, i16* %5, i64 %164
%166 = load i16, i16* %165
%167 = sext i16 %166 to i32
%168 = getelementptr inbounds i16, i16* %6, i64 %164
%169 = load i16, i16* %168
%170 = sext i16 %169 to i32
%171 = add nsw i32 %170, 1
%172 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %163, i32 %167, i32 %170, i32 %167, i32 %171)
%173 = fcmp olt double %172, %160
br i1 %173, label %174, label %179
174: ; preds = %159
%175 = getelementptr inbounds i16, i16* %5, i64 %112
store i16 %166, i16* %175
%176 = trunc i32 %171 to i16
%177 = getelementptr inbounds i16, i16* %6, i64 %112
store i16 %176, i16* %177
store double %172, double* %116
%178 = fadd double %172, -1.000000e-03
br label %179
179: ; preds = %174, %159
%180 = phi double [ %178, %174 ], [ %160, %159 ]
%181 = phi i32 [ 1, %174 ], [ %161, %159 ]
%182 = add nsw i64 %112, %22
%183 = getelementptr inbounds i16, i16* %5, i64 %182
%184 = load i16, i16* %183
%185 = sext i16 %184 to i32
%186 = getelementptr inbounds i16, i16* %6, i64 %182
%187 = load i16, i16* %186
%188 = sext i16 %187 to i32
%189 = add nsw i32 %185, -1
%190 = add nsw i32 %188, 1
%191 = trunc i64 %182 to i32
%192 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %191, i32 %185, i32 %188, i32 %189, i32 %190)
%193 = fcmp olt double %192, %180
br i1 %193, label %194, label %199
194: ; preds = %179
%195 = trunc i32 %189 to i16
%196 = getelementptr inbounds i16, i16* %5, i64 %112
store i16 %195, i16* %196
%197 = trunc i32 %190 to i16
%198 = getelementptr inbounds i16, i16* %6, i64 %112
store i16 %197, i16* %198
store double %192, double* %116
br label %199
199: ; preds = %119, %179, %194
%200 = phi i32 [ %120, %119 ], [ %162, %179 ], [ %162, %194 ]
%201 = phi i32 [ %114, %119 ], [ %181, %179 ], [ 1, %194 ]
%202 = add nuw nsw i32 %113, 1
%203 = add nsw i64 %112, 1
%204 = icmp eq i32 %202, %11
br i1 %204, label %205, label %111
205: ; preds = %199
%206 = trunc i64 %203 to i32
br label %207
207: ; preds = %205, %107
%208 = phi i32 [ %68, %107 ], [ %200, %205 ]
%209 = phi i32 [ %108, %107 ], [ %201, %205 ]
%210 = phi i32 [ %110, %107 ], [ %206, %205 ]
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %7, i64 %211
%213 = load double, double* %212
%214 = fcmp ogt double %213, 0.000000e+00
br i1 %214, label %215, label %271
215: ; preds = %207
%216 = sext i32 %208 to i64
%217 = getelementptr inbounds i16, i16* %5, i64 %216
%218 = load i16, i16* %217
%219 = sext i16 %218 to i32
%220 = getelementptr inbounds i16, i16* %6, i64 %216
%221 = load i16, i16* %220
%222 = sext i16 %221 to i32
%223 = add nsw i32 %219, 1
%224 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %208, i32 %219, i32 %222, i32 %223, i32 %222)
%225 = fadd double %213, -1.000000e-03
%226 = fcmp olt double %224, %225
br i1 %226, label %227, label %232
227: ; preds = %215
%228 = trunc i32 %223 to i16
%229 = getelementptr inbounds i16, i16* %5, i64 %211
store i16 %228, i16* %229
%230 = getelementptr inbounds i16, i16* %6, i64 %211
store i16 %221, i16* %230
store double %224, double* %212
%231 = fadd double %224, -1.000000e-03
br label %232
232: ; preds = %227, %215
%233 = phi double [ %231, %227 ], [ %225, %215 ]
%234 = phi i32 [ 1, %227 ], [ %209, %215 ]
%235 = sub i32 %208, %3
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i16, i16* %5, i64 %236
%238 = load i16, i16* %237
%239 = sext i16 %238 to i32
%240 = getelementptr inbounds i16, i16* %6, i64 %236
%241 = load i16, i16* %240
%242 = sext i16 %241 to i32
%243 = add nsw i32 %239, 1
%244 = add nsw i32 %242, 1
%245 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %235, i32 %239, i32 %242, i32 %243, i32 %244)
%246 = fcmp olt double %245, %233
br i1 %246, label %247, label %253
247: ; preds = %232
%248 = trunc i32 %243 to i16
%249 = getelementptr inbounds i16, i16* %5, i64 %211
store i16 %248, i16* %249
%250 = trunc i32 %244 to i16
%251 = getelementptr inbounds i16, i16* %6, i64 %211
store i16 %250, i16* %251
store double %245, double* %212
%252 = fadd double %245, -1.000000e-03
br label %253
253: ; preds = %247, %232
%254 = phi double [ %252, %247 ], [ %233, %232 ]
%255 = phi i32 [ 1, %247 ], [ %234, %232 ]
%256 = sub i32 %210, %3
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i16, i16* %5, i64 %257
%259 = load i16, i16* %258
%260 = sext i16 %259 to i32
%261 = getelementptr inbounds i16, i16* %6, i64 %257
%262 = load i16, i16* %261
%263 = sext i16 %262 to i32
%264 = add nsw i32 %263, 1
%265 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %256, i32 %260, i32 %263, i32 %260, i32 %264)
%266 = fcmp olt double %265, %254
br i1 %266, label %267, label %271
267: ; preds = %253
%268 = getelementptr inbounds i16, i16* %5, i64 %211
store i16 %259, i16* %268
%269 = trunc i32 %264 to i16
%270 = getelementptr inbounds i16, i16* %6, i64 %211
store i16 %269, i16* %270
store double %265, double* %212
br label %271
271: ; preds = %253, %267, %207
%272 = phi i32 [ 1, %267 ], [ %255, %253 ], [ %209, %207 ]
br i1 %20, label %273, label %302
273: ; preds = %271, %297
%274 = phi i64 [ %300, %297 ], [ %62, %271 ]
%275 = phi i32 [ %299, %297 ], [ %19, %271 ]
%276 = phi i32 [ %298, %297 ], [ %272, %271 ]
%277 = getelementptr inbounds double, double* %7, i64 %274
%278 = load double, double* %277
%279 = fcmp ugt double %278, 0.000000e+00
br i1 %279, label %280, label %297
280: ; preds = %273
%281 = add nsw i64 %274, 1
%282 = getelementptr inbounds i16, i16* %5, i64 %281
%283 = load i16, i16* %282
%284 = sext i16 %283 to i32
%285 = getelementptr inbounds i16, i16* %6, i64 %281
%286 = load i16, i16* %285
%287 = sext i16 %286 to i32
%288 = add nsw i32 %284, -1
%289 = trunc i64 %281 to i32
%290 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %289, i32 %284, i32 %287, i32 %288, i32 %287)
%291 = fadd double %278, -1.000000e-03
%292 = fcmp olt double %290, %291
br i1 %292, label %293, label %297
293: ; preds = %280
%294 = trunc i32 %288 to i16
%295 = getelementptr inbounds i16, i16* %5, i64 %274
store i16 %294, i16* %295
%296 = getelementptr inbounds i16, i16* %6, i64 %274
store i16 %286, i16* %296
store double %290, double* %277
br label %297
297: ; preds = %280, %293, %273
%298 = phi i32 [ %276, %273 ], [ 1, %293 ], [ %276, %280 ]
%299 = add nsw i32 %275, -1
%300 = add nsw i64 %274, -1
%301 = icmp sgt i32 %275, 0
br i1 %301, label %273, label %302
302: ; preds = %297, %271
%303 = phi i32 [ %272, %271 ], [ %298, %297 ]
%304 = add nuw nsw i64 %58, 1
%305 = add i32 %60, %3
%306 = add i32 %59, %3
%307 = icmp eq i64 %304, %36
br i1 %307, label %313, label %308
308: ; preds = %302, %560
%309 = phi i64 [ %304, %302 ], [ 1, %560 ]
%310 = phi i32 [ %306, %302 ], [ %24, %560 ]
%311 = phi i32 [ %305, %302 ], [ %10, %560 ]
%312 = phi i32 [ %303, %302 ], [ 0, %560 ]
br label %57
313: ; preds = %302
br i1 %17, label %314, label %560
314: ; preds = %313, %554
%315 = phi i64 [ %556, %554 ], [ %35, %313 ]
%316 = phi i64 [ %559, %554 ], [ %32, %313 ]
%317 = phi i32 [ %558, %554 ], [ %28, %313 ]
%318 = phi i32 [ %555, %554 ], [ %303, %313 ]
%319 = sext i32 %317 to i64
%320 = mul nsw i64 %315, %25
%321 = add nsw i64 %320, %25
%322 = add nsw i64 %321, -1
%323 = getelementptr inbounds double, double* %7, i64 %322
%324 = load double, double* %323
%325 = fcmp ogt double %324, 0.000000e+00
br i1 %325, label %326, label %364
326: ; preds = %314
%327 = add nsw i64 %322, %25
%328 = getelementptr inbounds i16, i16* %5, i64 %327
%329 = load i16, i16* %328
%330 = sext i16 %329 to i32
%331 = getelementptr inbounds i16, i16* %6, i64 %327
%332 = load i16, i16* %331
%333 = sext i16 %332 to i32
%334 = add nsw i32 %333, -1
%335 = trunc i64 %327 to i32
%336 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %335, i32 %330, i32 %333, i32 %330, i32 %334)
%337 = fadd double %324, -1.000000e-03
%338 = fcmp olt double %336, %337
br i1 %338, label %339, label %344
339: ; preds = %326
%340 = getelementptr inbounds i16, i16* %5, i64 %322
store i16 %329, i16* %340
%341 = trunc i32 %334 to i16
%342 = getelementptr inbounds i16, i16* %6, i64 %322
store i16 %341, i16* %342
store double %336, double* %323
%343 = fadd double %336, -1.000000e-03
br label %344
344: ; preds = %339, %326
%345 = phi double [ %343, %339 ], [ %337, %326 ]
%346 = phi i32 [ 1, %339 ], [ %318, %326 ]
%347 = add nsw i64 %322, %29
%348 = getelementptr inbounds i16, i16* %5, i64 %347
%349 = load i16, i16* %348
%350 = sext i16 %349 to i32
%351 = getelementptr inbounds i16, i16* %6, i64 %347
%352 = load i16, i16* %351
%353 = sext i16 %352 to i32
%354 = add nsw i32 %350, 1
%355 = add nsw i32 %353, -1
%356 = trunc i64 %347 to i32
%357 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %356, i32 %350, i32 %353, i32 %354, i32 %355)
%358 = fcmp olt double %357, %345
br i1 %358, label %359, label %364
359: ; preds = %344
%360 = trunc i32 %354 to i16
%361 = getelementptr inbounds i16, i16* %5, i64 %322
store i16 %360, i16* %361
%362 = trunc i32 %355 to i16
%363 = getelementptr inbounds i16, i16* %6, i64 %322
store i16 %362, i16* %363
store double %357, double* %323
br label %364
364: ; preds = %344, %359, %314
%365 = phi i32 [ 1, %359 ], [ %346, %344 ], [ %318, %314 ]
%366 = trunc i64 %321 to i32
%367 = add i32 %366, -2
br i1 %18, label %368, label %460
368: ; preds = %364, %453
%369 = phi i64 [ %456, %453 ], [ %319, %364 ]
%370 = phi i32 [ %455, %453 ], [ %19, %364 ]
%371 = phi i32 [ %454, %453 ], [ %365, %364 ]
%372 = getelementptr inbounds double, double* %7, i64 %369
%373 = load double, double* %372
%374 = fcmp ugt double %373, 0.000000e+00
br i1 %374, label %375, label %453
375: ; preds = %368
%376 = add nsw i64 %369, 1
%377 = getelementptr inbounds i16, i16* %5, i64 %376
%378 = load i16, i16* %377
%379 = sext i16 %378 to i32
%380 = getelementptr inbounds i16, i16* %6, i64 %376
%381 = load i16, i16* %380
%382 = sext i16 %381 to i32
%383 = add nsw i32 %379, -1
%384 = trunc i64 %376 to i32
%385 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %384, i32 %379, i32 %382, i32 %383, i32 %382)
%386 = fadd double %373, -1.000000e-03
%387 = fcmp olt double %385, %386
br i1 %387, label %388, label %393
388: ; preds = %375
%389 = trunc i32 %383 to i16
%390 = getelementptr inbounds i16, i16* %5, i64 %369
store i16 %389, i16* %390
%391 = getelementptr inbounds i16, i16* %6, i64 %369
store i16 %381, i16* %391
store double %385, double* %372
%392 = fadd double %385, -1.000000e-03
br label %393
393: ; preds = %388, %375
%394 = phi double [ %392, %388 ], [ %386, %375 ]
%395 = phi i32 [ 1, %388 ], [ %371, %375 ]
%396 = add nsw i64 %369, %30
%397 = getelementptr inbounds i16, i16* %5, i64 %396
%398 = load i16, i16* %397
%399 = sext i16 %398 to i32
%400 = getelementptr inbounds i16, i16* %6, i64 %396
%401 = load i16, i16* %400
%402 = sext i16 %401 to i32
%403 = add nsw i32 %399, -1
%404 = add nsw i32 %402, -1
%405 = trunc i64 %396 to i32
%406 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %405, i32 %399, i32 %402, i32 %403, i32 %404)
%407 = fcmp olt double %406, %394
br i1 %407, label %408, label %414
408: ; preds = %393
%409 = trunc i32 %403 to i16
%410 = getelementptr inbounds i16, i16* %5, i64 %369
store i16 %409, i16* %410
%411 = trunc i32 %404 to i16
%412 = getelementptr inbounds i16, i16* %6, i64 %369
store i16 %411, i16* %412
store double %406, double* %372
%413 = fadd double %406, -1.000000e-03
br label %414
414: ; preds = %408, %393
%415 = phi double [ %413, %408 ], [ %394, %393 ]
%416 = phi i32 [ 1, %408 ], [ %395, %393 ]
%417 = add nsw i64 %369, %25
%418 = getelementptr inbounds i16, i16* %5, i64 %417
%419 = load i16, i16* %418
%420 = sext i16 %419 to i32
%421 = getelementptr inbounds i16, i16* %6, i64 %417
%422 = load i16, i16* %421
%423 = sext i16 %422 to i32
%424 = add nsw i32 %423, -1
%425 = trunc i64 %417 to i32
%426 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %425, i32 %420, i32 %423, i32 %420, i32 %424)
%427 = fcmp olt double %426, %415
br i1 %427, label %428, label %433
428: ; preds = %414
%429 = getelementptr inbounds i16, i16* %5, i64 %369
store i16 %419, i16* %429
%430 = trunc i32 %424 to i16
%431 = getelementptr inbounds i16, i16* %6, i64 %369
store i16 %430, i16* %431
store double %426, double* %372
%432 = fadd double %426, -1.000000e-03
br label %433
433: ; preds = %428, %414
%434 = phi double [ %432, %428 ], [ %415, %414 ]
%435 = phi i32 [ 1, %428 ], [ %416, %414 ]
%436 = add nsw i64 %369, %29
%437 = getelementptr inbounds i16, i16* %5, i64 %436
%438 = load i16, i16* %437
%439 = sext i16 %438 to i32
%440 = getelementptr inbounds i16, i16* %6, i64 %436
%441 = load i16, i16* %440
%442 = sext i16 %441 to i32
%443 = add nsw i32 %439, 1
%444 = add nsw i32 %442, -1
%445 = trunc i64 %436 to i32
%446 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %445, i32 %439, i32 %442, i32 %443, i32 %444)
%447 = fcmp olt double %446, %434
br i1 %447, label %448, label %453
448: ; preds = %433
%449 = trunc i32 %443 to i16
%450 = getelementptr inbounds i16, i16* %5, i64 %369
store i16 %449, i16* %450
%451 = trunc i32 %444 to i16
%452 = getelementptr inbounds i16, i16* %6, i64 %369
store i16 %451, i16* %452
store double %446, double* %372
br label %453
453: ; preds = %433, %448, %368
%454 = phi i32 [ %371, %368 ], [ 1, %448 ], [ %435, %433 ]
%455 = add nsw i32 %370, -1
%456 = add nsw i64 %369, -1
%457 = icmp sgt i32 %370, 1
br i1 %457, label %368, label %458
458: ; preds = %453
%459 = trunc i64 %456 to i32
br label %460
460: ; preds = %458, %364
%461 = phi i32 [ %367, %364 ], [ %459, %458 ]
%462 = phi i32 [ %365, %364 ], [ %454, %458 ]
%463 = sext i32 %461 to i64
%464 = getelementptr inbounds double, double* %7, i64 %463
%465 = load double, double* %464
%466 = fcmp ogt double %465, 0.000000e+00
br i1 %466, label %467, label %524
467: ; preds = %460
%468 = add nsw i32 %461, 1
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds i16, i16* %5, i64 %469
%471 = load i16, i16* %470
%472 = sext i16 %471 to i32
%473 = getelementptr inbounds i16, i16* %6, i64 %469
%474 = load i16, i16* %473
%475 = sext i16 %474 to i32
%476 = add nsw i32 %472, -1
%477 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %468, i32 %472, i32 %475, i32 %476, i32 %475)
%478 = fadd double %465, -1.000000e-03
%479 = fcmp olt double %477, %478
br i1 %479, label %480, label %485
480: ; preds = %467
%481 = trunc i32 %476 to i16
%482 = getelementptr inbounds i16, i16* %5, i64 %463
store i16 %481, i16* %482
%483 = getelementptr inbounds i16, i16* %6, i64 %463
store i16 %474, i16* %483
store double %477, double* %464
%484 = fadd double %477, -1.000000e-03
br label %485
485: ; preds = %480, %467
%486 = phi double [ %484, %480 ], [ %478, %467 ]
%487 = phi i32 [ 1, %480 ], [ %462, %467 ]
%488 = add nsw i32 %461, %10
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds i16, i16* %5, i64 %489
%491 = load i16, i16* %490
%492 = sext i16 %491 to i32
%493 = getelementptr inbounds i16, i16* %6, i64 %489
%494 = load i16, i16* %493
%495 = sext i16 %494 to i32
%496 = add nsw i32 %492, -1
%497 = add nsw i32 %495, -1
%498 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %488, i32 %492, i32 %495, i32 %496, i32 %497)
%499 = fcmp olt double %498, %486
br i1 %499, label %500, label %506
500: ; preds = %485
%501 = trunc i32 %496 to i16
%502 = getelementptr inbounds i16, i16* %5, i64 %463
store i16 %501, i16* %502
%503 = trunc i32 %497 to i16
%504 = getelementptr inbounds i16, i16* %6, i64 %463
store i16 %503, i16* %504
store double %498, double* %464
%505 = fadd double %498, -1.000000e-03
br label %506
506: ; preds = %500, %485
%507 = phi double [ %505, %500 ], [ %486, %485 ]
%508 = phi i32 [ 1, %500 ], [ %487, %485 ]
%509 = add nsw i32 %461, %3
%510 = sext i32 %509 to i64
%511 = getelementptr inbounds i16, i16* %5, i64 %510
%512 = load i16, i16* %511
%513 = sext i16 %512 to i32
%514 = getelementptr inbounds i16, i16* %6, i64 %510
%515 = load i16, i16* %514
%516 = sext i16 %515 to i32
%517 = add nsw i32 %516, -1
%518 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %509, i32 %513, i32 %516, i32 %513, i32 %517)
%519 = fcmp olt double %518, %507
br i1 %519, label %520, label %524
520: ; preds = %506
%521 = getelementptr inbounds i16, i16* %5, i64 %463
store i16 %512, i16* %521
%522 = trunc i32 %517 to i16
%523 = getelementptr inbounds i16, i16* %6, i64 %463
store i16 %522, i16* %523
store double %518, double* %464
br label %524
524: ; preds = %506, %520, %460
%525 = phi i32 [ 1, %520 ], [ %508, %506 ], [ %462, %460 ]
br i1 %20, label %526, label %554
526: ; preds = %524, %550
%527 = phi i64 [ %530, %550 ], [ %316, %524 ]
%528 = phi i32 [ %552, %550 ], [ 1, %524 ]
%529 = phi i32 [ %551, %550 ], [ %525, %524 ]
%530 = add nsw i64 %527, 1
%531 = getelementptr inbounds double, double* %7, i64 %530
%532 = load double, double* %531
%533 = fcmp ugt double %532, 0.000000e+00
br i1 %533, label %534, label %550
534: ; preds = %526
%535 = getelementptr inbounds i16, i16* %5, i64 %527
%536 = load i16, i16* %535
%537 = sext i16 %536 to i32
%538 = getelementptr inbounds i16, i16* %6, i64 %527
%539 = load i16, i16* %538
%540 = sext i16 %539 to i32
%541 = add nsw i32 %537, 1
%542 = trunc i64 %527 to i32
%543 = tail call double @distaa3(double* %0, double* %1, double* %2, i32 %3, i32 %542, i32 %537, i32 %540, i32 %541, i32 %540)
%544 = fadd double %532, -1.000000e-03
%545 = fcmp olt double %543, %544
br i1 %545, label %546, label %550
546: ; preds = %534
%547 = trunc i32 %541 to i16
%548 = getelementptr inbounds i16, i16* %5, i64 %530
store i16 %547, i16* %548
%549 = getelementptr inbounds i16, i16* %6, i64 %530
store i16 %539, i16* %549
store double %543, double* %531
br label %550
550: ; preds = %534, %546, %526
%551 = phi i32 [ %529, %526 ], [ 1, %546 ], [ %529, %534 ]
%552 = add nuw nsw i32 %528, 1
%553 = icmp eq i32 %552, %3
br i1 %553, label %554, label %526
554: ; preds = %550, %524
%555 = phi i32 [ %525, %524 ], [ %551, %550 ]
%556 = add nsw i64 %315, -1
%557 = icmp sgt i64 %315, 0
%558 = sub i32 %317, %3
%559 = add i64 %316, %34
br i1 %557, label %314, label %560
560: ; preds = %554, %313
%561 = phi i32 [ %303, %313 ], [ %555, %554 ]
%562 = icmp ne i32 %561, 0
%563 = and i1 %17, %562
br i1 %563, label %308, label %564
564: ; preds = %560, %16
ret void
}