void argConvGLcpara2(double cparam[3][4], int width, int height, double gnear,
                     double gfar, double 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    153d <argConvGLcpara2+0x40d>
movl   $0x0,-0x1c8(%rbp)
cmpl   $0x3,-0x1c8(%rbp)
jge    1485 <argConvGLcpara2+0x355>
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
mov    -0x28(%rbp),%rax
mov    -0x1c4(%rbp),%ecx
mov    -0x1c8(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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
mov    -0x28(%rbp),%rax
mov    -0x1c4(%rbp),%ecx
add    $0xc,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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     15e9 <argConvGLcpara2+0x4b9>
movsd  0x170(%rsp),%xmm1
movapd 0x120(%rsp),%xmm6
movsd  0x130(%rsp),%xmm2
divsd  %xmm1,%xmm2
movsd  0x148(%rsp),%xmm3
divsd  %xmm1,%xmm3
movsd  0x150(%rsp),%xmm0
divsd  %xmm1,%xmm0
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm6
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
addpd  %xmm6,%xmm6
addsd  %xmm2,%xmm2
divsd  %xmm1,%xmm2
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm6
movapd %xmm6,0x40(%rsp)
movsd  0xe29(%rip),%xmm1
addsd  %xmm1,%xmm2
movsd  %xmm2,0x50(%rsp)
addsd  %xmm3,%xmm3
cvtsi2sd %r14d,%xmm4
divsd  %xmm4,%xmm3
xorps  %xmm5,%xmm5
movups %xmm5,0x58(%rsp)
movsd  %xmm3,0x68(%rsp)
addsd  %xmm0,%xmm0
divsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x70(%rsp)
movsd  0x8(%rsp),%xmm7
movapd %xmm7,%xmm0
movapd 0x10(%rsp),%xmm4
subsd  %xmm4,%xmm0
movups %xmm5,0x78(%rsp)
movq   $0x0,0x88(%rsp)
movsd  0xdcd(%rip),%xmm1
mulsd  %xmm7,%xmm1
movapd %xmm4,%xmm3
unpcklpd %xmm4,%xmm3
unpcklpd %xmm1,%xmm1
mulpd  %xmm3,%xmm1
addsd  %xmm7,%xmm4
shufpd $0x2,%xmm1,%xmm4
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm4
movapd %xmm4,0x90(%rsp)
movaps %xmm5,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),%xmm4
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  %xmm4,%xmm10
movapd %xmm4,%xmm13
movsd  %xmm4,0x8(%rsp)
movapd %xmm6,%xmm4
mulsd  %xmm9,%xmm4
addsd  %xmm10,%xmm4
movapd %xmm2,%xmm5
mulsd  %xmm11,%xmm5
addsd  %xmm4,%xmm5
movsd  0x110(%rsp),%xmm10
movsd  %xmm10,0x30(%rsp)
movsd  %xmm5,(%rbx)
movapd %xmm3,%xmm4
mulsd  %xmm1,%xmm4
movapd %xmm6,%xmm5
mulsd  %xmm14,%xmm5
addsd  %xmm4,%xmm5
movapd %xmm2,%xmm4
mulsd  %xmm15,%xmm4
addsd  %xmm5,%xmm4
movsd  %xmm4,0x20(%rbx)
movapd %xmm3,%xmm4
mulsd  %xmm0,%xmm4
movapd %xmm6,%xmm5
mulsd  %xmm7,%xmm5
addsd  %xmm4,%xmm5
movapd %xmm2,%xmm4
mulsd  %xmm10,%xmm4
addsd  %xmm5,%xmm4
movsd  %xmm4,0x40(%rbx)
movsd  0x10(%rsp),%xmm7
mulsd  %xmm7,%xmm3
mulsd  %xmm12,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm8,%xmm2
addsd  %xmm6,%xmm2
xorpd  %xmm3,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x60(%rbx)
movapd 0x60(%rsp),%xmm5
movapd %xmm5,%xmm0
unpckhpd %xmm5,%xmm0
movapd %xmm0,%xmm2
mulsd  %xmm13,%xmm2
movapd %xmm5,%xmm4
mulsd  %xmm9,%xmm4
addsd  %xmm2,%xmm4
movsd  0x70(%rsp),%xmm2
movapd %xmm2,%xmm6
mulsd  %xmm11,%xmm6
addsd  %xmm4,%xmm6
movapd %xmm0,%xmm4
mulsd  %xmm7,%xmm4
movapd %xmm5,%xmm3
mulsd  %xmm12,%xmm3
addsd  %xmm4,%xmm3
movapd %xmm2,%xmm4
mulsd  %xmm8,%xmm4
addsd  %xmm3,%xmm4
addsd  0x78(%rsp),%xmm4
movsd  %xmm6,0x8(%rbx)
movapd %xmm0,%xmm3
mulsd  %xmm1,%xmm3
movapd %xmm1,%xmm13
movapd %xmm5,%xmm6
mulsd  %xmm14,%xmm6
addsd  %xmm3,%xmm6
movapd %xmm2,%xmm3
mulsd  %xmm15,%xmm3
addsd  %xmm6,%xmm3
movsd  %xmm3,0x28(%rbx)
movsd  0x28(%rsp),%xmm10
mulsd  %xmm10,%xmm0
movsd  0x38(%rsp),%xmm1
mulsd  %xmm1,%xmm5
addsd  %xmm0,%xmm5
movsd  0x30(%rsp),%xmm7
mulsd  %xmm7,%xmm2
addsd  %xmm5,%xmm2
movsd  %xmm2,0x48(%rbx)
movsd  %xmm4,0x68(%rbx)
movapd 0x80(%rsp),%xmm3
movapd %xmm3,%xmm5
unpckhpd %xmm3,%xmm5
movapd %xmm5,%xmm0
mulsd  0x8(%rsp),%xmm0
movapd %xmm3,%xmm2
mulsd  %xmm9,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm5,%xmm0
mulsd  0x10(%rsp),%xmm0
movapd %xmm3,%xmm4
mulsd  %xmm12,%xmm4
addsd  %xmm0,%xmm4
movsd  0x90(%rsp),%xmm0
movapd %xmm0,%xmm6
mulsd  %xmm8,%xmm6
addsd  %xmm4,%xmm6
movapd %xmm0,%xmm4
mulsd  %xmm11,%xmm4
addsd  0x98(%rsp),%xmm6
addsd  %xmm2,%xmm4
movsd  %xmm4,0x10(%rbx)
movapd %xmm5,%xmm2
mulsd  %xmm13,%xmm2
movapd %xmm3,%xmm4
mulsd  %xmm14,%xmm4
addsd  %xmm2,%xmm4
movapd %xmm0,%xmm2
mulsd  %xmm15,%xmm2
addsd  %xmm4,%xmm2
movsd  %xmm2,0x30(%rbx)
mulsd  %xmm10,%xmm5
mulsd  %xmm1,%xmm3
addsd  %xmm5,%xmm3
mulsd  %xmm7,%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,0x50(%rbx)
movsd  %xmm6,0x70(%rbx)
movapd 0xa0(%rsp),%xmm3
movapd %xmm3,%xmm5
unpckhpd %xmm3,%xmm5
movsd  0x8(%rsp),%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm3,%xmm9
addsd  %xmm0,%xmm9
movsd  0xb0(%rsp),%xmm2
mulsd  %xmm2,%xmm11
addsd  %xmm9,%xmm11
movsd  0x10(%rsp),%xmm0
mulsd  %xmm5,%xmm0
mulsd  %xmm3,%xmm12
addsd  %xmm0,%xmm12
mulsd  %xmm2,%xmm8
addsd  %xmm12,%xmm8
addsd  0xb8(%rsp),%xmm8
movsd  %xmm11,0x18(%rbx)
mulsd  %xmm5,%xmm13
mulsd  %xmm3,%xmm14
addsd  %xmm13,%xmm14
mulsd  %xmm2,%xmm15
addsd  %xmm14,%xmm15
movsd  %xmm15,0x38(%rbx)
mulsd  %xmm10,%xmm5
mulsd  %xmm1,%xmm3
addsd  %xmm5,%xmm3
mulsd  %xmm7,%xmm2
addsd  %xmm3,%xmm2
movsd  %xmm2,0x58(%rbx)
movsd  %xmm8,0x78(%rbx)
add    $0x180,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
lea    0xa28(%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, double* %5) {
%7 = alloca [4 x double]*
%8 = alloca i32
%9 = alloca i32
%10 = alloca double
%11 = alloca double
%12 = alloca double*
%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 double* %5, double** %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 = %234, %59
%145 = load i32, i32* %17
%146 = icmp slt i32 %145, 4
br i1 %146, label %147, label %237
147: ; preds = %144
store i32 0, i32* %18
br label %148
148: ; preds = %192, %147
%149 = load i32, i32* %18
%150 = icmp slt i32 %149, 3
br i1 %150, label %151, label %195
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 = load double*, double** %12
%186 = load i32, i32* %17
%187 = load i32, i32* %18
%188 = mul nsw i32 %187, 4
%189 = add nsw i32 %186, %188
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %185, i64 %190
store double %184, double* %191
br label %192
192: ; preds = %151
%193 = load i32, i32* %18
%194 = add nsw i32 %193, 1
store i32 %194, i32* %18
br label %148
195: ; preds = %148
%196 = load i32, i32* %17
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %16, i64 0, i64 %197
%199 = getelementptr inbounds [4 x double], [4 x double]* %198, i64 0, i64 0
%200 = load double, double* %199
%201 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %14, i64 0, i64 0
%202 = getelementptr inbounds [4 x double], [4 x double]* %201, i64 0, i64 3
%203 = load double, double* %202
%204 = load i32, i32* %17
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %16, i64 0, i64 %205
%207 = getelementptr inbounds [4 x double], [4 x double]* %206, i64 0, i64 1
%208 = load double, double* %207
%209 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %14, i64 0, i64 1
%210 = getelementptr inbounds [4 x double], [4 x double]* %209, i64 0, i64 3
%211 = load double, double* %210
%212 = fmul double %208, %211
%213 = call double @llvm.fmuladd.f64(double %200, double %203, double %212)
%214 = load i32, i32* %17
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %16, i64 0, i64 %215
%217 = getelementptr inbounds [4 x double], [4 x double]* %216, i64 0, i64 2
%218 = load double, double* %217
%219 = getelementptr inbounds [3 x [4 x double]], [3 x [4 x double]]* %14, i64 0, i64 2
%220 = getelementptr inbounds [4 x double], [4 x double]* %219, i64 0, i64 3
%221 = load double, double* %220
%222 = call double @llvm.fmuladd.f64(double %218, double %221, double %213)
%223 = load i32, i32* %17
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %16, i64 0, i64 %224
%226 = getelementptr inbounds [4 x double], [4 x double]* %225, i64 0, i64 3
%227 = load double, double* %226
%228 = fadd double %222, %227
%229 = load double*, double** %12
%230 = load i32, i32* %17
%231 = add nsw i32 %230, 12
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds double, double* %229, i64 %232
store double %228, double* %233
br label %234
234: ; preds = %195
%235 = load i32, i32* %17
%236 = add nsw i32 %235, 1
store i32 %236, i32* %17
br label %144
237: ; 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, double* 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 %194, 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)
store double %102, double* %5
%103 = fmul double %98, %89
%104 = call double @llvm.fmuladd.f64(double %100, double %87, double %103)
%105 = call double @llvm.fmuladd.f64(double %42, double %91, double %104)
%106 = getelementptr inbounds double, double* %5, i64 4
store double %105, double* %106
%107 = fmul double %98, %95
%108 = call double @llvm.fmuladd.f64(double %100, double %93, double %107)
%109 = call double @llvm.fmuladd.f64(double %42, double %97, double %108)
%110 = getelementptr inbounds double, double* %5, i64 8
store double %109, double* %110
%111 = fmul double %98, %77
%112 = call double @llvm.fmuladd.f64(double %100, double %75, double %111)
%113 = call double @llvm.fmuladd.f64(double %42, double %79, double %112)
%114 = fadd double %113, 0.000000e+00
%115 = getelementptr inbounds double, double* %5, i64 12
store double %114, double* %115
%116 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %9, i64 0, i64 1, i64 0
%117 = bitcast double* %116 to <2 x double>*
%118 = load <2 x double>, <2 x double>* %117
%119 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %9, i64 0, i64 1, i64 2
%120 = load double, double* %119
%121 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %9, i64 0, i64 1, i64 3
%122 = load double, double* %121
%123 = extractelement <2 x double> %118, i64 1
%124 = fmul double %123, %83
%125 = extractelement <2 x double> %118, i64 0
%126 = call double @llvm.fmuladd.f64(double %125, double %81, double %124)
%127 = call double @llvm.fmuladd.f64(double %120, double %85, double %126)
%128 = getelementptr inbounds double, double* %5, i64 1
store double %127, double* %128
%129 = fmul double %123, %89
%130 = call double @llvm.fmuladd.f64(double %125, double %87, double %129)
%131 = call double @llvm.fmuladd.f64(double %120, double %91, double %130)
%132 = getelementptr inbounds double, double* %5, i64 5
store double %131, double* %132
%133 = fmul double %123, %95
%134 = call double @llvm.fmuladd.f64(double %125, double %93, double %133)
%135 = call double @llvm.fmuladd.f64(double %120, double %97, double %134)
%136 = getelementptr inbounds double, double* %5, i64 9
store double %135, double* %136
%137 = fmul double %123, %77
%138 = call double @llvm.fmuladd.f64(double %125, double %75, double %137)
%139 = call double @llvm.fmuladd.f64(double %120, double %79, double %138)
%140 = fadd double %139, %122
%141 = getelementptr inbounds double, double* %5, i64 13
store double %140, double* %141
%142 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %9, i64 0, i64 2, i64 0
%143 = bitcast double* %142 to <2 x double>*
%144 = load <2 x double>, <2 x double>* %143
%145 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %9, i64 0, i64 2, i64 2
%146 = load double, double* %145
%147 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %9, i64 0, i64 2, i64 3
%148 = load double, double* %147
%149 = extractelement <2 x double> %144, i64 1
%150 = fmul double %149, %83
%151 = extractelement <2 x double> %144, i64 0
%152 = call double @llvm.fmuladd.f64(double %151, double %81, double %150)
%153 = call double @llvm.fmuladd.f64(double %146, double %85, double %152)
%154 = getelementptr inbounds double, double* %5, i64 2
store double %153, double* %154
%155 = fmul double %149, %89
%156 = call double @llvm.fmuladd.f64(double %151, double %87, double %155)
%157 = call double @llvm.fmuladd.f64(double %146, double %91, double %156)
%158 = getelementptr inbounds double, double* %5, i64 6
store double %157, double* %158
%159 = fmul double %149, %95
%160 = call double @llvm.fmuladd.f64(double %151, double %93, double %159)
%161 = call double @llvm.fmuladd.f64(double %146, double %97, double %160)
%162 = getelementptr inbounds double, double* %5, i64 10
store double %161, double* %162
%163 = fmul double %149, %77
%164 = call double @llvm.fmuladd.f64(double %151, double %75, double %163)
%165 = call double @llvm.fmuladd.f64(double %146, double %79, double %164)
%166 = fadd double %165, %148
%167 = getelementptr inbounds double, double* %5, i64 14
store double %166, double* %167
%168 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %9, i64 0, i64 3, i64 0
%169 = bitcast double* %168 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %9, i64 0, i64 3, i64 2
%172 = load double, double* %171
%173 = getelementptr inbounds [4 x [4 x double]], [4 x [4 x double]]* %9, i64 0, i64 3, i64 3
%174 = load double, double* %173
%175 = extractelement <2 x double> %170, i64 1
%176 = fmul double %175, %83
%177 = extractelement <2 x double> %170, i64 0
%178 = call double @llvm.fmuladd.f64(double %177, double %81, double %176)
%179 = call double @llvm.fmuladd.f64(double %172, double %85, double %178)
%180 = getelementptr inbounds double, double* %5, i64 3
store double %179, double* %180
%181 = fmul double %175, %89
%182 = call double @llvm.fmuladd.f64(double %177, double %87, double %181)
%183 = call double @llvm.fmuladd.f64(double %172, double %91, double %182)
%184 = getelementptr inbounds double, double* %5, i64 7
store double %183, double* %184
%185 = fmul double %175, %95
%186 = call double @llvm.fmuladd.f64(double %177, double %93, double %185)
%187 = call double @llvm.fmuladd.f64(double %172, double %97, double %186)
%188 = getelementptr inbounds double, double* %5, i64 11
store double %187, double* %188
%189 = fmul double %175, %77
%190 = call double @llvm.fmuladd.f64(double %177, double %75, double %189)
%191 = call double @llvm.fmuladd.f64(double %172, double %79, double %190)
%192 = fadd double %191, %174
%193 = getelementptr inbounds double, double* %5, i64 15
store double %192, double* %193
ret void
194: ; preds = %6
%195 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @str, i64 0, i64 0))
unreachable
}