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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double RAND_MAX;
scalar_t__ ceil(double);
int /*<<< orphan*/ free_vector(float *, int, int);
float mean(float *, int);
scalar_t__ rand();
float *vector(int, int);
void trtrans(float *tr, int n, float rr1, float rr2, float *trb) {
  int i, iturn;
  float rr12, rrthrs, rrdrop, rrmin, a, b, *rr, *rrb, *rrdev, rrbmean;
  rr = vector(1, n);
  rrb = vector(1, n);
  rrdev = vector(1, n);
  rr12 = (rr1 < rr2 ? rr1 : rr2);
  rrthrs = 0.4 + 0.2 * (float)rand() / RAND_MAX;
  rrdrop = 0.1 + 0.1 * (float)rand() / RAND_MAX;
  rrmin = (rrthrs > rr12 - rrdrop ? rrthrs : rr12 - rrdrop);
  iturn = (int)ceil((0.3 + 0.3 * (float)rand() / RAND_MAX) * (n + 1));
  a = (rrmin - rr1) / (iturn - 0.0);
  b = (rr2 - rrmin) / (n + 1 - iturn);
  for (i = 1; i <= iturn; i++)
    rr[i] = rr1 + a * i;
  for (i = iturn + 1; i <= n; i++)
    rr[i] = rrmin + b * (i - iturn);
  rrb[1] = trb[1];
  for (i = 2; i <= n; i++)
    rrb[i] = trb[i] - trb[i - 1];
  rrbmean = mean(rrb, n);
  for (i = 1; i <= n; i++)
    rrdev[i] = rrb[i] - rrbmean;
  tr[1] = rr[1] + rrdev[1];
  for (i = 2; i <= n; i++)
    tr[i] = tr[i - 1] + rr[i] + rrdev[i];
  free_vector(rr, 1, n);
  free_vector(rrb, 1, n);
  free_vector(rrdev, 1, n);
}


x86 assembly (clang, -O0):
<trtrans>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movss  %xmm0,-0x10(%rbp)
movss  %xmm1,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,-0x48(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,-0x50(%rbp)
mov    -0xc(%rbp),%esi
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,-0x58(%rbp)
movss  -0x10(%rbp),%xmm1
movss  -0x14(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    11c2 <trtrans+0x72>
movss  -0x10(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
jmp    11cc <trtrans+0x7c>
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe22(%rip),%xmm1
mulsd  %xmm0,%xmm1
mov    0x2def(%rip),%rax
divsd  (%rax),%xmm1
movsd  0xe03(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdd6(%rip),%xmm1
mulsd  %xmm0,%xmm1
mov    0x2db3(%rip),%rax
divsd  (%rax),%xmm1
movsd  0xdbf(%rip),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x30(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm1
subss  -0x34(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    1275 <trtrans+0x125>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
jmp    1284 <trtrans+0x134>
movss  -0x2c(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    $0x0,%al
call   1070 <rand@plt>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd72(%rip),%xmm1
mulsd  %xmm0,%xmm1
mov    0x2d37(%rip),%rax
divsd  (%rax),%xmm1
movsd  0xd5b(%rip),%xmm0
addsd  %xmm1,%xmm0
mov    -0xc(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
mov    %eax,-0x28(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x10(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsi2sdl -0x28(%rbp),%xmm1
xorps  %xmm2,%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x14(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
mov    -0xc(%rbp),%eax
add    $0x1,%eax
sub    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1363 <trtrans+0x213>
movss  -0x10(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
cvtsi2ssl -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1325 <trtrans+0x1d5>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     13af <trtrans+0x25f>
movss  -0x38(%rbp),%xmm1
movss  -0x40(%rbp),%xmm0
mov    -0x24(%rbp),%eax
sub    -0x28(%rbp),%eax
cvtsi2ss %eax,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    136c <trtrans+0x21c>
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     140e <trtrans+0x2be>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    13c8 <trtrans+0x278>
mov    -0x50(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1060 <mean@plt>
movss  %xmm0,-0x5c(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     145f <trtrans+0x30f>
mov    -0x50(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x5c(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1426 <trtrans+0x2d6>
mov    -0x48(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
addss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
movss  %xmm0,0x4(%rax)
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14d4 <trtrans+0x384>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1481 <trtrans+0x331>
mov    -0x48(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    -0x50(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    -0x58(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<trtrans>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rdx,%r15
movaps %xmm1,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
mov    %esi,%ebp
mov    %rdi,0x18(%rsp)
mov    $0x1,%edi
call   1050 <vector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %ebp,%esi
call   1050 <vector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    %ebp,%esi
call   1050 <vector@plt>
mov    %rax,%r13
movaps 0x20(%rsp),%xmm0
minss  0x30(%rsp),%xmm0
movaps %xmm0,0x40(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0xe38(%rip),%xmm0
mov    0x2e19(%rip),%r14
divsd  (%r14),%xmm0
addsd  0xe2c(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe11(%rip),%xmm1
mulsd  %xmm1,%xmm0
divsd  (%r14),%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movaps 0x40(%rsp),%xmm1
subss  %xmm0,%xmm1
movaps (%rsp),%xmm0
maxss  %xmm1,%xmm0
movaps %xmm0,(%rsp)
xor    %eax,%eax
call   1070 <rand@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm0,%xmm1
movsd  0xdd5(%rip),%xmm0
mulsd  %xmm0,%xmm1
divsd  (%r14),%xmm1
addsd  %xmm0,%xmm1
lea    0x1(%rbp),%r14d
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
mulsd  %xmm1,%xmm0
call   1030 <ceil@plt>
movaps 0x20(%rsp),%xmm6
movaps (%rsp),%xmm10
test   %eax,%eax
jle    13de <trtrans+0x28e>
movaps %xmm10,%xmm0
subss  %xmm6,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
cvtss2sd %xmm0,%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
lea    0x1(%rax),%ecx
lea    -0x1(%rcx),%r8
mov    $0x1,%edx
cmp    $0x8,%r8
jb     13c0 <trtrans+0x270>
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
movaps %xmm6,%xmm2
shufps $0x0,%xmm6,%xmm2
lea    -0x8(%rdx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     18c0 <trtrans+0x770>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0xd3c(%rip),%xmm4
xor    %edi,%edi
movdqa 0xd41(%rip),%xmm8
movdqa 0xd48(%rip),%xmm9
movdqa 0xd4f(%rip),%xmm11
movdqa 0xd57(%rip),%xmm7
nopl   0x0(%rax)
movdqa %xmm4,%xmm3
paddd  %xmm8,%xmm3
cvtdq2ps %xmm4,%xmm5
cvtdq2ps %xmm3,%xmm3
mulps  %xmm1,%xmm5
addps  %xmm2,%xmm5
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm5,0x4(%r12,%rdi,4)
movups %xmm3,0x14(%r12,%rdi,4)
movdqa %xmm4,%xmm3
paddd  %xmm9,%xmm3
movdqa %xmm4,%xmm5
paddd  %xmm11,%xmm5
cvtdq2ps %xmm3,%xmm3
cvtdq2ps %xmm5,%xmm5
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
mulps  %xmm1,%xmm5
addps  %xmm2,%xmm5
movups %xmm3,0x24(%r12,%rdi,4)
movups %xmm5,0x34(%r12,%rdi,4)
add    $0x10,%rdi
paddd  %xmm7,%xmm4
add    $0xfffffffffffffffe,%rsi
jne    1310 <trtrans+0x1c0>
test   $0x1,%r9b
je     13a8 <trtrans+0x258>
shl    $0x2,%rdi
cvtdq2ps %xmm4,%xmm3
paddd  0xca6(%rip),%xmm4
cvtdq2ps %xmm4,%xmm4
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
mulps  %xmm1,%xmm4
addps  %xmm2,%xmm4
or     $0x4,%rdi
movups %xmm3,(%r12,%rdi,1)
movups %xmm4,0x10(%r12,%rdi,1)
cmp    %rdx,%r8
je     13de <trtrans+0x28e>
or     $0x1,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2ss %edx,%xmm1
mulss  %xmm0,%xmm1
addss  %xmm6,%xmm1
movss  %xmm1,(%r12,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    13c0 <trtrans+0x270>
cmp    %ebp,%eax
movaps 0x30(%rsp),%xmm4
jge    14f6 <trtrans+0x3a6>
mov    %r14d,%ecx
sub    %eax,%ecx
subss  %xmm10,%xmm4
xorps  %xmm0,%xmm0
cvtsi2ss %ecx,%xmm0
divss  %xmm0,%xmm4
movslq %eax,%rsi
movslq %ebp,%rcx
mov    %rcx,%r9
sub    %rsi,%r9
cmp    $0x8,%r9
jae    141a <trtrans+0x2ca>
mov    %rsi,%rdx
jmp    14c4 <trtrans+0x374>
mov    %rbp,%r10
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    (%rsi,%r8,1),%rdx
movq   %rax,%xmm0
pshufd $0x44,%xmm0,%xmm0
movaps %xmm4,%xmm1
shufps $0x0,%xmm4,%xmm1
movaps %xmm10,%xmm2
shufps $0x0,%xmm10,%xmm2
movdqa 0xc25(%rip),%xmm8
movdqa 0xc2c(%rip),%xmm9
movdqa 0xc34(%rip),%xmm5
mov    %r8,%rdi
nop
movq   %rsi,%xmm6
pshufd $0x44,%xmm6,%xmm3
movdqa %xmm3,%xmm7
paddq  %xmm8,%xmm7
movq   %xmm7,%rbp
psubq  %xmm0,%xmm7
psubq  %xmm0,%xmm3
movdqa %xmm3,%xmm6
paddq  %xmm9,%xmm6
shufps $0x88,%xmm6,%xmm7
shufps $0x88,%xmm3,%xmm3
paddd  %xmm5,%xmm3
cvtdq2ps %xmm7,%xmm6
cvtdq2ps %xmm3,%xmm3
mulps  %xmm1,%xmm6
addps  %xmm2,%xmm6
mulps  %xmm1,%xmm3
addps  %xmm2,%xmm3
movups %xmm6,(%r12,%rbp,4)
movups %xmm3,0x10(%r12,%rbp,4)
add    $0x8,%rsi
add    $0xfffffffffffffff8,%rdi
jne    1460 <trtrans+0x310>
cmp    %r8,%r9
mov    %r10,%rbp
je     14f6 <trtrans+0x3a6>
mov    $0x1,%esi
sub    %eax,%esi
nopl   0x0(%rax,%rax,1)
lea    (%rsi,%rdx,1),%eax
xorps  %xmm0,%xmm0
cvtsi2ss %eax,%xmm0
mulss  %xmm4,%xmm0
addss  %xmm10,%xmm0
movss  %xmm0,0x4(%r12,%rdx,4)
lea    0x1(%rdx),%rax
mov    %rax,%rdx
cmp    %rax,%rcx
jne    14d0 <trtrans+0x380>
movss  0x4(%r15),%xmm0
movss  %xmm0,0x4(%rbx)
mov    %r14d,(%rsp)
mov    %r14d,%r14d
cmp    $0x2,%ebp
jl     166e <trtrans+0x51e>
lea    -0x2(%r14),%rcx
mov    $0x2,%eax
cmp    $0x8,%rcx
jb     160d <trtrans+0x4bd>
lea    0x8(%rbx),%rdx
lea    (%r15,%r14,4),%rsi
cmp    %rsi,%rdx
jae    1542 <trtrans+0x3f2>
lea    (%rbx,%r14,4),%rdx
lea    0x4(%r15),%rsi
cmp    %rdx,%rsi
jb     160d <trtrans+0x4bd>
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     18ed <trtrans+0x79d>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups 0x4(%r15,%rdx,4),%xmm0
movups 0x8(%r15,%rdx,4),%xmm1
subps  %xmm0,%xmm1
movups 0x14(%r15,%rdx,4),%xmm0
movups 0x18(%r15,%rdx,4),%xmm2
subps  %xmm0,%xmm2
movups %xmm1,0x8(%rbx,%rdx,4)
movups %xmm2,0x18(%rbx,%rdx,4)
movups 0x24(%r15,%rdx,4),%xmm0
movups 0x28(%r15,%rdx,4),%xmm1
subps  %xmm0,%xmm1
movups 0x34(%r15,%rdx,4),%xmm0
movups 0x38(%r15,%rdx,4),%xmm2
subps  %xmm0,%xmm2
movups %xmm1,0x28(%rbx,%rdx,4)
movups %xmm2,0x38(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1570 <trtrans+0x420>
test   $0x1,%sil
je     1604 <trtrans+0x4b4>
shl    $0x2,%rdx
mov    %rdx,%rsi
or     $0x8,%rsi
movups (%r15,%rsi,1),%xmm0
movups 0x10(%r15,%rsi,1),%xmm1
or     $0x4,%rdx
movups (%r15,%rdx,1),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%r15,%rdx,1),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
cmp    %rax,%rcx
je     166e <trtrans+0x51e>
or     $0x2,%rax
mov    %r14d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
test   $0x1,%dl
je     1633 <trtrans+0x4e3>
movss  (%r15,%rax,4),%xmm0
subss  -0x4(%r15,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    %r14,%rcx
je     166e <trtrans+0x51e>
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rax,4),%xmm0
subss  -0x4(%r15,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  0x4(%r15,%rax,4),%xmm0
subss  (%r15,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%r14
jne    1640 <trtrans+0x4f0>
mov    %rbx,%rdi
mov    %ebp,%esi
call   1060 <mean@plt>
mov    %rbp,%r8
test   %ebp,%ebp
mov    0x18(%rsp),%rbp
jle    17fc <trtrans+0x6ac>
lea    -0x1(%r14),%rcx
mov    $0x1,%eax
cmp    $0x8,%rcx
jb     176f <trtrans+0x61f>
lea    0x4(%r13),%rdx
lea    (%rbx,%r14,4),%rsi
cmp    %rsi,%rdx
jae    16c3 <trtrans+0x573>
lea    0x0(,%r14,4),%rdx
add    %r13,%rdx
mov    %rbx,%rsi
add    $0x4,%rsi
cmp    %rdx,%rsi
jb     176f <trtrans+0x61f>
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     18d9 <trtrans+0x789>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rbx,%rdx,4),%xmm2
movups 0x10(%rbx,%rdx,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,0x0(%r13,%rdx,4)
movups %xmm3,0x10(%r13,%rdx,4)
movups 0x20(%rbx,%rdx,4),%xmm2
movups 0x30(%rbx,%rdx,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,0x20(%r13,%rdx,4)
movups %xmm3,0x30(%r13,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1700 <trtrans+0x5b0>
test   $0x1,%sil
je     1762 <trtrans+0x612>
movups (%rbx,%rdx,4),%xmm2
movups 0x10(%rbx,%rdx,4),%xmm3
subps  %xmm1,%xmm2
subps  %xmm1,%xmm3
movups %xmm2,0x0(%r13,%rdx,4)
movups %xmm3,0x10(%r13,%rdx,4)
cmp    %rax,%rcx
je     17fc <trtrans+0x6ac>
or     $0x1,%rax
mov    %r14d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
and    $0x3,%rdx
je     17aa <trtrans+0x65a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rbx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1790 <trtrans+0x640>
cmp    $0x3,%rcx
jb     17fc <trtrans+0x6ac>
movss  (%rbx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
movss  0x4(%rbx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x4(%r13,%rax,4)
movss  0x8(%rbx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0x8(%r13,%rax,4)
movss  0xc(%rbx,%rax,4),%xmm1
subss  %xmm0,%xmm1
movss  %xmm1,0xc(%r13,%rax,4)
add    $0x4,%rax
cmp    %rax,%r14
jne    17b0 <trtrans+0x660>
movss  0x4(%r12),%xmm0
addss  0x4(%r13),%xmm0
movss  %xmm0,0x4(%rbp)
cmp    $0x2,%r8d
jl     1882 <trtrans+0x732>
mov    $0x2,%eax
cmpl   $0x3,(%rsp)
je     1869 <trtrans+0x719>
lea    -0x2(%r14),%rcx
and    $0xfffffffffffffffe,%rcx
neg    %rcx
mov    $0x2,%eax
nop
addss  (%r12,%rax,4),%xmm0
addss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
addss  0x4(%r12,%rax,4),%xmm0
addss  0x4(%r13,%rax,4),%xmm0
movss  %xmm0,0x4(%rbp,%rax,4)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x2,%rdx
jne    1830 <trtrans+0x6e0>
test   $0x1,%r14b
je     1882 <trtrans+0x732>
addss  (%r12,%rax,4),%xmm0
addss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
mov    %r12,%rdi
mov    $0x1,%esi
mov    %r8,%rbp
mov    %ebp,%edx
call   1040 <free_vector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
call   1040 <free_vector@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    %ebp,%edx
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>
movdqa 0x758(%rip),%xmm4
xor    %edi,%edi
test   $0x1,%r9b
jne    137b <trtrans+0x22b>
jmp    13a8 <trtrans+0x258>
mov    $0x1,%edx
test   $0x1,%sil
jne    1747 <trtrans+0x5f7>
jmp    1762 <trtrans+0x612>
xor    %edx,%edx
test   $0x1,%sil
jne    15d0 <trtrans+0x480>
jmp    1604 <trtrans+0x4b4>

LLVM IR (-O0):
@RAND_MAX = global double 0.000000e+00
define void @trtrans(float* %0, i32 %1, float %2, float %3, float* %4) {
%6 = alloca float*
%7 = alloca i32
%8 = alloca float
%9 = alloca float
%10 = alloca float*
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float*
%20 = alloca float*
%21 = alloca float*
%22 = alloca float
store float* %0, float** %6
store i32 %1, i32* %7
store float %2, float* %8
store float %3, float* %9
store float* %4, float** %10
%23 = load i32, i32* %7
%24 = call float* @vector(i32 1, i32 %23)
store float* %24, float** %19
%25 = load i32, i32* %7
%26 = call float* @vector(i32 1, i32 %25)
store float* %26, float** %20
%27 = load i32, i32* %7
%28 = call float* @vector(i32 1, i32 %27)
store float* %28, float** %21
%29 = load float, float* %8
%30 = load float, float* %9
%31 = fcmp olt float %29, %30
br i1 %31, label %32, label %34
32: ; preds = %5
%33 = load float, float* %8
br label %36
34: ; preds = %5
%35 = load float, float* %9
br label %36
36: ; preds = %34, %32
%37 = phi float [ %33, %32 ], [ %35, %34 ]
store float %37, float* %13
%38 = call i64 (...) @rand()
%39 = sitofp i64 %38 to float
%40 = fpext float %39 to double
%41 = fmul double 2.000000e-01, %40
%42 = load double, double* @RAND_MAX
%43 = fdiv double %41, %42
%44 = fadd double 4.000000e-01, %43
%45 = fptrunc double %44 to float
store float %45, float* %14
%46 = call i64 (...) @rand()
%47 = sitofp i64 %46 to float
%48 = fpext float %47 to double
%49 = fmul double 1.000000e-01, %48
%50 = load double, double* @RAND_MAX
%51 = fdiv double %49, %50
%52 = fadd double 1.000000e-01, %51
%53 = fptrunc double %52 to float
store float %53, float* %15
%54 = load float, float* %14
%55 = load float, float* %13
%56 = load float, float* %15
%57 = fsub float %55, %56
%58 = fcmp ogt float %54, %57
br i1 %58, label %59, label %61
59: ; preds = %36
%60 = load float, float* %14
br label %65
61: ; preds = %36
%62 = load float, float* %13
%63 = load float, float* %15
%64 = fsub float %62, %63
br label %65
65: ; preds = %61, %59
%66 = phi float [ %60, %59 ], [ %64, %61 ]
store float %66, float* %16
%67 = call i64 (...) @rand()
%68 = sitofp i64 %67 to float
%69 = fpext float %68 to double
%70 = fmul double 3.000000e-01, %69
%71 = load double, double* @RAND_MAX
%72 = fdiv double %70, %71
%73 = fadd double 3.000000e-01, %72
%74 = load i32, i32* %7
%75 = add nsw i32 %74, 1
%76 = sitofp i32 %75 to double
%77 = fmul double %73, %76
%78 = call i64 @ceil(double %77)
%79 = trunc i64 %78 to i32
store i32 %79, i32* %12
%80 = load float, float* %16
%81 = load float, float* %8
%82 = fsub float %80, %81
%83 = fpext float %82 to double
%84 = load i32, i32* %12
%85 = sitofp i32 %84 to double
%86 = fsub double %85, 0.000000e+00
%87 = fdiv double %83, %86
%88 = fptrunc double %87 to float
store float %88, float* %17
%89 = load float, float* %9
%90 = load float, float* %16
%91 = fsub float %89, %90
%92 = load i32, i32* %7
%93 = add nsw i32 %92, 1
%94 = load i32, i32* %12
%95 = sub nsw i32 %93, %94
%96 = sitofp i32 %95 to float
%97 = fdiv float %91, %96
store float %97, float* %18
store i32 1, i32* %11
br label %98
98: ; preds = %112, %65
%99 = load i32, i32* %11
%100 = load i32, i32* %12
%101 = icmp sle i32 %99, %100
br i1 %101, label %102, label %115
102: ; preds = %98
%103 = load float, float* %8
%104 = load float, float* %17
%105 = load i32, i32* %11
%106 = sitofp i32 %105 to float
%107 = call float @llvm.fmuladd.f32(float %104, float %106, float %103)
%108 = load float*, float** %19
%109 = load i32, i32* %11
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %108, i64 %110
store float %107, float* %111
br label %112
112: ; preds = %102
%113 = load i32, i32* %11
%114 = add nsw i32 %113, 1
store i32 %114, i32* %11
br label %98
115: ; preds = %98
%116 = load i32, i32* %12
%117 = add nsw i32 %116, 1
store i32 %117, i32* %11
br label %118
118: ; preds = %134, %115
%119 = load i32, i32* %11
%120 = load i32, i32* %7
%121 = icmp sle i32 %119, %120
br i1 %121, label %122, label %137
122: ; preds = %118
%123 = load float, float* %16
%124 = load float, float* %18
%125 = load i32, i32* %11
%126 = load i32, i32* %12
%127 = sub nsw i32 %125, %126
%128 = sitofp i32 %127 to float
%129 = call float @llvm.fmuladd.f32(float %124, float %128, float %123)
%130 = load float*, float** %19
%131 = load i32, i32* %11
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %130, i64 %132
store float %129, float* %133
br label %134
134: ; preds = %122
%135 = load i32, i32* %11
%136 = add nsw i32 %135, 1
store i32 %136, i32* %11
br label %118
137: ; preds = %118
%138 = load float*, float** %10
%139 = getelementptr inbounds float, float* %138, i64 1
%140 = load float, float* %139
%141 = load float*, float** %20
%142 = getelementptr inbounds float, float* %141, i64 1
store float %140, float* %142
store i32 2, i32* %11
br label %143
143: ; preds = %164, %137
%144 = load i32, i32* %11
%145 = load i32, i32* %7
%146 = icmp sle i32 %144, %145
br i1 %146, label %147, label %167
147: ; preds = %143
%148 = load float*, float** %10
%149 = load i32, i32* %11
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float, float* %148, i64 %150
%152 = load float, float* %151
%153 = load float*, float** %10
%154 = load i32, i32* %11
%155 = sub nsw i32 %154, 1
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds float, float* %153, i64 %156
%158 = load float, float* %157
%159 = fsub float %152, %158
%160 = load float*, float** %20
%161 = load i32, i32* %11
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds float, float* %160, i64 %162
store float %159, float* %163
br label %164
164: ; preds = %147
%165 = load i32, i32* %11
%166 = add nsw i32 %165, 1
store i32 %166, i32* %11
br label %143
167: ; preds = %143
%168 = load float*, float** %20
%169 = load i32, i32* %7
%170 = call float @mean(float* %168, i32 %169)
store float %170, float* %22
store i32 1, i32* %11
br label %171
171: ; preds = %187, %167
%172 = load i32, i32* %11
%173 = load i32, i32* %7
%174 = icmp sle i32 %172, %173
br i1 %174, label %175, label %190
175: ; preds = %171
%176 = load float*, float** %20
%177 = load i32, i32* %11
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds float, float* %176, i64 %178
%180 = load float, float* %179
%181 = load float, float* %22
%182 = fsub float %180, %181
%183 = load float*, float** %21
%184 = load i32, i32* %11
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds float, float* %183, i64 %185
store float %182, float* %186
br label %187
187: ; preds = %175
%188 = load i32, i32* %11
%189 = add nsw i32 %188, 1
store i32 %189, i32* %11
br label %171
190: ; preds = %171
%191 = load float*, float** %19
%192 = getelementptr inbounds float, float* %191, i64 1
%193 = load float, float* %192
%194 = load float*, float** %21
%195 = getelementptr inbounds float, float* %194, i64 1
%196 = load float, float* %195
%197 = fadd float %193, %196
%198 = load float*, float** %6
%199 = getelementptr inbounds float, float* %198, i64 1
store float %197, float* %199
store i32 2, i32* %11
br label %200
200: ; preds = %227, %190
%201 = load i32, i32* %11
%202 = load i32, i32* %7
%203 = icmp sle i32 %201, %202
br i1 %203, label %204, label %230
204: ; preds = %200
%205 = load float*, float** %6
%206 = load i32, i32* %11
%207 = sub nsw i32 %206, 1
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds float, float* %205, i64 %208
%210 = load float, float* %209
%211 = load float*, float** %19
%212 = load i32, i32* %11
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds float, float* %211, i64 %213
%215 = load float, float* %214
%216 = fadd float %210, %215
%217 = load float*, float** %21
%218 = load i32, i32* %11
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %217, i64 %219
%221 = load float, float* %220
%222 = fadd float %216, %221
%223 = load float*, float** %6
%224 = load i32, i32* %11
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds float, float* %223, i64 %225
store float %222, float* %226
br label %227
227: ; preds = %204
%228 = load i32, i32* %11
%229 = add nsw i32 %228, 1
store i32 %229, i32* %11
br label %200
230: ; preds = %200
%231 = load float*, float** %19
%232 = load i32, i32* %7
%233 = call i32 @free_vector(float* %231, i32 1, i32 %232)
%234 = load float*, float** %20
%235 = load i32, i32* %7
%236 = call i32 @free_vector(float* %234, i32 1, i32 %235)
%237 = load float*, float** %21
%238 = load i32, i32* %7
%239 = call i32 @free_vector(float* %237, i32 1, i32 %238)
ret void
}

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