void test3f(__complex__ float x, __complex__ float y, int i) {
  if (ccosf(x) != ccosf(-x))
    link_error();
  if (ccosf(ctanf(x)) != ccosf(ctanf(-x)))
    link_error();
  if (ctanf(x - y) != -ctanf(y - x))
    link_error();
  if (ccosf(x / y) != ccosf(-x / y))
    link_error();
  if (ccosf(x / y) != ccosf(x / -y))
    link_error();
  if (ccosf(x / ctanf(y)) != ccosf(-x / ctanf(-y)))
    link_error();
  if (ccosf(x * y) != ccosf(-x * y))
    link_error();
  if (ccosf(x * y) != ccosf(x * -y))
    link_error();
  if (ccosf(ctanf(x) * y) != ccosf(ctanf(-x) * -y))
    link_error();
  if (ccosf(ctanf(x / y)) != ccosf(-ctanf(x / -y)))
    link_error();
  if (ccosf(i ? x : y) != ccosf(i ? -x : y))
    link_error();
  if (ccosf(i ? x : y) != ccosf(i ? x : -y))
    link_error();
  if (ccosf(i ? x : ctanf(y / x)) != ccosf(i ? -x : -ctanf(-y / x)))
    link_error();
  if (~x != -~-x)
    link_error();
  if (ccosf(~x) != ccosf(-~-x))
    link_error();
  if (ctanf(~(x - y)) != -ctanf(~(y - x)))
    link_error();
  if (ctanf(~(x / y)) != -ctanf(~(x / -y)))
    link_error();
  if (cargf(x) != atan2f(__imag__ x, __real__ x))
    link_error();
}


x86 assembly (clang, -O0):
<test3f>:
push   %rbp
mov    %rsp,%rbp
sub    $0x530,%rsp
movlpd %xmm0,-0x8(%rbp)
movlpd %xmm1,-0x10(%rbp)
mov    %edi,-0x14(%rbp)
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  %xmm1,-0x20(%rbp)
movss  %xmm0,-0x1c(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1040 <ccosf@plt>
movlpd %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x358(%rbp)
ff
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x354(%rbp)
ff
movaps 0x2e54(%rip),%xmm2
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
pxor   %xmm2,%xmm1
pxor   %xmm2,%xmm0
movss  %xmm1,-0x30(%rbp)
movss  %xmm0,-0x2c(%rbp)
movsd  -0x30(%rbp),%xmm0
call   1040 <ccosf@plt>
movss  -0x358(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x354(%rbp),%xmm0
ff
movlpd %xmm1,-0x38(%rbp)
movss  -0x38(%rbp),%xmm3
movss  -0x34(%rbp),%xmm1
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1219 <test3f+0xc9>
jmp    1220 <test3f+0xd0>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  %xmm1,-0x40(%rbp)
movss  %xmm0,-0x3c(%rbp)
movsd  -0x40(%rbp),%xmm0
call   1050 <ctanf@plt>
movlpd %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
movss  %xmm1,-0x50(%rbp)
movss  %xmm0,-0x4c(%rbp)
movsd  -0x50(%rbp),%xmm0
call   1040 <ccosf@plt>
movlpd %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x360(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x35c(%rbp)
ff
movaps 0x2d79(%rip),%xmm2
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
pxor   %xmm2,%xmm1
pxor   %xmm2,%xmm0
movss  %xmm1,-0x60(%rbp)
movss  %xmm0,-0x5c(%rbp)
movsd  -0x60(%rbp),%xmm0
call   1050 <ctanf@plt>
movlpd %xmm0,-0x68(%rbp)
movss  -0x68(%rbp),%xmm1
movss  -0x64(%rbp),%xmm0
movss  %xmm1,-0x70(%rbp)
movss  %xmm0,-0x6c(%rbp)
movsd  -0x70(%rbp),%xmm0
call   1040 <ccosf@plt>
movss  -0x360(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x35c(%rbp),%xmm0
ff
movlpd %xmm1,-0x78(%rbp)
movss  -0x78(%rbp),%xmm3
movss  -0x74(%rbp),%xmm1
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1317 <test3f+0x1c7>
jmp    131e <test3f+0x1ce>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  -0x10(%rbp),%xmm3
movss  -0xc(%rbp),%xmm2
subss  %xmm3,%xmm1
subss  %xmm2,%xmm0
movss  %xmm1,-0x80(%rbp)
movss  %xmm0,-0x7c(%rbp)
movsd  -0x80(%rbp),%xmm0
call   1050 <ctanf@plt>
movlpd %xmm0,-0x88(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x368(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x364(%rbp)
ff
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
movss  -0x8(%rbp),%xmm3
movss  -0x4(%rbp),%xmm2
subss  %xmm3,%xmm1
subss  %xmm2,%xmm0
movss  %xmm1,-0x90(%rbp)
ff
movss  %xmm0,-0x8c(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movss  -0x368(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x364(%rbp),%xmm0
ff
movlpd %xmm1,-0x98(%rbp)
ff
movss  -0x98(%rbp),%xmm3
ff
movss  -0x94(%rbp),%xmm1
ff
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1419 <test3f+0x2c9>
jmp    1420 <test3f+0x2d0>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm3
call   2f50 <__divsc3>
movlpd %xmm0,-0xa0(%rbp)
ff
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm1,-0xa8(%rbp)
ff
movss  %xmm0,-0xa4(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0xb0(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
movss  %xmm0,-0x370(%rbp)
ff
movss  -0xac(%rbp),%xmm0
ff
movss  %xmm0,-0x36c(%rbp)
ff
movaps 0x2b63(%rip),%xmm2
movss  -0x8(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
pxor   %xmm2,%xmm0
pxor   %xmm2,%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm3
call   2f50 <__divsc3>
movlpd %xmm0,-0xb8(%rbp)
ff
movss  -0xb8(%rbp),%xmm1
ff
movss  -0xb4(%rbp),%xmm0
ff
movss  %xmm1,-0xc0(%rbp)
ff
movss  %xmm0,-0xbc(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x370(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x36c(%rbp),%xmm0
ff
movlpd %xmm1,-0xc8(%rbp)
ff
movss  -0xc8(%rbp),%xmm3
ff
movss  -0xc4(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1543 <test3f+0x3f3>
jmp    154a <test3f+0x3fa>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm3
call   2f50 <__divsc3>
movlpd %xmm0,-0xd0(%rbp)
ff
movss  -0xd0(%rbp),%xmm1
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  %xmm1,-0xd8(%rbp)
ff
movss  %xmm0,-0xd4(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0xe0(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  %xmm0,-0x378(%rbp)
ff
movss  -0xdc(%rbp),%xmm0
ff
movss  %xmm0,-0x374(%rbp)
ff
movss  -0x8(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
movaps 0x2a2f(%rip),%xmm4
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm3
pxor   %xmm4,%xmm2
pxor   %xmm4,%xmm3
call   2f50 <__divsc3>
movlpd %xmm0,-0xe8(%rbp)
ff
movss  -0xe8(%rbp),%xmm1
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm1,-0xf0(%rbp)
ff
movss  %xmm0,-0xec(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x378(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x374(%rbp),%xmm0
ff
movlpd %xmm1,-0xf8(%rbp)
ff
movss  -0xf8(%rbp),%xmm3
ff
movss  -0xf4(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    166d <test3f+0x51d>
jmp    1674 <test3f+0x524>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x38c(%rbp)
ff
movss  -0x4(%rbp),%xmm0
movss  %xmm0,-0x390(%rbp)
ff
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
movss  %xmm1,-0x100(%rbp)
ff
movss  %xmm0,-0xfc(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movss  -0x390(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x38c(%rbp),%xmm0
ff
movlpd %xmm2,-0x108(%rbp)
ff
movss  -0x108(%rbp),%xmm2
ff
movss  -0x104(%rbp),%xmm3
ff
call   2f50 <__divsc3>
movlpd %xmm0,-0x110(%rbp)
ff
movss  -0x110(%rbp),%xmm1
ff
movss  -0x10c(%rbp),%xmm0
ff
movss  %xmm1,-0x118(%rbp)
ff
movss  %xmm0,-0x114(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0x120(%rbp)
ff
movss  -0x120(%rbp),%xmm0
ff
movss  %xmm0,-0x380(%rbp)
ff
movss  -0x11c(%rbp),%xmm0
ff
movss  %xmm0,-0x37c(%rbp)
ff
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movaps 0x28ad(%rip),%xmm2
pxor   %xmm2,%xmm1
movss  %xmm1,-0x384(%rbp)
ff
pxor   %xmm2,%xmm0
movss  %xmm0,-0x388(%rbp)
ff
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
pxor   %xmm2,%xmm1
pxor   %xmm2,%xmm0
movss  %xmm1,-0x128(%rbp)
ff
movss  %xmm0,-0x124(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movss  -0x388(%rbp),%xmm1
ff
movaps %xmm0,%xmm2
movss  -0x384(%rbp),%xmm0
ff
movlpd %xmm2,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm2
ff
movss  -0x12c(%rbp),%xmm3
ff
call   2f50 <__divsc3>
movlpd %xmm0,-0x138(%rbp)
ff
movss  -0x138(%rbp),%xmm1
ff
movss  -0x134(%rbp),%xmm0
ff
movss  %xmm1,-0x140(%rbp)
ff
movss  %xmm0,-0x13c(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x380(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x37c(%rbp),%xmm0
ff
movlpd %xmm1,-0x148(%rbp)
ff
movss  -0x148(%rbp),%xmm3
ff
movss  -0x144(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    184f <test3f+0x6ff>
jmp    1856 <test3f+0x706>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x3b0(%rbp)
ff
movss  -0x4(%rbp),%xmm2
movss  %xmm2,-0x3ac(%rbp)
ff
movss  -0x10(%rbp),%xmm4
movss  %xmm4,-0x3a8(%rbp)
ff
movss  -0xc(%rbp),%xmm5
movss  %xmm5,-0x3a4(%rbp)
ff
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0x3a0(%rbp)
ff
addss  %xmm2,%xmm0
movss  %xmm0,-0x39c(%rbp)
ff
ucomiss %xmm1,%xmm1
movss  %xmm1,-0x398(%rbp)
ff
movss  %xmm0,-0x394(%rbp)
ff
jnp    1947 <test3f+0x7f7>
movss  -0x39c(%rbp),%xmm0
ff
movss  -0x3a0(%rbp),%xmm1
ff
ucomiss %xmm0,%xmm0
movss  %xmm1,-0x398(%rbp)
ff
movss  %xmm0,-0x394(%rbp)
ff
jnp    1947 <test3f+0x7f7>
movss  -0x3a4(%rbp),%xmm3
ff
movss  -0x3a8(%rbp),%xmm2
ff
movss  -0x3ac(%rbp),%xmm1
ff
movss  -0x3b0(%rbp),%xmm0
ff
call   2cc0 <__mulsc3>
movlpd %xmm0,-0x150(%rbp)
ff
movss  -0x150(%rbp),%xmm1
ff
movss  -0x14c(%rbp),%xmm0
ff
movss  %xmm1,-0x398(%rbp)
ff
movss  %xmm0,-0x394(%rbp)
ff
movss  -0x398(%rbp),%xmm1
ff
movss  -0x394(%rbp),%xmm0
ff
movss  %xmm1,-0x158(%rbp)
ff
movss  %xmm0,-0x154(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0x160(%rbp)
ff
movss  -0x160(%rbp),%xmm0
ff
movss  %xmm0,-0x3d8(%rbp)
ff
movss  -0x15c(%rbp),%xmm0
ff
movss  %xmm0,-0x3d4(%rbp)
ff
movss  -0x8(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x3d0(%rbp)
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
movss  %xmm2,-0x3cc(%rbp)
ff
movss  -0x10(%rbp),%xmm4
movss  %xmm4,-0x3c8(%rbp)
ff
movss  -0xc(%rbp),%xmm5
movss  %xmm5,-0x3c4(%rbp)
ff
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0x3c0(%rbp)
ff
addss  %xmm2,%xmm0
movss  %xmm0,-0x3bc(%rbp)
ff
ucomiss %xmm1,%xmm1
movss  %xmm1,-0x3b8(%rbp)
ff
movss  %xmm0,-0x3b4(%rbp)
ff
jnp    1aa7 <test3f+0x957>
movss  -0x3bc(%rbp),%xmm0
ff
movss  -0x3c0(%rbp),%xmm1
ff
ucomiss %xmm0,%xmm0
movss  %xmm1,-0x3b8(%rbp)
ff
movss  %xmm0,-0x3b4(%rbp)
ff
jnp    1aa7 <test3f+0x957>
movss  -0x3c4(%rbp),%xmm3
ff
movss  -0x3c8(%rbp),%xmm2
ff
movss  -0x3cc(%rbp),%xmm1
ff
movss  -0x3d0(%rbp),%xmm0
ff
call   2cc0 <__mulsc3>
movlpd %xmm0,-0x168(%rbp)
ff
movss  -0x168(%rbp),%xmm1
ff
movss  -0x164(%rbp),%xmm0
ff
movss  %xmm1,-0x3b8(%rbp)
ff
movss  %xmm0,-0x3b4(%rbp)
ff
movss  -0x3b8(%rbp),%xmm1
ff
movss  -0x3b4(%rbp),%xmm0
ff
movss  %xmm1,-0x170(%rbp)
ff
movss  %xmm0,-0x16c(%rbp)
ff
movsd  -0x170(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x3d8(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x3d4(%rbp),%xmm0
ff
movlpd %xmm1,-0x178(%rbp)
ff
movss  -0x178(%rbp),%xmm3
ff
movss  -0x174(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1b24 <test3f+0x9d4>
jmp    1b2b <test3f+0x9db>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x3f8(%rbp)
ff
movss  -0x4(%rbp),%xmm2
movss  %xmm2,-0x3f4(%rbp)
ff
movss  -0x10(%rbp),%xmm4
movss  %xmm4,-0x3f0(%rbp)
ff
movss  -0xc(%rbp),%xmm5
movss  %xmm5,-0x3ec(%rbp)
ff
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0x3e8(%rbp)
ff
addss  %xmm2,%xmm0
movss  %xmm0,-0x3e4(%rbp)
ff
ucomiss %xmm1,%xmm1
movss  %xmm1,-0x3e0(%rbp)
ff
movss  %xmm0,-0x3dc(%rbp)
ff
jnp    1c1c <test3f+0xacc>
movss  -0x3e4(%rbp),%xmm0
ff
movss  -0x3e8(%rbp),%xmm1
ff
ucomiss %xmm0,%xmm0
movss  %xmm1,-0x3e0(%rbp)
ff
movss  %xmm0,-0x3dc(%rbp)
ff
jnp    1c1c <test3f+0xacc>
movss  -0x3ec(%rbp),%xmm3
ff
movss  -0x3f0(%rbp),%xmm2
ff
movss  -0x3f4(%rbp),%xmm1
ff
movss  -0x3f8(%rbp),%xmm0
ff
call   2cc0 <__mulsc3>
movlpd %xmm0,-0x180(%rbp)
ff
movss  -0x180(%rbp),%xmm1
ff
movss  -0x17c(%rbp),%xmm0
ff
movss  %xmm1,-0x3e0(%rbp)
ff
movss  %xmm0,-0x3dc(%rbp)
ff
movss  -0x3e0(%rbp),%xmm1
ff
movss  -0x3dc(%rbp),%xmm0
ff
movss  %xmm1,-0x188(%rbp)
ff
movss  %xmm0,-0x184(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0x190(%rbp)
ff
movss  -0x190(%rbp),%xmm0
ff
movss  %xmm0,-0x420(%rbp)
ff
movss  -0x18c(%rbp),%xmm0
ff
movss  %xmm0,-0x41c(%rbp)
ff
movss  -0x8(%rbp),%xmm0
movss  %xmm0,-0x418(%rbp)
ff
movss  -0x4(%rbp),%xmm2
movss  %xmm2,-0x414(%rbp)
ff
movss  -0x10(%rbp),%xmm3
movss  -0xc(%rbp),%xmm1
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
movss  %xmm4,-0x410(%rbp)
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movss  %xmm5,-0x40c(%rbp)
ff
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0x408(%rbp)
ff
addss  %xmm2,%xmm0
movss  %xmm0,-0x404(%rbp)
ff
ucomiss %xmm1,%xmm1
movss  %xmm1,-0x400(%rbp)
ff
movss  %xmm0,-0x3fc(%rbp)
ff
jnp    1d7c <test3f+0xc2c>
movss  -0x404(%rbp),%xmm0
ff
movss  -0x408(%rbp),%xmm1
ff
ucomiss %xmm0,%xmm0
movss  %xmm1,-0x400(%rbp)
ff
movss  %xmm0,-0x3fc(%rbp)
ff
jnp    1d7c <test3f+0xc2c>
movss  -0x40c(%rbp),%xmm3
ff
movss  -0x410(%rbp),%xmm2
ff
movss  -0x414(%rbp),%xmm1
ff
movss  -0x418(%rbp),%xmm0
ff
call   2cc0 <__mulsc3>
movlpd %xmm0,-0x198(%rbp)
ff
movss  -0x198(%rbp),%xmm1
ff
movss  -0x194(%rbp),%xmm0
ff
movss  %xmm1,-0x400(%rbp)
ff
movss  %xmm0,-0x3fc(%rbp)
ff
movss  -0x400(%rbp),%xmm1
ff
movss  -0x3fc(%rbp),%xmm0
ff
movss  %xmm1,-0x1a0(%rbp)
ff
movss  %xmm0,-0x19c(%rbp)
ff
movsd  -0x1a0(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x420(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x41c(%rbp),%xmm0
ff
movlpd %xmm1,-0x1a8(%rbp)
ff
movss  -0x1a8(%rbp),%xmm3
ff
movss  -0x1a4(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    1df9 <test3f+0xca9>
jmp    1e00 <test3f+0xcb0>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  %xmm1,-0x1b0(%rbp)
ff
movss  %xmm0,-0x1ac(%rbp)
ff
movsd  -0x1b0(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movlpd %xmm0,-0x1b8(%rbp)
ff
movss  -0x1b8(%rbp),%xmm0
ff
movss  %xmm0,-0x440(%rbp)
ff
movss  -0x1b4(%rbp),%xmm2
ff
movss  %xmm2,-0x43c(%rbp)
ff
movss  -0x10(%rbp),%xmm4
movss  %xmm4,-0x438(%rbp)
ff
movss  -0xc(%rbp),%xmm5
movss  %xmm5,-0x434(%rbp)
ff
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0x430(%rbp)
ff
addss  %xmm2,%xmm0
movss  %xmm0,-0x42c(%rbp)
ff
ucomiss %xmm1,%xmm1
movss  %xmm1,-0x428(%rbp)
ff
movss  %xmm0,-0x424(%rbp)
ff
jnp    1f26 <test3f+0xdd6>
movss  -0x42c(%rbp),%xmm0
ff
movss  -0x430(%rbp),%xmm1
ff
ucomiss %xmm0,%xmm0
movss  %xmm1,-0x428(%rbp)
ff
movss  %xmm0,-0x424(%rbp)
ff
jnp    1f26 <test3f+0xdd6>
movss  -0x434(%rbp),%xmm3
ff
movss  -0x438(%rbp),%xmm2
ff
movss  -0x43c(%rbp),%xmm1
ff
movss  -0x440(%rbp),%xmm0
ff
call   2cc0 <__mulsc3>
movlpd %xmm0,-0x1c0(%rbp)
ff
movss  -0x1c0(%rbp),%xmm1
ff
movss  -0x1bc(%rbp),%xmm0
ff
movss  %xmm1,-0x428(%rbp)
ff
movss  %xmm0,-0x424(%rbp)
ff
movss  -0x428(%rbp),%xmm1
ff
movss  -0x424(%rbp),%xmm0
ff
movss  %xmm1,-0x1c8(%rbp)
ff
movss  %xmm0,-0x1c4(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0x1d0(%rbp)
ff
movss  -0x1d0(%rbp),%xmm0
ff
movss  %xmm0,-0x468(%rbp)
ff
movss  -0x1cc(%rbp),%xmm0
ff
movss  %xmm0,-0x464(%rbp)
ff
movaps 0x207e(%rip),%xmm2
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
pxor   %xmm2,%xmm1
pxor   %xmm2,%xmm0
movss  %xmm1,-0x1d8(%rbp)
ff
movss  %xmm0,-0x1d4(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movlpd %xmm0,-0x1e0(%rbp)
ff
movss  -0x1e0(%rbp),%xmm0
ff
movss  %xmm0,-0x460(%rbp)
ff
movss  -0x1dc(%rbp),%xmm2
ff
movss  %xmm2,-0x45c(%rbp)
ff
movss  -0x10(%rbp),%xmm3
movss  -0xc(%rbp),%xmm1
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm4
movss  %xmm4,-0x458(%rbp)
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm5
movss  %xmm5,-0x454(%rbp)
movaps %xmm0,%xmm1
mulss  %xmm4,%xmm1
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  %xmm5,%xmm0
mulss  %xmm4,%xmm2
subss  %xmm3,%xmm1
movss  %xmm1,-0x450(%rbp)
ff
addss  %xmm2,%xmm0
movss  %xmm0,-0x44c(%rbp)
ff
ucomiss %xmm1,%xmm1
movss  %xmm1,-0x448(%rbp)
ff
movss  %xmm0,-0x444(%rbp)
ff
jnp    20ca <test3f+0xf7a>
movss  -0x44c(%rbp),%xmm0
ff
movss  -0x450(%rbp),%xmm1
ff
ucomiss %xmm0,%xmm0
movss  %xmm1,-0x448(%rbp)
ff
movss  %xmm0,-0x444(%rbp)
ff
jnp    20ca <test3f+0xf7a>
movss  -0x454(%rbp),%xmm3
ff
movss  -0x458(%rbp),%xmm2
ff
movss  -0x45c(%rbp),%xmm1
ff
movss  -0x460(%rbp),%xmm0
ff
call   2cc0 <__mulsc3>
movlpd %xmm0,-0x1e8(%rbp)
ff
movss  -0x1e8(%rbp),%xmm1
ff
movss  -0x1e4(%rbp),%xmm0
ff
movss  %xmm1,-0x448(%rbp)
ff
movss  %xmm0,-0x444(%rbp)
ff
movss  -0x448(%rbp),%xmm1
ff
movss  -0x444(%rbp),%xmm0
ff
movss  %xmm1,-0x1f0(%rbp)
ff
movss  %xmm0,-0x1ec(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x468(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x464(%rbp),%xmm0
ff
movlpd %xmm1,-0x1f8(%rbp)
ff
movss  -0x1f8(%rbp),%xmm3
ff
movss  -0x1f4(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2147 <test3f+0xff7>
jmp    214e <test3f+0xffe>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm3
call   2f50 <__divsc3>
movlpd %xmm0,-0x200(%rbp)
ff
movss  -0x200(%rbp),%xmm1
ff
movss  -0x1fc(%rbp),%xmm0
ff
movss  %xmm1,-0x208(%rbp)
ff
movss  %xmm0,-0x204(%rbp)
ff
movsd  -0x208(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movlpd %xmm0,-0x210(%rbp)
ff
movss  -0x210(%rbp),%xmm1
ff
movss  -0x20c(%rbp),%xmm0
ff
movss  %xmm1,-0x218(%rbp)
ff
movss  %xmm0,-0x214(%rbp)
ff
movsd  -0x218(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0x220(%rbp)
ff
movss  -0x220(%rbp),%xmm0
ff
movss  %xmm0,-0x470(%rbp)
ff
movss  -0x21c(%rbp),%xmm0
ff
movss  %xmm0,-0x46c(%rbp)
ff
movss  -0x8(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm3
movaps 0x1dec(%rip),%xmm4
movaps %xmm4,-0x480(%rbp)
pxor   %xmm4,%xmm2
pxor   %xmm4,%xmm3
call   2f50 <__divsc3>
movlpd %xmm0,-0x228(%rbp)
ff
movss  -0x228(%rbp),%xmm1
ff
movss  -0x224(%rbp),%xmm0
ff
movss  %xmm1,-0x230(%rbp)
ff
movss  %xmm0,-0x22c(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movaps -0x480(%rbp),%xmm2
movlpd %xmm0,-0x238(%rbp)
ff
movss  -0x238(%rbp),%xmm1
ff
movss  -0x234(%rbp),%xmm0
ff
pxor   %xmm2,%xmm1
pxor   %xmm2,%xmm0
movss  %xmm1,-0x240(%rbp)
ff
movss  %xmm0,-0x23c(%rbp)
ff
movsd  -0x240(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x470(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x46c(%rbp),%xmm0
ff
movlpd %xmm1,-0x248(%rbp)
ff
movss  -0x248(%rbp),%xmm3
ff
movss  -0x244(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    22f1 <test3f+0x11a1>
jmp    22f8 <test3f+0x11a8>
mov    $0x0,%al
call   1060 <link_error@plt>
cmpl   $0x0,-0x14(%rbp)
je     2321 <test3f+0x11d1>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  %xmm1,-0x488(%rbp)
ff
movss  %xmm0,-0x484(%rbp)
ff
jmp    233b <test3f+0x11eb>
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
movss  %xmm1,-0x488(%rbp)
ff
movss  %xmm0,-0x484(%rbp)
ff
movss  -0x488(%rbp),%xmm1
ff
movss  -0x484(%rbp),%xmm0
ff
movss  %xmm1,-0x250(%rbp)
ff
movss  %xmm0,-0x24c(%rbp)
ff
movsd  -0x250(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0x258(%rbp)
ff
movss  -0x258(%rbp),%xmm0
ff
movss  %xmm0,-0x490(%rbp)
ff
movss  -0x254(%rbp),%xmm0
ff
movss  %xmm0,-0x48c(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
je     23d3 <test3f+0x1283>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm1,-0x498(%rbp)
ff
movss  %xmm0,-0x494(%rbp)
ff
jmp    23ed <test3f+0x129d>
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
movss  %xmm1,-0x498(%rbp)
ff
movss  %xmm0,-0x494(%rbp)
ff
movss  -0x498(%rbp),%xmm1
ff
movss  -0x494(%rbp),%xmm0
ff
movss  %xmm1,-0x260(%rbp)
ff
movss  %xmm0,-0x25c(%rbp)
ff
movsd  -0x260(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x490(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x48c(%rbp),%xmm0
ff
movlpd %xmm1,-0x268(%rbp)
ff
movss  -0x268(%rbp),%xmm3
ff
movss  -0x264(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    246a <test3f+0x131a>
jmp    2471 <test3f+0x1321>
mov    $0x0,%al
call   1060 <link_error@plt>
cmpl   $0x0,-0x14(%rbp)
je     249a <test3f+0x134a>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  %xmm1,-0x4a0(%rbp)
ff
movss  %xmm0,-0x49c(%rbp)
ff
jmp    24b4 <test3f+0x1364>
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
movss  %xmm1,-0x4a0(%rbp)
ff
movss  %xmm0,-0x49c(%rbp)
ff
movss  -0x4a0(%rbp),%xmm1
ff
movss  -0x49c(%rbp),%xmm0
ff
movss  %xmm1,-0x270(%rbp)
ff
movss  %xmm0,-0x26c(%rbp)
ff
movsd  -0x270(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0x278(%rbp)
ff
movss  -0x278(%rbp),%xmm0
ff
movss  %xmm0,-0x4a8(%rbp)
ff
movss  -0x274(%rbp),%xmm0
movss  %xmm0,-0x4a4(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
je     2532 <test3f+0x13e2>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  %xmm1,-0x4b0(%rbp)
ff
movss  %xmm0,-0x4ac(%rbp)
ff
jmp    2566 <test3f+0x1416>
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm1,-0x4b0(%rbp)
ff
movss  %xmm0,-0x4ac(%rbp)
ff
movss  -0x4b0(%rbp),%xmm1
ff
movss  -0x4ac(%rbp),%xmm0
ff
movss  %xmm1,-0x280(%rbp)
ff
movss  %xmm0,-0x27c(%rbp)
ff
movsd  -0x280(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x4a8(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x4a4(%rbp),%xmm0
ff
movlpd %xmm1,-0x288(%rbp)
ff
movss  -0x288(%rbp),%xmm3
ff
movss  -0x284(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    25e3 <test3f+0x1493>
jmp    25ea <test3f+0x149a>
mov    $0x0,%al
call   1060 <link_error@plt>
cmpl   $0x0,-0x14(%rbp)
je     2613 <test3f+0x14c3>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  %xmm1,-0x4b8(%rbp)
ff
movss  %xmm0,-0x4b4(%rbp)
ff
jmp    2689 <test3f+0x1539>
movss  -0x10(%rbp),%xmm0
movss  -0xc(%rbp),%xmm1
movss  -0x8(%rbp),%xmm2
movss  -0x4(%rbp),%xmm3
call   2f50 <__divsc3>
movlpd %xmm0,-0x290(%rbp)
ff
movss  -0x290(%rbp),%xmm1
ff
movss  -0x28c(%rbp),%xmm0
ff
movss  %xmm1,-0x298(%rbp)
ff
movss  %xmm0,-0x294(%rbp)
ff
movsd  -0x298(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movlpd %xmm0,-0x2a0(%rbp)
ff
movss  -0x2a0(%rbp),%xmm1
ff
movss  -0x29c(%rbp),%xmm0
ff
movss  %xmm1,-0x4b8(%rbp)
ff
movss  %xmm0,-0x4b4(%rbp)
ff
movss  -0x4b8(%rbp),%xmm1
ff
movss  -0x4b4(%rbp),%xmm0
ff
movss  %xmm1,-0x2a8(%rbp)
ff
movss  %xmm0,-0x2a4(%rbp)
ff
movsd  -0x2a8(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movlpd %xmm0,-0x2b0(%rbp)
ff
movss  -0x2b0(%rbp),%xmm0
ff
movss  %xmm0,-0x4c0(%rbp)
ff
movss  -0x2ac(%rbp),%xmm0
ff
movss  %xmm0,-0x4bc(%rbp)
ff
cmpl   $0x0,-0x14(%rbp)
je     2721 <test3f+0x15d1>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm1,-0x4c8(%rbp)
ff
movss  %xmm0,-0x4c4(%rbp)
ff
jmp    27c0 <test3f+0x1670>
movaps 0x18d8(%rip),%xmm2
movss  -0x10(%rbp),%xmm0
movss  -0xc(%rbp),%xmm1
pxor   %xmm2,%xmm0
pxor   %xmm2,%xmm1
movss  -0x8(%rbp),%xmm2
movss  -0x4(%rbp),%xmm3
call   2f50 <__divsc3>
movlpd %xmm0,-0x2b8(%rbp)
ff
movss  -0x2b8(%rbp),%xmm1
ff
movss  -0x2b4(%rbp),%xmm0
ff
movss  %xmm1,-0x2c0(%rbp)
ff
movss  %xmm0,-0x2bc(%rbp)
ff
movsd  -0x2c0(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movlpd %xmm0,-0x2c8(%rbp)
ff
movss  -0x2c8(%rbp),%xmm1
ff
movss  -0x2c4(%rbp),%xmm0
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm1,-0x4c8(%rbp)
ff
movss  %xmm0,-0x4c4(%rbp)
ff
movss  -0x4c8(%rbp),%xmm1
ff
movss  -0x4c4(%rbp),%xmm0
ff
movss  %xmm1,-0x2d0(%rbp)
ff
movss  %xmm0,-0x2cc(%rbp)
ff
movsd  -0x2d0(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x4c0(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x4bc(%rbp),%xmm0
ff
movlpd %xmm1,-0x2d8(%rbp)
ff
movss  -0x2d8(%rbp),%xmm3
ff
movss  -0x2d4(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    283d <test3f+0x16ed>
jmp    2844 <test3f+0x16f4>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm2
movss  -0x4(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x8(%rbp),%xmm3
movss  -0x4(%rbp),%xmm1
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    28cb <test3f+0x177b>
jmp    28d2 <test3f+0x1782>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movaps 0x171d(%rip),%xmm2
movaps %xmm2,-0x4e0(%rbp)
pxor   %xmm2,%xmm0
movss  %xmm1,-0x2e0(%rbp)
ff
movss  %xmm0,-0x2dc(%rbp)
ff
movsd  -0x2e0(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movaps -0x4e0(%rbp),%xmm2
movlpd %xmm0,-0x2e8(%rbp)
ff
movss  -0x2e8(%rbp),%xmm0
ff
movss  %xmm0,-0x4d0(%rbp)
ff
movss  -0x2e4(%rbp),%xmm0
ff
movss  %xmm0,-0x4cc(%rbp)
ff
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
pxor   %xmm2,%xmm0
movss  %xmm1,-0x2f0(%rbp)
ff
movss  %xmm0,-0x2ec(%rbp)
ff
movsd  -0x2f0(%rbp),%xmm0
ff
call   1040 <ccosf@plt>
movss  -0x4d0(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x4cc(%rbp),%xmm0
ff
movlpd %xmm1,-0x2f8(%rbp)
ff
movss  -0x2f8(%rbp),%xmm3
ff
movss  -0x2f4(%rbp),%xmm1
ff
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    29b5 <test3f+0x1865>
jmp    29bc <test3f+0x186c>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  -0x10(%rbp),%xmm3
movss  -0xc(%rbp),%xmm2
subss  %xmm3,%xmm1
subss  %xmm2,%xmm0
movaps 0x1621(%rip),%xmm2
movaps %xmm2,-0x500(%rbp)
pxor   %xmm2,%xmm0
movss  %xmm1,-0x300(%rbp)
ff
movss  %xmm0,-0x2fc(%rbp)
ff
movsd  -0x300(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movaps -0x500(%rbp),%xmm2
movlpd %xmm0,-0x308(%rbp)
ff
movss  -0x308(%rbp),%xmm0
ff
movss  %xmm0,-0x4e8(%rbp)
ff
movss  -0x304(%rbp),%xmm0
ff
movss  %xmm0,-0x4e4(%rbp)
ff
movss  -0x10(%rbp),%xmm1
movss  -0xc(%rbp),%xmm0
movss  -0x8(%rbp),%xmm4
movss  -0x4(%rbp),%xmm3
subss  %xmm4,%xmm1
subss  %xmm3,%xmm0
pxor   %xmm2,%xmm0
movss  %xmm1,-0x310(%rbp)
ff
movss  %xmm0,-0x30c(%rbp)
ff
movsd  -0x310(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movss  -0x4e8(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x4e4(%rbp),%xmm0
ff
movlpd %xmm1,-0x318(%rbp)
ff
movss  -0x318(%rbp),%xmm3
ff
movss  -0x314(%rbp),%xmm1
ff
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2add <test3f+0x198d>
jmp    2ae4 <test3f+0x1994>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm3
call   2f50 <__divsc3>
movlpd %xmm0,-0x320(%rbp)
ff
movss  -0x320(%rbp),%xmm1
ff
movss  -0x31c(%rbp),%xmm0
ff
movaps 0x14e4(%rip),%xmm2
movaps %xmm2,-0x520(%rbp)
pxor   %xmm2,%xmm0
movss  %xmm1,-0x328(%rbp)
ff
movss  %xmm0,-0x324(%rbp)
ff
movsd  -0x328(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movaps -0x520(%rbp),%xmm4
movlpd %xmm0,-0x330(%rbp)
ff
movss  -0x330(%rbp),%xmm0
ff
movss  %xmm0,-0x508(%rbp)
ff
movss  -0x32c(%rbp),%xmm0
ff
movss  %xmm0,-0x504(%rbp)
ff
movss  -0x8(%rbp),%xmm0
movss  -0x4(%rbp),%xmm1
movss  -0x10(%rbp),%xmm2
movss  -0xc(%rbp),%xmm3
pxor   %xmm4,%xmm2
pxor   %xmm4,%xmm3
call   2f50 <__divsc3>
movaps -0x520(%rbp),%xmm2
movlpd %xmm0,-0x338(%rbp)
ff
movss  -0x338(%rbp),%xmm1
ff
movss  -0x334(%rbp),%xmm0
ff
pxor   %xmm2,%xmm0
movss  %xmm1,-0x340(%rbp)
ff
movss  %xmm0,-0x33c(%rbp)
ff
movsd  -0x340(%rbp),%xmm0
ff
call   1050 <ctanf@plt>
movss  -0x508(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movss  -0x504(%rbp),%xmm0
ff
movlpd %xmm1,-0x348(%rbp)
ff
movss  -0x348(%rbp),%xmm3
ff
movss  -0x344(%rbp),%xmm1
ff
movd   %xmm3,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm3
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
ucomiss %xmm3,%xmm2
setne  %al
setp   %cl
or     %cl,%al
ucomiss %xmm1,%xmm0
setne  %cl
setp   %dl
or     %dl,%cl
or     %cl,%al
test   $0x1,%al
jne    2c3e <test3f+0x1aee>
jmp    2c45 <test3f+0x1af5>
mov    $0x0,%al
call   1060 <link_error@plt>
movss  -0x8(%rbp),%xmm1
movss  -0x4(%rbp),%xmm0
movss  %xmm1,-0x350(%rbp)
ff
movss  %xmm0,-0x34c(%rbp)
ff
movsd  -0x350(%rbp),%xmm0
ff
call   1030 <cargf@plt>
movss  %xmm0,-0x524(%rbp)
ff
movss  -0x4(%rbp),%xmm0
movss  -0x8(%rbp),%xmm1
call   1070 <atan2f@plt>
movaps %xmm0,%xmm1
movss  -0x524(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jne    2ca2 <test3f+0x1b52>
jp     2ca2 <test3f+0x1b52>
jmp    2ca9 <test3f+0x1b59>
mov    $0x0,%al
call   1060 <link_error@plt>
add    $0x530,%rsp
pop    %rbp
ret
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)

x86 assembly (clang, -O2):
<test3f>:
push   %rbx
sub    $0x140,%rsp
mov    %edi,%ebx
movaps %xmm0,(%rsp)
movaps %xmm0,%xmm2
shufps $0x55,%xmm0,%xmm2
movaps %xmm2,0x30(%rsp)
movaps %xmm1,0x10(%rsp)
shufps $0x55,%xmm1,%xmm1
movaps %xmm1,0x50(%rsp)
call   1040 <ccosf@plt>
movaps %xmm0,0x40(%rsp)
movaps 0xe77(%rip),%xmm0
xorps  (%rsp),%xmm0
movaps %xmm0,0x60(%rsp)
call   1040 <ccosf@plt>
movaps 0x40(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    11b0 <test3f+0x60>
jp     11b0 <test3f+0x60>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     11b7 <test3f+0x67>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm0
call   1050 <ctanf@plt>
call   1040 <ccosf@plt>
movaps %xmm0,0x40(%rsp)
movaps 0x60(%rsp),%xmm0
call   1050 <ctanf@plt>
call   1040 <ccosf@plt>
movaps 0x40(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    11f2 <test3f+0xa2>
jp     11f2 <test3f+0xa2>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     11f9 <test3f+0xa9>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm1
subps  0x10(%rsp),%xmm1
movaps 0x30(%rsp),%xmm0
subss  0x50(%rsp),%xmm0
movaps %xmm0,0x120(%rsp)
movlhps %xmm1,%xmm0
movaps %xmm1,0x130(%rsp)
shufps $0xe2,%xmm1,%xmm0
call   1050 <ctanf@plt>
movaps %xmm0,0x40(%rsp)
movaps 0x10(%rsp),%xmm1
subps  (%rsp),%xmm1
movaps 0x50(%rsp),%xmm0
subss  0x30(%rsp),%xmm0
movaps %xmm0,0x100(%rsp)
movlhps %xmm1,%xmm0
movaps %xmm1,0x110(%rsp)
shufps $0xe2,%xmm1,%xmm0
call   1050 <ctanf@plt>
movaps 0xd9b(%rip),%xmm2
movaps %xmm0,%xmm1
xorps  %xmm2,%xmm1
movaps 0x40(%rsp),%xmm3
ucomiss %xmm1,%xmm3
jne    128c <test3f+0x13c>
jp     128c <test3f+0x13c>
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
shufps $0x55,%xmm0,%xmm0
xorps  %xmm2,%xmm0
ucomiss %xmm0,%xmm1
jne    128c <test3f+0x13c>
jnp    1293 <test3f+0x143>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movaps 0x10(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
call   1d40 <__divsc3>
call   1040 <ccosf@plt>
movaps %xmm0,0x40(%rsp)
movaps 0x60(%rsp),%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps %xmm1,0x70(%rsp)
movaps 0x10(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
call   1d40 <__divsc3>
call   1040 <ccosf@plt>
movaps 0x40(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    12f3 <test3f+0x1a3>
jp     12f3 <test3f+0x1a3>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     12fa <test3f+0x1aa>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movaps 0x10(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
call   1d40 <__divsc3>
call   1040 <ccosf@plt>
movaps %xmm0,0x20(%rsp)
movdqa 0xcdc(%rip),%xmm2
pxor   0x10(%rsp),%xmm2
pshufd $0x55,%xmm2,%xmm3
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movdqa %xmm2,0x40(%rsp)
movdqa %xmm3,0x80(%rsp)
call   1d40 <__divsc3>
call   1040 <ccosf@plt>
movaps 0x20(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    136a <test3f+0x21a>
jp     136a <test3f+0x21a>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     1371 <test3f+0x221>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps 0x10(%rsp),%xmm0
call   1050 <ctanf@plt>
movaps %xmm0,%xmm2
movaps %xmm0,%xmm3
shufps $0x55,%xmm0,%xmm3
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
call   1d40 <__divsc3>
call   1040 <ccosf@plt>
movaps %xmm0,0x20(%rsp)
movaps 0x40(%rsp),%xmm0
call   1050 <ctanf@plt>
movaps %xmm0,%xmm2
movaps %xmm0,%xmm3
shufps $0x55,%xmm0,%xmm3
movaps 0x60(%rsp),%xmm0
movaps 0x70(%rsp),%xmm1
call   1d40 <__divsc3>
call   1040 <ccosf@plt>
movaps 0x20(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    13de <test3f+0x28e>
jp     13de <test3f+0x28e>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     13e5 <test3f+0x295>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps 0x50(%rsp),%xmm1
movaps (%rsp),%xmm0
mulps  %xmm0,%xmm1
movaps %xmm1,0xa0(%rsp)
movaps %xmm1,%xmm2
shufps $0xe1,%xmm1,%xmm2
movaps 0x10(%rsp),%xmm1
shufps $0x0,%xmm1,%xmm1
movaps %xmm1,0xf0(%rsp)
movaps %xmm1,%xmm3
mulps  %xmm0,%xmm3
movaps %xmm3,%xmm1
subps  %xmm2,%xmm1
movaps %xmm3,0xc0(%rsp)
movaps %xmm3,%xmm0
movaps %xmm2,0x20(%rsp)
addps  %xmm2,%xmm0
movaps %xmm0,0xb0(%rsp)
shufps $0x1,%xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
movaps %xmm1,0xe0(%rsp)
ucomiss %xmm1,%xmm1
movaps %xmm0,0x90(%rsp)
jp     197b <test3f+0x82b>
call   1040 <ccosf@plt>
movaps %xmm0,0xd0(%rsp)
movaps 0x70(%rsp),%xmm1
mulss  0x10(%rsp),%xmm1
movaps 0x20(%rsp),%xmm2
subps  0xc0(%rsp),%xmm2
movaps 0xa0(%rsp),%xmm0
subss  %xmm0,%xmm1
ucomiss %xmm2,%xmm2
movaps %xmm2,%xmm0
movaps %xmm2,0x20(%rsp)
jp     19b5 <test3f+0x865>
unpcklps %xmm1,%xmm0
call   1040 <ccosf@plt>
movaps 0xd0(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    14bf <test3f+0x36f>
jp     14bf <test3f+0x36f>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     14c6 <test3f+0x376>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps 0xe0(%rsp),%xmm0
ucomiss %xmm0,%xmm0
jp     19e3 <test3f+0x893>
movaps 0x90(%rsp),%xmm0
call   1040 <ccosf@plt>
movaps %xmm0,0x90(%rsp)
movaps 0x20(%rsp),%xmm2
ucomiss %xmm2,%xmm2
movaps 0x30(%rsp),%xmm1
mulss  0x40(%rsp),%xmm1
subss  0xa0(%rsp),%xmm1
movaps %xmm1,%xmm0
movlhps %xmm2,%xmm0
shufps $0xe2,%xmm2,%xmm0
jp     1a1d <test3f+0x8cd>
call   1040 <ccosf@plt>
movaps 0x90(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    1539 <test3f+0x3e9>
jp     1539 <test3f+0x3e9>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     1540 <test3f+0x3f0>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm0
call   1050 <ctanf@plt>
movaps 0x50(%rsp),%xmm1
mulps  %xmm0,%xmm1
shufps $0xe1,%xmm1,%xmm1
movaps 0xf0(%rsp),%xmm3
mulps  %xmm0,%xmm3
movaps %xmm3,%xmm2
subps  %xmm1,%xmm2
addps  %xmm1,%xmm3
movaps %xmm3,%xmm1
shufps $0x1,%xmm2,%xmm1
shufps $0xe2,%xmm2,%xmm1
ucomiss %xmm2,%xmm2
jp     1a46 <test3f+0x8f6>
movaps %xmm1,%xmm0
call   1040 <ccosf@plt>
movaps %xmm0,0x20(%rsp)
movaps 0x60(%rsp),%xmm0
call   1050 <ctanf@plt>
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps 0x40(%rsp),%xmm2
movaps 0x10(%rsp),%xmm4
shufps $0x10,%xmm4,%xmm2
shufps $0xe2,%xmm4,%xmm2
mulps  %xmm1,%xmm2
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
mulps  %xmm4,%xmm3
subps  %xmm3,%xmm2
ucomiss %xmm2,%xmm2
jp     1a71 <test3f+0x921>
movaps %xmm2,%xmm0
call   1040 <ccosf@plt>
movaps 0x20(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    15e7 <test3f+0x497>
jp     15e7 <test3f+0x497>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     15ee <test3f+0x49e>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movaps 0x10(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
call   1d40 <__divsc3>
call   1050 <ctanf@plt>
call   1040 <ccosf@plt>
movaps %xmm0,0x20(%rsp)
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps 0x80(%rsp),%xmm3
call   1d40 <__divsc3>
call   1050 <ctanf@plt>
xorps  0x9c4(%rip),%xmm0
call   1040 <ccosf@plt>
movaps 0x20(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    165a <test3f+0x50a>
jp     165a <test3f+0x50a>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     1661 <test3f+0x511>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps 0x10(%rsp),%xmm1
movaps %xmm1,%xmm0
movaps 0x50(%rsp),%xmm2
test   %ebx,%ebx
je     167b <test3f+0x52b>
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm2
unpcklps %xmm2,%xmm0
movaps %xmm1,%xmm2
movaps 0x50(%rsp),%xmm1
je     1692 <test3f+0x542>
movaps 0x60(%rsp),%xmm2
movaps 0x70(%rsp),%xmm1
unpcklps %xmm1,%xmm2
movaps %xmm2,0x70(%rsp)
movaps %xmm0,0x20(%rsp)
call   1040 <ccosf@plt>
movaps %xmm0,0xa0(%rsp)
movaps 0x70(%rsp),%xmm0
call   1040 <ccosf@plt>
movaps 0xa0(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    16d2 <test3f+0x582>
jp     16d2 <test3f+0x582>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     16d9 <test3f+0x589>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps 0x20(%rsp),%xmm0
call   1040 <ccosf@plt>
movaps %xmm0,0x20(%rsp)
movaps 0x40(%rsp),%xmm0
movaps 0x80(%rsp),%xmm1
test   %ebx,%ebx
je     1702 <test3f+0x5b2>
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
unpcklps %xmm1,%xmm0
call   1040 <ccosf@plt>
movaps 0x20(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    173c <test3f+0x5ec>
jp     173c <test3f+0x5ec>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
jne    173c <test3f+0x5ec>
test   %ebx,%ebx
je     1747 <test3f+0x5f7>
movaps (%rsp),%xmm0
call   1040 <ccosf@plt>
movaps %xmm0,0x20(%rsp)
movaps 0x60(%rsp),%xmm0
jmp    1795 <test3f+0x645>
xor    %eax,%eax
call   1060 <link_error@plt>
test   %ebx,%ebx
jne    1727 <test3f+0x5d7>
movaps 0x10(%rsp),%xmm0
movaps 0x50(%rsp),%xmm1
movaps (%rsp),%xmm2
movaps 0x30(%rsp),%xmm3
call   1d40 <__divsc3>
call   1050 <ctanf@plt>
call   1040 <ccosf@plt>
movaps %xmm0,0x20(%rsp)
movaps 0x40(%rsp),%xmm0
movaps 0x80(%rsp),%xmm1
movaps (%rsp),%xmm2
movaps 0x30(%rsp),%xmm3
call   1d40 <__divsc3>
call   1050 <ctanf@plt>
xorps  0x86b(%rip),%xmm0
call   1040 <ccosf@plt>
movaps 0x20(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    17b3 <test3f+0x663>
jp     17b3 <test3f+0x663>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     17ba <test3f+0x66a>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm1
ucomiss 0x30(%rsp),%xmm1
jp     1a9b <test3f+0x94b>
movaps 0x60(%rsp),%xmm0
shufps $0x1,%xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
movaps %xmm0,0x60(%rsp)
call   1040 <ccosf@plt>
movaps %xmm0,0x20(%rsp)
movaps 0x60(%rsp),%xmm0
call   1040 <ccosf@plt>
movaps 0x20(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    1808 <test3f+0x6b8>
jp     1808 <test3f+0x6b8>
cmpneqps %xmm0,%xmm1
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     180f <test3f+0x6bf>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps 0x7ea(%rip),%xmm1
movaps 0x120(%rsp),%xmm0
xorps  %xmm1,%xmm0
movaps 0x130(%rsp),%xmm1
movlhps %xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
call   1050 <ctanf@plt>
movaps %xmm0,0x60(%rsp)
movaps 0x100(%rsp),%xmm0
xorps  0x7b7(%rip),%xmm0
movaps 0x110(%rsp),%xmm1
movlhps %xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
call   1050 <ctanf@plt>
movaps 0x79c(%rip),%xmm2
movaps %xmm0,%xmm1
xorps  %xmm2,%xmm1
movaps 0x60(%rsp),%xmm3
ucomiss %xmm1,%xmm3
jne    188b <test3f+0x73b>
jp     188b <test3f+0x73b>
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
shufps $0x55,%xmm0,%xmm0
xorps  %xmm2,%xmm0
ucomiss %xmm0,%xmm1
jne    188b <test3f+0x73b>
jnp    1892 <test3f+0x742>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movaps 0x10(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
call   1d40 <__divsc3>
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
xorps  0x748(%rip),%xmm1
movlhps %xmm0,%xmm1
shufps $0xe2,%xmm0,%xmm1
movaps %xmm1,%xmm0
call   1050 <ctanf@plt>
movaps %xmm0,0x10(%rsp)
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps 0x80(%rsp),%xmm3
call   1d40 <__divsc3>
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
xorps  0x70b(%rip),%xmm1
movlhps %xmm0,%xmm1
shufps $0xe2,%xmm0,%xmm1
movaps %xmm1,%xmm0
call   1050 <ctanf@plt>
movaps 0x6f5(%rip),%xmm2
movaps %xmm0,%xmm1
xorps  %xmm2,%xmm1
movaps 0x10(%rsp),%xmm3
ucomiss %xmm1,%xmm3
jne    1932 <test3f+0x7e2>
jp     1932 <test3f+0x7e2>
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
shufps $0x55,%xmm0,%xmm0
xorps  %xmm2,%xmm0
ucomiss %xmm0,%xmm1
jne    1932 <test3f+0x7e2>
jnp    1939 <test3f+0x7e9>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm0
call   1030 <cargf@plt>
movss  %xmm0,0x10(%rsp)
movaps 0x30(%rsp),%xmm0
movaps (%rsp),%xmm1
call   1070 <atan2f@plt>
movss  0x10(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    1963 <test3f+0x813>
jnp    1972 <test3f+0x822>
xor    %eax,%eax
add    $0x140,%rsp
pop    %rbx
jmp    1060 <link_error@plt>
add    $0x140,%rsp
pop    %rbx
ret
movaps 0xb0(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
ucomiss %xmm0,%xmm0
movaps 0x90(%rsp),%xmm0
jnp    1459 <test3f+0x309>
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movaps 0x10(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
call   1ab0 <__mulsc3>
jmp    1459 <test3f+0x309>
ucomiss %xmm1,%xmm1
jnp    149b <test3f+0x34b>
movaps 0x60(%rsp),%xmm0
movaps 0x70(%rsp),%xmm1
movaps 0x10(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
call   1ab0 <__mulsc3>
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
jmp    149b <test3f+0x34b>
movaps 0xb0(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
ucomiss %xmm0,%xmm0
jnp    14d7 <test3f+0x387>
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movaps 0x10(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
call   1ab0 <__mulsc3>
movaps %xmm0,0x90(%rsp)
jmp    14d7 <test3f+0x387>
ucomiss %xmm1,%xmm1
jnp    1518 <test3f+0x3c8>
movaps (%rsp),%xmm0
movaps 0x30(%rsp),%xmm1
movaps 0x40(%rsp),%xmm2
movaps 0x80(%rsp),%xmm3
call   1ab0 <__mulsc3>
jmp    1518 <test3f+0x3c8>
shufps $0x55,%xmm3,%xmm3
ucomiss %xmm3,%xmm3
jnp    157d <test3f+0x42d>
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps 0x10(%rsp),%xmm2
movaps 0x50(%rsp),%xmm3
call   1ab0 <__mulsc3>
movaps %xmm0,%xmm1
jmp    157d <test3f+0x42d>
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
ucomiss %xmm3,%xmm3
jnp    15c6 <test3f+0x476>
movaps 0x40(%rsp),%xmm2
movaps 0x80(%rsp),%xmm3
call   1ab0 <__mulsc3>
movaps %xmm0,%xmm2
jmp    15c6 <test3f+0x476>
xor    %eax,%eax
call   1060 <link_error@plt>
movaps (%rsp),%xmm1
jmp    17c9 <test3f+0x679>
nopl   0x0(%rax,%rax,1)

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

LLVM IR (-O2):
define void @test3f(<2 x float> %0, <2 x float> %1, i32 %2) {
%4 = extractelement <2 x float> %0, i64 1
%5 = extractelement <2 x float> %0, i64 0
%6 = extractelement <2 x float> %1, i64 1
%7 = extractelement <2 x float> %1, i64 0
%8 = tail call <2 x float> @ccosf(<2 x float> %0)
%9 = extractelement <2 x float> %8, i64 0
%10 = fneg <2 x float> %0
%11 = tail call <2 x float> @ccosf(<2 x float> %10)
%12 = extractelement <2 x float> %11, i64 0
%13 = fcmp une float %9, %12
%14 = fcmp une <2 x float> %8, %11
%15 = extractelement <2 x i1> %14, i64 1
%16 = or i1 %13, %15
br i1 %16, label %17, label %19
17: ; preds = %3
%18 = tail call i32 (...) @link_error()
br label %19
19: ; preds = %17, %3
%20 = tail call <2 x float> @ctanf(<2 x float> %0)
%21 = tail call <2 x float> @ccosf(<2 x float> %20)
%22 = extractelement <2 x float> %21, i64 0
%23 = tail call <2 x float> @ctanf(<2 x float> %10)
%24 = tail call <2 x float> @ccosf(<2 x float> %23)
%25 = extractelement <2 x float> %24, i64 0
%26 = fcmp une float %22, %25
%27 = fcmp une <2 x float> %21, %24
%28 = extractelement <2 x i1> %27, i64 1
%29 = or i1 %26, %28
br i1 %29, label %30, label %32
30: ; preds = %19
%31 = tail call i32 (...) @link_error()
br label %32
32: ; preds = %30, %19
%33 = fsub <2 x float> %0, %1
%34 = fsub float %4, %6
%35 = shufflevector <2 x float> %33, <2 x float> undef, <2 x i32> <i32 0, i32 undef>
%36 = insertelement <2 x float> %35, float %34, i64 1
%37 = tail call <2 x float> @ctanf(<2 x float> %36)
%38 = extractelement <2 x float> %37, i64 0
%39 = extractelement <2 x float> %37, i64 1
%40 = fsub <2 x float> %1, %0
%41 = fsub float %6, %4
%42 = shufflevector <2 x float> %40, <2 x float> undef, <2 x i32> <i32 0, i32 undef>
%43 = insertelement <2 x float> %42, float %41, i64 1
%44 = tail call <2 x float> @ctanf(<2 x float> %43)
%45 = extractelement <2 x float> %44, i64 0
%46 = extractelement <2 x float> %44, i64 1
%47 = fneg float %45
%48 = fneg float %46
%49 = fcmp une float %38, %47
%50 = fcmp une float %39, %48
%51 = or i1 %49, %50
br i1 %51, label %52, label %54
52: ; preds = %32
%53 = tail call i32 (...) @link_error()
br label %54
54: ; preds = %52, %32
%55 = tail call <2 x float> @__divsc3(float %5, float %4, float %7, float %6)
%56 = tail call <2 x float> @ccosf(<2 x float> %55)
%57 = extractelement <2 x float> %56, i64 0
%58 = extractelement <2 x float> %10, i64 0
%59 = extractelement <2 x float> %10, i64 1
%60 = tail call <2 x float> @__divsc3(float %58, float %59, float %7, float %6)
%61 = tail call <2 x float> @ccosf(<2 x float> %60)
%62 = extractelement <2 x float> %61, i64 0
%63 = fcmp une float %57, %62
%64 = fcmp une <2 x float> %56, %61
%65 = extractelement <2 x i1> %64, i64 1
%66 = or i1 %63, %65
br i1 %66, label %67, label %69
67: ; preds = %54
%68 = tail call i32 (...) @link_error()
br label %69
69: ; preds = %67, %54
%70 = tail call <2 x float> @__divsc3(float %5, float %4, float %7, float %6)
%71 = tail call <2 x float> @ccosf(<2 x float> %70)
%72 = extractelement <2 x float> %71, i64 0
%73 = fneg <2 x float> %1
%74 = extractelement <2 x float> %73, i64 0
%75 = extractelement <2 x float> %73, i64 1
%76 = tail call <2 x float> @__divsc3(float %5, float %4, float %74, float %75)
%77 = tail call <2 x float> @ccosf(<2 x float> %76)
%78 = extractelement <2 x float> %77, i64 0
%79 = fcmp une float %72, %78
%80 = fcmp une <2 x float> %71, %77
%81 = extractelement <2 x i1> %80, i64 1
%82 = or i1 %79, %81
br i1 %82, label %83, label %85
83: ; preds = %69
%84 = tail call i32 (...) @link_error()
br label %85
85: ; preds = %83, %69
%86 = tail call <2 x float> @ctanf(<2 x float> %1)
%87 = extractelement <2 x float> %86, i64 0
%88 = extractelement <2 x float> %86, i64 1
%89 = tail call <2 x float> @__divsc3(float %5, float %4, float %87, float %88)
%90 = tail call <2 x float> @ccosf(<2 x float> %89)
%91 = extractelement <2 x float> %90, i64 0
%92 = tail call <2 x float> @ctanf(<2 x float> %73)
%93 = extractelement <2 x float> %92, i64 0
%94 = extractelement <2 x float> %92, i64 1
%95 = tail call <2 x float> @__divsc3(float %58, float %59, float %93, float %94)
%96 = tail call <2 x float> @ccosf(<2 x float> %95)
%97 = extractelement <2 x float> %96, i64 0
%98 = fcmp une float %91, %97
%99 = fcmp une <2 x float> %90, %96
%100 = extractelement <2 x i1> %99, i64 1
%101 = or i1 %98, %100
br i1 %101, label %102, label %104
102: ; preds = %85
%103 = tail call i32 (...) @link_error()
br label %104
104: ; preds = %102, %85
%105 = shufflevector <2 x float> %1, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%106 = fmul <2 x float> %105, %0
%107 = shufflevector <2 x float> %106, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%108 = shufflevector <2 x float> %1, <2 x float> undef, <2 x i32> zeroinitializer
%109 = fmul <2 x float> %108, %0
%110 = fsub <2 x float> %109, %107
%111 = fadd <2 x float> %109, %107
%112 = shufflevector <2 x float> %110, <2 x float> %111, <2 x i32> <i32 0, i32 3>
%113 = extractelement <2 x float> %110, i64 0
%114 = fcmp uno float %113, 0.000000e+00
br i1 %114, label %115, label %120
115: ; preds = %104
%116 = extractelement <2 x float> %111, i64 1
%117 = fcmp uno float %116, 0.000000e+00
br i1 %117, label %118, label %120
118: ; preds = %115
%119 = tail call <2 x float> @__mulsc3(float %5, float %4, float %7, float %6)
br label %120
120: ; preds = %118, %115, %104
%121 = phi <2 x float> [ %112, %104 ], [ %112, %115 ], [ %119, %118 ]
%122 = tail call <2 x float> @ccosf(<2 x float> %121)
%123 = extractelement <2 x float> %122, i64 0
%124 = fmul float %7, %59
%125 = fsub <2 x float> %107, %109
%126 = extractelement <2 x float> %125, i64 0
%127 = extractelement <2 x float> %106, i64 0
%128 = fsub float %124, %127
%129 = fcmp uno float %126, 0.000000e+00
br i1 %129, label %130, label %136
130: ; preds = %120
%131 = fcmp uno float %128, 0.000000e+00
br i1 %131, label %132, label %136
132: ; preds = %130
%133 = tail call <2 x float> @__mulsc3(float %58, float %59, float %7, float %6)
%134 = extractelement <2 x float> %133, i64 0
%135 = extractelement <2 x float> %133, i64 1
br label %136
136: ; preds = %132, %130, %120
%137 = phi float [ %126, %120 ], [ %126, %130 ], [ %134, %132 ]
%138 = phi float [ %128, %120 ], [ %128, %130 ], [ %135, %132 ]
%139 = insertelement <2 x float> undef, float %137, i64 0
%140 = insertelement <2 x float> %139, float %138, i64 1
%141 = tail call <2 x float> @ccosf(<2 x float> %140)
%142 = extractelement <2 x float> %141, i64 0
%143 = fcmp une float %123, %142
%144 = fcmp une <2 x float> %122, %141
%145 = extractelement <2 x i1> %144, i64 1
%146 = or i1 %143, %145
br i1 %146, label %147, label %149
147: ; preds = %136
%148 = tail call i32 (...) @link_error()
br label %149
149: ; preds = %147, %136
br i1 %114, label %150, label %155
150: ; preds = %149
%151 = extractelement <2 x float> %111, i64 1
%152 = fcmp uno float %151, 0.000000e+00
br i1 %152, label %153, label %155
153: ; preds = %150
%154 = tail call <2 x float> @__mulsc3(float %5, float %4, float %7, float %6)
br label %155
155: ; preds = %153, %150, %149
%156 = phi <2 x float> [ %112, %149 ], [ %112, %150 ], [ %154, %153 ]
%157 = tail call <2 x float> @ccosf(<2 x float> %156)
%158 = extractelement <2 x float> %157, i64 0
%159 = fmul float %4, %74
%160 = fsub float %159, %127
%161 = insertelement <2 x float> %125, float %160, i64 1
br i1 %129, label %162, label %166
162: ; preds = %155
%163 = fcmp uno float %160, 0.000000e+00
br i1 %163, label %164, label %166
164: ; preds = %162
%165 = tail call <2 x float> @__mulsc3(float %5, float %4, float %74, float %75)
br label %166
166: ; preds = %164, %162, %155
%167 = phi <2 x float> [ %161, %155 ], [ %161, %162 ], [ %165, %164 ]
%168 = tail call <2 x float> @ccosf(<2 x float> %167)
%169 = extractelement <2 x float> %168, i64 0
%170 = fcmp une float %158, %169
%171 = fcmp une <2 x float> %157, %168
%172 = extractelement <2 x i1> %171, i64 1
%173 = or i1 %170, %172
br i1 %173, label %174, label %176
174: ; preds = %166
%175 = tail call i32 (...) @link_error()
br label %176
176: ; preds = %174, %166
%177 = tail call <2 x float> @ctanf(<2 x float> %0)
%178 = fmul <2 x float> %105, %177
%179 = shufflevector <2 x float> %178, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%180 = fmul <2 x float> %108, %177
%181 = fsub <2 x float> %180, %179
%182 = fadd <2 x float> %180, %179
%183 = shufflevector <2 x float> %181, <2 x float> %182, <2 x i32> <i32 0, i32 3>
%184 = extractelement <2 x float> %181, i64 0
%185 = fcmp uno float %184, 0.000000e+00
br i1 %185, label %186, label %193
186: ; preds = %176
%187 = extractelement <2 x float> %182, i64 1
%188 = fcmp uno float %187, 0.000000e+00
br i1 %188, label %189, label %193
189: ; preds = %186
%190 = extractelement <2 x float> %177, i64 0
%191 = extractelement <2 x float> %177, i64 1
%192 = tail call <2 x float> @__mulsc3(float %190, float %191, float %7, float %6)
br label %193
193: ; preds = %189, %186, %176
%194 = phi <2 x float> [ %183, %176 ], [ %183, %186 ], [ %192, %189 ]
%195 = tail call <2 x float> @ccosf(<2 x float> %194)
%196 = extractelement <2 x float> %195, i64 0
%197 = tail call <2 x float> @ctanf(<2 x float> %10)
%198 = extractelement <2 x float> %197, i64 0
%199 = extractelement <2 x float> %197, i64 1
%200 = shufflevector <2 x float> %73, <2 x float> %1, <2 x i32> <i32 0, i32 3>
%201 = shufflevector <2 x float> %197, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%202 = fmul <2 x float> %200, %201
%203 = shufflevector <2 x float> %202, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%204 = shufflevector <2 x float> %197, <2 x float> undef, <2 x i32> zeroinitializer
%205 = fmul <2 x float> %204, %1
%206 = fsub <2 x float> %203, %205
%207 = extractelement <2 x float> %206, i64 0
%208 = fcmp uno float %207, 0.000000e+00
br i1 %208, label %209, label %214
209: ; preds = %193
%210 = extractelement <2 x float> %206, i64 1
%211 = fcmp uno float %210, 0.000000e+00
br i1 %211, label %212, label %214
212: ; preds = %209
%213 = tail call <2 x float> @__mulsc3(float %198, float %199, float %74, float %75)
br label %214
214: ; preds = %212, %209, %193
%215 = phi <2 x float> [ %206, %193 ], [ %206, %209 ], [ %213, %212 ]
%216 = tail call <2 x float> @ccosf(<2 x float> %215)
%217 = extractelement <2 x float> %216, i64 0
%218 = fcmp une float %196, %217
%219 = fcmp une <2 x float> %195, %216
%220 = extractelement <2 x i1> %219, i64 1
%221 = or i1 %218, %220
br i1 %221, label %222, label %224
222: ; preds = %214
%223 = tail call i32 (...) @link_error()
br label %224
224: ; preds = %222, %214
%225 = tail call <2 x float> @__divsc3(float %5, float %4, float %7, float %6)
%226 = tail call <2 x float> @ctanf(<2 x float> %225)
%227 = tail call <2 x float> @ccosf(<2 x float> %226)
%228 = extractelement <2 x float> %227, i64 0
%229 = tail call <2 x float> @__divsc3(float %5, float %4, float %74, float %75)
%230 = tail call <2 x float> @ctanf(<2 x float> %229)
%231 = fneg <2 x float> %230
%232 = tail call <2 x float> @ccosf(<2 x float> %231)
%233 = extractelement <2 x float> %232, i64 0
%234 = fcmp une float %228, %233
%235 = fcmp une <2 x float> %227, %232
%236 = extractelement <2 x i1> %235, i64 1
%237 = or i1 %234, %236
br i1 %237, label %238, label %240
238: ; preds = %224
%239 = tail call i32 (...) @link_error()
br label %240
240: ; preds = %238, %224
%241 = icmp eq i32 %2, 0
%242 = select i1 %241, float %7, float %5
%243 = select i1 %241, float %6, float %4
%244 = insertelement <2 x float> undef, float %242, i64 0
%245 = insertelement <2 x float> %244, float %243, i64 1
%246 = tail call <2 x float> @ccosf(<2 x float> %245)
%247 = extractelement <2 x float> %246, i64 0
%248 = select i1 %241, float %7, float %58
%249 = select i1 %241, float %6, float %59
%250 = insertelement <2 x float> undef, float %248, i64 0
%251 = insertelement <2 x float> %250, float %249, i64 1
%252 = tail call <2 x float> @ccosf(<2 x float> %251)
%253 = extractelement <2 x float> %252, i64 0
%254 = fcmp une float %247, %253
%255 = fcmp une <2 x float> %246, %252
%256 = extractelement <2 x i1> %255, i64 1
%257 = or i1 %254, %256
br i1 %257, label %258, label %260
258: ; preds = %240
%259 = tail call i32 (...) @link_error()
br label %260
260: ; preds = %258, %240
%261 = tail call <2 x float> @ccosf(<2 x float> %245)
%262 = extractelement <2 x float> %261, i64 0
%263 = select i1 %241, float %74, float %5
%264 = select i1 %241, float %75, float %4
%265 = insertelement <2 x float> undef, float %263, i64 0
%266 = insertelement <2 x float> %265, float %264, i64 1
%267 = tail call <2 x float> @ccosf(<2 x float> %266)
%268 = extractelement <2 x float> %267, i64 0
%269 = fcmp une float %262, %268
%270 = fcmp une <2 x float> %261, %267
%271 = extractelement <2 x i1> %270, i64 1
%272 = or i1 %269, %271
br i1 %272, label %273, label %275
273: ; preds = %260
%274 = tail call i32 (...) @link_error()
br label %275
275: ; preds = %273, %260
br i1 %241, label %278, label %276
276: ; preds = %275
%277 = tail call <2 x float> @ccosf(<2 x float> %0)
br label %285
278: ; preds = %275
%279 = tail call <2 x float> @__divsc3(float %7, float %6, float %5, float %4)
%280 = tail call <2 x float> @ctanf(<2 x float> %279)
%281 = tail call <2 x float> @ccosf(<2 x float> %280)
%282 = tail call <2 x float> @__divsc3(float %74, float %75, float %5, float %4)
%283 = tail call <2 x float> @ctanf(<2 x float> %282)
%284 = fneg <2 x float> %283
br label %285
285: ; preds = %276, %278
%286 = phi <2 x float> [ %10, %276 ], [ %284, %278 ]
%287 = phi <2 x float> [ %277, %276 ], [ %281, %278 ]
%288 = tail call <2 x float> @ccosf(<2 x float> %286)
%289 = extractelement <2 x float> %288, i64 0
%290 = extractelement <2 x float> %287, i64 0
%291 = fcmp une float %290, %289
%292 = fcmp une <2 x float> %287, %288
%293 = extractelement <2 x i1> %292, i64 1
%294 = or i1 %291, %293
br i1 %294, label %295, label %297
295: ; preds = %285
%296 = tail call i32 (...) @link_error()
br label %297
297: ; preds = %295, %285
%298 = fcmp uno float %5, %4
br i1 %298, label %299, label %301
299: ; preds = %297
%300 = tail call i32 (...) @link_error()
br label %301
301: ; preds = %299, %297
%302 = shufflevector <2 x float> %0, <2 x float> %10, <2 x i32> <i32 0, i32 3>
%303 = tail call <2 x float> @ccosf(<2 x float> %302)
%304 = extractelement <2 x float> %303, i64 0
%305 = tail call <2 x float> @ccosf(<2 x float> %302)
%306 = extractelement <2 x float> %305, i64 0
%307 = fcmp une float %304, %306
%308 = fcmp une <2 x float> %303, %305
%309 = extractelement <2 x i1> %308, i64 1
%310 = or i1 %307, %309
br i1 %310, label %311, label %313
311: ; preds = %301
%312 = tail call i32 (...) @link_error()
br label %313
313: ; preds = %311, %301
%314 = fneg float %34
%315 = insertelement <2 x float> %35, float %314, i64 1
%316 = tail call <2 x float> @ctanf(<2 x float> %315)
%317 = extractelement <2 x float> %316, i64 0
%318 = extractelement <2 x float> %316, i64 1
%319 = fneg float %41
%320 = insertelement <2 x float> %42, float %319, i64 1
%321 = tail call <2 x float> @ctanf(<2 x float> %320)
%322 = extractelement <2 x float> %321, i64 0
%323 = extractelement <2 x float> %321, i64 1
%324 = fneg float %322
%325 = fneg float %323
%326 = fcmp une float %317, %324
%327 = fcmp une float %318, %325
%328 = or i1 %326, %327
br i1 %328, label %329, label %331
329: ; preds = %313
%330 = tail call i32 (...) @link_error()
br label %331
331: ; preds = %329, %313
%332 = tail call <2 x float> @__divsc3(float %5, float %4, float %7, float %6)
%333 = extractelement <2 x float> %332, i64 1
%334 = fneg float %333
%335 = insertelement <2 x float> %332, float %334, i64 1
%336 = tail call <2 x float> @ctanf(<2 x float> %335)
%337 = extractelement <2 x float> %336, i64 0
%338 = extractelement <2 x float> %336, i64 1
%339 = tail call <2 x float> @__divsc3(float %5, float %4, float %74, float %75)
%340 = extractelement <2 x float> %339, i64 1
%341 = fneg float %340
%342 = insertelement <2 x float> %339, float %341, i64 1
%343 = tail call <2 x float> @ctanf(<2 x float> %342)
%344 = extractelement <2 x float> %343, i64 0
%345 = extractelement <2 x float> %343, i64 1
%346 = fneg float %344
%347 = fneg float %345
%348 = fcmp une float %337, %346
%349 = fcmp une float %338, %347
%350 = or i1 %348, %349
br i1 %350, label %351, label %353
351: ; preds = %331
%352 = tail call i32 (...) @link_error()
br label %353
353: ; preds = %351, %331
%354 = tail call float @cargf(<2 x float> %0)
%355 = tail call float @atan2f(float %4, float %5)
%356 = fcmp une float %354, %355
br i1 %356, label %357, label %359
357: ; preds = %353
%358 = tail call i32 (...) @link_error()
br label %359
359: ; preds = %357, %353
ret void
}