void rg4th(float *pyv[6], float pos[3], float vel[3], float m, float gamma,
           float q, float rt) {
  int i;
  float v1[3];
  float r1[3];
  float v2[3];
  float r2[3];
  float v3[3];
  float r3[3];
  float *ace1[3];
  float *ace2[3];
  float *ace3[3];
  float *ace4[3];
  aceleracion(ace1, pos, vel, m, gamma, q, rt);
  for (i = 0; i < 3; i++) {
    v1[i] = vel[i] + *ace1[i] / 2;
    r1[i] = pos[i] + vel[i] / 2;
  }
  aceleracion(ace2, r1, v1, m, gamma, q, rt);
  for (i = 0; i < 3; i++) {
    v2[i] = vel[i] + *ace2[i] / 2;
    r2[i] = pos[i] + v1[i] / 2;
  }
  aceleracion(ace3, r2, v2, m, gamma, q, rt);
  for (i = 0; i < 3; i++) {
    v3[i] = vel[i] + *ace3[i];
    r3[i] = pos[i] + v2[i];
  }
  aceleracion(ace4, r3, v3, m, gamma, q, rt);
  float va[3];
  float ra[3];
  for (i = 0; i < 3; i++) {
    va[i] = (1.0 / 6.0) *
            (*ace1[i] + 2.0 * (*ace2[i]) + 2.0 * (*ace3[i]) + *ace4[i]);
    ra[i] = (1.0 / 6.0) * (vel[i] + 2.0 * (v1[i]) + 2.0 * (v2[i]) + v3[i]);
  }
  *pyv[0] = pos[0] + ra[0];
  *pyv[1] = pos[1] + ra[1];
  *pyv[2] = pos[2] + ra[2];
  *pyv[3] = vel[0] + va[0];
  *pyv[4] = vel[1] + va[1];
  *pyv[5] = vel[2] + va[2];
}


x86 assembly (clang, -O0):
<rg4th>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
movss  %xmm2,-0x24(%rbp)
movss  %xmm3,-0x28(%rbp)
lea    -0x90(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x24(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x28(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mov    $0x4,%al
call   1030 <aceleracion@plt>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    11ff <rg4th+0xef>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x2c(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rax
ff
movss  (%rax),%xmm1
movss  0xe5d(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x38(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0xe29(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x44(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117c <rg4th+0x6c>
lea    -0xb0(%rbp),%rdi
lea    -0x44(%rbp),%rsi
lea    -0x38(%rbp),%rdx
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x24(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x28(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mov    $0x4,%al
call   1030 <aceleracion@plt>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    12c0 <rg4th+0x1b0>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x2c(%rbp),%rax
mov    -0xb0(%rbp,%rax,8),%rax
ff
movss  (%rax),%xmm1
movss  0xd99(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x2c(%rbp),%rax
movss  -0x38(%rbp,%rax,4),%xmm1
movss  0xd68(%rip),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x5c(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1240 <rg4th+0x130>
lea    -0xd0(%rbp),%rdi
lea    -0x5c(%rbp),%rsi
lea    -0x50(%rbp),%rdx
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x24(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x28(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mov    $0x4,%al
call   1030 <aceleracion@plt>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1361 <rg4th+0x251>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x2c(%rbp),%rax
mov    -0xd0(%rbp,%rax,8),%rax
ff
addss  (%rax),%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x68(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x2c(%rbp),%rax
addss  -0x50(%rbp,%rax,4),%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x74(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1301 <rg4th+0x1f1>
lea    -0xf0(%rbp),%rdi
lea    -0x74(%rbp),%rsi
lea    -0x68(%rbp),%rdx
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x20(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x24(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x28(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mov    $0x4,%al
call   1030 <aceleracion@plt>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    14a7 <rg4th+0x397>
movslq -0x2c(%rbp),%rax
mov    -0x90(%rbp,%rax,8),%rax
ff
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movslq -0x2c(%rbp),%rax
mov    -0xb0(%rbp,%rax,8),%rax
ff
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
mov    -0xd0(%rbp,%rax,8),%rax
ff
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movslq -0x2c(%rbp),%rax
mov    -0xf0(%rbp,%rax,8),%rax
ff
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
movsd  0xbe8(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0xfc(%rbp,%rax,4)
ff ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movslq -0x2c(%rbp),%rax
movss  -0x38(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movslq -0x2c(%rbp),%rax
movss  -0x50(%rbp,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movslq -0x2c(%rbp),%rax
movss  -0x68(%rbp,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm1
movsd  0xb7c(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x2c(%rbp),%rax
movss  %xmm0,-0x108(%rbp,%rax,4)
ff ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13a2 <rg4th+0x292>
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm0
addss  -0x108(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0x104(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0x100(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
addss  -0xfc(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
addss  -0xf8(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
addss  -0xf4(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rax
movss  %xmm0,(%rax)
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rg4th>:
push   %r15
push   %r14
push   %rbx
sub    $0xf0,%rsp
mov    %rdx,%rbx
mov    %rsi,%r15
mov    %rdi,%r14
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x38(%rsp)
cvtss2sd %xmm2,%xmm2
movsd  %xmm2,0x30(%rsp)
cvtss2sd %xmm3,%xmm3
movsd  %xmm3,0x28(%rsp)
lea    0xb0(%rsp),%rdi
mov    $0x4,%al
call   1030 <aceleracion@plt>
movss  (%rbx),%xmm0
mov    0xb0(%rsp),%rax
mov    0xb8(%rsp),%rcx
movss  0xe88(%rip),%xmm2
movss  (%rax),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x10(%rsp)
mulss  %xmm2,%xmm0
addss  (%r15),%xmm0
movss  %xmm0,0x64(%rsp)
movss  0x4(%rbx),%xmm0
movss  (%rcx),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x14(%rsp)
mulss  %xmm2,%xmm0
addss  0x4(%r15),%xmm0
movss  %xmm0,0x68(%rsp)
movss  0x8(%rbx),%xmm0
mov    0xc0(%rsp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x18(%rsp)
mulss  %xmm2,%xmm0
addss  0x8(%r15),%xmm0
movss  %xmm0,0x6c(%rsp)
lea    0x90(%rsp),%rdi
lea    0x64(%rsp),%rsi
lea    0x10(%rsp),%rdx
movsd  0x40(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
movsd  0x28(%rsp),%xmm3
mov    $0x4,%al
call   1030 <aceleracion@plt>
mov    0x90(%rsp),%rax
movss  (%rax),%xmm0
movss  0xdcc(%rip),%xmm1
mulss  %xmm1,%xmm0
addss  (%rbx),%xmm0
mov    0x98(%rsp),%rax
movss  %xmm0,0x4(%rsp)
movss  0x10(%rsp),%xmm0
mulss  %xmm1,%xmm0
addss  (%r15),%xmm0
movss  %xmm0,0x58(%rsp)
movss  (%rax),%xmm0
mulss  %xmm1,%xmm0
addss  0x4(%rbx),%xmm0
movss  %xmm0,0x8(%rsp)
movss  0x14(%rsp),%xmm0
mulss  %xmm1,%xmm0
addss  0x4(%r15),%xmm0
movss  %xmm0,0x5c(%rsp)
mov    0xa0(%rsp),%rax
movss  (%rax),%xmm0
mulss  %xmm1,%xmm0
addss  0x8(%rbx),%xmm0
mulss  0x18(%rsp),%xmm1
movss  %xmm0,0xc(%rsp)
addss  0x8(%r15),%xmm1
movss  %xmm1,0x60(%rsp)
lea    0x70(%rsp),%rdi
lea    0x58(%rsp),%rsi
lea    0x4(%rsp),%rdx
movsd  0x40(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
movsd  0x28(%rsp),%xmm3
mov    $0x4,%al
call   1030 <aceleracion@plt>
movss  (%rbx),%xmm0
mov    0x70(%rsp),%rax
mov    0x78(%rsp),%rcx
addss  (%rax),%xmm0
movss  %xmm0,0x1c(%rsp)
movss  (%r15),%xmm0
addss  0x4(%rsp),%xmm0
movss  %xmm0,0x4c(%rsp)
movss  0x4(%rbx),%xmm0
addss  (%rcx),%xmm0
movss  %xmm0,0x20(%rsp)
movss  0x4(%r15),%xmm0
addss  0x8(%rsp),%xmm0
movss  %xmm0,0x50(%rsp)
movss  0x8(%rbx),%xmm0
mov    0x80(%rsp),%rax
addss  (%rax),%xmm0
movss  %xmm0,0x24(%rsp)
movss  0x8(%r15),%xmm0
addss  0xc(%rsp),%xmm0
movss  %xmm0,0x54(%rsp)
lea    0xd0(%rsp),%rdi
lea    0x4c(%rsp),%rsi
lea    0x1c(%rsp),%rdx
movsd  0x40(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
movsd  0x28(%rsp),%xmm3
mov    $0x4,%al
call   1030 <aceleracion@plt>
mov    0xb0(%rsp),%rcx
mov    0xb8(%rsp),%rax
movss  (%rcx),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x90(%rsp),%rdx
mov    0x98(%rsp),%rcx
movss  (%rdx),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mov    0x70(%rsp),%rsi
mov    0x78(%rsp),%rdx
movss  (%rsi),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0xd0(%rsp),%rdi
mov    0xd8(%rsp),%rsi
movss  (%rdi),%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  0xc07(%rip),%xmm8
mulsd  %xmm8,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  (%rbx),%xmm2
movss  0x4(%rbx),%xmm4
cvtss2sd %xmm2,%xmm2
movss  0x10(%rsp),%xmm3
movss  0x14(%rsp),%xmm5
cvtss2sd %xmm3,%xmm3
addsd  %xmm3,%xmm3
addsd  %xmm2,%xmm3
movss  0x4(%rsp),%xmm2
movss  0x8(%rsp),%xmm6
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
movss  0x1c(%rsp),%xmm3
movss  0x20(%rsp),%xmm7
cvtss2sd %xmm3,%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm8,%xmm3
xorps  %xmm2,%xmm2
cvtsd2ss %xmm3,%xmm2
movss  (%rax),%xmm3
cvtss2sd %xmm3,%xmm3
movss  (%rcx),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm3,%xmm1
movss  (%rdx),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
movss  (%rsi),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm3,%xmm1
mulsd  %xmm8,%xmm1
xorps  %xmm3,%xmm3
cvtsd2ss %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtss2sd %xmm4,%xmm1
xorps  %xmm4,%xmm4
cvtss2sd %xmm5,%xmm4
addsd  %xmm4,%xmm4
addsd  %xmm1,%xmm4
xorps  %xmm1,%xmm1
cvtss2sd %xmm6,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm4,%xmm1
xorps  %xmm4,%xmm4
cvtss2sd %xmm7,%xmm4
addsd  %xmm1,%xmm4
mulsd  %xmm8,%xmm4
cvtsd2ss %xmm4,%xmm4
mov    0xc0(%rsp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
mov    0xa0(%rsp),%rax
movss  (%rax),%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm5,%xmm5
addsd  %xmm1,%xmm5
mov    0x80(%rsp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm5,%xmm1
mov    0xe0(%rsp),%rax
movss  (%rax),%xmm5
cvtss2sd %xmm5,%xmm5
addsd  %xmm1,%xmm5
mulsd  %xmm8,%xmm5
cvtsd2ss %xmm5,%xmm5
movss  0x8(%rbx),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x18(%rsp),%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm6,%xmm6
addsd  %xmm1,%xmm6
movss  0xc(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm6,%xmm1
movss  0x24(%rsp),%xmm6
cvtss2sd %xmm6,%xmm6
addsd  %xmm1,%xmm6
mulsd  %xmm8,%xmm6
xorps  %xmm1,%xmm1
cvtsd2ss %xmm6,%xmm1
addss  (%r15),%xmm2
mov    (%r14),%rax
movss  %xmm2,(%rax)
addss  0x4(%r15),%xmm4
mov    0x8(%r14),%rax
movss  %xmm4,(%rax)
addss  0x8(%r15),%xmm1
mov    0x10(%r14),%rax
movss  %xmm1,(%rax)
addss  (%rbx),%xmm0
mov    0x18(%r14),%rax
movss  %xmm0,(%rax)
addss  0x4(%rbx),%xmm3
mov    0x20(%r14),%rax
movss  %xmm3,(%rax)
addss  0x8(%rbx),%xmm5
mov    0x28(%r14),%rax
movss  %xmm5,(%rax)
add    $0xf0,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

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

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