void argConvGLcpara2(double cparam[3][4], int width, int height, double gnear,
                     double gfar, float m[16]) {
  double icpara[3][4];
  double trans[3][4];
  double p[3][3], q[4][4];
  int i, j;
  if (arParamDecompMat(cparam, icpara, trans) < 0) {
    printf("gConvGLcpara: Parameter error!!\n");
    exit(0);
  }
  for (i = 0; i < 3; i++) {
    for (j = 0; j < 3; j++) {
      p[i][j] = icpara[i][j] / icpara[2][2];
    }
  }
  q[0][0] = (2.0 * p[0][0] / width);
  q[0][1] = (2.0 * p[0][1] / width);
  q[0][2] = ((2.0 * p[0][2] / width) - 1.0);
  q[0][3] = 0.0;
  q[1][0] = 0.0;
  q[1][1] = (2.0 * p[1][1] / height);
  q[1][2] = ((2.0 * p[1][2] / height) - 1.0);
  q[1][3] = 0.0;
  q[2][0] = 0.0;
  q[2][1] = 0.0;
  q[2][2] = (gfar + gnear) / (gfar - gnear);
  q[2][3] = -2.0 * gfar * gnear / (gfar - gnear);
  q[3][0] = 0.0;
  q[3][1] = 0.0;
  q[3][2] = 1.0;
  q[3][3] = 0.0;
  for (i = 0; i < 4; i++) {
    for (j = 0; j < 3; j++) {
      m[i + j * 4] =
          q[i][0] * trans[0][j] + q[i][1] * trans[1][j] + q[i][2] * trans[2][j];
    }
    m[i + 3 * 4] = q[i][0] * trans[0][3] + q[i][1] * trans[1][3] +
                   q[i][2] * trans[2][3] + q[i][3];
  }
}


x86 assembly (clang, -O0):
<argConvGLcpara2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
lea    -0x90(%rbp),%rsi
lea    -0xf0(%rbp),%rdx
mov    $0x0,%al
call   1030 <arParamDecompMat@plt>
cmp    $0x0,%eax
jge    118a <argConvGLcpara2+0x5a>
lea    0xe9c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %edi,%edi
call   1050 <exit@plt>
movl   $0x0,-0x1c4(%rbp)
cmpl   $0x3,-0x1c4(%rbp)
jge    122c <argConvGLcpara2+0xfc>
movl   $0x0,-0x1c8(%rbp)
cmpl   $0x3,-0x1c8(%rbp)
jge    1213 <argConvGLcpara2+0xe3>
movslq -0x1c4(%rbp),%rcx
lea    -0x90(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movslq -0x1c8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x40(%rbp),%xmm0
movslq -0x1c4(%rbp),%rcx
lea    -0x140(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c8(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
jmp    11ab <argConvGLcpara2+0x7b>
jmp    1218 <argConvGLcpara2+0xe8>
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
jmp    1194 <argConvGLcpara2+0x64>
movsd  0xddc(%rip),%xmm0
mulsd  -0x140(%rbp),%xmm0
ff
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movsd  0xdbb(%rip),%xmm0
mulsd  -0x138(%rbp),%xmm0
ff
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  0xd9a(%rip),%xmm0
mulsd  -0x130(%rbp),%xmm0
ff
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  0xd71(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  0xd57(%rip),%xmm0
mulsd  -0x120(%rbp),%xmm0
ff
cvtsi2sdl -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  0xd36(%rip),%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
cvtsi2sdl -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  0xd0d(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
addsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
subsd  -0x18(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  0xcc0(%rip),%xmm0
mulsd  -0x20(%rbp),%xmm0
mulsd  -0x18(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
subsd  -0x18(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0xc7a(%rip),%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movl   $0x0,-0x1c4(%rbp)
cmpl   $0x4,-0x1c4(%rbp)
jge    1545 <argConvGLcpara2+0x415>
movl   $0x0,-0x1c8(%rbp)
cmpl   $0x3,-0x1c8(%rbp)
jge    1489 <argConvGLcpara2+0x359>
movslq -0x1c4(%rbp),%rcx
lea    -0x1c0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm1
movslq -0x1c8(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm2
ff ff
movslq -0x1c4(%rbp),%rcx
lea    -0x1c0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movslq -0x1c8(%rbp),%rax
mulsd  -0xd0(%rbp,%rax,8),%xmm0
ff ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movslq -0x1c4(%rbp),%rcx
lea    -0x1c0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movslq -0x1c8(%rbp),%rax
movsd  -0xb0(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x1c4(%rbp),%ecx
mov    -0x1c8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
jmp    13ba <argConvGLcpara2+0x28a>
movslq -0x1c4(%rbp),%rcx
lea    -0x1c0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm1
movsd  -0xd8(%rbp),%xmm2
ff
movslq -0x1c4(%rbp),%rcx
lea    -0x1c0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movslq -0x1c4(%rbp),%rcx
lea    -0x1c0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
movsd  0x10(%rax),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x1c4(%rbp),%rcx
lea    -0x1c0(%rbp),%rax
shl    $0x5,%rcx
add    %rcx,%rax
addsd  0x18(%rax),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x1c4(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c4(%rbp)
jmp    13a3 <argConvGLcpara2+0x273>
add    $0x1d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<argConvGLcpara2>:
push   %rbp
push   %r14
push   %rbx
sub    $0x180,%rsp
mov    %rcx,%rbx
movsd  %xmm1,0x8(%rsp)
movaps %xmm0,0x10(%rsp)
mov    %edx,%r14d
mov    %esi,%ebp
lea    0x120(%rsp),%rsi
lea    0xc0(%rsp),%rdx
xor    %eax,%eax
call   1030 <arParamDecompMat@plt>
test   %eax,%eax
js     1646 <argConvGLcpara2+0x516>
movsd  0x170(%rsp),%xmm1
movapd 0x120(%rsp),%xmm6
movsd  0x130(%rsp),%xmm4
divsd  %xmm1,%xmm4
movsd  0x148(%rsp),%xmm2
divsd  %xmm1,%xmm2
movsd  0x150(%rsp),%xmm0
divsd  %xmm1,%xmm0
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm6
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
addpd  %xmm6,%xmm6
addsd  %xmm4,%xmm4
divsd  %xmm1,%xmm4
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm6
movapd %xmm6,0x40(%rsp)
movsd  0xe29(%rip),%xmm1
addsd  %xmm1,%xmm4
movsd  %xmm4,0x50(%rsp)
addsd  %xmm2,%xmm2
cvtsi2sd %r14d,%xmm5
divsd  %xmm5,%xmm2
xorps  %xmm3,%xmm3
movups %xmm3,0x58(%rsp)
movsd  %xmm2,0x68(%rsp)
addsd  %xmm0,%xmm0
divsd  %xmm5,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0x8(%rsp),%xmm7
movapd %xmm7,%xmm0
movapd 0x10(%rsp),%xmm5
subsd  %xmm5,%xmm0
movups %xmm3,0x78(%rsp)
movq   $0x0,0x88(%rsp)
movsd  0xdcd(%rip),%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm5,%xmm2
unpcklpd %xmm5,%xmm2
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
addsd  %xmm7,%xmm5
shufpd $0x2,%xmm1,%xmm5
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm5
movapd %xmm5,0x90(%rsp)
movaps %xmm3,0xa0(%rsp)
movsd  0xd97(%rip),%xmm0
movaps %xmm0,0xb0(%rsp)
movsd  0xd8(%rsp),%xmm12
movsd  0xf8(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x118(%rsp),%xmm8
movsd  0xe0(%rsp),%xmm2
movsd  0x100(%rsp),%xmm11
movsd  0xc0(%rsp),%xmm9
movsd  0xc8(%rsp),%xmm14
movsd  0xe8(%rsp),%xmm1
movsd  0x108(%rsp),%xmm15
movsd  0xd0(%rsp),%xmm7
movsd  %xmm7,0x38(%rsp)
movsd  0xf0(%rsp),%xmm0
movsd  %xmm0,0x28(%rsp)
movapd %xmm6,%xmm3
unpckhpd %xmm6,%xmm3
movapd %xmm3,%xmm10
mulsd  %xmm2,%xmm10
movapd %xmm2,%xmm13
movsd  %xmm2,0x8(%rsp)
movapd %xmm6,%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm10,%xmm2
movapd %xmm4,%xmm5
mulsd  %xmm11,%xmm5
addsd  %xmm2,%xmm5
movsd  0x110(%rsp),%xmm10
movsd  %xmm10,0x30(%rsp)
xorps  %xmm2,%xmm2
cvtsd2ss %xmm5,%xmm2
movss  %xmm2,(%rbx)
movapd %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm6,%xmm5
mulsd  %xmm14,%xmm5
addsd  %xmm2,%xmm5
movapd %xmm4,%xmm2
mulsd  %xmm15,%xmm2
addsd  %xmm5,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x10(%rbx)
movapd %xmm3,%xmm2
mulsd  %xmm0,%xmm2
movapd %xmm6,%xmm5
mulsd  %xmm7,%xmm5
addsd  %xmm2,%xmm5
movapd %xmm4,%xmm2
mulsd  %xmm10,%xmm2
addsd  %xmm5,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x20(%rbx)
movsd  0x10(%rsp),%xmm7
mulsd  %xmm7,%xmm3
mulsd  %xmm12,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm8,%xmm4
addsd  %xmm6,%xmm4
xorps  %xmm2,%xmm2
addsd  %xmm4,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x30(%rbx)
movapd 0x60(%rsp),%xmm3
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd %xmm0,%xmm4
mulsd  %xmm13,%xmm4
movapd %xmm3,%xmm6
mulsd  %xmm9,%xmm6
addsd  %xmm4,%xmm6
movsd  0x70(%rsp),%xmm5
movapd %xmm5,%xmm4
mulsd  %xmm11,%xmm4
addsd  %xmm6,%xmm4
movapd %xmm0,%xmm6
mulsd  %xmm7,%xmm6
movapd %xmm3,%xmm2
mulsd  %xmm12,%xmm2
addsd  %xmm6,%xmm2
movapd %xmm5,%xmm6
mulsd  %xmm8,%xmm6
addsd  %xmm2,%xmm6
xorps  %xmm2,%xmm2
cvtsd2ss %xmm4,%xmm2
addsd  0x78(%rsp),%xmm6
movss  %xmm2,0x4(%rbx)
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm1,%xmm13
movapd %xmm3,%xmm4
mulsd  %xmm14,%xmm4
addsd  %xmm2,%xmm4
movapd %xmm5,%xmm2
mulsd  %xmm15,%xmm2
addsd  %xmm4,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,0x14(%rbx)
movsd  0x28(%rsp),%xmm10
mulsd  %xmm10,%xmm0
movsd  0x38(%rsp),%xmm1
mulsd  %xmm1,%xmm3
addsd  %xmm0,%xmm3
movsd  0x30(%rsp),%xmm7
mulsd  %xmm7,%xmm5
addsd  %xmm3,%xmm5
xorps  %xmm0,%xmm0
cvtsd2ss %xmm5,%xmm0
xorps  %xmm2,%xmm2
cvtsd2ss %xmm6,%xmm2
movss  %xmm0,0x24(%rbx)
movss  %xmm2,0x34(%rbx)
movapd 0x80(%rsp),%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm3,%xmm0
mulsd  0x8(%rsp),%xmm0
movapd %xmm2,%xmm4
mulsd  %xmm9,%xmm4
addsd  %xmm0,%xmm4
movsd  0x90(%rsp),%xmm5
movapd %xmm5,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm4,%xmm0
movapd %xmm3,%xmm4
mulsd  0x10(%rsp),%xmm4
movapd %xmm2,%xmm6
mulsd  %xmm12,%xmm6
addsd  %xmm4,%xmm6
cvtsd2ss %xmm0,%xmm0
movapd %xmm5,%xmm4
mulsd  %xmm8,%xmm4
addsd  %xmm6,%xmm4
addsd  0x98(%rsp),%xmm4
movss  %xmm0,0x8(%rbx)
movapd %xmm3,%xmm0
mulsd  %xmm13,%xmm0
movapd %xmm2,%xmm6
mulsd  %xmm14,%xmm6
addsd  %xmm0,%xmm6
movapd %xmm5,%xmm0
mulsd  %xmm15,%xmm0
addsd  %xmm6,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x18(%rbx)
mulsd  %xmm10,%xmm3
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm7,%xmm5
addsd  %xmm2,%xmm5
xorps  %xmm0,%xmm0
cvtsd2ss %xmm5,%xmm0
movss  %xmm0,0x28(%rbx)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm4,%xmm0
movss  %xmm0,0x38(%rbx)
movapd 0xa0(%rsp),%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movsd  0x8(%rsp),%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm9
addsd  %xmm0,%xmm9
movsd  0xb0(%rsp),%xmm5
mulsd  %xmm5,%xmm11
addsd  %xmm9,%xmm11
movsd  0x10(%rsp),%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm12
addsd  %xmm0,%xmm12
mulsd  %xmm5,%xmm8
addsd  %xmm12,%xmm8
xorps  %xmm0,%xmm0
cvtsd2ss %xmm11,%xmm0
addsd  0xb8(%rsp),%xmm8
movss  %xmm0,0xc(%rbx)
mulsd  %xmm3,%xmm13
mulsd  %xmm2,%xmm14
addsd  %xmm13,%xmm14
mulsd  %xmm5,%xmm15
addsd  %xmm14,%xmm15
xorps  %xmm0,%xmm0
cvtsd2ss %xmm15,%xmm0
movss  %xmm0,0x1c(%rbx)
mulsd  %xmm10,%xmm3
mulsd  %xmm1,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm7,%xmm5
addsd  %xmm2,%xmm5
xorps  %xmm0,%xmm0
cvtsd2ss %xmm5,%xmm0
movss  %xmm0,0x2c(%rbx)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm8,%xmm0
movss  %xmm0,0x3c(%rbx)
add    $0x180,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
lea    0x9cb(%rip),%rdi
call   1040 <puts@plt>
xor    %edi,%edi
call   1050 <exit@plt>

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

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