void nmtensor(float iso, float clvd, float str, float dip, float rake,
              float tensor[3][3]) {
  float cstr, cdip, crak, sstr, sdip, srak, sstr2, cstr2, sdip2, cdip2, dum,
      dev;
  float n[3], v[3], N[3];
  dum = 0.8164966 * iso;
  tensor[0][0] = tensor[1][1] = tensor[2][2] = dum;
  tensor[0][1] = tensor[0][2] = tensor[1][2] = 0.;
  dev = 1. - iso * iso;
  if (dev > 0.) {
    dev = sqrt(dev);
    dum = dev * sqrt(1. - clvd * clvd);
    str *= 1.745329252e-2;
    dip *= 1.745329252e-2;
    rake *= 1.745329252e-2;
    sstr = sin(str);
    cstr = cos(str);
    sstr2 = 2 * sstr * cstr;
    cstr2 = 1 - 2 * sstr * sstr;
    sdip = sin(dip);
    cdip = cos(dip);
    sdip2 = 2 * sdip * cdip;
    cdip2 = 1 - 2 * sdip * sdip;
    crak = cos(rake);
    srak = sin(rake);
    tensor[0][0] += -dum * (sdip * crak * sstr2 + sdip2 * srak * sstr * sstr);
    tensor[0][1] += dum * (sdip * crak * cstr2 + 0.5 * sdip2 * srak * sstr2);
    tensor[0][2] += -dum * (cdip * crak * cstr + cdip2 * srak * sstr);
    tensor[1][1] += dum * (sdip * crak * sstr2 - sdip2 * srak * cstr * cstr);
    tensor[1][2] += dum * (cdip2 * srak * cstr - cdip * crak * sstr);
    tensor[2][2] += dum * sdip2 * srak;
    if (clvd > 0.0001 || clvd < -0.0001) {
      n[0] = -sdip * sstr;
      n[1] = sdip * cstr;
      n[2] = -cdip;
      v[0] = crak * cstr + srak * cdip * sstr;
      v[1] = crak * sstr - srak * cdip * cstr;
      v[2] = -srak * sdip;
      N[0] = n[1] * v[2] - n[2] * v[1];
      N[1] = n[2] * v[0] - n[0] * v[2];
      N[2] = n[0] * v[1] - n[1] * v[0];
      dum = dev * clvd / sqrt(3.);
      tensor[0][0] += dum * (2 * N[0] * N[0] - n[0] * n[0] - v[0] * v[0]);
      tensor[0][1] += dum * (2 * N[0] * N[1] - n[0] * n[1] - v[0] * v[1]);
      tensor[0][2] += dum * (2 * N[0] * N[2] - n[0] * n[2] - v[0] * v[2]);
      tensor[1][1] += dum * (2 * N[1] * N[1] - n[1] * n[1] - v[1] * v[1]);
      tensor[1][2] += dum * (2 * N[1] * N[2] - n[1] * n[2] - v[1] * v[2]);
      tensor[2][2] += dum * (2 * N[2] * N[2] - n[2] * n[2] - v[2] * v[2]);
    }
  }
  tensor[1][0] = tensor[0][1];
  tensor[2][0] = tensor[0][2];
  tensor[2][1] = tensor[1][2];
}


x86 assembly (clang, -O0):
<nmtensor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
movss  %xmm4,-0x14(%rbp)
mov    %rdi,-0x20(%rbp)
movss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe9f(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x20(%rax)
mov    -0x20(%rbp),%rax
movss  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x14(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x4(%rbp),%xmm0
mulss  -0x4(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe31(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    19ce <nmtensor+0x89e>
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movss  -0x8(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdd3(%rip),%xmm0
subsd  %xmm1,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x80(%rbp),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdc4(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xda6(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd88(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0xc(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  0xd61(%rip),%xmm0
mulss  -0x30(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  0xd4a(%rip),%xmm0
mulss  -0x30(%rbp),%xmm0
movss  -0x30(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xd23(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  0xce8(%rip),%xmm0
mulss  -0x34(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0xcd1(%rip),%xmm0
mulss  -0x34(%rbp),%xmm0
movss  -0x34(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm1,%xmm0
movss  0xcaa(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <cos@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x34(%rbp),%xmm2
mulss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
movss  -0x44(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x34(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x44(%rbp),%xmm2
cvtss2sd %xmm2,%xmm3
movsd  0xbd5(%rip),%xmm2
mulsd  %xmm3,%xmm2
movss  -0x38(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm2
movss  -0x3c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x28(%rbp),%xmm2
mulss  -0x2c(%rbp),%xmm2
movss  -0x24(%rbp),%xmm3
movss  -0x48(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm0
movss  -0x34(%rbp),%xmm2
mulss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm3
movss  -0x44(%rbp),%xmm1
mulss  -0x38(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x4c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
mulss  -0x38(%rbp),%xmm2
movss  -0x24(%rbp),%xmm3
movss  -0x28(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x4c(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rax)
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa68(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     15cd <nmtensor+0x49d>
movss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa65(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    19c9 <nmtensor+0x899>
movss  -0x34(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x34(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x28(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x30(%rbp),%xmm2
movss  -0x38(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x38(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x58(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x54(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x50(%rbp),%xmm0
mulss  -0x8(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x904(%rip),%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x4c(%rbp),%xmm0
movss  0x8e6(%rip),%xmm1
mulss  -0x74(%rbp),%xmm1
movss  -0x74(%rbp),%xmm3
movss  -0x5c(%rbp),%xmm2
mulss  -0x5c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x68(%rbp),%xmm2
movss  -0x68(%rbp),%xmm3
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
movss  0x87d(%rip),%xmm1
mulss  -0x74(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x5c(%rbp),%xmm2
mulss  -0x58(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x68(%rbp),%xmm2
movss  -0x64(%rbp),%xmm3
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%rax)
movss  -0x4c(%rbp),%xmm0
movss  0x812(%rip),%xmm1
mulss  -0x74(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm3
movss  -0x5c(%rbp),%xmm2
mulss  -0x54(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x68(%rbp),%xmm2
movss  -0x60(%rbp),%xmm3
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x8(%rax)
movss  -0x4c(%rbp),%xmm0
movss  0x7a7(%rip),%xmm1
mulss  -0x70(%rbp),%xmm1
movss  -0x70(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x58(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x64(%rbp),%xmm2
movss  -0x64(%rbp),%xmm3
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x10(%rax)
movss  -0x4c(%rbp),%xmm0
movss  0x73c(%rip),%xmm1
mulss  -0x70(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm3
movss  -0x58(%rbp),%xmm2
mulss  -0x54(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x64(%rbp),%xmm2
movss  -0x60(%rbp),%xmm3
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x14(%rax)
movss  -0x4c(%rbp),%xmm0
movss  0x6d1(%rip),%xmm1
mulss  -0x6c(%rbp),%xmm1
movss  -0x6c(%rbp),%xmm3
movss  -0x54(%rbp),%xmm2
mulss  -0x54(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  -0x60(%rbp),%xmm2
movss  -0x60(%rbp),%xmm3
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x20(%rax)
jmp    19ce <nmtensor+0x89e>
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0xc(%rax)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x1c(%rax)
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nmtensor>:
push   %rbx
sub    $0xc0,%rsp
mov    %rdi,%rbx
movaps %xmm0,%xmm5
cvtss2sd %xmm0,%xmm0
mulsd  0xea6(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x20(%rdi)
movss  %xmm0,0x10(%rdi)
movss  %xmm0,(%rdi)
movl   $0x0,0x14(%rdi)
movq   $0x0,0x4(%rdi)
mulss  %xmm5,%xmm5
movss  0xeb1(%rip),%xmm0
subss  %xmm5,%xmm0
xorps  %xmm5,%xmm5
xorps  %xmm13,%xmm13
ucomiss %xmm13,%xmm0
jbe    16fa <nmtensor+0x5ba>
xorps  %xmm5,%xmm5
ucomiss %xmm5,%xmm0
movss  %xmm1,0xc(%rsp)
movss  %xmm4,0x10(%rsp)
movss  %xmm3,0x30(%rsp)
movss  %xmm2,0x20(%rsp)
jb     11c2 <nmtensor+0x82>
sqrtss %xmm0,%xmm0
jmp    11cd <nmtensor+0x8d>
call   1040 <sqrtf@plt>
movss  0xc(%rsp),%xmm1
movss  %xmm0,0x48(%rsp)
xorps  %xmm2,%xmm2
cvtss2sd %xmm0,%xmm2
movaps %xmm1,%xmm0
mulss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xe18(%rip),%xmm0
subsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1204 <nmtensor+0xc4>
sqrtsd %xmm0,%xmm0
jmp    1215 <nmtensor+0xd5>
movsd  %xmm2,0x70(%rsp)
call   1060 <sqrt@plt>
movsd  0x70(%rsp),%xmm2
movss  0x10(%rsp),%xmm3
movss  0x20(%rsp),%xmm1
mulsd  %xmm2,%xmm0
cvtsd2ss %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  0xdd3(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  0x30(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm1,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x30(%rsp)
xorps  %xmm2,%xmm2
cvtss2sd %xmm3,%xmm2
mulsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,0x60(%rsp)
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x20(%rsp)
call   1030 <sin@plt>
movaps %xmm0,0x10(%rsp)
movsd  0x20(%rsp),%xmm0
call   1050 <cos@plt>
movapd 0x10(%rsp),%xmm1
unpcklpd %xmm0,%xmm1
cvtpd2ps %xmm1,%xmm1
movapd %xmm1,0xa0(%rsp)
movapd %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
movaps %xmm3,0x90(%rsp)
movaps %xmm1,%xmm0
addss  %xmm1,%xmm0
movaps %xmm0,%xmm2
mulss  %xmm3,%xmm2
movaps %xmm2,0xb0(%rsp)
mulss  %xmm1,%xmm0
movss  0xd5b(%rip),%xmm1
movaps %xmm1,0x50(%rsp)
subss  %xmm0,%xmm1
movss  %xmm1,0x4c(%rsp)
movss  0x30(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
call   1030 <sin@plt>
cvtsd2ss %xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
movsd  0x10(%rsp),%xmm0
call   1050 <cos@plt>
xorps  %xmm2,%xmm2
cvtsd2ss %xmm0,%xmm2
movaps %xmm2,0x20(%rsp)
movaps 0x30(%rsp),%xmm3
movaps %xmm3,%xmm0
addss  %xmm3,%xmm0
movaps %xmm0,%xmm1
mulss  %xmm2,%xmm1
movaps %xmm1,0x10(%rsp)
mulss  %xmm3,%xmm0
movaps 0x50(%rsp),%xmm1
subss  %xmm0,%xmm1
movaps %xmm1,0x50(%rsp)
movss  0x60(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x88(%rsp)
call   1050 <cos@plt>
movaps %xmm0,0x60(%rsp)
movsd  0x88(%rsp),%xmm0
call   1030 <sin@plt>
movaps 0x90(%rsp),%xmm2
unpcklpd 0x60(%rsp),%xmm0
cvtpd2ps %xmm0,%xmm14
movapd %xmm14,%xmm8
shufps $0x55,%xmm14,%xmm8
movaps %xmm8,%xmm10
mulss  0x30(%rsp),%xmm10
movaps 0x10(%rsp),%xmm12
movaps %xmm12,%xmm1
mulss  %xmm14,%xmm1
movaps %xmm1,%xmm3
movaps 0xa0(%rsp),%xmm11
mulss  %xmm11,%xmm3
mulss  %xmm11,%xmm3
movss  0x4c(%rsp),%xmm6
mulss  %xmm10,%xmm6
movaps 0xb0(%rsp),%xmm5
mulss  %xmm5,%xmm10
addss  %xmm10,%xmm3
movaps 0x70(%rsp),%xmm0
mulss  %xmm0,%xmm3
movss  (%rbx),%xmm7
subss  %xmm3,%xmm7
xorps  %xmm3,%xmm3
cvtss2sd %xmm12,%xmm3
mulsd  0xc17(%rip),%xmm3
cvtss2sd %xmm14,%xmm4
mulsd  %xmm3,%xmm4
movaps 0xc2e(%rip),%xmm15
cvtss2sd %xmm5,%xmm5
mulsd  %xmm4,%xmm5
movss  0x4(%rbx),%xmm4
cvtss2sd %xmm6,%xmm6
addsd  %xmm6,%xmm5
xorps  %xmm6,%xmm6
cvtss2sd %xmm0,%xmm6
mulsd  %xmm6,%xmm5
cvtss2sd %xmm4,%xmm4
addsd  %xmm5,%xmm4
movaps 0x20(%rsp),%xmm3
movaps %xmm3,%xmm9
movaps 0x50(%rsp),%xmm6
unpcklps %xmm3,%xmm6
mulps  %xmm14,%xmm6
movaps %xmm6,%xmm5
shufps $0x55,%xmm6,%xmm5
xorps  %xmm15,%xmm5
movaps %xmm11,%xmm3
shufps $0x0,%xmm11,%xmm3
unpcklps %xmm6,%xmm5
mulps  %xmm3,%xmm5
movaps %xmm0,%xmm3
xorps  %xmm15,%xmm3
movss  %xmm7,(%rbx)
cvtsd2ss %xmm4,%xmm13
movss  %xmm13,0x4(%rbx)
mulps  %xmm2,%xmm6
addps  %xmm5,%xmm6
movaps %xmm0,%xmm4
unpcklps %xmm3,%xmm4
mulps  %xmm6,%xmm4
movss  0x8(%rbx),%xmm6
movss  0x14(%rbx),%xmm5
unpcklps %xmm6,%xmm5
addps  %xmm4,%xmm5
movaps %xmm5,%xmm4
shufps $0x55,%xmm5,%xmm4
movss  %xmm4,0x8(%rbx)
mulss  %xmm2,%xmm1
mulss  %xmm2,%xmm1
subss  %xmm1,%xmm10
mulss  %xmm0,%xmm10
addss  0x10(%rbx),%xmm10
movss  %xmm10,0x10(%rbx)
movss  %xmm5,0x14(%rbx)
movaps %xmm12,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm14,%xmm1
addss  0x20(%rbx),%xmm1
movaps %xmm1,0x10(%rsp)
movss  %xmm1,0x20(%rbx)
movss  0xc(%rsp),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
ucomisd 0xb22(%rip),%xmm1
ja     1512 <nmtensor+0x3d2>
movsd  0xb20(%rip),%xmm4
ucomisd %xmm1,%xmm4
jbe    16fa <nmtensor+0x5ba>
movaps 0x30(%rsp),%xmm3
movaps %xmm3,%xmm1
xorps  %xmm15,%xmm1
movaps %xmm2,%xmm4
unpcklps %xmm11,%xmm4
movaps %xmm3,%xmm12
unpcklps %xmm1,%xmm12
mulps  %xmm4,%xmm12
movaps %xmm9,%xmm6
xorps  %xmm15,%xmm6
movaps %xmm14,%xmm1
mulss  %xmm9,%xmm1
movaps %xmm1,%xmm4
xorps  %xmm15,%xmm4
movlhps %xmm2,%xmm1
shufps $0xe2,%xmm2,%xmm1
unpcklps %xmm11,%xmm4
mulps  %xmm1,%xmm4
mulps  %xmm11,%xmm8
addps  %xmm4,%xmm8
xorps  %xmm15,%xmm14
mulss  %xmm3,%xmm14
movaps %xmm12,%xmm2
shufps $0x55,%xmm12,%xmm2
movss  %xmm7,0x50(%rsp)
movaps %xmm2,%xmm7
xorps  %xmm15,%xmm7
movaps %xmm14,%xmm1
unpcklps %xmm8,%xmm1
unpcklps %xmm9,%xmm7
mulps  %xmm1,%xmm7
unpcklps %xmm12,%xmm6
movaps %xmm8,%xmm4
shufps $0x55,%xmm8,%xmm4
movaps %xmm14,%xmm1
shufps $0xd4,%xmm8,%xmm1
shufps $0x52,%xmm8,%xmm1
mulps  %xmm6,%xmm1
addps  %xmm7,%xmm1
movaps %xmm4,%xmm6
mulss  %xmm12,%xmm6
movaps %xmm2,%xmm9
mulss  %xmm8,%xmm9
subss  %xmm6,%xmm9
movss  0x48(%rsp),%xmm11
mulss  %xmm0,%xmm11
movaps %xmm2,%xmm7
mulss  %xmm2,%xmm7
movaps %xmm1,%xmm3
addps  %xmm1,%xmm3
movaps %xmm3,%xmm6
shufps $0x55,%xmm3,%xmm6
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
mulss  %xmm6,%xmm0
subss  %xmm7,%xmm0
xorps  %xmm8,%xmm15
pshufd $0x55,%xmm15,%xmm7
mulss  %xmm7,%xmm4
addss  %xmm0,%xmm4
xorps  %xmm0,%xmm0
cvtss2sd %xmm11,%xmm0
divsd  0xa1b(%rip),%xmm0
xorps  %xmm11,%xmm11
cvtsd2ss %xmm0,%xmm11
mulss  %xmm11,%xmm4
addss  0x50(%rsp),%xmm4
movss  %xmm4,(%rbx)
mulss  %xmm12,%xmm2
mulss  %xmm1,%xmm6
subss  %xmm2,%xmm6
mulss  %xmm8,%xmm7
addss  %xmm6,%xmm7
mulss  %xmm11,%xmm7
addss  %xmm7,%xmm13
movaps 0x20(%rsp),%xmm4
movaps %xmm4,%xmm7
shufps $0x0,%xmm4,%xmm7
mulps  %xmm12,%xmm7
movaps %xmm9,%xmm0
addss  %xmm9,%xmm0
mulss  %xmm9,%xmm0
shufps $0x0,%xmm9,%xmm9
mulps  %xmm3,%xmm9
addps  %xmm7,%xmm9
movaps %xmm14,%xmm2
shufps $0x0,%xmm14,%xmm2
mulps  %xmm8,%xmm2
subps  %xmm2,%xmm9
mulss  %xmm1,%xmm3
mulss  %xmm12,%xmm12
subss  %xmm12,%xmm3
mulss  %xmm8,%xmm15
addss  %xmm3,%xmm15
movaps %xmm4,%xmm1
mulss  %xmm4,%xmm1
subss  %xmm1,%xmm0
mulss  %xmm14,%xmm14
subss  %xmm14,%xmm0
mulss  %xmm11,%xmm15
mulss  %xmm11,%xmm0
shufps $0x0,%xmm11,%xmm11
mulps  %xmm9,%xmm11
movss  %xmm13,0x4(%rbx)
addps  %xmm11,%xmm5
movaps %xmm5,%xmm1
shufps $0x55,%xmm5,%xmm1
movss  %xmm1,0x8(%rbx)
addss  %xmm10,%xmm15
movss  %xmm15,0x10(%rbx)
addss  0x10(%rsp),%xmm0
movss  %xmm5,0x14(%rbx)
movss  %xmm0,0x20(%rbx)
movss  %xmm13,0xc(%rbx)
movaps %xmm5,%xmm0
shufps $0x55,%xmm5,%xmm0
movss  %xmm0,0x18(%rbx)
movss  %xmm5,0x1c(%rbx)
add    $0xc0,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define void @nmtensor(float %0, float %1, float %2, float %3, float %4, [3 x float]* nocapture %5) {
%7 = fpext float %0 to double
%8 = fmul double %7, 0x3FEA20BD7A49723A
%9 = fptrunc double %8 to float
%10 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 2, i64 2
store float %9, float* %10
%11 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 1, i64 1
store float %9, float* %11
%12 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 0
store float %9, float* %12
%13 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 1, i64 2
store float 0.000000e+00, float* %13
%14 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 2
store float 0.000000e+00, float* %14
%15 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 0, i64 1
store float 0.000000e+00, float* %15
%16 = fmul float %0, %0
%17 = fsub float 1.000000e+00, %16
%18 = fcmp ogt float %17, 0.000000e+00
br i1 %18, label %19, label %199
19: ; preds = %6
%20 = tail call float @sqrtf(float %17)
%21 = fpext float %20 to double
%22 = fmul float %1, %1
%23 = fpext float %22 to double
%24 = fsub double 1.000000e+00, %23
%25 = tail call double @sqrt(double %24)
%26 = fmul double %25, %21
%27 = fptrunc double %26 to float
%28 = fpext float %2 to double
%29 = fmul double %28, 0x3F91DF46A252DD11
%30 = fptrunc double %29 to float
%31 = fpext float %3 to double
%32 = fmul double %31, 0x3F91DF46A252DD11
%33 = fptrunc double %32 to float
%34 = fpext float %4 to double
%35 = fmul double %34, 0x3F91DF46A252DD11
%36 = fptrunc double %35 to float
%37 = fpext float %30 to double
%38 = tail call double @sin(double %37)
%39 = tail call double @cos(double %37)
%40 = insertelement <2 x double> poison, double %38, i64 0
%41 = insertelement <2 x double> %40, double %39, i64 1
%42 = fptrunc <2 x double> %41 to <2 x float>
%43 = extractelement <2 x float> %42, i64 0
%44 = fmul float %43, 2.000000e+00
%45 = extractelement <2 x float> %42, i64 1
%46 = fmul float %44, %45
%47 = fneg float %44
%48 = tail call float @llvm.fmuladd.f32(float %47, float %43, float 1.000000e+00)
%49 = fpext float %33 to double
%50 = tail call double @sin(double %49)
%51 = fptrunc double %50 to float
%52 = tail call double @cos(double %49)
%53 = fptrunc double %52 to float
%54 = fmul float %51, 2.000000e+00
%55 = fmul float %54, %53
%56 = fneg float %54
%57 = tail call float @llvm.fmuladd.f32(float %56, float %51, float 1.000000e+00)
%58 = fpext float %36 to double
%59 = tail call double @cos(double %58)
%60 = tail call double @sin(double %58)
%61 = insertelement <2 x double> poison, double %60, i64 0
%62 = insertelement <2 x double> %61, double %59, i64 1
%63 = fptrunc <2 x double> %62 to <2 x float>
%64 = fneg float %27
%65 = extractelement <2 x float> %63, i64 1
%66 = fmul float %65, %51
%67 = extractelement <2 x float> %63, i64 0
%68 = fmul float %55, %67
%69 = fmul float %68, %43
%70 = fmul float %69, %43
%71 = tail call float @llvm.fmuladd.f32(float %66, float %46, float %70)
%72 = load float, float* %12
%73 = tail call float @llvm.fmuladd.f32(float %64, float %71, float %72)
store float %73, float* %12
%74 = fpext float %27 to double
%75 = fmul float %48, %66
%76 = fpext float %75 to double
%77 = fpext float %55 to double
%78 = fmul double %77, 5.000000e-01
%79 = fpext float %67 to double
%80 = fmul double %78, %79
%81 = fpext float %46 to double
%82 = tail call double @llvm.fmuladd.f64(double %80, double %81, double %76)
%83 = load float, float* %15
%84 = fpext float %83 to double
%85 = tail call double @llvm.fmuladd.f64(double %74, double %82, double %84)
%86 = fptrunc double %85 to float
store float %86, float* %15
%87 = insertelement <2 x float> poison, float %57, i64 0
%88 = insertelement <2 x float> %87, float %53, i64 1
%89 = fmul <2 x float> %88, %63
%90 = load float, float* %14
%91 = extractelement <2 x float> %89, i64 1
%92 = fneg float %91
%93 = shufflevector <2 x float> %42, <2 x float> undef, <2 x i32> zeroinitializer
%94 = insertelement <2 x float> poison, float %92, i64 0
%95 = shufflevector <2 x float> %94, <2 x float> %89, <2 x i32> <i32 0, i32 2>
%96 = fmul <2 x float> %93, %95
%97 = shufflevector <2 x float> %42, <2 x float> undef, <2 x i32> <i32 1, i32 undef>
%98 = shufflevector <2 x float> %42, <2 x float> poison, <2 x i32> <i32 1, i32 1>
%99 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %89, <2 x float> %98, <2 x float> %96)
%100 = load float, float* %13
%101 = insertelement <2 x float> poison, float %27, i64 0
%102 = insertelement <2 x float> %101, float %64, i64 1
%103 = insertelement <2 x float> poison, float %100, i64 0
%104 = insertelement <2 x float> %103, float %90, i64 1
%105 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %102, <2 x float> %99, <2 x float> %104)
%106 = extractelement <2 x float> %105, i64 1
store float %106, float* %14
%107 = fneg float %68
%108 = fmul float %45, %107
%109 = fmul float %108, %45
%110 = tail call float @llvm.fmuladd.f32(float %66, float %46, float %109)
%111 = load float, float* %11
%112 = tail call float @llvm.fmuladd.f32(float %27, float %110, float %111)
store float %112, float* %11
%113 = extractelement <2 x float> %105, i64 0
store float %113, float* %13
%114 = fmul float %55, %27
%115 = load float, float* %10
%116 = tail call float @llvm.fmuladd.f32(float %114, float %67, float %115)
store float %116, float* %10
%117 = fpext float %1 to double
%118 = fcmp ogt double %117, 1.000000e-04
%119 = fcmp olt double %117, -1.000000e-04
%120 = or i1 %118, %119
br i1 %120, label %121, label %199
121: ; preds = %19
%122 = fneg float %51
%123 = shufflevector <2 x float> %97, <2 x float> %42, <2 x i32> <i32 0, i32 2>
%124 = insertelement <2 x float> poison, float %51, i64 0
%125 = insertelement <2 x float> %124, float %122, i64 1
%126 = fmul <2 x float> %123, %125
%127 = fneg float %53
%128 = fmul float %67, %53
%129 = fneg float %128
%130 = insertelement <2 x float> %97, float %128, i64 1
%131 = insertelement <2 x float> poison, float %129, i64 0
%132 = shufflevector <2 x float> %131, <2 x float> %42, <2 x i32> <i32 0, i32 2>
%133 = fmul <2 x float> %130, %132
%134 = shufflevector <2 x float> %63, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%135 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %134, <2 x float> %42, <2 x float> %133)
%136 = fneg float %67
%137 = fmul float %51, %136
%138 = extractelement <2 x float> %126, i64 1
%139 = fneg float %138
%140 = insertelement <2 x float> poison, float %137, i64 0
%141 = extractelement <2 x float> %135, i64 0
%142 = shufflevector <2 x float> %140, <2 x float> %135, <2 x i32> <i32 0, i32 2>
%143 = insertelement <2 x float> poison, float %139, i64 0
%144 = insertelement <2 x float> %143, float %53, i64 1
%145 = fmul <2 x float> %142, %144
%146 = insertelement <2 x float> poison, float %127, i64 0
%147 = extractelement <2 x float> %126, i64 0
%148 = shufflevector <2 x float> %146, <2 x float> %126, <2 x i32> <i32 0, i32 2>
%149 = extractelement <2 x float> %135, i64 1
%150 = insertelement <2 x float> poison, float %149, i64 0
%151 = insertelement <2 x float> %150, float %137, i64 1
%152 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %148, <2 x float> %151, <2 x float> %145)
%153 = fneg float %147
%154 = fmul float %149, %153
%155 = tail call float @llvm.fmuladd.f32(float %138, float %141, float %154)
%156 = fmul float %20, %1
%157 = fpext float %156 to double
%158 = fdiv double %157, 0x3FFBB67AE8584CAA
%159 = fptrunc double %158 to float
%160 = fmul float %138, %139
%161 = fmul <2 x float> %152, <float 2.000000e+00, float 2.000000e+00>
%162 = extractelement <2 x float> %161, i64 1
%163 = extractelement <2 x float> %152, i64 1
%164 = tail call float @llvm.fmuladd.f32(float %162, float %163, float %160)
%165 = fneg <2 x float> %135
%166 = extractelement <2 x float> %165, i64 1
%167 = tail call float @llvm.fmuladd.f32(float %166, float %149, float %164)
%168 = tail call float @llvm.fmuladd.f32(float %159, float %167, float %73)
store float %168, float* %12
%169 = fmul float %147, %139
%170 = extractelement <2 x float> %152, i64 0
%171 = tail call float @llvm.fmuladd.f32(float %162, float %170, float %169)
%172 = tail call float @llvm.fmuladd.f32(float %166, float %141, float %171)
%173 = tail call float @llvm.fmuladd.f32(float %159, float %172, float %86)
store float %173, float* %15
%174 = insertelement <2 x float> poison, float %53, i64 0
%175 = shufflevector <2 x float> %174, <2 x float> poison, <2 x i32> zeroinitializer
%176 = fmul <2 x float> %126, %175
%177 = insertelement <2 x float> poison, float %155, i64 0
%178 = shufflevector <2 x float> %177, <2 x float> poison, <2 x i32> zeroinitializer
%179 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %161, <2 x float> %178, <2 x float> %176)
%180 = shufflevector <2 x float> %140, <2 x float> poison, <2 x i32> zeroinitializer
%181 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %165, <2 x float> %180, <2 x float> %179)
%182 = insertelement <2 x float> poison, float %159, i64 0
%183 = shufflevector <2 x float> %182, <2 x float> poison, <2 x i32> zeroinitializer
%184 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %183, <2 x float> %181, <2 x float> %105)
%185 = extractelement <2 x float> %184, i64 1
store float %185, float* %14
%186 = fmul float %147, %153
%187 = extractelement <2 x float> %161, i64 0
%188 = tail call float @llvm.fmuladd.f32(float %187, float %170, float %186)
%189 = extractelement <2 x float> %165, i64 0
%190 = tail call float @llvm.fmuladd.f32(float %189, float %141, float %188)
%191 = tail call float @llvm.fmuladd.f32(float %159, float %190, float %112)
store float %191, float* %11
%192 = extractelement <2 x float> %184, i64 0
store float %192, float* %13
%193 = fmul float %155, 2.000000e+00
%194 = fmul float %127, %53
%195 = tail call float @llvm.fmuladd.f32(float %193, float %155, float %194)
%196 = fneg float %137
%197 = tail call float @llvm.fmuladd.f32(float %196, float %137, float %195)
%198 = tail call float @llvm.fmuladd.f32(float %159, float %197, float %116)
store float %198, float* %10
br label %199
199: ; preds = %19, %121, %6
%200 = phi float [ %86, %19 ], [ %173, %121 ], [ 0.000000e+00, %6 ]
%201 = phi <2 x float> [ %105, %19 ], [ %184, %121 ], [ zeroinitializer, %6 ]
%202 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 1, i64 0
store float %200, float* %202
%203 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 2, i64 0
%204 = extractelement <2 x float> %201, i64 1
store float %204, float* %203
%205 = getelementptr inbounds [3 x float], [3 x float]* %5, i64 2, i64 1
%206 = extractelement <2 x float> %201, i64 0
store float %206, float* %205
ret void
}