#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 */
float point_nearest_line(float *, float *, float *, float *);
double sqrt(float);
int /*<<< orphan*/ vis5d_get_box_bounds(int, float *, float *, float *, float *,
                                        float *, float *);
int /*<<< orphan*/ vis5d_get_ctx_display_index(int, int *);
int /*<<< orphan*/ vis5d_get_size(int, int *, int *, int *, int *, int *, int *,
                                  int *, int *);
int /*<<< orphan*/ vis5d_get_sizePRIME(int, int *, int *, int *, int *, int *,
                                       int *);
int /*<<< orphan*/ vis5d_gridPRIME_to_xyzPRIME(int, int, int, double, double,
                                               float, float *, float *,
                                               float *);
int /*<<< orphan*/ vis5d_project(int, float *, float *, float *);
int /*<<< orphan*/ vis5d_unproject(int, float, float, float *, float *);
int /*<<< orphan*/ vis5d_xyzPRIME_to_gridPRIME(int, int, int, float, float,
                                               float, float *, float *,
                                               float *);
int move_vslice(int index, int curx, int cury, int time, int var, float *r1,
                float *c1, float *r2, float *c2, int corner) {
  float cx, cy;
  float b[3], db[3];
  float p[3], px, py;
  float nr, nc;
  int Nr, Nc, Nl, LowLev, MaxNlVar, WindNl, WindLow;
  int vNr, vNc, vNl[200], vLowLev[200], vMaxNl, vMaxNlVar, vWindNl, vWindLow;
  float xmin, xmax, ymin, ymax;
  int dindex;
  vis5d_get_ctx_display_index(index, &dindex);
  vis5d_get_sizePRIME(dindex, &Nr, &Nc, &Nl, &LowLev, &WindNl, &WindLow);
  vis5d_get_size(index, &vNr, &vNc, vNl, vLowLev, &vMaxNl, &vMaxNlVar, &vWindNl,
                 &vWindLow);
  vis5d_get_box_bounds(dindex, &xmin, &xmax, &ymin, &ymax, &cx, &cy);
  nr = (float)(Nr - 1);
  nc = (float)(Nc - 1);
  cx = (float)curx;
  cy = (float)cury;
  vis5d_unproject(dindex, cx, cy, b, db);
  if (corner < 4) {
    float dist, neardist, neart, t, l;
    float newcol, newrow;
    int edge, nearedge;
    if (corner < 2) {
      l = (float)(Nl - 1 + LowLev);
    } else {
      l = (float)LowLev;
    }
    neardist = 10000.0;
    for (edge = 0; edge < 4; edge++) {
      float r0, c0, r1, c1, a[3], da[3], aa[3];
      switch (edge) {
      case 0:
        r0 = 0.0;
        c0 = 0.0;
        r1 = 0.0;
        c1 = (float)(Nc - 1);
        break;
      case 1:
        r0 = 0.0;
        c0 = (float)(Nc - 1);
        r1 = (float)(Nr - 1);
        c1 = c0;
        break;
      case 2:
        r0 = (float)(Nr - 1);
        c0 = 0.0;
        r1 = (float)(Nr - 1);
        c1 = (float)(Nc - 1);
        break;
      case 3:
        r0 = 0.0;
        c0 = 0.0;
        r1 = (float)(Nr - 1);
        c1 = 0.0;
        break;
      }
      vis5d_gridPRIME_to_xyzPRIME(dindex, time, var, r0, c0, l, &a[0], &a[1],
                                  &a[2]);
      vis5d_gridPRIME_to_xyzPRIME(dindex, time, var, r1, c1, l, &aa[0], &aa[1],
                                  &aa[2]);
      da[0] = aa[0] - a[0];
      da[1] = aa[1] - a[1];
      da[2] = aa[2] - a[2];
      t = point_nearest_line(a, da, b, db);
      p[0] = a[0] + da[0] * t;
      p[1] = a[1] + da[1] * t;
      p[2] = a[2] + da[2] * t;
      vis5d_project(dindex, p, &px, &py);
      dist = sqrt((px - cx) * (px - cx) + (py - cy) * (py - cy));
      if (dist == 0.0)
        return 0;
      if (dist < neardist) {
        neardist = dist;
        nearedge = edge;
        neart = ((t < 0.0) ? 0.0 : ((t > 1.0) ? 1.0 : t));
      }
    }
    switch (nearedge) {
    case 0:
      vis5d_xyzPRIME_to_gridPRIME(dindex, time, var,
                                  xmin + neart * (xmax - xmin), 0.0, 0.0, &t,
                                  &newcol, &t);
      newrow = 0.0;
      break;
    case 1:
      newcol = nc;
      vis5d_xyzPRIME_to_gridPRIME(dindex, time, var, 0.0,
                                  ymax - neart * (ymax - ymin), 0.0, &newrow,
                                  &t, &t);
      break;
    case 2:
      vis5d_xyzPRIME_to_gridPRIME(dindex, time, var,
                                  xmin + neart * (xmax - xmin), 0.0, 0.0, &t,
                                  &newcol, &t);
      newrow = nr;
      break;
    case 3:
      newcol = 0.0;
      vis5d_xyzPRIME_to_gridPRIME(dindex, time, var, 0.0,
                                  ymax - neart * (ymax - ymin), 0.0, &newrow,
                                  &t, &t);
      break;
    }
    if (corner % 2 == 0) {
      if (sqrt((*r2 - newrow) * (*r2 - newrow) +
               (*c2 - newcol) * (*c2 - newcol)) > 2.0) {
        *r1 = newrow;
        *c1 = newcol;
      }
    } else {
      if (sqrt((*r1 - newrow) * (*r1 - newrow) +
               (*c1 - newcol) * (*c1 - newcol)) > 2.0) {
        *r2 = newrow;
        *c2 = newcol;
      }
    }
    return 1;
  } else {
    float prow, pcol, plev, drow, dcol;
    float newr1, newc1, newr2, newc2;
    float x, y, t;
    if (corner == 4) {
      vis5d_gridPRIME_to_xyzPRIME(dindex, time, var, 1.0, 1.0,
                                  (float)(Nl - 1 + LowLev), &x, &y, &t);
      t = (t - b[2]) / db[2];
    } else {
      vis5d_gridPRIME_to_xyzPRIME(dindex, time, var, 1.0, 1.0, (float)LowLev,
                                  &x, &y, &t);
      t = (t - b[2]) / db[2];
    }
    p[0] = b[0] + t * db[0];
    p[1] = b[1] + t * db[1];
    p[2] = b[2] + t * db[2];
    vis5d_xyzPRIME_to_gridPRIME(dindex, time, var, p[0], p[1], p[2], &prow,
                                &pcol, &plev);
    drow = *r2 - *r1;
    dcol = *c2 - *c1;
    if (drow == 0.0) {
      newc1 = *c1;
      newc2 = *c2;
      newr1 = newr2 = prow;
    } else if (dcol == 0.0) {
      newr1 = *r1;
      newr2 = *r2;
      newc1 = newc2 = pcol;
    } else {
      t = -prow / drow;
      newr1 = 0.0;
      newc1 = pcol + dcol * t;
      t = (nr - prow) / drow;
      newr2 = Nr - 1.0;
      newc2 = pcol + dcol * t;
      if (newc1 < 0.0) {
        t = -pcol / dcol;
        newr1 = prow + drow * t;
        newc1 = 0.0;
      }
      if (newc1 > (float)(Nc - 1)) {
        t = (nc - pcol) / dcol;
        newr1 = prow + drow * t;
        newc1 = (float)(Nc - 1);
      }
      if (newc2 < 0.0) {
        t = -pcol / dcol;
        newr2 = prow + drow * t;
        newc2 = 0.0;
      }
      if (newc2 > (float)(Nc - 1)) {
        t = (nc - pcol) / dcol;
        newr2 = prow + drow * t;
        newc2 = (float)(Nc - 1);
      }
      drow = *r1 - *r2;
      if (drow < 0.0)
        drow = -drow;
      dcol = *c1 - *c2;
      if (dcol < 0.0)
        dcol = -dcol;
      if (drow >= dcol) {
        if (((*r1 < *r2) && (newr1 > newr2)) ||
            ((*r1 > *r2) && (newr1 < newr2)))
          drow = -1.0;
      } else {
        if (((*c1 < *c2) && (newc1 > newc2)) ||
            ((*c1 > *c2) && (newc1 < newc2)))
          drow = -1.0;
      }
      if (drow < 0.0) {
        x = newr1, newr1 = newr2, newr2 = x;
        y = newc1, newc1 = newc2, newc2 = y;
      }
    }
    newc1 = ((newc1 < 0.0) ? 0.0 : ((newc1 > nc) ? nc : newc1));
    newc2 = ((newc2 < 0.0) ? 0.0 : ((newc2 > nc) ? nc : newc2));
    newr1 = ((newr1 < 0.0) ? 0.0 : ((newr1 > nr) ? nr : newr1));
    newr2 = ((newr2 < 0.0) ? 0.0 : ((newr2 > nr) ? nr : newr2));
    if (sqrt((newr1 - newr2) * (newr1 - newr2) +
             (newc1 - newc2) * (newc1 - newc2)) > 2.0) {
      *r1 = newr1;
      *c1 = newc1;
      *r2 = newr2;
      *c2 = newc2;
    }
    return 1;
  }
}


x86 assembly (clang, -O0):
<move_vslice>:
push   %rbp
mov    %rsp,%rbp
sub    $0x7f0,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x8(%rbp),%edi
lea    -0x6e4(%rbp),%rsi
call   1030 <vis5d_get_ctx_display_index@plt>
mov    -0x6e4(%rbp),%edi
lea    -0x60(%rbp),%rsi
lea    -0x64(%rbp),%rdx
lea    -0x68(%rbp),%rcx
lea    -0x6c(%rbp),%r8
lea    -0x74(%rbp),%r9
lea    -0x78(%rbp),%rax
mov    %rax,(%rsp)
call   1080 <vis5d_get_sizePRIME@plt>
mov    -0x8(%rbp),%edi
lea    -0x3a0(%rbp),%rcx
lea    -0x6c0(%rbp),%r8
lea    -0x7c(%rbp),%rsi
lea    -0x80(%rbp),%rdx
lea    -0x6c4(%rbp),%r9
lea    -0x6c8(%rbp),%r11
lea    -0x6cc(%rbp),%r10
lea    -0x6d0(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
call   1040 <vis5d_get_size@plt>
mov    -0x6e4(%rbp),%edi
lea    -0x6d4(%rbp),%rsi
lea    -0x6d8(%rbp),%rdx
lea    -0x6dc(%rbp),%rcx
lea    -0x6e0(%rbp),%r8
lea    -0x24(%rbp),%r9
lea    -0x28(%rbp),%rax
mov    %rax,(%rsp)
call   10c0 <vis5d_get_box_bounds@plt>
mov    -0x60(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x5c(%rbp)
cvtsi2ssl -0xc(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
cvtsi2ssl -0x10(%rbp),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x6e4(%rbp),%edi
movss  -0x24(%rbp),%xmm0
movss  -0x28(%rbp),%xmm1
lea    -0x34(%rbp),%rsi
lea    -0x40(%rbp),%rdx
call   1060 <vis5d_unproject@plt>
cmpl   $0x4,0x28(%rbp)
jge    1a29 <move_vslice+0x889>
cmpl   $0x2,0x28(%rbp)
jge    12fc <move_vslice+0x15c>
mov    -0x68(%rbp),%eax
sub    $0x1,%eax
add    -0x6c(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x6f8(%rbp)
ff
jmp    1309 <move_vslice+0x169>
cvtsi2ssl -0x6c(%rbp),%xmm0
movss  %xmm0,-0x6f8(%rbp)
ff
movss  0x1d03(%rip),%xmm0
movss  %xmm0,-0x6ec(%rbp)
ff
movl   $0x0,-0x704(%rbp)
cmpl   $0x4,-0x704(%rbp)
jge    1732 <move_vslice+0x592>
mov    -0x704(%rbp),%eax
mov    %rax,-0x778(%rbp)
sub    $0x3,%rax
ja     1453 <move_vslice+0x2b3>
mov    -0x778(%rbp),%rax
lea    0x1cd3(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x710(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x714(%rbp)
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x718(%rbp)
ff
jmp    1453 <move_vslice+0x2b3>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70c(%rbp)
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x710(%rbp)
ff
mov    -0x60(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x714(%rbp)
ff
movss  -0x710(%rbp),%xmm0
ff
movss  %xmm0,-0x718(%rbp)
ff
jmp    1453 <move_vslice+0x2b3>
mov    -0x60(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x70c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x710(%rbp)
ff
mov    -0x60(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x714(%rbp)
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x718(%rbp)
ff
jmp    1453 <move_vslice+0x2b3>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x710(%rbp)
ff
mov    -0x60(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x714(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x718(%rbp)
ff
mov    -0x6e4(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movss  -0x70c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x710(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x6f8(%rbp),%xmm2
ff
lea    -0x724(%rbp),%rcx
lea    -0x724(%rbp),%r8
add    $0x4,%r8
lea    -0x724(%rbp),%r9
add    $0x8,%r9
call   1090 <vis5d_gridPRIME_to_xyzPRIME@plt>
mov    -0x6e4(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movss  -0x714(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0x718(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x6f8(%rbp),%xmm2
ff
lea    -0x73c(%rbp),%rcx
lea    -0x73c(%rbp),%r8
add    $0x4,%r8
lea    -0x73c(%rbp),%r9
add    $0x8,%r9
call   1090 <vis5d_gridPRIME_to_xyzPRIME@plt>
movss  -0x73c(%rbp),%xmm0
ff
subss  -0x724(%rbp),%xmm0
ff
movss  %xmm0,-0x730(%rbp)
ff
movss  -0x738(%rbp),%xmm0
ff
subss  -0x720(%rbp),%xmm0
ff
movss  %xmm0,-0x72c(%rbp)
ff
movss  -0x734(%rbp),%xmm0
ff
subss  -0x71c(%rbp),%xmm0
ff
movss  %xmm0,-0x728(%rbp)
ff
lea    -0x724(%rbp),%rdi
lea    -0x730(%rbp),%rsi
lea    -0x34(%rbp),%rdx
lea    -0x40(%rbp),%rcx
call   1050 <point_nearest_line@plt>
movss  %xmm0,-0x6f4(%rbp)
ff
movss  -0x724(%rbp),%xmm1
ff
movss  -0x730(%rbp),%xmm0
ff
movss  -0x6f4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x720(%rbp),%xmm1
ff
movss  -0x72c(%rbp),%xmm0
ff
movss  -0x6f4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x71c(%rbp),%xmm1
ff
movss  -0x728(%rbp),%xmm0
ff
movss  -0x6f4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x6e4(%rbp),%edi
lea    -0x4c(%rbp),%rsi
lea    -0x50(%rbp),%rdx
lea    -0x54(%rbp),%rcx
call   1070 <vis5d_project@plt>
movss  -0x50(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
subss  -0x24(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
subss  -0x28(%rbp),%xmm1
movss  -0x54(%rbp),%xmm3
subss  -0x28(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6e8(%rbp)
ff
movss  -0x6e8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1650 <move_vslice+0x4b0>
jp     1650 <move_vslice+0x4b0>
movl   $0x0,-0x4(%rbp)
jmp    23ae <move_vslice+0x120e>
movss  -0x6e8(%rbp),%xmm1
ff
movss  -0x6ec(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1719 <move_vslice+0x579>
movss  -0x6e8(%rbp),%xmm0
ff
movss  %xmm0,-0x6ec(%rbp)
ff
mov    -0x704(%rbp),%eax
mov    %eax,-0x708(%rbp)
movss  -0x6f4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    16ae <move_vslice+0x50e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x780(%rbp)
ff
jmp    1705 <move_vslice+0x565>
movss  -0x6f4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  0x193e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    16e1 <move_vslice+0x541>
movsd  0x192c(%rip),%xmm0
movsd  %xmm0,-0x788(%rbp)
ff
jmp    16f5 <move_vslice+0x555>
movss  -0x6f4(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x788(%rbp)
ff
movsd  -0x788(%rbp),%xmm0
ff
movsd  %xmm0,-0x780(%rbp)
ff
movsd  -0x780(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x6f0(%rbp)
ff
jmp    171e <move_vslice+0x57e>
mov    -0x704(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x704(%rbp)
jmp    1323 <move_vslice+0x183>
mov    -0x708(%rbp),%eax
mov    %rax,-0x790(%rbp)
sub    $0x3,%rax
ja     18f9 <move_vslice+0x759>
mov    -0x790(%rbp),%rax
lea    0x18c1(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x6e4(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movss  -0x6d4(%rbp),%xmm1
ff
movss  -0x6f0(%rbp),%xmm0
ff
movss  -0x6d8(%rbp),%xmm2
ff
subss  -0x6d4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm2,%xmm2
lea    -0x6f4(%rbp),%r9
lea    -0x6fc(%rbp),%r8
movaps %xmm2,%xmm1
mov    %r9,%rcx
call   10b0 <vis5d_xyzPRIME_to_gridPRIME@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x700(%rbp)
ff
jmp    18f9 <move_vslice+0x759>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x6fc(%rbp)
ff
mov    -0x6e4(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movss  -0x6e0(%rbp),%xmm0
ff
movss  -0x6f0(%rbp),%xmm1
ff
movss  -0x6e0(%rbp),%xmm2
ff
subss  -0x6dc(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
xorps  %xmm2,%xmm2
lea    -0x700(%rbp),%rcx
lea    -0x6f4(%rbp),%r9
movaps %xmm2,%xmm0
mov    %r9,%r8
call   10b0 <vis5d_xyzPRIME_to_gridPRIME@plt>
jmp    18f9 <move_vslice+0x759>
mov    -0x6e4(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movss  -0x6d4(%rbp),%xmm1
ff
movss  -0x6f0(%rbp),%xmm0
ff
movss  -0x6d8(%rbp),%xmm2
ff
subss  -0x6d4(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm2,%xmm2
lea    -0x6f4(%rbp),%r9
lea    -0x6fc(%rbp),%r8
movaps %xmm2,%xmm1
mov    %r9,%rcx
call   10b0 <vis5d_xyzPRIME_to_gridPRIME@plt>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x700(%rbp)
ff
jmp    18f9 <move_vslice+0x759>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6fc(%rbp)
ff
mov    -0x6e4(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movss  -0x6e0(%rbp),%xmm0
ff
movss  -0x6f0(%rbp),%xmm1
ff
movss  -0x6e0(%rbp),%xmm2
ff
subss  -0x6dc(%rbp),%xmm2
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
xorps  %xmm2,%xmm2
lea    -0x700(%rbp),%rcx
lea    -0x6f4(%rbp),%r9
movaps %xmm2,%xmm0
mov    %r9,%r8
call   10b0 <vis5d_xyzPRIME_to_gridPRIME@plt>
mov    0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1995 <move_vslice+0x7f5>
mov    0x18(%rbp),%rax
movss  (%rax),%xmm0
subss  -0x700(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  (%rax),%xmm2
subss  -0x700(%rbp),%xmm2
ff
mov    0x20(%rbp),%rax
movss  (%rax),%xmm1
subss  -0x6fc(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movss  (%rax),%xmm3
subss  -0x6fc(%rbp),%xmm3
ff
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  0x16a2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1990 <move_vslice+0x7f0>
movss  -0x700(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x6fc(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
jmp    1a1d <move_vslice+0x87d>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
subss  -0x700(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
subss  -0x700(%rbp),%xmm2
ff
mov    0x10(%rbp),%rax
movss  (%rax),%xmm1
subss  -0x6fc(%rbp),%xmm1
ff
mov    0x10(%rbp),%rax
movss  (%rax),%xmm3
subss  -0x6fc(%rbp),%xmm3
ff
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  0x161a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1a18 <move_vslice+0x878>
movss  -0x700(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x6fc(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
jmp    1a1d <move_vslice+0x87d>
movl   $0x1,-0x4(%rbp)
jmp    23ae <move_vslice+0x120e>
cmpl   $0x4,0x28(%rbp)
jne    1a90 <move_vslice+0x8f0>
mov    -0x6e4(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x68(%rbp),%eax
sub    $0x1,%eax
add    -0x6c(%rbp),%eax
cvtsi2ss %eax,%xmm2
movsd  0x15ac(%rip),%xmm1
lea    -0x764(%rbp),%rcx
lea    -0x768(%rbp),%r8
lea    -0x76c(%rbp),%r9
movaps %xmm1,%xmm0
call   1090 <vis5d_gridPRIME_to_xyzPRIME@plt>
movss  -0x76c(%rbp),%xmm0
ff
subss  -0x2c(%rbp),%xmm0
divss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x76c(%rbp)
ff
jmp    1ae0 <move_vslice+0x940>
mov    -0x6e4(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
cvtsi2ssl -0x6c(%rbp),%xmm2
movsd  0x1557(%rip),%xmm1
lea    -0x764(%rbp),%rcx
lea    -0x768(%rbp),%r8
lea    -0x76c(%rbp),%r9
movaps %xmm1,%xmm0
call   1090 <vis5d_gridPRIME_to_xyzPRIME@plt>
movss  -0x76c(%rbp),%xmm0
ff
subss  -0x2c(%rbp),%xmm0
divss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x76c(%rbp)
ff
movss  -0x34(%rbp),%xmm1
movss  -0x76c(%rbp),%xmm0
ff
movss  -0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x76c(%rbp),%xmm0
ff
movss  -0x3c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x2c(%rbp),%xmm1
movss  -0x76c(%rbp),%xmm0
ff
movss  -0x38(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x6e4(%rbp),%edi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
movss  -0x4c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm1
movss  -0x44(%rbp),%xmm2
lea    -0x740(%rbp),%rcx
lea    -0x744(%rbp),%r8
lea    -0x748(%rbp),%r9
call   10b0 <vis5d_xyzPRIME_to_gridPRIME@plt>
mov    0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x74c(%rbp)
ff
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x750(%rbp)
ff
movss  -0x74c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1bfe <move_vslice+0xa5e>
jp     1bfe <move_vslice+0xa5e>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x758(%rbp)
ff
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x760(%rbp)
ff
movss  -0x740(%rbp),%xmm0
ff
movss  %xmm0,-0x75c(%rbp)
ff
movss  %xmm0,-0x754(%rbp)
ff
jmp    20f0 <move_vslice+0xf50>
movss  -0x750(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c5a <move_vslice+0xaba>
jp     1c5a <move_vslice+0xaba>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x754(%rbp)
ff
mov    0x18(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x75c(%rbp)
ff
movss  -0x744(%rbp),%xmm0
ff
movss  %xmm0,-0x760(%rbp)
ff
movss  %xmm0,-0x758(%rbp)
ff
jmp    20eb <move_vslice+0xf4b>
movss  -0x740(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x74c(%rbp),%xmm0
ff
movss  %xmm0,-0x76c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x754(%rbp)
ff
movss  -0x744(%rbp),%xmm1
ff
movss  -0x750(%rbp),%xmm0
ff
movss  -0x76c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x758(%rbp)
ff
movss  -0x58(%rbp),%xmm0
subss  -0x740(%rbp),%xmm0
ff
divss  -0x74c(%rbp),%xmm0
ff
movss  %xmm0,-0x76c(%rbp)
ff
cvtsi2sdl -0x60(%rbp),%xmm0
movsd  0x1324(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x75c(%rbp)
ff
movss  -0x744(%rbp),%xmm1
ff
movss  -0x750(%rbp),%xmm0
ff
movss  -0x76c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x760(%rbp)
ff
movss  -0x758(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1d85 <move_vslice+0xbe5>
movss  -0x744(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x750(%rbp),%xmm0
ff
movss  %xmm0,-0x76c(%rbp)
ff
movss  -0x740(%rbp),%xmm1
ff
movss  -0x74c(%rbp),%xmm0
ff
movss  -0x76c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x754(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x758(%rbp)
ff
movss  -0x758(%rbp),%xmm0
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
ucomiss %xmm1,%xmm0
jbe    1df7 <move_vslice+0xc57>
movss  -0x5c(%rbp),%xmm0
subss  -0x744(%rbp),%xmm0
ff
divss  -0x750(%rbp),%xmm0
ff
movss  %xmm0,-0x76c(%rbp)
ff
movss  -0x740(%rbp),%xmm1
ff
movss  -0x74c(%rbp),%xmm0
ff
movss  -0x76c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x754(%rbp)
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x758(%rbp)
ff
movss  -0x760(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1e68 <move_vslice+0xcc8>
movss  -0x744(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
divss  -0x750(%rbp),%xmm0
ff
movss  %xmm0,-0x76c(%rbp)
ff
movss  -0x740(%rbp),%xmm1
ff
movss  -0x74c(%rbp),%xmm0
ff
movss  -0x76c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x75c(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0x760(%rbp)
ff
movss  -0x760(%rbp),%xmm0
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm1
ucomiss %xmm1,%xmm0
jbe    1eda <move_vslice+0xd3a>
movss  -0x5c(%rbp),%xmm0
subss  -0x744(%rbp),%xmm0
ff
divss  -0x750(%rbp),%xmm0
ff
movss  %xmm0,-0x76c(%rbp)
ff
movss  -0x740(%rbp),%xmm1
ff
movss  -0x74c(%rbp),%xmm0
ff
movss  -0x76c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x75c(%rbp)
ff
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
cvtsi2ss %eax,%xmm0
movss  %xmm0,-0x760(%rbp)
ff
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    0x18(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x74c(%rbp)
ff
movss  -0x74c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1f28 <move_vslice+0xd88>
movss  -0x74c(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x74c(%rbp)
ff
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    0x20(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x750(%rbp)
ff
movss  -0x750(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1f76 <move_vslice+0xdd6>
movss  -0x750(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x750(%rbp)
ff
movss  -0x74c(%rbp),%xmm0
ff
ucomiss -0x750(%rbp),%xmm0
jb     1ffc <move_vslice+0xe5c>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
mov    0x18(%rbp),%rax
movss  (%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    1fb9 <move_vslice+0xe19>
movss  -0x754(%rbp),%xmm0
ff
ucomiss -0x75c(%rbp),%xmm0
ja     1fe7 <move_vslice+0xe47>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    0x18(%rbp),%rax
ucomiss (%rax),%xmm0
jbe    1ff7 <move_vslice+0xe57>
movss  -0x754(%rbp),%xmm1
ff
movss  -0x75c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1ff7 <move_vslice+0xe57>
movss  0x1021(%rip),%xmm0
movss  %xmm0,-0x74c(%rbp)
ff
jmp    206d <move_vslice+0xecd>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm1
mov    0x20(%rbp),%rax
movss  (%rax),%xmm0
ucomiss %xmm1,%xmm0
jbe    202a <move_vslice+0xe8a>
movss  -0x758(%rbp),%xmm0
ff
ucomiss -0x760(%rbp),%xmm0
ja     2058 <move_vslice+0xeb8>
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    0x20(%rbp),%rax
ucomiss (%rax),%xmm0
jbe    2068 <move_vslice+0xec8>
movss  -0x758(%rbp),%xmm1
ff
movss  -0x760(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    2068 <move_vslice+0xec8>
movss  0xfb0(%rip),%xmm0
movss  %xmm0,-0x74c(%rbp)
ff
jmp    206d <move_vslice+0xecd>
movss  -0x74c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    20e6 <move_vslice+0xf46>
movss  -0x754(%rbp),%xmm0
ff
movss  %xmm0,-0x764(%rbp)
ff
movss  -0x75c(%rbp),%xmm0
ff
movss  %xmm0,-0x754(%rbp)
ff
movss  -0x764(%rbp),%xmm0
ff
movss  %xmm0,-0x75c(%rbp)
ff
movss  -0x758(%rbp),%xmm0
ff
movss  %xmm0,-0x768(%rbp)
ff
movss  -0x760(%rbp),%xmm0
ff
movss  %xmm0,-0x758(%rbp)
ff
movss  -0x768(%rbp),%xmm0
ff
movss  %xmm0,-0x760(%rbp)
ff
jmp    20eb <move_vslice+0xf4b>
jmp    20f0 <move_vslice+0xf50>
movss  -0x758(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    2119 <move_vslice+0xf79>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x798(%rbp)
ff
jmp    2161 <move_vslice+0xfc1>
movss  -0x758(%rbp),%xmm0
ff
ucomiss -0x5c(%rbp),%xmm0
jbe    213d <move_vslice+0xf9d>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x79c(%rbp)
ff
jmp    214d <move_vslice+0xfad>
movss  -0x758(%rbp),%xmm0
ff
movss  %xmm0,-0x79c(%rbp)
ff
movss  -0x79c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x798(%rbp)
ff
movsd  -0x798(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x758(%rbp)
ff
movss  -0x760(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    219e <move_vslice+0xffe>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x7a8(%rbp)
ff
jmp    21e6 <move_vslice+0x1046>
movss  -0x760(%rbp),%xmm0
ff
ucomiss -0x5c(%rbp),%xmm0
jbe    21c2 <move_vslice+0x1022>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x7ac(%rbp)
ff
jmp    21d2 <move_vslice+0x1032>
movss  -0x760(%rbp),%xmm0
ff
movss  %xmm0,-0x7ac(%rbp)
ff
movss  -0x7ac(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x7a8(%rbp)
ff
movsd  -0x7a8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x760(%rbp)
ff
movss  -0x754(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    2223 <move_vslice+0x1083>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x7b8(%rbp)
ff
jmp    226b <move_vslice+0x10cb>
movss  -0x754(%rbp),%xmm0
ff
ucomiss -0x58(%rbp),%xmm0
jbe    2247 <move_vslice+0x10a7>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x7bc(%rbp)
ff
jmp    2257 <move_vslice+0x10b7>
movss  -0x754(%rbp),%xmm0
ff
movss  %xmm0,-0x7bc(%rbp)
ff
movss  -0x7bc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x7b8(%rbp)
ff
movsd  -0x7b8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x754(%rbp)
ff
movss  -0x75c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    22a8 <move_vslice+0x1108>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x7c8(%rbp)
ff
jmp    22f0 <move_vslice+0x1150>
movss  -0x75c(%rbp),%xmm0
ff
ucomiss -0x58(%rbp),%xmm0
jbe    22cc <move_vslice+0x112c>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x7cc(%rbp)
ff
jmp    22dc <move_vslice+0x113c>
movss  -0x75c(%rbp),%xmm0
ff
movss  %xmm0,-0x7cc(%rbp)
ff
movss  -0x7cc(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x7c8(%rbp)
ff
movsd  -0x7c8(%rbp),%xmm0
ff
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x75c(%rbp)
ff
movss  -0x754(%rbp),%xmm0
ff
subss  -0x75c(%rbp),%xmm0
ff
movss  -0x754(%rbp),%xmm2
ff
subss  -0x75c(%rbp),%xmm2
ff
movss  -0x758(%rbp),%xmm1
ff
subss  -0x760(%rbp),%xmm1
ff
movss  -0x758(%rbp),%xmm3
ff
subss  -0x760(%rbp),%xmm3
ff
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
movsd  0xcab(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    23a7 <move_vslice+0x1207>
movss  -0x754(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x758(%rbp),%xmm0
ff
mov    0x10(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x75c(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x760(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x7f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<move_vslice>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x788,%rsp
mov    %r9,0x90(%rsp)
mov    %r8d,%r13d
mov    %ecx,%ebx
mov    %edx,%r14d
mov    %esi,%r15d
mov    %edi,%ebp
mov    0x7d8(%rsp),%r12d
lea    0x20(%rsp),%rsi
call   1030 <vis5d_get_ctx_display_index@plt>
mov    0x20(%rsp),%edi
lea    0x128(%rsp),%rax
mov    %rax,(%rsp)
lea    0x40(%rsp),%rsi
lea    0x3c(%rsp),%rdx
lea    0x6c(%rsp),%rcx
lea    0x50(%rsp),%r8
lea    0x12c(%rsp),%r9
call   1080 <vis5d_get_sizePRIME@plt>
lea    0x110(%rsp),%rax
mov    %rax,0x10(%rsp)
lea    0x114(%rsp),%rax
mov    %rax,0x8(%rsp)
lea    0x118(%rsp),%rax
mov    %rax,(%rsp)
lea    0x124(%rsp),%rsi
lea    0x120(%rsp),%rdx
lea    0x460(%rsp),%rcx
lea    0x140(%rsp),%r8
lea    0x11c(%rsp),%r9
mov    %ebp,%edi
call   1040 <vis5d_get_size@plt>
mov    0x20(%rsp),%edi
lea    0x70(%rsp),%rax
mov    %rax,(%rsp)
lea    0x68(%rsp),%rsi
lea    0x64(%rsp),%rdx
lea    0x60(%rsp),%rcx
lea    0x5c(%rsp),%r8
lea    0x74(%rsp),%r9
call   10c0 <vis5d_get_box_bounds@plt>
mov    0x40(%rsp),%eax
add    $0xffffffff,%eax
cvtsi2ss %eax,%xmm0
movaps %xmm0,0xd0(%rsp)
mov    0x3c(%rsp),%eax
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movaps %xmm0,0xe0(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %r15d,%xmm0
cvtsi2ss %r14d,%xmm1
movss  %xmm0,0x74(%rsp)
movss  %xmm1,0x70(%rsp)
mov    0x20(%rsp),%edi
lea    0xa4(%rsp),%rsi
lea    0x98(%rsp),%rdx
call   1060 <vis5d_unproject@plt>
cmp    $0x3,%r12d
jg     12ff <move_vslice+0x15f>
cmp    $0x1,%r12d
jg     1323 <move_vslice+0x183>
mov    0x6c(%rsp),%eax
mov    0x50(%rsp),%ecx
add    %ecx,%eax
add    $0xffffffff,%eax
jmp    1327 <move_vslice+0x187>
mov    0x20(%rsp),%edi
cmp    $0x4,%r12d
jne    1669 <move_vslice+0x4c9>
mov    0x6c(%rsp),%eax
mov    0x50(%rsp),%ecx
add    %ecx,%eax
add    $0xffffffff,%eax
cvtsi2ss %eax,%xmm2
jmp    166f <move_vslice+0x4cf>
mov    0x50(%rsp),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0xf0(%rsp)
movss  0xcf1(%rip),%xmm1
xor    %ebp,%ebp
lea    0x24(%rsp),%r15
lea    0xceb(%rip),%r14
jmp    135f <move_vslice+0x1bf>
nop
add    $0x1,%ebp
movaps %xmm0,%xmm1
cmp    $0x4,%ebp
je     178d <move_vslice+0x5ed>
movss  %xmm1,0x100(%rsp)
cmp    $0x3,%ebp
ja     1490 <move_vslice+0x2f0>
mov    %ebp,%eax
movslq (%r14,%rax,4),%rax
add    %r14,%rax
jmp    *%rax
mov    0x3c(%rsp),%eax
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x48(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0xc0(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0xb0(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x4c(%rsp)
jmp    1490 <move_vslice+0x2f0>
cs nopw 0x0(%rax,%rax,1)
mov    0x3c(%rsp),%eax
add    $0xffffffff,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
mov    0x40(%rsp),%eax
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x4c(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0xc0(%rsp)
movss  %xmm1,0xb0(%rsp)
movss  %xmm1,0x48(%rsp)
jmp    1490 <move_vslice+0x2f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x40(%rsp),%eax
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mov    0x3c(%rsp),%eax
add    $0xffffffff,%eax
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
movss  %xmm1,0x48(%rsp)
xorps  %xmm1,%xmm1
movss  %xmm1,0xb0(%rsp)
movss  %xmm0,0xc0(%rsp)
movss  %xmm0,0x4c(%rsp)
jmp    1490 <move_vslice+0x2f0>
nop
mov    0x40(%rsp),%eax
add    $0xffffffff,%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
movss  %xmm0,0x4c(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0xc0(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0xb0(%rsp)
xorps  %xmm0,%xmm0
movss  %xmm0,0x48(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%edi
movss  0xc0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0xb0(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %ebx,%esi
mov    %r13d,%edx
movss  0xf0(%rsp),%xmm2
mov    %r15,%rcx
lea    0x28(%rsp),%r8
lea    0x2c(%rsp),%r9
call   1090 <vis5d_gridPRIME_to_xyzPRIME@plt>
mov    0x20(%rsp),%edi
movss  0x4c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x48(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %ebx,%esi
mov    %r13d,%edx
movss  0xf0(%rsp),%xmm2
lea    0x78(%rsp),%rcx
lea    0x7c(%rsp),%r8
lea    0x80(%rsp),%r9
call   1090 <vis5d_gridPRIME_to_xyzPRIME@plt>
movss  0x78(%rsp),%xmm0
movss  0x7c(%rsp),%xmm1
subss  0x24(%rsp),%xmm0
movss  %xmm0,0x30(%rsp)
subss  0x28(%rsp),%xmm1
movss  %xmm1,0x34(%rsp)
movss  0x80(%rsp),%xmm0
subss  0x2c(%rsp),%xmm0
movss  %xmm0,0x38(%rsp)
mov    %r15,%rdi
lea    0x30(%rsp),%rsi
lea    0xa4(%rsp),%rdx
lea    0x98(%rsp),%rcx
call   1050 <point_nearest_line@plt>
movss  0x30(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  0x24(%rsp),%xmm1
movss  %xmm1,0x84(%rsp)
movss  0x34(%rsp),%xmm1
mulss  %xmm0,%xmm1
addss  0x28(%rsp),%xmm1
movss  %xmm0,0x1c(%rsp)
movss  %xmm1,0x88(%rsp)
movss  0x38(%rsp),%xmm1
movaps %xmm0,0x130(%rsp)
mulss  %xmm0,%xmm1
addss  0x2c(%rsp),%xmm1
movss  %xmm1,0x8c(%rsp)
mov    0x20(%rsp),%edi
lea    0x84(%rsp),%rsi
lea    0x58(%rsp),%rdx
lea    0x54(%rsp),%rcx
call   1070 <vis5d_project@plt>
movss  0x58(%rsp),%xmm0
subss  0x74(%rsp),%xmm0
movss  0x54(%rsp),%xmm1
subss  0x70(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm0
setp   %al
setne  %cl
or     %al,%cl
movss  0x100(%rsp),%xmm3
ucomiss %xmm0,%xmm3
seta   %al
and    %cl,%al
test   %al,%al
je     1647 <move_vslice+0x4a7>
movss  0xa07(%rip),%xmm1
movaps 0x130(%rsp),%xmm4
minss  %xmm4,%xmm1
cmpltss %xmm2,%xmm4
andnps %xmm1,%xmm4
movss  %xmm4,0x44(%rsp)
cmovne %ebp,%r12d
ucomiss %xmm2,%xmm0
jne    1652 <move_vslice+0x4b2>
jnp    1662 <move_vslice+0x4c2>
test   %al,%al
jne    1350 <move_vslice+0x1b0>
movaps %xmm3,%xmm0
jmp    1350 <move_vslice+0x1b0>
xor    %eax,%eax
jmp    1c4f <move_vslice+0xaaf>
cvtsi2ssl 0x50(%rsp),%xmm2
movsd  0x989(%rip),%xmm0
lea    0x58(%rsp),%rcx
lea    0x54(%rsp),%r8
lea    0x1c(%rsp),%r9
mov    %ebx,%esi
mov    %r13d,%edx
movaps %xmm0,%xmm1
call   1090 <vis5d_gridPRIME_to_xyzPRIME@plt>
movss  0x1c(%rsp),%xmm4
movss  0xac(%rsp),%xmm3
subss  %xmm3,%xmm4
movss  0xa0(%rsp),%xmm2
divss  %xmm2,%xmm4
mov    0x7d0(%rsp),%r15
movss  %xmm4,0x1c(%rsp)
movss  0x98(%rsp),%xmm0
mulss  %xmm4,%xmm0
addss  0xa4(%rsp),%xmm0
movss  %xmm0,0x84(%rsp)
movss  0x9c(%rsp),%xmm1
mulss  %xmm4,%xmm1
addss  0xa8(%rsp),%xmm1
movss  %xmm1,0x88(%rsp)
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  %xmm2,0x8c(%rsp)
mov    0x20(%rsp),%edi
lea    0x24(%rsp),%rcx
lea    0x30(%rsp),%r8
lea    0x78(%rsp),%r9
mov    %ebx,%esi
mov    %r13d,%edx
call   10b0 <vis5d_xyzPRIME_to_gridPRIME@plt>
mov    0x7c8(%rsp),%r14
movss  (%r14),%xmm0
mov    0x90(%rsp),%rbx
movss  (%rbx),%xmm5
movaps %xmm0,%xmm3
subss  %xmm5,%xmm3
movss  (%r15),%xmm10
mov    0x7c0(%rsp),%rbp
movss  0x0(%rbp),%xmm14
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm3
jne    17f6 <move_vslice+0x656>
jp     17f6 <move_vslice+0x656>
movss  0x24(%rsp),%xmm5
movaps %xmm5,%xmm2
movaps %xmm10,%xmm6
movaps 0xd0(%rsp),%xmm13
jmp    1b85 <move_vslice+0x9e5>
cmp    $0x3,%r12d
ja     19a5 <move_vslice+0x805>
mov    %r12d,%eax
lea    0x8a7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    0x20(%rsp),%edi
movss  0x68(%rsp),%xmm2
movss  0x64(%rsp),%xmm1
subss  %xmm2,%xmm1
movss  0x44(%rsp),%xmm0
mulss  %xmm1,%xmm0
addss  %xmm2,%xmm0
lea    0x24(%rsp),%r8
lea    0x1c(%rsp),%rcx
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
mov    %ebx,%esi
mov    %r13d,%edx
mov    %rcx,%r9
call   10b0 <vis5d_xyzPRIME_to_gridPRIME@plt>
movl   $0x0,0x30(%rsp)
jmp    19a5 <move_vslice+0x805>
movaps %xmm10,%xmm1
subss  %xmm14,%xmm1
ucomiss %xmm2,%xmm1
jne    1822 <move_vslice+0x682>
jp     1822 <move_vslice+0x682>
movss  0x30(%rsp),%xmm14
movaps %xmm0,%xmm2
movaps %xmm14,%xmm6
movaps 0xd0(%rsp),%xmm13
jmp    1b85 <move_vslice+0x9e5>
movss  0x24(%rsp),%xmm8
movaps %xmm8,%xmm2
divss  %xmm3,%xmm2
movss  0x30(%rsp),%xmm11
mulss  %xmm1,%xmm2
movaps %xmm11,%xmm6
subss  %xmm2,%xmm6
movaps 0xd0(%rsp),%xmm13
movaps %xmm13,%xmm9
subss  %xmm8,%xmm9
divss  %xmm3,%xmm9
movss  %xmm9,0x1c(%rsp)
mulss  %xmm1,%xmm9
xorps  %xmm2,%xmm2
ucomiss %xmm6,%xmm2
jbe    1890 <move_vslice+0x6f0>
movaps 0x7aa(%rip),%xmm2
xorps  %xmm11,%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x1c(%rsp)
mulss  %xmm3,%xmm2
addss  %xmm8,%xmm2
xorps  %xmm6,%xmm6
mov    0x3c(%rsp),%eax
add    $0xffffffff,%eax
cvtsi2ss %eax,%xmm7
addss  %xmm11,%xmm9
ucomiss %xmm7,%xmm6
jbe    18c8 <move_vslice+0x728>
movaps 0xe0(%rsp),%xmm2
subss  %xmm11,%xmm2
divss  %xmm1,%xmm2
movss  %xmm2,0x1c(%rsp)
mulss  %xmm3,%xmm2
addss  %xmm8,%xmm2
movaps %xmm7,%xmm6
xorps  %xmm4,%xmm4
ucomiss %xmm9,%xmm4
jbe    1a92 <move_vslice+0x8f2>
movaps 0x743(%rip),%xmm12
xorps  %xmm11,%xmm12
divss  %xmm1,%xmm12
movss  %xmm12,0x1c(%rsp)
mulss  %xmm3,%xmm12
addss  %xmm8,%xmm12
xorps  %xmm9,%xmm9
jmp    1aa8 <move_vslice+0x908>
movaps 0xe0(%rsp),%xmm0
movss  %xmm0,0x24(%rsp)
jmp    1967 <move_vslice+0x7c7>
mov    0x20(%rsp),%edi
movss  0x68(%rsp),%xmm2
movss  0x64(%rsp),%xmm1
subss  %xmm2,%xmm1
movss  0x44(%rsp),%xmm0
mulss  %xmm1,%xmm0
addss  %xmm2,%xmm0
lea    0x24(%rsp),%r8
lea    0x1c(%rsp),%rcx
xorps  %xmm1,%xmm1
xorps  %xmm2,%xmm2
mov    %ebx,%esi
mov    %r13d,%edx
mov    %rcx,%r9
call   10b0 <vis5d_xyzPRIME_to_gridPRIME@plt>
movaps 0xd0(%rsp),%xmm0
movss  %xmm0,0x30(%rsp)
jmp    19a5 <move_vslice+0x805>
movl   $0x0,0x24(%rsp)
mov    0x20(%rsp),%edi
movss  0x5c(%rsp),%xmm1
movaps %xmm1,%xmm0
subss  0x60(%rsp),%xmm0
movss  0x44(%rsp),%xmm2
mulss  %xmm0,%xmm2
subss  %xmm2,%xmm1
lea    0x30(%rsp),%rcx
lea    0x1c(%rsp),%r8
xorps  %xmm0,%xmm0
xorps  %xmm2,%xmm2
mov    %ebx,%esi
mov    %r13d,%edx
mov    %r8,%r9
call   10b0 <vis5d_xyzPRIME_to_gridPRIME@plt>
mov    0x7d8(%rsp),%eax
test   $0x1,%al
jne    1a21 <move_vslice+0x881>
mov    0x7c8(%rsp),%rax
movss  (%rax),%xmm0
subss  0x30(%rsp),%xmm0
mov    0x7d0(%rsp),%rax
movss  (%rax),%xmm1
subss  0x24(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
mov    $0x1,%eax
ucomisd 0x61e(%rip),%xmm0
jbe    1c4f <move_vslice+0xaaf>
movss  0x30(%rsp),%xmm0
mov    0x90(%rsp),%rcx
movss  %xmm0,(%rcx)
movss  0x24(%rsp),%xmm0
mov    0x7c0(%rsp),%rcx
movss  %xmm0,(%rcx)
jmp    1c4f <move_vslice+0xaaf>
mov    0x90(%rsp),%rax
movss  (%rax),%xmm0
subss  0x30(%rsp),%xmm0
mov    0x7c0(%rsp),%rax
movss  (%rax),%xmm1
subss  0x24(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
mov    $0x1,%eax
ucomisd 0x5ad(%rip),%xmm0
jbe    1c4f <move_vslice+0xaaf>
movss  0x30(%rsp),%xmm0
mov    0x7c8(%rsp),%rcx
movss  %xmm0,(%rcx)
movss  0x24(%rsp),%xmm0
mov    0x7d0(%rsp),%rcx
movss  %xmm0,(%rcx)
jmp    1c4f <move_vslice+0xaaf>
xorps  %xmm4,%xmm4
cvtsi2sdl 0x40(%rsp),%xmm4
addsd  0x565(%rip),%xmm4
cvtsd2ss %xmm4,%xmm12
ucomiss %xmm7,%xmm9
jbe    1ad6 <move_vslice+0x936>
movaps 0xe0(%rsp),%xmm4
subss  %xmm11,%xmm4
divss  %xmm1,%xmm4
movss  %xmm4,0x1c(%rsp)
mulss  %xmm4,%xmm3
addss  %xmm8,%xmm3
movaps %xmm3,%xmm12
movaps %xmm7,%xmm9
movaps %xmm5,%xmm1
subss  %xmm0,%xmm1
movaps 0x53c(%rip),%xmm4
movaps %xmm1,%xmm7
xorps  %xmm4,%xmm7
xorps  %xmm8,%xmm8
movaps %xmm1,%xmm3
cmpltss %xmm8,%xmm3
andps  %xmm3,%xmm7
andnps %xmm1,%xmm3
orps   %xmm7,%xmm3
movaps %xmm14,%xmm1
subss  %xmm10,%xmm1
xorps  %xmm1,%xmm4
movaps %xmm1,%xmm7
cmpltss %xmm8,%xmm7
andps  %xmm7,%xmm4
andnps %xmm1,%xmm7
orps   %xmm4,%xmm7
ucomiss %xmm7,%xmm3
jae    1b3c <move_vslice+0x99c>
ucomiss %xmm14,%xmm10
jbe    1b2f <move_vslice+0x98f>
ucomiss %xmm9,%xmm6
ja     1b71 <move_vslice+0x9d1>
ucomiss %xmm10,%xmm14
seta   %al
ucomiss %xmm6,%xmm9
jmp    1b51 <move_vslice+0x9b1>
ucomiss %xmm5,%xmm0
jbe    1b47 <move_vslice+0x9a7>
ucomiss %xmm12,%xmm2
ja     1b71 <move_vslice+0x9d1>
ucomiss %xmm0,%xmm5
seta   %al
ucomiss %xmm2,%xmm12
seta   %cl
test   %cl,%al
jne    1b71 <move_vslice+0x9d1>
xorps  %xmm0,%xmm0
ucomiss %xmm3,%xmm0
ja     1b71 <move_vslice+0x9d1>
movaps %xmm2,%xmm5
movaps %xmm6,%xmm14
movaps %xmm12,%xmm2
movaps %xmm9,%xmm6
jmp    1b85 <move_vslice+0x9e5>
movss  %xmm2,0x58(%rsp)
movss  %xmm6,0x54(%rsp)
movaps %xmm12,%xmm5
movaps %xmm9,%xmm14
movaps 0xe0(%rsp),%xmm3
movaps %xmm3,%xmm0
minss  %xmm14,%xmm0
xorps  %xmm1,%xmm1
cmpltss %xmm1,%xmm14
andnps %xmm0,%xmm14
movaps %xmm14,0xc0(%rsp)
minss  %xmm6,%xmm3
cmpltss %xmm1,%xmm6
andnps %xmm3,%xmm6
movaps %xmm6,0xf0(%rsp)
movaps %xmm13,%xmm0
minss  %xmm5,%xmm0
cmpltss %xmm1,%xmm5
andnps %xmm0,%xmm5
movaps %xmm5,0xb0(%rsp)
minss  %xmm2,%xmm13
cmpltss %xmm1,%xmm2
andnps %xmm13,%xmm2
movaps %xmm2,0x100(%rsp)
movaps %xmm5,%xmm0
subss  %xmm2,%xmm0
movaps %xmm14,%xmm1
subss  %xmm6,%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
call   10a0 <sqrt@plt>
ucomisd 0x3fb(%rip),%xmm0
jbe    1c4a <move_vslice+0xaaa>
movaps 0xb0(%rsp),%xmm0
movss  %xmm0,(%rbx)
movaps 0xc0(%rsp),%xmm0
movss  %xmm0,0x0(%rbp)
movaps 0x100(%rsp),%xmm0
movss  %xmm0,(%r14)
movaps 0xf0(%rsp),%xmm0
movss  %xmm0,(%r15)
mov    $0x1,%eax
add    $0x788,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @move_vslice(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, float* %5, float* %6, float* %7, float* %8, i32 %9) {
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca float*
%18 = alloca float*
%19 = alloca float*
%20 = alloca float*
%21 = alloca i32
%22 = alloca float
%23 = alloca float
%24 = alloca [3 x float]
%25 = alloca [3 x float]
%26 = alloca [3 x float]
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca i32
%39 = alloca i32
%40 = alloca [200 x i32]
%41 = alloca [200 x i32]
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca float
%47 = alloca float
%48 = alloca float
%49 = alloca float
%50 = alloca i32
%51 = alloca float
%52 = alloca float
%53 = alloca float
%54 = alloca float
%55 = alloca float
%56 = alloca float
%57 = alloca float
%58 = alloca i32
%59 = alloca i32
%60 = alloca float
%61 = alloca float
%62 = alloca float
%63 = alloca float
%64 = alloca [3 x float]
%65 = alloca [3 x float]
%66 = alloca [3 x float]
%67 = alloca float
%68 = alloca float
%69 = alloca float
%70 = alloca float
%71 = alloca float
%72 = alloca float
%73 = alloca float
%74 = alloca float
%75 = alloca float
%76 = alloca float
%77 = alloca float
%78 = alloca float
store i32 %0, i32* %12
store i32 %1, i32* %13
store i32 %2, i32* %14
store i32 %3, i32* %15
store i32 %4, i32* %16
store float* %5, float** %17
store float* %6, float** %18
store float* %7, float** %19
store float* %8, float** %20
store i32 %9, i32* %21
%79 = load i32, i32* %12
%80 = call i32 @vis5d_get_ctx_display_index(i32 %79, i32* %50)
%81 = load i32, i32* %50
%82 = call i32 @vis5d_get_sizePRIME(i32 %81, i32* %31, i32* %32, i32* %33, i32* %34, i32* %36, i32* %37)
%83 = load i32, i32* %12
%84 = getelementptr inbounds [200 x i32], [200 x i32]* %40, i64 0, i64 0
%85 = getelementptr inbounds [200 x i32], [200 x i32]* %41, i64 0, i64 0
%86 = call i32 @vis5d_get_size(i32 %83, i32* %38, i32* %39, i32* %84, i32* %85, i32* %42, i32* %43, i32* %44, i32* %45)
%87 = load i32, i32* %50
%88 = call i32 @vis5d_get_box_bounds(i32 %87, float* %46, float* %47, float* %48, float* %49, float* %22, float* %23)
%89 = load i32, i32* %31
%90 = sub nsw i32 %89, 1
%91 = sitofp i32 %90 to float
store float %91, float* %29
%92 = load i32, i32* %32
%93 = sub nsw i32 %92, 1
%94 = sitofp i32 %93 to float
store float %94, float* %30
%95 = load i32, i32* %13
%96 = sitofp i32 %95 to float
store float %96, float* %22
%97 = load i32, i32* %14
%98 = sitofp i32 %97 to float
store float %98, float* %23
%99 = load i32, i32* %50
%100 = load float, float* %22
%101 = load float, float* %23
%102 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 0
%103 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0, i64 0
%104 = call i32 @vis5d_unproject(i32 %99, float %100, float %101, float* %102, float* %103)
%105 = load i32, i32* %21
%106 = icmp slt i32 %105, 4
br i1 %106, label %107, label %380
107: ; preds = %10
%108 = load i32, i32* %21
%109 = icmp slt i32 %108, 2
br i1 %109, label %110, label %116
110: ; preds = %107
%111 = load i32, i32* %33
%112 = sub nsw i32 %111, 1
%113 = load i32, i32* %34
%114 = add nsw i32 %112, %113
%115 = sitofp i32 %114 to float
store float %115, float* %55
br label %119
116: ; preds = %107
%117 = load i32, i32* %34
%118 = sitofp i32 %117 to float
store float %118, float* %55
br label %119
119: ; preds = %116, %110
store float 1.000000e+04, float* %52
store i32 0, i32* %58
br label %120
120: ; preds = %268, %119
%121 = load i32, i32* %58
%122 = icmp slt i32 %121, 4
br i1 %122, label %123, label %271
123: ; preds = %120
%124 = load i32, i32* %58
switch i32 %124, label %151 [
i32 0, label %125
i32 1, label %129
i32 2, label %137
i32 3, label %147
]
125: ; preds = %123
store float 0.000000e+00, float* %60
store float 0.000000e+00, float* %61
store float 0.000000e+00, float* %62
%126 = load i32, i32* %32
%127 = sub nsw i32 %126, 1
%128 = sitofp i32 %127 to float
store float %128, float* %63
br label %151
129: ; preds = %123
store float 0.000000e+00, float* %60
%130 = load i32, i32* %32
%131 = sub nsw i32 %130, 1
%132 = sitofp i32 %131 to float
store float %132, float* %61
%133 = load i32, i32* %31
%134 = sub nsw i32 %133, 1
%135 = sitofp i32 %134 to float
store float %135, float* %62
%136 = load float, float* %61
store float %136, float* %63
br label %151
137: ; preds = %123
%138 = load i32, i32* %31
%139 = sub nsw i32 %138, 1
%140 = sitofp i32 %139 to float
store float %140, float* %60
store float 0.000000e+00, float* %61
%141 = load i32, i32* %31
%142 = sub nsw i32 %141, 1
%143 = sitofp i32 %142 to float
store float %143, float* %62
%144 = load i32, i32* %32
%145 = sub nsw i32 %144, 1
%146 = sitofp i32 %145 to float
store float %146, float* %63
br label %151
147: ; preds = %123
store float 0.000000e+00, float* %60
store float 0.000000e+00, float* %61
%148 = load i32, i32* %31
%149 = sub nsw i32 %148, 1
%150 = sitofp i32 %149 to float
store float %150, float* %62
store float 0.000000e+00, float* %63
br label %151
151: ; preds = %123, %147, %137, %129, %125
%152 = load i32, i32* %50
%153 = load i32, i32* %15
%154 = load i32, i32* %16
%155 = load float, float* %60
%156 = fpext float %155 to double
%157 = load float, float* %61
%158 = fpext float %157 to double
%159 = load float, float* %55
%160 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 0
%161 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 1
%162 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 2
%163 = call i32 @vis5d_gridPRIME_to_xyzPRIME(i32 %152, i32 %153, i32 %154, double %156, double %158, float %159, float* %160, float* %161, float* %162)
%164 = load i32, i32* %50
%165 = load i32, i32* %15
%166 = load i32, i32* %16
%167 = load float, float* %62
%168 = fpext float %167 to double
%169 = load float, float* %63
%170 = fpext float %169 to double
%171 = load float, float* %55
%172 = getelementptr inbounds [3 x float], [3 x float]* %66, i64 0, i64 0
%173 = getelementptr inbounds [3 x float], [3 x float]* %66, i64 0, i64 1
%174 = getelementptr inbounds [3 x float], [3 x float]* %66, i64 0, i64 2
%175 = call i32 @vis5d_gridPRIME_to_xyzPRIME(i32 %164, i32 %165, i32 %166, double %168, double %170, float %171, float* %172, float* %173, float* %174)
%176 = getelementptr inbounds [3 x float], [3 x float]* %66, i64 0, i64 0
%177 = load float, float* %176
%178 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 0
%179 = load float, float* %178
%180 = fsub float %177, %179
%181 = getelementptr inbounds [3 x float], [3 x float]* %65, i64 0, i64 0
store float %180, float* %181
%182 = getelementptr inbounds [3 x float], [3 x float]* %66, i64 0, i64 1
%183 = load float, float* %182
%184 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 1
%185 = load float, float* %184
%186 = fsub float %183, %185
%187 = getelementptr inbounds [3 x float], [3 x float]* %65, i64 0, i64 1
store float %186, float* %187
%188 = getelementptr inbounds [3 x float], [3 x float]* %66, i64 0, i64 2
%189 = load float, float* %188
%190 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 2
%191 = load float, float* %190
%192 = fsub float %189, %191
%193 = getelementptr inbounds [3 x float], [3 x float]* %65, i64 0, i64 2
store float %192, float* %193
%194 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 0
%195 = getelementptr inbounds [3 x float], [3 x float]* %65, i64 0, i64 0
%196 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 0
%197 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0, i64 0
%198 = call float @point_nearest_line(float* %194, float* %195, float* %196, float* %197)
store float %198, float* %54
%199 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 0
%200 = load float, float* %199
%201 = getelementptr inbounds [3 x float], [3 x float]* %65, i64 0, i64 0
%202 = load float, float* %201
%203 = load float, float* %54
%204 = call float @llvm.fmuladd.f32(float %202, float %203, float %200)
%205 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
store float %204, float* %205
%206 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 1
%207 = load float, float* %206
%208 = getelementptr inbounds [3 x float], [3 x float]* %65, i64 0, i64 1
%209 = load float, float* %208
%210 = load float, float* %54
%211 = call float @llvm.fmuladd.f32(float %209, float %210, float %207)
%212 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 1
store float %211, float* %212
%213 = getelementptr inbounds [3 x float], [3 x float]* %64, i64 0, i64 2
%214 = load float, float* %213
%215 = getelementptr inbounds [3 x float], [3 x float]* %65, i64 0, i64 2
%216 = load float, float* %215
%217 = load float, float* %54
%218 = call float @llvm.fmuladd.f32(float %216, float %217, float %214)
%219 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 2
store float %218, float* %219
%220 = load i32, i32* %50
%221 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
%222 = call i32 @vis5d_project(i32 %220, float* %221, float* %27, float* %28)
%223 = load float, float* %27
%224 = load float, float* %22
%225 = fsub float %223, %224
%226 = load float, float* %27
%227 = load float, float* %22
%228 = fsub float %226, %227
%229 = load float, float* %28
%230 = load float, float* %23
%231 = fsub float %229, %230
%232 = load float, float* %28
%233 = load float, float* %23
%234 = fsub float %232, %233
%235 = fmul float %231, %234
%236 = call float @llvm.fmuladd.f32(float %225, float %228, float %235)
%237 = call double @sqrt(float %236)
%238 = fptrunc double %237 to float
store float %238, float* %51
%239 = load float, float* %51
%240 = fpext float %239 to double
%241 = fcmp oeq double %240, 0.000000e+00
br i1 %241, label %242, label %243
242: ; preds = %151
store i32 0, i32* %11
br label %744
243: ; preds = %151
%244 = load float, float* %51
%245 = load float, float* %52
%246 = fcmp olt float %244, %245
br i1 %246, label %247, label %267
247: ; preds = %243
%248 = load float, float* %51
store float %248, float* %52
%249 = load i32, i32* %58
store i32 %249, i32* %59
%250 = load float, float* %54
%251 = fpext float %250 to double
%252 = fcmp olt double %251, 0.000000e+00
br i1 %252, label %253, label %254
253: ; preds = %247
br label %264
254: ; preds = %247
%255 = load float, float* %54
%256 = fpext float %255 to double
%257 = fcmp ogt double %256, 1.000000e+00
br i1 %257, label %258, label %259
258: ; preds = %254
br label %262
259: ; preds = %254
%260 = load float, float* %54
%261 = fpext float %260 to double
br label %262
262: ; preds = %259, %258
%263 = phi double [ 1.000000e+00, %258 ], [ %261, %259 ]
br label %264
264: ; preds = %262, %253
%265 = phi double [ 0.000000e+00, %253 ], [ %263, %262 ]
%266 = fptrunc double %265 to float
store float %266, float* %53
br label %267
267: ; preds = %264, %243
br label %268
268: ; preds = %267
%269 = load i32, i32* %58
%270 = add nsw i32 %269, 1
store i32 %270, i32* %58
br label %120
271: ; preds = %120
%272 = load i32, i32* %59
switch i32 %272, label %321 [
i32 0, label %273
i32 1, label %284
i32 2, label %297
i32 3, label %309
]
273: ; preds = %271
%274 = load i32, i32* %50
%275 = load i32, i32* %15
%276 = load i32, i32* %16
%277 = load float, float* %46
%278 = load float, float* %53
%279 = load float, float* %47
%280 = load float, float* %46
%281 = fsub float %279, %280
%282 = call float @llvm.fmuladd.f32(float %278, float %281, float %277)
%283 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %274, i32 %275, i32 %276, float %282, float 0.000000e+00, float 0.000000e+00, float* %54, float* %56, float* %54)
store float 0.000000e+00, float* %57
br label %321
284: ; preds = %271
%285 = load float, float* %30
store float %285, float* %56
%286 = load i32, i32* %50
%287 = load i32, i32* %15
%288 = load i32, i32* %16
%289 = load float, float* %49
%290 = load float, float* %53
%291 = load float, float* %49
%292 = load float, float* %48
%293 = fsub float %291, %292
%294 = fneg float %290
%295 = call float @llvm.fmuladd.f32(float %294, float %293, float %289)
%296 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %286, i32 %287, i32 %288, float 0.000000e+00, float %295, float 0.000000e+00, float* %57, float* %54, float* %54)
br label %321
297: ; preds = %271
%298 = load i32, i32* %50
%299 = load i32, i32* %15
%300 = load i32, i32* %16
%301 = load float, float* %46
%302 = load float, float* %53
%303 = load float, float* %47
%304 = load float, float* %46
%305 = fsub float %303, %304
%306 = call float @llvm.fmuladd.f32(float %302, float %305, float %301)
%307 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %298, i32 %299, i32 %300, float %306, float 0.000000e+00, float 0.000000e+00, float* %54, float* %56, float* %54)
%308 = load float, float* %29
store float %308, float* %57
br label %321
309: ; preds = %271
store float 0.000000e+00, float* %56
%310 = load i32, i32* %50
%311 = load i32, i32* %15
%312 = load i32, i32* %16
%313 = load float, float* %49
%314 = load float, float* %53
%315 = load float, float* %49
%316 = load float, float* %48
%317 = fsub float %315, %316
%318 = fneg float %314
%319 = call float @llvm.fmuladd.f32(float %318, float %317, float %313)
%320 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %310, i32 %311, i32 %312, float 0.000000e+00, float %319, float 0.000000e+00, float* %57, float* %54, float* %54)
br label %321
321: ; preds = %271, %309, %297, %284, %273
%322 = load i32, i32* %21
%323 = srem i32 %322, 2
%324 = icmp eq i32 %323, 0
br i1 %324, label %325, label %352
325: ; preds = %321
%326 = load float*, float** %19
%327 = load float, float* %326
%328 = load float, float* %57
%329 = fsub float %327, %328
%330 = load float*, float** %19
%331 = load float, float* %330
%332 = load float, float* %57
%333 = fsub float %331, %332
%334 = load float*, float** %20
%335 = load float, float* %334
%336 = load float, float* %56
%337 = fsub float %335, %336
%338 = load float*, float** %20
%339 = load float, float* %338
%340 = load float, float* %56
%341 = fsub float %339, %340
%342 = fmul float %337, %341
%343 = call float @llvm.fmuladd.f32(float %329, float %333, float %342)
%344 = call double @sqrt(float %343)
%345 = fcmp ogt double %344, 2.000000e+00
br i1 %345, label %346, label %351
346: ; preds = %325
%347 = load float, float* %57
%348 = load float*, float** %17
store float %347, float* %348
%349 = load float, float* %56
%350 = load float*, float** %18
store float %349, float* %350
br label %351
351: ; preds = %346, %325
br label %379
352: ; preds = %321
%353 = load float*, float** %17
%354 = load float, float* %353
%355 = load float, float* %57
%356 = fsub float %354, %355
%357 = load float*, float** %17
%358 = load float, float* %357
%359 = load float, float* %57
%360 = fsub float %358, %359
%361 = load float*, float** %18
%362 = load float, float* %361
%363 = load float, float* %56
%364 = fsub float %362, %363
%365 = load float*, float** %18
%366 = load float, float* %365
%367 = load float, float* %56
%368 = fsub float %366, %367
%369 = fmul float %364, %368
%370 = call float @llvm.fmuladd.f32(float %356, float %360, float %369)
%371 = call double @sqrt(float %370)
%372 = fcmp ogt double %371, 2.000000e+00
br i1 %372, label %373, label %378
373: ; preds = %352
%374 = load float, float* %57
%375 = load float*, float** %19
store float %374, float* %375
%376 = load float, float* %56
%377 = load float*, float** %20
store float %376, float* %377
br label %378
378: ; preds = %373, %352
br label %379
379: ; preds = %378, %351
store i32 1, i32* %11
br label %744
380: ; preds = %10
%381 = load i32, i32* %21
%382 = icmp eq i32 %381, 4
br i1 %382, label %383, label %400
383: ; preds = %380
%384 = load i32, i32* %50
%385 = load i32, i32* %15
%386 = load i32, i32* %16
%387 = load i32, i32* %33
%388 = sub nsw i32 %387, 1
%389 = load i32, i32* %34
%390 = add nsw i32 %388, %389
%391 = sitofp i32 %390 to float
%392 = call i32 @vis5d_gridPRIME_to_xyzPRIME(i32 %384, i32 %385, i32 %386, double 1.000000e+00, double 1.000000e+00, float %391, float* %76, float* %77, float* %78)
%393 = load float, float* %78
%394 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 2
%395 = load float, float* %394
%396 = fsub float %393, %395
%397 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0, i64 2
%398 = load float, float* %397
%399 = fdiv float %396, %398
store float %399, float* %78
br label %414
400: ; preds = %380
%401 = load i32, i32* %50
%402 = load i32, i32* %15
%403 = load i32, i32* %16
%404 = load i32, i32* %34
%405 = sitofp i32 %404 to float
%406 = call i32 @vis5d_gridPRIME_to_xyzPRIME(i32 %401, i32 %402, i32 %403, double 1.000000e+00, double 1.000000e+00, float %405, float* %76, float* %77, float* %78)
%407 = load float, float* %78
%408 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 2
%409 = load float, float* %408
%410 = fsub float %407, %409
%411 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0, i64 2
%412 = load float, float* %411
%413 = fdiv float %410, %412
store float %413, float* %78
br label %414
414: ; preds = %400, %383
%415 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 0
%416 = load float, float* %415
%417 = load float, float* %78
%418 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0, i64 0
%419 = load float, float* %418
%420 = call float @llvm.fmuladd.f32(float %417, float %419, float %416)
%421 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
store float %420, float* %421
%422 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 1
%423 = load float, float* %422
%424 = load float, float* %78
%425 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0, i64 1
%426 = load float, float* %425
%427 = call float @llvm.fmuladd.f32(float %424, float %426, float %423)
%428 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 1
store float %427, float* %428
%429 = getelementptr inbounds [3 x float], [3 x float]* %24, i64 0, i64 2
%430 = load float, float* %429
%431 = load float, float* %78
%432 = getelementptr inbounds [3 x float], [3 x float]* %25, i64 0, i64 2
%433 = load float, float* %432
%434 = call float @llvm.fmuladd.f32(float %431, float %433, float %430)
%435 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 2
store float %434, float* %435
%436 = load i32, i32* %50
%437 = load i32, i32* %15
%438 = load i32, i32* %16
%439 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
%440 = load float, float* %439
%441 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 1
%442 = load float, float* %441
%443 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 2
%444 = load float, float* %443
%445 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %436, i32 %437, i32 %438, float %440, float %442, float %444, float* %67, float* %68, float* %69)
%446 = load float*, float** %19
%447 = load float, float* %446
%448 = load float*, float** %17
%449 = load float, float* %448
%450 = fsub float %447, %449
store float %450, float* %70
%451 = load float*, float** %20
%452 = load float, float* %451
%453 = load float*, float** %18
%454 = load float, float* %453
%455 = fsub float %452, %454
store float %455, float* %71
%456 = load float, float* %70
%457 = fpext float %456 to double
%458 = fcmp oeq double %457, 0.000000e+00
br i1 %458, label %459, label %465
459: ; preds = %414
%460 = load float*, float** %18
%461 = load float, float* %460
store float %461, float* %73
%462 = load float*, float** %20
%463 = load float, float* %462
store float %463, float* %75
%464 = load float, float* %67
store float %464, float* %74
store float %464, float* %72
br label %645
465: ; preds = %414
%466 = load float, float* %71
%467 = fpext float %466 to double
%468 = fcmp oeq double %467, 0.000000e+00
br i1 %468, label %469, label %475
469: ; preds = %465
%470 = load float*, float** %17
%471 = load float, float* %470
store float %471, float* %72
%472 = load float*, float** %19
%473 = load float, float* %472
store float %473, float* %74
%474 = load float, float* %68
store float %474, float* %75
store float %474, float* %73
br label %644
475: ; preds = %465
%476 = load float, float* %67
%477 = fneg float %476
%478 = load float, float* %70
%479 = fdiv float %477, %478
store float %479, float* %78
store float 0.000000e+00, float* %72
%480 = load float, float* %68
%481 = load float, float* %71
%482 = load float, float* %78
%483 = call float @llvm.fmuladd.f32(float %481, float %482, float %480)
store float %483, float* %73
%484 = load float, float* %29
%485 = load float, float* %67
%486 = fsub float %484, %485
%487 = load float, float* %70
%488 = fdiv float %486, %487
store float %488, float* %78
%489 = load i32, i32* %31
%490 = sitofp i32 %489 to double
%491 = fsub double %490, 1.000000e+00
%492 = fptrunc double %491 to float
store float %492, float* %74
%493 = load float, float* %68
%494 = load float, float* %71
%495 = load float, float* %78
%496 = call float @llvm.fmuladd.f32(float %494, float %495, float %493)
store float %496, float* %75
%497 = load float, float* %73
%498 = fpext float %497 to double
%499 = fcmp olt double %498, 0.000000e+00
br i1 %499, label %500, label %509
500: ; preds = %475
%501 = load float, float* %68
%502 = fneg float %501
%503 = load float, float* %71
%504 = fdiv float %502, %503
store float %504, float* %78
%505 = load float, float* %67
%506 = load float, float* %70
%507 = load float, float* %78
%508 = call float @llvm.fmuladd.f32(float %506, float %507, float %505)
store float %508, float* %72
store float 0.000000e+00, float* %73
br label %509
509: ; preds = %500, %475
%510 = load float, float* %73
%511 = load i32, i32* %32
%512 = sub nsw i32 %511, 1
%513 = sitofp i32 %512 to float
%514 = fcmp ogt float %510, %513
br i1 %514, label %515, label %528
515: ; preds = %509
%516 = load float, float* %30
%517 = load float, float* %68
%518 = fsub float %516, %517
%519 = load float, float* %71
%520 = fdiv float %518, %519
store float %520, float* %78
%521 = load float, float* %67
%522 = load float, float* %70
%523 = load float, float* %78
%524 = call float @llvm.fmuladd.f32(float %522, float %523, float %521)
store float %524, float* %72
%525 = load i32, i32* %32
%526 = sub nsw i32 %525, 1
%527 = sitofp i32 %526 to float
store float %527, float* %73
br label %528
528: ; preds = %515, %509
%529 = load float, float* %75
%530 = fpext float %529 to double
%531 = fcmp olt double %530, 0.000000e+00
br i1 %531, label %532, label %541
532: ; preds = %528
%533 = load float, float* %68
%534 = fneg float %533
%535 = load float, float* %71
%536 = fdiv float %534, %535
store float %536, float* %78
%537 = load float, float* %67
%538 = load float, float* %70
%539 = load float, float* %78
%540 = call float @llvm.fmuladd.f32(float %538, float %539, float %537)
store float %540, float* %74
store float 0.000000e+00, float* %75
br label %541
541: ; preds = %532, %528
%542 = load float, float* %75
%543 = load i32, i32* %32
%544 = sub nsw i32 %543, 1
%545 = sitofp i32 %544 to float
%546 = fcmp ogt float %542, %545
br i1 %546, label %547, label %560
547: ; preds = %541
%548 = load float, float* %30
%549 = load float, float* %68
%550 = fsub float %548, %549
%551 = load float, float* %71
%552 = fdiv float %550, %551
store float %552, float* %78
%553 = load float, float* %67
%554 = load float, float* %70
%555 = load float, float* %78
%556 = call float @llvm.fmuladd.f32(float %554, float %555, float %553)
store float %556, float* %74
%557 = load i32, i32* %32
%558 = sub nsw i32 %557, 1
%559 = sitofp i32 %558 to float
store float %559, float* %75
br label %560
560: ; preds = %547, %541
%561 = load float*, float** %17
%562 = load float, float* %561
%563 = load float*, float** %19
%564 = load float, float* %563
%565 = fsub float %562, %564
store float %565, float* %70
%566 = load float, float* %70
%567 = fpext float %566 to double
%568 = fcmp olt double %567, 0.000000e+00
br i1 %568, label %569, label %572
569: ; preds = %560
%570 = load float, float* %70
%571 = fneg float %570
store float %571, float* %70
br label %572
572: ; preds = %569, %560
%573 = load float*, float** %18
%574 = load float, float* %573
%575 = load float*, float** %20
%576 = load float, float* %575
%577 = fsub float %574, %576
store float %577, float* %71
%578 = load float, float* %71
%579 = fpext float %578 to double
%580 = fcmp olt double %579, 0.000000e+00
br i1 %580, label %581, label %584
581: ; preds = %572
%582 = load float, float* %71
%583 = fneg float %582
store float %583, float* %71
br label %584
584: ; preds = %581, %572
%585 = load float, float* %70
%586 = load float, float* %71
%587 = fcmp oge float %585, %586
br i1 %587, label %588, label %610
588: ; preds = %584
%589 = load float*, float** %17
%590 = load float, float* %589
%591 = load float*, float** %19
%592 = load float, float* %591
%593 = fcmp olt float %590, %592
br i1 %593, label %594, label %598
594: ; preds = %588
%595 = load float, float* %72
%596 = load float, float* %74
%597 = fcmp ogt float %595, %596
br i1 %597, label %608, label %598
598: ; preds = %594, %588
%599 = load float*, float** %17
%600 = load float, float* %599
%601 = load float*, float** %19
%602 = load float, float* %601
%603 = fcmp ogt float %600, %602
br i1 %603, label %604, label %609
604: ; preds = %598
%605 = load float, float* %72
%606 = load float, float* %74
%607 = fcmp olt float %605, %606
br i1 %607, label %608, label %609
608: ; preds = %604, %594
store float -1.000000e+00, float* %70
br label %609
609: ; preds = %608, %604, %598
br label %632
610: ; preds = %584
%611 = load float*, float** %18
%612 = load float, float* %611
%613 = load float*, float** %20
%614 = load float, float* %613
%615 = fcmp olt float %612, %614
br i1 %615, label %616, label %620
616: ; preds = %610
%617 = load float, float* %73
%618 = load float, float* %75
%619 = fcmp ogt float %617, %618
br i1 %619, label %630, label %620
620: ; preds = %616, %610
%621 = load float*, float** %18
%622 = load float, float* %621
%623 = load float*, float** %20
%624 = load float, float* %623
%625 = fcmp ogt float %622, %624
br i1 %625, label %626, label %631
626: ; preds = %620
%627 = load float, float* %73
%628 = load float, float* %75
%629 = fcmp olt float %627, %628
br i1 %629, label %630, label %631
630: ; preds = %626, %616
store float -1.000000e+00, float* %70
br label %631
631: ; preds = %630, %626, %620
br label %632
632: ; preds = %631, %609
%633 = load float, float* %70
%634 = fpext float %633 to double
%635 = fcmp olt double %634, 0.000000e+00
br i1 %635, label %636, label %643
636: ; preds = %632
%637 = load float, float* %72
store float %637, float* %76
%638 = load float, float* %74
store float %638, float* %72
%639 = load float, float* %76
store float %639, float* %74
%640 = load float, float* %73
store float %640, float* %77
%641 = load float, float* %75
store float %641, float* %73
%642 = load float, float* %77
store float %642, float* %75
br label %643
643: ; preds = %636, %632
br label %644
644: ; preds = %643, %469
br label %645
645: ; preds = %644, %459
%646 = load float, float* %73
%647 = fpext float %646 to double
%648 = fcmp olt double %647, 0.000000e+00
br i1 %648, label %649, label %650
649: ; preds = %645
br label %661
650: ; preds = %645
%651 = load float, float* %73
%652 = load float, float* %30
%653 = fcmp ogt float %651, %652
br i1 %653, label %654, label %656
654: ; preds = %650
%655 = load float, float* %30
br label %658
656: ; preds = %650
%657 = load float, float* %73
br label %658
658: ; preds = %656, %654
%659 = phi float [ %655, %654 ], [ %657, %656 ]
%660 = fpext float %659 to double
br label %661
661: ; preds = %658, %649
%662 = phi double [ 0.000000e+00, %649 ], [ %660, %658 ]
%663 = fptrunc double %662 to float
store float %663, float* %73
%664 = load float, float* %75
%665 = fpext float %664 to double
%666 = fcmp olt double %665, 0.000000e+00
br i1 %666, label %667, label %668
667: ; preds = %661
br label %679
668: ; preds = %661
%669 = load float, float* %75
%670 = load float, float* %30
%671 = fcmp ogt float %669, %670
br i1 %671, label %672, label %674
672: ; preds = %668
%673 = load float, float* %30
br label %676
674: ; preds = %668
%675 = load float, float* %75
br label %676
676: ; preds = %674, %672
%677 = phi float [ %673, %672 ], [ %675, %674 ]
%678 = fpext float %677 to double
br label %679
679: ; preds = %676, %667
%680 = phi double [ 0.000000e+00, %667 ], [ %678, %676 ]
%681 = fptrunc double %680 to float
store float %681, float* %75
%682 = load float, float* %72
%683 = fpext float %682 to double
%684 = fcmp olt double %683, 0.000000e+00
br i1 %684, label %685, label %686
685: ; preds = %679
br label %697
686: ; preds = %679
%687 = load float, float* %72
%688 = load float, float* %29
%689 = fcmp ogt float %687, %688
br i1 %689, label %690, label %692
690: ; preds = %686
%691 = load float, float* %29
br label %694
692: ; preds = %686
%693 = load float, float* %72
br label %694
694: ; preds = %692, %690
%695 = phi float [ %691, %690 ], [ %693, %692 ]
%696 = fpext float %695 to double
br label %697
697: ; preds = %694, %685
%698 = phi double [ 0.000000e+00, %685 ], [ %696, %694 ]
%699 = fptrunc double %698 to float
store float %699, float* %72
%700 = load float, float* %74
%701 = fpext float %700 to double
%702 = fcmp olt double %701, 0.000000e+00
br i1 %702, label %703, label %704
703: ; preds = %697
br label %715
704: ; preds = %697
%705 = load float, float* %74
%706 = load float, float* %29
%707 = fcmp ogt float %705, %706
br i1 %707, label %708, label %710
708: ; preds = %704
%709 = load float, float* %29
br label %712
710: ; preds = %704
%711 = load float, float* %74
br label %712
712: ; preds = %710, %708
%713 = phi float [ %709, %708 ], [ %711, %710 ]
%714 = fpext float %713 to double
br label %715
715: ; preds = %712, %703
%716 = phi double [ 0.000000e+00, %703 ], [ %714, %712 ]
%717 = fptrunc double %716 to float
store float %717, float* %74
%718 = load float, float* %72
%719 = load float, float* %74
%720 = fsub float %718, %719
%721 = load float, float* %72
%722 = load float, float* %74
%723 = fsub float %721, %722
%724 = load float, float* %73
%725 = load float, float* %75
%726 = fsub float %724, %725
%727 = load float, float* %73
%728 = load float, float* %75
%729 = fsub float %727, %728
%730 = fmul float %726, %729
%731 = call float @llvm.fmuladd.f32(float %720, float %723, float %730)
%732 = call double @sqrt(float %731)
%733 = fcmp ogt double %732, 2.000000e+00
br i1 %733, label %734, label %743
734: ; preds = %715
%735 = load float, float* %72
%736 = load float*, float** %17
store float %735, float* %736
%737 = load float, float* %73
%738 = load float*, float** %18
store float %737, float* %738
%739 = load float, float* %74
%740 = load float*, float** %19
store float %739, float* %740
%741 = load float, float* %75
%742 = load float*, float** %20
store float %741, float* %742
br label %743
743: ; preds = %734, %715
store i32 1, i32* %11
br label %744
744: ; preds = %743, %379, %242
%745 = load i32, i32* %11
ret i32 %745
}

LLVM IR (-O2):
define i32 @move_vslice(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4, float* nocapture %5, float* nocapture %6, float* nocapture %7, float* nocapture %8, i32 %9) {
%11 = alloca float
%12 = alloca float
%13 = alloca [3 x float]
%14 = alloca [3 x float]
%15 = alloca [3 x float]
%16 = alloca float
%17 = alloca float
%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 [200 x i32]
%27 = alloca [200 x i32]
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca i32
%37 = alloca float
%38 = alloca float
%39 = alloca float
%40 = alloca [3 x float]
%41 = alloca [3 x float]
%42 = alloca [3 x float]
%43 = alloca float
%44 = alloca float
%45 = alloca float
%46 = alloca float
%47 = alloca float
%48 = alloca float
%49 = bitcast float* %11 to i8*
%50 = bitcast float* %12 to i8*
%51 = bitcast [3 x float]* %13 to i8*
%52 = bitcast [3 x float]* %14 to i8*
%53 = bitcast [3 x float]* %15 to i8*
%54 = bitcast float* %16 to i8*
%55 = bitcast float* %17 to i8*
%56 = bitcast i32* %18 to i8*
%57 = bitcast i32* %19 to i8*
%58 = bitcast i32* %20 to i8*
%59 = bitcast i32* %21 to i8*
%60 = bitcast i32* %22 to i8*
%61 = bitcast i32* %23 to i8*
%62 = bitcast i32* %24 to i8*
%63 = bitcast i32* %25 to i8*
%64 = bitcast [200 x i32]* %26 to i8*
%65 = bitcast [200 x i32]* %27 to i8*
%66 = bitcast i32* %28 to i8*
%67 = bitcast i32* %29 to i8*
%68 = bitcast i32* %30 to i8*
%69 = bitcast i32* %31 to i8*
%70 = bitcast float* %32 to i8*
%71 = bitcast float* %33 to i8*
%72 = bitcast float* %34 to i8*
%73 = bitcast float* %35 to i8*
%74 = bitcast i32* %36 to i8*
%75 = call i32 @vis5d_get_ctx_display_index(i32 %0, i32* %36)
%76 = load i32, i32* %36
%77 = call i32 @vis5d_get_sizePRIME(i32 %76, i32* %18, i32* %19, i32* %20, i32* %21, i32* %22, i32* %23)
%78 = getelementptr inbounds [200 x i32], [200 x i32]* %26, i64 0, i64 0
%79 = getelementptr inbounds [200 x i32], [200 x i32]* %27, i64 0, i64 0
%80 = call i32 @vis5d_get_size(i32 %0, i32* %24, i32* %25, i32* %78, i32* %79, i32* %28, i32* %29, i32* %30, i32* %31)
%81 = load i32, i32* %36
%82 = call i32 @vis5d_get_box_bounds(i32 %81, float* %32, float* %33, float* %34, float* %35, float* %11, float* %12)
%83 = load i32, i32* %18
%84 = add nsw i32 %83, -1
%85 = sitofp i32 %84 to float
%86 = load i32, i32* %19
%87 = add nsw i32 %86, -1
%88 = sitofp i32 %87 to float
%89 = sitofp i32 %1 to float
store float %89, float* %11
%90 = sitofp i32 %2 to float
store float %90, float* %12
%91 = load i32, i32* %36
%92 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 0
%93 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%94 = call i32 @vis5d_unproject(i32 %91, float %89, float %90, float* %92, float* %93)
%95 = icmp slt i32 %9, 4
br i1 %95, label %96, label %279
96: ; preds = %10
%97 = bitcast float* %37 to i8*
%98 = bitcast float* %38 to i8*
%99 = bitcast float* %39 to i8*
%100 = icmp slt i32 %9, 2
br i1 %100, label %101, label %106
101: ; preds = %96
%102 = load i32, i32* %20
%103 = add nsw i32 %102, -1
%104 = load i32, i32* %21
%105 = add nsw i32 %103, %104
br label %108
106: ; preds = %96
%107 = load i32, i32* %21
br label %108
108: ; preds = %106, %101
%109 = phi i32 [ %105, %101 ], [ %107, %106 ]
%110 = sitofp i32 %109 to float
%111 = bitcast [3 x float]* %40 to i8*
%112 = bitcast [3 x float]* %41 to i8*
%113 = bitcast [3 x float]* %42 to i8*
%114 = getelementptr inbounds [3 x float], [3 x float]* %40, i64 0, i64 0
%115 = getelementptr inbounds [3 x float], [3 x float]* %40, i64 0, i64 1
%116 = getelementptr inbounds [3 x float], [3 x float]* %40, i64 0, i64 2
%117 = getelementptr inbounds [3 x float], [3 x float]* %42, i64 0, i64 0
%118 = getelementptr inbounds [3 x float], [3 x float]* %42, i64 0, i64 1
%119 = getelementptr inbounds [3 x float], [3 x float]* %42, i64 0, i64 2
%120 = getelementptr inbounds [3 x float], [3 x float]* %41, i64 0, i64 0
%121 = getelementptr inbounds [3 x float], [3 x float]* %41, i64 0, i64 1
%122 = getelementptr inbounds [3 x float], [3 x float]* %41, i64 0, i64 2
%123 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%124 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%125 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
br label %130
126: ; preds = %161
%127 = select i1 %208, float %204, float %138
%128 = add nuw nsw i32 %136, 1
%129 = icmp eq i32 %128, 4
br i1 %129, label %215, label %130
130: ; preds = %108, %126
%131 = phi float [ undef, %108 ], [ %165, %126 ]
%132 = phi float [ undef, %108 ], [ %164, %126 ]
%133 = phi float [ undef, %108 ], [ %163, %126 ]
%134 = phi float [ undef, %108 ], [ %162, %126 ]
%135 = phi i32 [ undef, %108 ], [ %214, %126 ]
%136 = phi i32 [ 0, %108 ], [ %128, %126 ]
%137 = phi float [ undef, %108 ], [ %213, %126 ]
%138 = phi float [ 1.000000e+04, %108 ], [ %127, %126 ]
switch i32 %136, label %161 [
i32 0, label %139
i32 1, label %143
i32 2, label %150
i32 3, label %157
]
139: ; preds = %130
%140 = load i32, i32* %19
%141 = add nsw i32 %140, -1
%142 = sitofp i32 %141 to float
br label %161
143: ; preds = %130
%144 = load i32, i32* %19
%145 = add nsw i32 %144, -1
%146 = sitofp i32 %145 to float
%147 = load i32, i32* %18
%148 = add nsw i32 %147, -1
%149 = sitofp i32 %148 to float
br label %161
150: ; preds = %130
%151 = load i32, i32* %18
%152 = add nsw i32 %151, -1
%153 = sitofp i32 %152 to float
%154 = load i32, i32* %19
%155 = add nsw i32 %154, -1
%156 = sitofp i32 %155 to float
br label %161
157: ; preds = %130
%158 = load i32, i32* %18
%159 = add nsw i32 %158, -1
%160 = sitofp i32 %159 to float
br label %161
161: ; preds = %130, %157, %150, %143, %139
%162 = phi float [ %134, %130 ], [ 0.000000e+00, %157 ], [ %153, %150 ], [ 0.000000e+00, %143 ], [ 0.000000e+00, %139 ]
%163 = phi float [ %133, %130 ], [ 0.000000e+00, %157 ], [ 0.000000e+00, %150 ], [ %146, %143 ], [ 0.000000e+00, %139 ]
%164 = phi float [ %132, %130 ], [ %160, %157 ], [ %153, %150 ], [ %149, %143 ], [ 0.000000e+00, %139 ]
%165 = phi float [ %131, %130 ], [ 0.000000e+00, %157 ], [ %156, %150 ], [ %146, %143 ], [ %142, %139 ]
%166 = load i32, i32* %36
%167 = fpext float %162 to double
%168 = fpext float %163 to double
%169 = call i32 @vis5d_gridPRIME_to_xyzPRIME(i32 %166, i32 %3, i32 %4, double %167, double %168, float %110, float* %114, float* %115, float* %116)
%170 = load i32, i32* %36
%171 = fpext float %164 to double
%172 = fpext float %165 to double
%173 = call i32 @vis5d_gridPRIME_to_xyzPRIME(i32 %170, i32 %3, i32 %4, double %171, double %172, float %110, float* %117, float* %118, float* %119)
%174 = load float, float* %117
%175 = load float, float* %114
%176 = fsub float %174, %175
store float %176, float* %120
%177 = load float, float* %118
%178 = load float, float* %115
%179 = fsub float %177, %178
store float %179, float* %121
%180 = load float, float* %119
%181 = load float, float* %116
%182 = fsub float %180, %181
store float %182, float* %122
%183 = call float @point_nearest_line(float* %114, float* %120, float* %92, float* %93)
store float %183, float* %37
%184 = load float, float* %114
%185 = load float, float* %120
%186 = call float @llvm.fmuladd.f32(float %185, float %183, float %184)
store float %186, float* %123
%187 = load float, float* %115
%188 = load float, float* %121
%189 = call float @llvm.fmuladd.f32(float %188, float %183, float %187)
store float %189, float* %124
%190 = load float, float* %116
%191 = load float, float* %122
%192 = call float @llvm.fmuladd.f32(float %191, float %183, float %190)
store float %192, float* %125
%193 = load i32, i32* %36
%194 = call i32 @vis5d_project(i32 %193, float* %123, float* %16, float* %17)
%195 = load float, float* %16
%196 = load float, float* %11
%197 = fsub float %195, %196
%198 = load float, float* %17
%199 = load float, float* %12
%200 = fsub float %198, %199
%201 = fmul float %200, %200
%202 = call float @llvm.fmuladd.f32(float %197, float %197, float %201)
%203 = call double @sqrt(float %202)
%204 = fptrunc double %203 to float
%205 = fcmp oeq float %204, 0.000000e+00
%206 = xor i1 %205, true
%207 = fcmp ogt float %138, %204
%208 = select i1 %206, i1 %207, i1 false
%209 = fcmp olt float %183, 0.000000e+00
%210 = fcmp ogt float %183, 1.000000e+00
%211 = select i1 %210, float 1.000000e+00, float %183
%212 = select i1 %209, float 0.000000e+00, float %211
%213 = select i1 %208, float %212, float %137
%214 = select i1 %208, i32 %136, i32 %135
br i1 %205, label %277, label %126
215: ; preds = %126
switch i32 %214, label %246 [
i32 0, label %216
i32 1, label %223
i32 2, label %231
i32 3, label %238
]
216: ; preds = %215
%217 = load i32, i32* %36
%218 = load float, float* %32
%219 = load float, float* %33
%220 = fsub float %219, %218
%221 = call float @llvm.fmuladd.f32(float %213, float %220, float %218)
%222 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %217, i32 %3, i32 %4, float %221, float 0.000000e+00, float 0.000000e+00, float* %37, float* %38, float* %37)
store float 0.000000e+00, float* %39
br label %246
223: ; preds = %215
store float %88, float* %38
%224 = load i32, i32* %36
%225 = load float, float* %35
%226 = load float, float* %34
%227 = fsub float %225, %226
%228 = fneg float %213
%229 = call float @llvm.fmuladd.f32(float %228, float %227, float %225)
%230 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %224, i32 %3, i32 %4, float 0.000000e+00, float %229, float 0.000000e+00, float* %39, float* %37, float* %37)
br label %246
231: ; preds = %215
%232 = load i32, i32* %36
%233 = load float, float* %32
%234 = load float, float* %33
%235 = fsub float %234, %233
%236 = call float @llvm.fmuladd.f32(float %213, float %235, float %233)
%237 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %232, i32 %3, i32 %4, float %236, float 0.000000e+00, float 0.000000e+00, float* %37, float* %38, float* %37)
store float %85, float* %39
br label %246
238: ; preds = %215
store float 0.000000e+00, float* %38
%239 = load i32, i32* %36
%240 = load float, float* %35
%241 = load float, float* %34
%242 = fsub float %240, %241
%243 = fneg float %213
%244 = call float @llvm.fmuladd.f32(float %243, float %242, float %240)
%245 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %239, i32 %3, i32 %4, float 0.000000e+00, float %244, float 0.000000e+00, float* %39, float* %37, float* %37)
br label %246
246: ; preds = %215, %238, %231, %223, %216
%247 = and i32 %9, 1
%248 = icmp eq i32 %247, 0
br i1 %248, label %249, label %263
249: ; preds = %246
%250 = load float, float* %7
%251 = load float, float* %39
%252 = fsub float %250, %251
%253 = load float, float* %8
%254 = load float, float* %38
%255 = fsub float %253, %254
%256 = fmul float %255, %255
%257 = call float @llvm.fmuladd.f32(float %252, float %252, float %256)
%258 = call double @sqrt(float %257)
%259 = fcmp ogt double %258, 2.000000e+00
br i1 %259, label %260, label %277
260: ; preds = %249
%261 = load float, float* %39
store float %261, float* %5
%262 = load float, float* %38
store float %262, float* %6
br label %277
263: ; preds = %246
%264 = load float, float* %5
%265 = load float, float* %39
%266 = fsub float %264, %265
%267 = load float, float* %6
%268 = load float, float* %38
%269 = fsub float %267, %268
%270 = fmul float %269, %269
%271 = call float @llvm.fmuladd.f32(float %266, float %266, float %270)
%272 = call double @sqrt(float %271)
%273 = fcmp ogt double %272, 2.000000e+00
br i1 %273, label %274, label %277
274: ; preds = %263
%275 = load float, float* %39
store float %275, float* %7
%276 = load float, float* %38
store float %276, float* %8
br label %277
277: ; preds = %161, %260, %249, %274, %263
%278 = phi i32 [ 1, %263 ], [ 1, %274 ], [ 1, %249 ], [ 1, %260 ], [ 0, %161 ]
br label %451
279: ; preds = %10
%280 = bitcast float* %43 to i8*
%281 = bitcast float* %44 to i8*
%282 = bitcast float* %45 to i8*
%283 = bitcast float* %46 to i8*
%284 = bitcast float* %47 to i8*
%285 = bitcast float* %48 to i8*
%286 = icmp eq i32 %9, 4
%287 = load i32, i32* %36
br i1 %286, label %288, label %302
288: ; preds = %279
%289 = load i32, i32* %20
%290 = add nsw i32 %289, -1
%291 = load i32, i32* %21
%292 = add nsw i32 %290, %291
%293 = sitofp i32 %292 to float
%294 = call i32 @vis5d_gridPRIME_to_xyzPRIME(i32 %287, i32 %3, i32 %4, double 1.000000e+00, double 1.000000e+00, float %293, float* %46, float* %47, float* %48)
%295 = load float, float* %48
%296 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
%297 = load float, float* %296
%298 = fsub float %295, %297
%299 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%300 = load float, float* %299
%301 = fdiv float %298, %300
br label %313
302: ; preds = %279
%303 = load i32, i32* %21
%304 = sitofp i32 %303 to float
%305 = call i32 @vis5d_gridPRIME_to_xyzPRIME(i32 %287, i32 %3, i32 %4, double 1.000000e+00, double 1.000000e+00, float %304, float* %46, float* %47, float* %48)
%306 = load float, float* %48
%307 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 2
%308 = load float, float* %307
%309 = fsub float %306, %308
%310 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%311 = load float, float* %310
%312 = fdiv float %309, %311
br label %313
313: ; preds = %302, %288
%314 = phi float [ %311, %302 ], [ %300, %288 ]
%315 = phi float [ %308, %302 ], [ %297, %288 ]
%316 = phi float [ %312, %302 ], [ %301, %288 ]
store float %316, float* %48
%317 = load float, float* %92
%318 = load float, float* %93
%319 = call float @llvm.fmuladd.f32(float %316, float %318, float %317)
%320 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float %319, float* %320
%321 = getelementptr inbounds [3 x float], [3 x float]* %13, i64 0, i64 1
%322 = load float, float* %321
%323 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%324 = load float, float* %323
%325 = call float @llvm.fmuladd.f32(float %316, float %324, float %322)
%326 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float %325, float* %326
%327 = call float @llvm.fmuladd.f32(float %316, float %314, float %315)
%328 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float %327, float* %328
%329 = load i32, i32* %36
%330 = call i32 @vis5d_xyzPRIME_to_gridPRIME(i32 %329, i32 %3, i32 %4, float %319, float %325, float %327, float* %43, float* %44, float* %45)
%331 = load float, float* %7
%332 = load float, float* %5
%333 = fsub float %331, %332
%334 = load float, float* %8
%335 = load float, float* %6
%336 = fsub float %334, %335
%337 = fcmp oeq float %333, 0.000000e+00
br i1 %337, label %338, label %340
338: ; preds = %313
%339 = load float, float* %43
br label %422
340: ; preds = %313
%341 = fcmp oeq float %336, 0.000000e+00
br i1 %341, label %342, label %344
342: ; preds = %340
%343 = load float, float* %44
br label %422
344: ; preds = %340
%345 = load float, float* %43
%346 = fneg float %345
%347 = fdiv float %346, %333
%348 = load float, float* %44
%349 = call float @llvm.fmuladd.f32(float %336, float %347, float %348)
%350 = fsub float %85, %345
%351 = fdiv float %350, %333
store float %351, float* %48
%352 = load i32, i32* %18
%353 = sitofp i32 %352 to double
%354 = fadd double %353, -1.000000e+00
%355 = fptrunc double %354 to float
%356 = call float @llvm.fmuladd.f32(float %336, float %351, float %348)
%357 = fcmp olt float %349, 0.000000e+00
br i1 %357, label %358, label %362
358: ; preds = %344
%359 = fneg float %348
%360 = fdiv float %359, %336
store float %360, float* %48
%361 = call float @llvm.fmuladd.f32(float %333, float %360, float %345)
br label %362
362: ; preds = %358, %344
%363 = phi float [ %361, %358 ], [ 0.000000e+00, %344 ]
%364 = phi float [ 0.000000e+00, %358 ], [ %349, %344 ]
%365 = load i32, i32* %19
%366 = add nsw i32 %365, -1
%367 = sitofp i32 %366 to float
%368 = fcmp ogt float %364, %367
br i1 %368, label %369, label %373
369: ; preds = %362
%370 = fsub float %88, %348
%371 = fdiv float %370, %336
store float %371, float* %48
%372 = call float @llvm.fmuladd.f32(float %333, float %371, float %345)
br label %373
373: ; preds = %369, %362
%374 = phi float [ %372, %369 ], [ %363, %362 ]
%375 = phi float [ %367, %369 ], [ %364, %362 ]
%376 = fcmp olt float %356, 0.000000e+00
br i1 %376, label %377, label %381
377: ; preds = %373
%378 = fneg float %348
%379 = fdiv float %378, %336
store float %379, float* %48
%380 = call float @llvm.fmuladd.f32(float %333, float %379, float %345)
br label %381
381: ; preds = %377, %373
%382 = phi float [ %380, %377 ], [ %355, %373 ]
%383 = phi float [ 0.000000e+00, %377 ], [ %356, %373 ]
%384 = fcmp ogt float %383, %367
br i1 %384, label %385, label %389
385: ; preds = %381
%386 = fsub float %88, %348
%387 = fdiv float %386, %336
store float %387, float* %48
%388 = call float @llvm.fmuladd.f32(float %333, float %387, float %345)
br label %389
389: ; preds = %385, %381
%390 = phi float [ %388, %385 ], [ %382, %381 ]
%391 = phi float [ %367, %385 ], [ %383, %381 ]
%392 = fsub float %332, %331
%393 = fcmp olt float %392, 0.000000e+00
%394 = fneg float %392
%395 = select i1 %393, float %394, float %392
%396 = fsub float %335, %334
%397 = fcmp olt float %396, 0.000000e+00
%398 = fneg float %396
%399 = select i1 %397, float %398, float %396
%400 = fcmp ult float %395, %399
br i1 %400, label %411, label %401
401: ; preds = %389
%402 = fcmp olt float %332, %331
%403 = fcmp ogt float %374, %390
%404 = select i1 %402, i1 %403, i1 false
br i1 %404, label %421, label %405
405: ; preds = %401
%406 = fcmp ogt float %332, %331
%407 = fcmp olt float %374, %390
%408 = select i1 %406, i1 %407, i1 false
%409 = fcmp olt float %395, 0.000000e+00
%410 = select i1 %408, i1 true, i1 %409
br i1 %410, label %421, label %422
411: ; preds = %389
%412 = fcmp olt float %335, %334
%413 = fcmp ogt float %375, %391
%414 = select i1 %412, i1 %413, i1 false
br i1 %414, label %421, label %415
415: ; preds = %411
%416 = fcmp ogt float %335, %334
%417 = fcmp olt float %375, %391
%418 = select i1 %416, i1 %417, i1 false
%419 = fcmp olt float %395, 0.000000e+00
%420 = select i1 %418, i1 true, i1 %419
br i1 %420, label %421, label %422
421: ; preds = %411, %415, %401, %405
store float %374, float* %46
store float %375, float* %47
br label %422
422: ; preds = %405, %415, %342, %421, %338
%423 = phi float [ %339, %338 ], [ %332, %342 ], [ %390, %421 ], [ %374, %415 ], [ %374, %405 ]
%424 = phi float [ %335, %338 ], [ %343, %342 ], [ %391, %421 ], [ %375, %415 ], [ %375, %405 ]
%425 = phi float [ %339, %338 ], [ %331, %342 ], [ %374, %421 ], [ %390, %415 ], [ %390, %405 ]
%426 = phi float [ %334, %338 ], [ %343, %342 ], [ %375, %421 ], [ %391, %415 ], [ %391, %405 ]
%427 = fcmp olt float %424, 0.000000e+00
%428 = fcmp ogt float %424, %88
%429 = select i1 %428, float %88, float %424
%430 = select i1 %427, float 0.000000e+00, float %429
%431 = fcmp olt float %426, 0.000000e+00
%432 = fcmp ogt float %426, %88
%433 = select i1 %432, float %88, float %426
%434 = select i1 %431, float 0.000000e+00, float %433
%435 = fcmp olt float %423, 0.000000e+00
%436 = fcmp ogt float %423, %85
%437 = select i1 %436, float %85, float %423
%438 = select i1 %435, float 0.000000e+00, float %437
%439 = fcmp olt float %425, 0.000000e+00
%440 = fcmp ogt float %425, %85
%441 = select i1 %440, float %85, float %425
%442 = select i1 %439, float 0.000000e+00, float %441
%443 = fsub float %438, %442
%444 = fsub float %430, %434
%445 = fmul float %444, %444
%446 = call float @llvm.fmuladd.f32(float %443, float %443, float %445)
%447 = call double @sqrt(float %446)
%448 = fcmp ogt double %447, 2.000000e+00
br i1 %448, label %449, label %450
449: ; preds = %422
store float %438, float* %5
store float %430, float* %6
store float %442, float* %7
store float %434, float* %8
br label %450
450: ; preds = %449, %422
br label %451
451: ; preds = %450, %277
%452 = phi i32 [ %278, %277 ], [ 1, %450 ]
ret i32 %452
}