float bstrot(x, y, z, xx, yy, zz, na, matrix, delta)
int na;
float x[], y[], z[];
float xx[], yy[], zz[];
float matrix[3][3], delta[3];
{
  float tensor[3][3], cx, cy, cz, cxx, cyy, czz;
  float tx, ty, tz, txx, tyy, tzz;
  float rms;
  float sx[3][3], sy[3][3], sz[3][3];
  float sq[3][3];
  void cpyvec();
  void matmul();
  int i, j, ipass;
  if (na < 1)
    return -1.;
  cx = 0.;
  cy = 0.;
  cz = 0.;
  cxx = 0.;
  cyy = 0.;
  czz = 0.;
  for (i = 0; i < na; i++) {
    cx += x[i];
    cy += y[i];
    cz += z[i];
    cxx += xx[i];
    cyy += yy[i];
    czz += zz[i];
  }
  cx /= na;
  cy /= na;
  cz /= na;
  cxx /= na;
  cyy /= na;
  czz /= na;
  for (i = 0; i < 3; i++)
    for (j = 0; j < 3; j++) {
      tensor[i][j] = 0.;
      matrix[i][j] = 0.;
      sx[i][j] = 0.;
      sy[i][j] = 0.;
      sz[i][j] = 0.;
    }
  matrix[0][0] = 1.;
  matrix[1][1] = 1.;
  matrix[2][2] = 1.;
  sx[0][0] = 1.;
  sy[1][1] = 1.;
  sz[2][2] = 1.;
  for (i = 0; i < na; i++) {
    tx = x[i] - cx;
    ty = y[i] - cy;
    tz = z[i] - cz;
    txx = xx[i] - cxx;
    tyy = yy[i] - cyy;
    tzz = zz[i] - czz;
    tensor[0][0] += tx * txx;
    tensor[0][1] += tx * tyy;
    tensor[0][2] += tx * tzz;
    tensor[1][0] += ty * txx;
    tensor[1][1] += ty * tyy;
    tensor[1][2] += ty * tzz;
    tensor[2][0] += tz * txx;
    tensor[2][1] += tz * tyy;
    tensor[2][2] += tz * tzz;
  }
  for (ipass = 0; ipass < 20; ipass++) {
    rms = 0.;
    tx = atan2(tensor[2][1] - tensor[1][2], tensor[1][1] + tensor[2][2]);
    rms += fabs(tx);
    ty = cos(tx);
    tz = sin(tx);
    sx[1][1] = ty;
    sx[2][1] = -tz;
    sx[1][2] = tz;
    sx[2][2] = ty;
    matmul(sx, tensor, sq, 3, 3);
    cpyvec(sq, tensor, 9);
    matmul(sx, matrix, sq, 3, 3);
    cpyvec(sq, matrix, 9);
    tx = atan2(tensor[2][0] - tensor[0][2], tensor[0][0] + tensor[2][2]);
    rms += fabs(tx);
    ty = cos(tx);
    tz = sin(tx);
    sy[0][0] = ty;
    sy[2][0] = -tz;
    sy[0][2] = tz;
    sy[2][2] = ty;
    matmul(sy, tensor, sq, 3, 3);
    cpyvec(sq, tensor, 9);
    matmul(sy, matrix, sq, 3, 3);
    cpyvec(sq, matrix, 9);
    tx = atan2(tensor[0][1] - tensor[1][0], tensor[1][1] + tensor[0][0]);
    rms += fabs(tx);
    ty = cos(tx);
    tz = sin(tx);
    sz[1][1] = ty;
    sz[0][1] = -tz;
    sz[1][0] = tz;
    sz[0][0] = ty;
    matmul(sz, tensor, sq, 3, 3);
    cpyvec(sq, tensor, 9);
    matmul(sz, matrix, sq, 3, 3);
    cpyvec(sq, matrix, 9);
    if (rms < 1.e-7)
      break;
  }
  rms = 0.;
  for (i = 0; i < na; i++) {
    txx = xx[i] - cxx;
    tyy = yy[i] - cyy;
    tzz = zz[i] - czz;
    tx = matrix[0][0] * txx + matrix[1][0] * tyy + matrix[2][0] * tzz;
    ty = matrix[0][1] * txx + matrix[1][1] * tyy + matrix[2][1] * tzz;
    tz = matrix[0][2] * txx + matrix[1][2] * tyy + matrix[2][2] * tzz;
    tx += cx - x[i];
    ty += cy - y[i];
    tz += cz - z[i];
    rms += tx * tx + ty * ty + tz * tz;
  }
  tx = matrix[0][0] * cxx + matrix[1][0] * cyy + matrix[2][0] * czz;
  ty = matrix[0][1] * cxx + matrix[1][1] * cyy + matrix[2][1] * czz;
  tz = matrix[0][2] * cxx + matrix[1][2] * cyy + matrix[2][2] * czz;
  delta[0] = cx - tx;
  delta[1] = cy - ty;
  delta[2] = cz - tz;
  return sqrt(rms / na);
}


x86 assembly (clang, -O0):
<bstrot>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
cmpl   $0x1,0x10(%rbp)
jge    11aa <bstrot+0x4a>
movss  0xe64(%rip),%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    1dcc <bstrot+0xc6c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x64(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x6c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    12a3 <bstrot+0x143>
mov    -0x10(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    11e4 <bstrot+0x84>
cvtsi2ssl 0x10(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm1
movss  -0x68(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm1
movss  -0x70(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm1
movss  -0x74(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
cvtsi2ssl 0x10(%rbp),%xmm1
movss  -0x78(%rbp),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,-0x78(%rbp)
movl   $0x0,-0x154(%rbp)
cmpl   $0x3,-0x154(%rbp)
jge    141e <bstrot+0x2be>
movl   $0x0,-0x158(%rbp)
cmpl   $0x3,-0x158(%rbp)
jge    1405 <bstrot+0x2a5>
movslq -0x154(%rbp),%rcx
lea    -0x60(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x158(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    0x18(%rbp),%rax
movslq -0x154(%rbp),%rcx
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x158(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq -0x154(%rbp),%rcx
lea    -0xc0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x158(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq -0x154(%rbp),%rcx
lea    -0xf0(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x158(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movslq -0x154(%rbp),%rcx
lea    -0x120(%rbp),%rax
imul   $0xc,%rcx,%rcx
add    %rcx,%rax
movslq -0x158(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    1336 <bstrot+0x1d6>
jmp    140a <bstrot+0x2aa>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    131f <bstrot+0x1bf>
mov    0x18(%rbp),%rax
movss  0xbd6(%rip),%xmm0
movss  %xmm0,(%rax)
mov    0x18(%rbp),%rax
movss  0xbc6(%rip),%xmm0
movss  %xmm0,0x10(%rax)
mov    0x18(%rbp),%rax
movss  0xbb5(%rip),%xmm0
movss  %xmm0,0x20(%rax)
movss  0xba8(%rip),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
movss  0xb98(%rip),%xmm0
movss  %xmm0,-0xe0(%rbp)
ff
movss  0xb88(%rip),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1675 <bstrot+0x515>
mov    -0x10(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x68(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x30(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x38(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x5c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x58(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x80(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x54(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x80(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x50(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x80(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
ff
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x88(%rbp),%xmm2
ff
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x90(%rbp),%xmm2
ff
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    148a <bstrot+0x32a>
movl   $0x0,-0x15c(%rbp)
cmpl   $0x14,-0x15c(%rbp)
jge    1a9f <bstrot+0x93f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x44(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x50(%rbp),%xmm1
addss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
call   1030 <atan2@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x93f(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xac(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
lea    -0xc0(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x150(%rbp),%rdx
mov    $0x3,%r8d
mov    %r8d,%ecx
mov    $0x0,%al
call   1070 <matmul@plt>
lea    -0x150(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    $0x9,%edx
mov    $0x0,%al
call   1040 <cpyvec@plt>
lea    -0xc0(%rbp),%rdi
mov    0x18(%rbp),%rsi
lea    -0x150(%rbp),%rdx
mov    $0x3,%r8d
mov    %r8d,%ecx
mov    $0x0,%al
call   1070 <matmul@plt>
lea    -0x150(%rbp),%rdi
mov    0x18(%rbp),%rsi
mov    $0x9,%edx
mov    $0x0,%al
call   1040 <cpyvec@plt>
movss  -0x48(%rbp),%xmm0
subss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x60(%rbp),%xmm1
addss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
call   1030 <atan2@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x7fb(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
lea    -0xf0(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x150(%rbp),%rdx
mov    $0x3,%r8d
mov    %r8d,%ecx
mov    $0x0,%al
call   1070 <matmul@plt>
lea    -0x150(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    $0x9,%edx
mov    $0x0,%al
call   1040 <cpyvec@plt>
lea    -0xf0(%rbp),%rdi
mov    0x18(%rbp),%rsi
lea    -0x150(%rbp),%rdx
mov    $0x3,%r8d
mov    %r8d,%ecx
mov    $0x0,%al
call   1070 <matmul@plt>
lea    -0x150(%rbp),%rdi
mov    0x18(%rbp),%rsi
mov    $0x9,%edx
mov    $0x0,%al
call   1040 <cpyvec@plt>
movss  -0x5c(%rbp),%xmm0
subss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x50(%rbp),%xmm1
addss  -0x60(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
call   1030 <atan2@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x6b7(%rip),%xmm0
pand   %xmm0,%xmm1
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1060 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x110(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x11c(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x120(%rbp)
ff
lea    -0x120(%rbp),%rdi
lea    -0x60(%rbp),%rsi
lea    -0x150(%rbp),%rdx
mov    $0x3,%r8d
mov    %r8d,%ecx
mov    $0x0,%al
call   1070 <matmul@plt>
lea    -0x150(%rbp),%rdi
lea    -0x60(%rbp),%rsi
mov    $0x9,%edx
mov    $0x0,%al
call   1040 <cpyvec@plt>
lea    -0x120(%rbp),%rdi
mov    0x18(%rbp),%rsi
lea    -0x150(%rbp),%rdx
mov    $0x3,%r8d
mov    %r8d,%ecx
mov    $0x0,%al
call   1070 <matmul@plt>
lea    -0x150(%rbp),%rdi
mov    0x18(%rbp),%rsi
mov    $0x9,%edx
mov    $0x0,%al
call   1040 <cpyvec@plt>
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x591(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a86 <bstrot+0x926>
jmp    1a9f <bstrot+0x93f>
jmp    1a8b <bstrot+0x92b>
mov    -0x15c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x15c(%rbp)
jmp    167f <bstrot+0x51f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movl   $0x0,-0x154(%rbp)
mov    -0x154(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1caf <bstrot+0xb4f>
mov    -0x28(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
mov    -0x30(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
mov    -0x38(%rbp),%rax
movslq -0x154(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x88(%rbp),%xmm2
ff
mov    0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
mulss  -0x8c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x90(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    0x18(%rbp),%rax
movss  0x4(%rax),%xmm1
movss  -0x88(%rbp),%xmm2
ff
mov    0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
mulss  -0x8c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x90(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
movss  -0x88(%rbp),%xmm2
ff
mov    0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
mulss  -0x8c(%rbp),%xmm0
ff
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x90(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x154(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
addss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x154(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
addss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x154(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
addss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x7c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
movss  -0x80(%rbp),%xmm0
mulss  -0x80(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x84(%rbp),%xmm0
ff
movss  -0x84(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x94(%rbp)
ff
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    1ab4 <bstrot+0x954>
mov    0x18(%rbp),%rax
movss  (%rax),%xmm1
movss  -0x70(%rbp),%xmm2
mov    0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
mulss  -0x74(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbp),%rax
movss  0x18(%rax),%xmm0
movss  -0x78(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    0x18(%rbp),%rax
movss  0x4(%rax),%xmm1
movss  -0x70(%rbp),%xmm2
mov    0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
mulss  -0x74(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbp),%rax
movss  0x1c(%rax),%xmm0
movss  -0x78(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x80(%rbp)
mov    0x18(%rbp),%rax
movss  0x8(%rax),%xmm1
movss  -0x70(%rbp),%xmm2
mov    0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
mulss  -0x74(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    0x18(%rbp),%rax
movss  0x20(%rax),%xmm0
movss  -0x78(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x64(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x68(%rbp),%xmm0
subss  -0x80(%rbp),%xmm0
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0x6c(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0x94(%rbp),%xmm0
ff
cvtsi2ssl 0x10(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1080 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<bstrot>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    0x1c0(%rsp),%ebp
test   %ebp,%ebp
jle    1998 <bstrot+0x838>
mov    %ebp,%ebx
xorps  %xmm10,%xmm10
xorps  %xmm11,%xmm11
xor    %eax,%eax
xorps  %xmm12,%xmm12
xorps  %xmm3,%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addss  (%rdi,%rax,4),%xmm12
movss  (%rsi,%rax,4),%xmm0
movss  (%rdx,%rax,4),%xmm1
unpcklps %xmm0,%xmm1
addps  %xmm1,%xmm10
addss  (%rcx,%rax,4),%xmm11
movss  (%r8,%rax,4),%xmm0
movss  (%r9,%rax,4),%xmm1
unpcklps %xmm0,%xmm1
addps  %xmm1,%xmm3
add    $0x1,%rax
cmp    %rax,%rbx
jne    11a0 <bstrot+0x40>
cvtsi2ss %ebp,%xmm2
divss  %xmm2,%xmm12
xorps  %xmm1,%xmm1
movaps %xmm1,0x20(%rsp)
movaps %xmm1,0x10(%rsp)
movl   $0x0,0x30(%rsp)
mov    0x1c8(%rsp),%rax
movups %xmm1,0x10(%rax)
movups %xmm1,0x4(%rax)
movaps %xmm1,0x100(%rsp)
movaps %xmm1,0xf0(%rsp)
movaps %xmm1,0x60(%rsp)
movaps %xmm1,0x70(%rsp)
movl   $0x0,0x80(%rsp)
movaps %xmm1,0xc0(%rsp)
movaps %xmm1,0xd0(%rsp)
movaps %xmm2,%xmm0
shufps $0x0,%xmm2,%xmm0
divps  %xmm0,%xmm10
movaps %xmm2,0x130(%rsp)
divss  %xmm2,%xmm11
divps  %xmm0,%xmm3
movl   $0x3f800000,(%rax)
movl   $0x3f800000,0x10(%rax)
movl   $0x3f800000,0x20(%rax)
movl   $0x3f800000,0xf0(%rsp)
movl   $0x3f800000,0x70(%rsp)
3f
movl   $0x3f800000,0xe0(%rsp)
test   %ebp,%ebp
jle    1368 <bstrot+0x208>
xorps  %xmm5,%xmm5
xorps  %xmm0,%xmm0
xor    %eax,%eax
xorps  %xmm6,%xmm6
nopl   0x0(%rax,%rax,1)
movaps %xmm6,%xmm8
movaps %xmm5,%xmm9
movss  (%rdi,%rax,4),%xmm5
subss  %xmm12,%xmm5
movss  (%rsi,%rax,4),%xmm1
movss  (%rdx,%rax,4),%xmm6
unpcklps %xmm1,%xmm6
subps  %xmm10,%xmm6
movaps %xmm6,%xmm1
shufps $0x14,%xmm6,%xmm1
movss  (%rcx,%rax,4),%xmm7
subss  %xmm11,%xmm7
movss  (%r8,%rax,4),%xmm2
movss  (%r9,%rax,4),%xmm4
unpcklps %xmm2,%xmm4
subps  %xmm3,%xmm4
movaps %xmm7,%xmm2
movlhps %xmm4,%xmm2
movlhps %xmm4,%xmm4
mulps  %xmm4,%xmm1
movss  %xmm7,%xmm4
mulss  %xmm6,%xmm7
movss  %xmm5,%xmm6
shufps $0x40,%xmm6,%xmm6
shufps $0x24,%xmm2,%xmm4
mulps  %xmm6,%xmm4
movaps %xmm4,%xmm6
addps  %xmm8,%xmm6
addss  %xmm7,%xmm0
movaps %xmm1,%xmm5
addps  %xmm9,%xmm5
add    $0x1,%rax
cmp    %rax,%rbx
jne    12a0 <bstrot+0x140>
addps  %xmm9,%xmm1
addps  %xmm8,%xmm4
movaps %xmm4,0x10(%rsp)
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movss  %xmm2,0x20(%rsp)
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
movss  %xmm2,0x24(%rsp)
movss  %xmm0,0x28(%rsp)
movaps %xmm1,%xmm0
shufps $0xff,%xmm1,%xmm0
movss  %xmm0,0x2c(%rsp)
movss  %xmm1,0x30(%rsp)
mov    %rdi,0x88(%rsp)
mov    %rsi,0x90(%rsp)
mov    %rdx,0x98(%rsp)
mov    %rbx,0xa0(%rsp)
mov    %rcx,0xa8(%rsp)
mov    %r8,0xb0(%rsp)
mov    %r9,0xb8(%rsp)
movaps %xmm3,0x140(%rsp)
movss  %xmm11,0x58(%rsp)
movss  %xmm12,0xc(%rsp)
movaps %xmm10,0x120(%rsp)
mov    $0x13,%r12d
lea    0x10(%rsp),%r14
lea    0x160(%rsp),%r15
lea    0x60(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movaps %xmm1,%xmm0
shufps $0xff,%xmm1,%xmm0
movaps %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
subss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm0
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
addss  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
call   1030 <atan2@plt>
cvtsd2ss %xmm0,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
movaps %xmm2,0x40(%rsp)
movaps %xmm2,%xmm0
movaps 0xbe9(%rip),%xmm1
andps  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
movaps %xmm2,%xmm0
call   1070 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rsp)
movaps 0x40(%rsp),%xmm0
call   1050 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  0x4(%rsp),%xmm3
movss  %xmm3,0x100(%rsp)
movaps %xmm0,%xmm1
movaps 0xbb3(%rip),%xmm2
xorps  %xmm2,%xmm1
movss  %xmm1,0x10c(%rsp)
movss  %xmm0,0x104(%rsp)
movss  %xmm3,0x110(%rsp)
lea    0xf0(%rsp),%rbx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
mov    $0x3,%ecx
mov    $0x3,%r8d
xor    %eax,%eax
call   1080 <matmul@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <cpyvec@plt>
mov    %rbx,%rdi
mov    0x1c8(%rsp),%r13
mov    %r13,%rsi
mov    %r15,%rdx
mov    $0x3,%ecx
mov    $0x3,%r8d
xor    %eax,%eax
call   1080 <matmul@plt>
mov    %r15,%rdi
mov    %r13,%rsi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <cpyvec@plt>
movss  0x10(%rsp),%xmm1
movss  0x28(%rsp),%xmm0
subss  0x18(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
addss  0x30(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
call   1030 <atan2@plt>
cvtsd2ss %xmm0,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
movaps %xmm2,0x40(%rsp)
movaps %xmm2,%xmm0
andps  0xadc(%rip),%xmm0
movss  0x8(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
movaps %xmm2,%xmm0
call   1070 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rsp)
movaps 0x40(%rsp),%xmm0
call   1050 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  0x4(%rsp),%xmm2
movss  %xmm2,0x60(%rsp)
movaps %xmm0,%xmm1
xorps  0xa9b(%rip),%xmm1
movss  %xmm1,0x78(%rsp)
movss  %xmm0,0x68(%rsp)
movss  %xmm2,0x80(%rsp)
mov    %rbp,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
mov    $0x3,%ecx
mov    $0x3,%r8d
xor    %eax,%eax
call   1080 <matmul@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <cpyvec@plt>
mov    %rbp,%rdi
mov    %r13,%rsi
mov    %r15,%rdx
mov    $0x3,%ecx
mov    $0x3,%r8d
xor    %eax,%eax
call   1080 <matmul@plt>
mov    %r15,%rdi
mov    %r13,%rsi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <cpyvec@plt>
movss  0x14(%rsp),%xmm0
movss  0x20(%rsp),%xmm1
subss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
addss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
call   1030 <atan2@plt>
cvtsd2ss %xmm0,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
movaps %xmm2,0x40(%rsp)
movaps %xmm2,%xmm0
andps  0x9dd(%rip),%xmm0
movss  0x8(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,0x8(%rsp)
movaps %xmm2,%xmm0
call   1070 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rsp)
movaps 0x40(%rsp),%xmm0
call   1050 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  0x4(%rsp),%xmm2
movss  %xmm2,0xd0(%rsp)
movaps %xmm0,%xmm1
xorps  0x999(%rip),%xmm1
movss  %xmm1,0xc4(%rsp)
movss  %xmm0,0xcc(%rsp)
movss  %xmm2,0xc0(%rsp)
lea    0xc0(%rsp),%rbx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %r15,%rdx
mov    $0x3,%ecx
mov    $0x3,%r8d
xor    %eax,%eax
call   1080 <matmul@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <cpyvec@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r15,%rdx
mov    $0x3,%ecx
mov    $0x3,%r8d
xor    %eax,%eax
call   1080 <matmul@plt>
mov    %r15,%rdi
mov    %r13,%rsi
mov    $0x9,%edx
xor    %eax,%eax
call   1040 <cpyvec@plt>
movss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x91a(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     1748 <bstrot+0x5e8>
sub    $0x1,%r12d
jb     1748 <bstrot+0x5e8>
movss  0x20(%rsp),%xmm0
movss  0x24(%rsp),%xmm2
movss  0x2c(%rsp),%xmm1
unpcklps %xmm1,%xmm2
movss  0x30(%rsp),%xmm1
unpcklps %xmm0,%xmm1
movlhps %xmm2,%xmm1
jmp    13e0 <bstrot+0x280>
mov    0x1c8(%rsp),%rax
movss  (%rax),%xmm15
movss  0x4(%rax),%xmm11
movss  0xc(%rax),%xmm7
movss  0x18(%rax),%xmm9
movss  0x10(%rax),%xmm4
movss  0x1c(%rax),%xmm3
movss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rsp)
movss  0x14(%rax),%xmm0
movss  %xmm0,0x4(%rsp)
movss  0x20(%rax),%xmm13
movaps 0x140(%rsp),%xmm14
movaps %xmm14,%xmm5
shufps $0x55,%xmm14,%xmm5
movaps 0x120(%rsp),%xmm8
movaps %xmm8,%xmm12
shufps $0x55,%xmm8,%xmm12
xorps  %xmm0,%xmm0
cmpl   $0x0,0x1c0(%rsp)
movss  0xc(%rsp),%xmm6
movss  0x58(%rsp),%xmm10
mov    0xb8(%rsp),%r8
mov    0xb0(%rsp),%rdx
mov    0xa8(%rsp),%rsi
mov    0xa0(%rsp),%rdi
mov    0x98(%rsp),%rbx
mov    0x90(%rsp),%rbp
mov    0x88(%rsp),%rcx
jle    1906 <bstrot+0x7a6>
xorps  %xmm0,%xmm0
xor    %eax,%eax
movss  %xmm4,0x40(%rsp)
movaps %xmm5,0x150(%rsp)
movss  %xmm7,0x5c(%rsp)
nop
movss  (%rsi,%rax,4),%xmm1
subss  %xmm10,%xmm1
movss  (%rdx,%rax,4),%xmm6
subss  %xmm5,%xmm6
movss  (%r8,%rax,4),%xmm5
subss  %xmm14,%xmm5
movaps %xmm6,%xmm8
mulss  %xmm7,%xmm8
movaps %xmm15,%xmm2
mulss  %xmm1,%xmm2
addss  %xmm8,%xmm2
movaps %xmm9,%xmm7
mulss  %xmm5,%xmm7
addss  %xmm2,%xmm7
movaps %xmm6,%xmm2
mulss  %xmm4,%xmm2
movaps %xmm11,%xmm4
mulss  %xmm1,%xmm4
addss  %xmm2,%xmm4
movaps %xmm3,%xmm2
mulss  %xmm5,%xmm2
addss  %xmm4,%xmm2
mulss  0x4(%rsp),%xmm6
mulss  0x8(%rsp),%xmm1
addss  %xmm6,%xmm1
movss  0xc(%rsp),%xmm6
mulss  %xmm13,%xmm5
movaps %xmm6,%xmm4
subss  (%rcx,%rax,4),%xmm4
addss  %xmm1,%xmm5
addss  %xmm7,%xmm4
movaps 0x120(%rsp),%xmm8
movaps %xmm12,%xmm1
subss  0x0(%rbp,%rax,4),%xmm1
addss  %xmm2,%xmm1
movaps %xmm8,%xmm2
subss  (%rbx,%rax,4),%xmm2
addss  %xmm5,%xmm2
movaps 0x150(%rsp),%xmm5
mulss  %xmm1,%xmm1
mulss  %xmm4,%xmm4
addss  %xmm1,%xmm4
mulss  %xmm2,%xmm2
addss  %xmm4,%xmm2
movss  0x40(%rsp),%xmm4
addss  %xmm2,%xmm0
movss  0x5c(%rsp),%xmm7
add    $0x1,%rax
cmp    %rax,%rdi
jne    1820 <bstrot+0x6c0>
mulss  %xmm5,%xmm7
mulss  %xmm10,%xmm15
addss  %xmm7,%xmm15
mulss  %xmm14,%xmm9
addss  %xmm15,%xmm9
mulss  %xmm5,%xmm4
mulss  %xmm10,%xmm11
addss  %xmm4,%xmm11
mulss  %xmm14,%xmm3
addss  %xmm11,%xmm3
movss  0x4(%rsp),%xmm2
mulss  %xmm5,%xmm2
movss  0x8(%rsp),%xmm1
mulss  %xmm10,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm14,%xmm13
addss  %xmm1,%xmm13
subss  %xmm9,%xmm6
mov    0x1d0(%rsp),%rax
movss  %xmm6,(%rax)
subss  %xmm3,%xmm12
movss  %xmm12,0x4(%rax)
subss  %xmm13,%xmm8
movss  %xmm8,0x8(%rax)
divss  0x130(%rsp),%xmm0
ucomiss 0x674(%rip),%xmm0
jb     19a2 <bstrot+0x842>
sqrtss %xmm0,%xmm0
jmp    19a7 <bstrot+0x847>
movss  0x660(%rip),%xmm0
jmp    19a7 <bstrot+0x847>
call   1060 <sqrtf@plt>
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define float @bstrot(float* nocapture %0, float* nocapture %1, float* nocapture %2, float* nocapture %3, float* nocapture %4, float* nocapture %5, i32 %6, [3 x float]* %7, float* nocapture writeonly %8) {
%10 = alloca [3 x [3 x float]]
%11 = bitcast [3 x [3 x float]]* %10 to i8*
%12 = alloca [3 x [3 x float]]
%13 = bitcast [3 x [3 x float]]* %12 to i8*
%14 = alloca [3 x [3 x float]]
%15 = bitcast [3 x [3 x float]]* %14 to i8*
%16 = alloca [3 x [3 x float]]
%17 = bitcast [3 x [3 x float]]* %16 to i8*
%18 = alloca [3 x [3 x float]]
%19 = bitcast [3 x [3 x float]]* %18 to i8*
%20 = icmp slt i32 %6, 1
br i1 %20, label %311, label %21
21: ; preds = %9
%22 = zext i32 %6 to i64
br label %23
23: ; preds = %21, %23
%24 = phi i64 [ 0, %21 ], [ %49, %23 ]
%25 = phi float [ 0.000000e+00, %21 ], [ %41, %23 ]
%26 = phi float [ 0.000000e+00, %21 ], [ %31, %23 ]
%27 = phi <2 x float> [ zeroinitializer, %21 ], [ %38, %23 ]
%28 = phi <2 x float> [ zeroinitializer, %21 ], [ %48, %23 ]
%29 = getelementptr inbounds float, float* %0, i64 %24
%30 = load float, float* %29
%31 = fadd float %26, %30
%32 = getelementptr inbounds float, float* %1, i64 %24
%33 = load float, float* %32
%34 = getelementptr inbounds float, float* %2, i64 %24
%35 = load float, float* %34
%36 = insertelement <2 x float> poison, float %35, i64 0
%37 = insertelement <2 x float> %36, float %33, i64 1
%38 = fadd <2 x float> %27, %37
%39 = getelementptr inbounds float, float* %3, i64 %24
%40 = load float, float* %39
%41 = fadd float %25, %40
%42 = getelementptr inbounds float, float* %4, i64 %24
%43 = load float, float* %42
%44 = getelementptr inbounds float, float* %5, i64 %24
%45 = load float, float* %44
%46 = insertelement <2 x float> poison, float %45, i64 0
%47 = insertelement <2 x float> %46, float %43, i64 1
%48 = fadd <2 x float> %28, %47
%49 = add nuw nsw i64 %24, 1
%50 = icmp eq i64 %49, %22
br i1 %50, label %51, label %23
51: ; preds = %23
%52 = sitofp i32 %6 to float
%53 = fdiv float %31, %52
%54 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%55 = bitcast float* %54 to i8*
%56 = insertelement <2 x float> poison, float %52, i64 0
%57 = shufflevector <2 x float> %56, <2 x float> poison, <2 x i32> zeroinitializer
%58 = fdiv <2 x float> %38, %57
%59 = fdiv float %41, %52
%60 = fdiv <2 x float> %48, %57
%61 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 0
store float 1.000000e+00, float* %61
%62 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 1, i64 1
store float 1.000000e+00, float* %62
%63 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 2, i64 2
store float 1.000000e+00, float* %63
%64 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %12, i64 0, i64 0
%65 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %12, i64 0, i64 0, i64 0
store float 1.000000e+00, float* %65
%66 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %14, i64 0, i64 1, i64 1
store float 1.000000e+00, float* %66
%67 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %16, i64 0, i64 2, i64 2
store float 1.000000e+00, float* %67
%68 = icmp sgt i32 %6, 0
br i1 %68, label %69, label %84
69: ; preds = %51
%70 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 1, i64 1
%71 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 1, i64 2
%72 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 2, i64 0
%73 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 2, i64 1
%74 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 2, i64 2
%75 = zext i32 %6 to i64
br label %111
76: ; preds = %111
%77 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %127, <4 x float> %138, <4 x float> %114)
%78 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %142, <4 x float> %146, <4 x float> %115)
%79 = bitcast [3 x [3 x float]]* %10 to <4 x float>*
store <4 x float> %78, <4 x float>* %79
%80 = extractelement <4 x float> %77, i64 1
store float %80, float* %70
%81 = extractelement <4 x float> %77, i64 2
store float %81, float* %71
store float %149, float* %72
%82 = extractelement <4 x float> %77, i64 3
store float %82, float* %73
%83 = extractelement <4 x float> %77, i64 0
store float %83, float* %74
br label %84
84: ; preds = %76, %51
%85 = phi <4 x float> [ %77, %76 ], [ zeroinitializer, %51 ]
%86 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 2, i64 1
%87 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 1, i64 2
%88 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 1, i64 1
%89 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 2, i64 2
%90 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %12, i64 0, i64 1, i64 1
%91 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %12, i64 0, i64 2, i64 1
%92 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %12, i64 0, i64 1, i64 2
%93 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %12, i64 0, i64 2, i64 2
%94 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 0
%95 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %18, i64 0, i64 0
%96 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 2, i64 0
%97 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 0, i64 2
%98 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 0, i64 0
%99 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %14, i64 0, i64 0
%100 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %14, i64 0, i64 0, i64 0
%101 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %14, i64 0, i64 2, i64 0
%102 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %14, i64 0, i64 0, i64 2
%103 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %14, i64 0, i64 2, i64 2
%104 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 0, i64 1
%105 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %10, i64 0, i64 1, i64 0
%106 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %16, i64 0, i64 1, i64 1
%107 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %16, i64 0, i64 0
%108 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %16, i64 0, i64 0, i64 1
%109 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %16, i64 0, i64 1, i64 0
%110 = getelementptr inbounds [3 x [3 x float]], [3 x [3 x float]]* %16, i64 0, i64 0, i64 0
br label %165
111: ; preds = %69, %111
%112 = phi i64 [ 0, %69 ], [ %151, %111 ]
%113 = phi float [ 0.000000e+00, %69 ], [ %149, %111 ]
%114 = phi <4 x float> [ zeroinitializer, %69 ], [ %150, %111 ]
%115 = phi <4 x float> [ zeroinitializer, %69 ], [ %147, %111 ]
%116 = getelementptr inbounds float, float* %0, i64 %112
%117 = load float, float* %116
%118 = fsub float %117, %53
%119 = getelementptr inbounds float, float* %1, i64 %112
%120 = load float, float* %119
%121 = getelementptr inbounds float, float* %2, i64 %112
%122 = load float, float* %121
%123 = insertelement <2 x float> poison, float %122, i64 0
%124 = insertelement <2 x float> %123, float %120, i64 1
%125 = fsub <2 x float> %124, %58
%126 = shufflevector <2 x float> %125, <2 x float> poison, <4 x i32> <i32 undef, i32 1, i32 undef, i32 undef>
%127 = shufflevector <2 x float> %125, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 1, i32 0>
%128 = getelementptr inbounds float, float* %3, i64 %112
%129 = load float, float* %128
%130 = fsub float %129, %59
%131 = getelementptr inbounds float, float* %4, i64 %112
%132 = load float, float* %131
%133 = getelementptr inbounds float, float* %5, i64 %112
%134 = load float, float* %133
%135 = insertelement <2 x float> poison, float %134, i64 0
%136 = insertelement <2 x float> %135, float %132, i64 1
%137 = fsub <2 x float> %136, %60
%138 = shufflevector <2 x float> %137, <2 x float> poison, <4 x i32> <i32 0, i32 1, i32 0, i32 1>
%139 = extractelement <2 x float> %137, i64 1
%140 = extractelement <2 x float> %137, i64 0
%141 = insertelement <4 x float> %126, float %118, i64 0
%142 = shufflevector <4 x float> %141, <4 x float> poison, <4 x i32> <i32 0, i32 0, i32 0, i32 1>
%143 = insertelement <4 x float> poison, float %130, i64 0
%144 = insertelement <4 x float> %143, float %139, i64 1
%145 = insertelement <4 x float> %144, float %140, i64 2
%146 = insertelement <4 x float> %145, float %130, i64 3
%147 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %142, <4 x float> %146, <4 x float> %115)
%148 = extractelement <2 x float> %125, i64 0
%149 = tail call float @llvm.fmuladd.f32(float %148, float %130, float %113)
%150 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %127, <4 x float> %138, <4 x float> %114)
%151 = add nuw nsw i64 %112, 1
%152 = icmp eq i64 %151, %75
br i1 %152, label %76, label %111
153: ; preds = %165
%154 = add nuw nsw i32 %166, 1
%155 = icmp eq i32 %154, 20
br i1 %155, label %228, label %156
156: ; preds = %153
%157 = load float, float* %86
%158 = load float, float* %87
%159 = load float, float* %88
%160 = load float, float* %89
%161 = insertelement <4 x float> poison, float %160, i64 0
%162 = insertelement <4 x float> %161, float %159, i64 1
%163 = insertelement <4 x float> %162, float %158, i64 2
%164 = insertelement <4 x float> %163, float %157, i64 3
br label %165
165: ; preds = %156, %84
%166 = phi i32 [ 0, %84 ], [ %154, %156 ]
%167 = phi <4 x float> [ %85, %84 ], [ %164, %156 ]
%168 = shufflevector <4 x float> %167, <4 x float> poison, <4 x i32> <i32 undef, i32 undef, i32 3, i32 undef>
%169 = fsub <4 x float> %168, %167
%170 = extractelement <4 x float> %169, i64 2
%171 = fpext float %170 to double
%172 = shufflevector <4 x float> %167, <4 x float> poison, <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
%173 = fadd <4 x float> %172, %167
%174 = extractelement <4 x float> %173, i64 0
%175 = fpext float %174 to double
%176 = call double @atan2(double %171, double %175)
%177 = fptrunc double %176 to float
%178 = fpext float %177 to double
%179 = call double @llvm.fabs.f64(double %178)
%180 = fptrunc double %179 to float
%181 = call double @cos(double %178)
%182 = fptrunc double %181 to float
%183 = call double @sin(double %178)
%184 = fptrunc double %183 to float
store float %182, float* %90
%185 = fneg float %184
store float %185, float* %91
store float %184, float* %92
store float %182, float* %93
%186 = load float, float* %96
%187 = load float, float* %97
%188 = fsub float %186, %187
%189 = fpext float %188 to double
%190 = load float, float* %98
%191 = load float, float* %89
%192 = fadd float %190, %191
%193 = fpext float %192 to double
%194 = call double @atan2(double %189, double %193)
%195 = fptrunc double %194 to float
%196 = fpext float %195 to double
%197 = call double @llvm.fabs.f64(double %196)
%198 = fpext float %180 to double
%199 = fadd double %197, %198
%200 = fptrunc double %199 to float
%201 = call double @cos(double %196)
%202 = fptrunc double %201 to float
%203 = call double @sin(double %196)
%204 = fptrunc double %203 to float
store float %202, float* %100
%205 = fneg float %204
store float %205, float* %101
store float %204, float* %102
store float %202, float* %103
%206 = load float, float* %104
%207 = load float, float* %105
%208 = fsub float %206, %207
%209 = fpext float %208 to double
%210 = load float, float* %88
%211 = load float, float* %98
%212 = fadd float %210, %211
%213 = fpext float %212 to double
%214 = call double @atan2(double %209, double %213)
%215 = fptrunc double %214 to float
%216 = fpext float %215 to double
%217 = call double @llvm.fabs.f64(double %216)
%218 = fpext float %200 to double
%219 = fadd double %217, %218
%220 = fptrunc double %219 to float
%221 = call double @cos(double %216)
%222 = fptrunc double %221 to float
%223 = call double @sin(double %216)
%224 = fptrunc double %223 to float
store float %222, float* %106
%225 = fneg float %224
store float %225, float* %108
store float %224, float* %109
store float %222, float* %110
%226 = fpext float %220 to double
%227 = fcmp olt double %226, 0x3E7AD7F29ABCAF48
br i1 %227, label %228, label %153
228: ; preds = %165, %153
%229 = load float, float* %61
%230 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 1, i64 0
%231 = load float, float* %230
%232 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 2, i64 0
%233 = load float, float* %232
%234 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 1
%235 = load float, float* %234
%236 = load float, float* %62
%237 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 2, i64 1
%238 = load float, float* %237
%239 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 0, i64 2
%240 = load float, float* %239
%241 = getelementptr inbounds [3 x float], [3 x float]* %7, i64 1, i64 2
%242 = load float, float* %241
%243 = load float, float* %63
br i1 %68, label %244, label %289
244: ; preds = %228
%245 = zext i32 %6 to i64
%246 = extractelement <2 x float> %60, i64 1
%247 = extractelement <2 x float> %60, i64 0
%248 = extractelement <2 x float> %58, i64 1
%249 = extractelement <2 x float> %58, i64 0
br label %250
250: ; preds = %244, %250
%251 = phi i64 [ 0, %244 ], [ %287, %250 ]
%252 = phi float [ 0.000000e+00, %244 ], [ %286, %250 ]
%253 = getelementptr inbounds float, float* %3, i64 %251
%254 = load float, float* %253
%255 = fsub float %254, %59
%256 = getelementptr inbounds float, float* %4, i64 %251
%257 = load float, float* %256
%258 = fsub float %257, %246
%259 = getelementptr inbounds float, float* %5, i64 %251
%260 = load float, float* %259
%261 = fsub float %260, %247
%262 = fmul float %258, %231
%263 = call float @llvm.fmuladd.f32(float %229, float %255, float %262)
%264 = call float @llvm.fmuladd.f32(float %233, float %261, float %263)
%265 = fmul float %258, %236
%266 = call float @llvm.fmuladd.f32(float %235, float %255, float %265)
%267 = call float @llvm.fmuladd.f32(float %238, float %261, float %266)
%268 = fmul float %258, %242
%269 = call float @llvm.fmuladd.f32(float %240, float %255, float %268)
%270 = call float @llvm.fmuladd.f32(float %243, float %261, float %269)
%271 = getelementptr inbounds float, float* %0, i64 %251
%272 = load float, float* %271
%273 = fsub float %53, %272
%274 = fadd float %264, %273
%275 = getelementptr inbounds float, float* %1, i64 %251
%276 = load float, float* %275
%277 = fsub float %248, %276
%278 = fadd float %267, %277
%279 = getelementptr inbounds float, float* %2, i64 %251
%280 = load float, float* %279
%281 = fsub float %249, %280
%282 = fadd float %270, %281
%283 = fmul float %278, %278
%284 = call float @llvm.fmuladd.f32(float %274, float %274, float %283)
%285 = call float @llvm.fmuladd.f32(float %282, float %282, float %284)
%286 = fadd float %252, %285
%287 = add nuw nsw i64 %251, 1
%288 = icmp eq i64 %287, %245
br i1 %288, label %289, label %250
289: ; preds = %250, %228
%290 = phi float [ 0.000000e+00, %228 ], [ %286, %250 ]
%291 = extractelement <2 x float> %60, i64 1
%292 = fmul float %291, %231
%293 = call float @llvm.fmuladd.f32(float %229, float %59, float %292)
%294 = extractelement <2 x float> %60, i64 0
%295 = call float @llvm.fmuladd.f32(float %233, float %294, float %293)
%296 = fmul float %291, %236
%297 = call float @llvm.fmuladd.f32(float %235, float %59, float %296)
%298 = call float @llvm.fmuladd.f32(float %238, float %294, float %297)
%299 = fmul float %291, %242
%300 = call float @llvm.fmuladd.f32(float %240, float %59, float %299)
%301 = call float @llvm.fmuladd.f32(float %243, float %294, float %300)
%302 = fsub float %53, %295
store float %302, float* %8
%303 = extractelement <2 x float> %58, i64 1
%304 = fsub float %303, %298
%305 = getelementptr inbounds float, float* %8, i64 1
store float %304, float* %305
%306 = extractelement <2 x float> %58, i64 0
%307 = fsub float %306, %301
%308 = getelementptr inbounds float, float* %8, i64 2
store float %307, float* %308
%309 = fdiv float %290, %52
%310 = call float @sqrtf(float %309)
br label %311
311: ; preds = %9, %289
%312 = phi float [ %310, %289 ], [ -1.000000e+00, %9 ]
ret float %312
}