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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, int, double, ...);
int main() {
  double train_x[4][3] = {{0, 0, 0}, {0, 1, 1}, {1, 0, 1}, {1, 1, 0}};
  double v1[2][3] = {{0.8, 1.0, -0.3}, {1.3, 0.6, -1.5}};
  double v2[2][3] = {{-6.0, 3.0, 1.5}, {-0.3, -1.2, 0.4}};
  double w[3] = {1.1, -1.2, -0.5};
  double z[4][2];
  double y[4];
  for (int k = 0; k < 2; k++) {
    for (int i = 0; i < 4; i++) {
      for (int j = 0; j < 3; j++) {
        if (j != 2) {
          z[i][k] += v1[k][j] * train_x[i][j];
        } else {
          z[i][k] += v1[k][j];
          if (z[i][k] >= 0) {
            z[i][k] = 1.0;
          } else {
            z[i][k] = 0.0;
          }
          printf("%d.z%d = %f\n", i + 1, k + 1, z[i][k]);
        }
      }
    }
  }
  for (int j = 0; j < 4; j++) {
    for (int k = 0; k < 3; k++) {
      if (k != 2) {
        y[j] += w[k] * z[j][k];
      } else {
        y[j] += w[k];
        if (y[j] >= 0) {
          y[j] = 1;
        } else {
          y[j] = 0;
        }
        printf("y%d = %f\n", j + 1, y[j]);
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x170,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x70(%rbp),%rdi
xor    %esi,%esi
mov    $0x60,%edx
call   1040 <memset@plt>
movsd  0xefe(%rip),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xef1(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xee4(%rip),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xed7(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0xeca(%rip),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  0xebd(%rip),%xmm0
movsd  %xmm0,-0x20(%rbp)
lea    -0xa0(%rbp),%rdi
xor    %esi,%esi
mov    $0x30,%edx
call   1040 <memset@plt>
movsd  0xea5(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xe8d(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xe45(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xe65(%rip),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xe4d(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xe38(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
lea    -0xd0(%rbp),%rdi
xor    %esi,%esi
mov    $0x30,%edx
call   1040 <memset@plt>
movsd  0xe10(%rip),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0xdf8(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  0xde0(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0xdc8(%rip),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xdb0(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0xd98(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0xde9(%rip),%rax
mov    %rax,-0xf0(%rbp)
mov    0xde3(%rip),%rax
mov    %rax,-0xe8(%rbp)
mov    0xddd(%rip),%rax
mov    %rax,-0xe0(%rbp)
movl   $0x0,-0x154(%rbp)
cmpl   $0x2,-0x154(%rbp)
jge    14b5 <main+0x395>
movl   $0x0,-0x158(%rbp)
cmpl   $0x4,-0x158(%rbp)
jge    149c <main+0x37c>
movl   $0x0,-0x15c(%rbp)
cmpl   $0x3,-0x15c(%rbp)
jge    1483 <main+0x363>
cmpl   $0x2,-0x15c(%rbp)
je     135e <main+0x23e>
movslq -0x154(%rbp),%rcx
lea    -0xa0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x15c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x158(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x15c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x158(%rbp),%rcx
lea    -0x130(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    146a <main+0x34a>
movslq -0x154(%rbp),%rcx
lea    -0xa0(%rbp),%rax
imul   $0x18,%rcx,%rcx
add    %rcx,%rax
movslq -0x15c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movslq -0x158(%rbp),%rcx
lea    -0x130(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x154(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movslq -0x158(%rbp),%rcx
lea    -0x130(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1401 <main+0x2e1>
movslq -0x158(%rbp),%rcx
lea    -0x130(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x154(%rbp),%rcx
movsd  0xc51(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1425 <main+0x305>
movslq -0x158(%rbp),%rcx
lea    -0x130(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x154(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x158(%rbp),%esi
add    $0x1,%esi
mov    -0x154(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
movslq -0x158(%rbp),%rcx
lea    -0x130(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x154(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
lea    0xc15(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
jmp    146f <main+0x34f>
mov    -0x15c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x15c(%rbp)
jmp    12d2 <main+0x1b2>
jmp    1488 <main+0x368>
mov    -0x158(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x158(%rbp)
jmp    12bb <main+0x19b>
jmp    14a1 <main+0x381>
mov    -0x154(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x154(%rbp)
jmp    12a4 <main+0x184>
movl   $0x0,-0x160(%rbp)
cmpl   $0x4,-0x160(%rbp)
jge    1616 <main+0x4f6>
movl   $0x0,-0x164(%rbp)
cmpl   $0x3,-0x164(%rbp)
jge    15fd <main+0x4dd>
cmpl   $0x2,-0x164(%rbp)
je     1547 <main+0x427>
movslq -0x164(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x160(%rbp),%rcx
lea    -0x130(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x164(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movslq -0x160(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
jmp    15e4 <main+0x4c4>
movslq -0x164(%rbp),%rax
movsd  -0xf0(%rbp,%rax,8),%xmm0
ff ff
movslq -0x160(%rbp),%rax
addsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
movslq -0x160(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     15aa <main+0x48a>
movslq -0x160(%rbp),%rax
movsd  0xaac(%rip),%xmm0
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
jmp    15bd <main+0x49d>
movslq -0x160(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
mov    -0x160(%rbp),%esi
add    $0x1,%esi
movslq -0x160(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
lea    0xaa8(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    15e9 <main+0x4c9>
mov    -0x164(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x164(%rbp)
jmp    14d6 <main+0x3b6>
jmp    1602 <main+0x4e2>
mov    -0x160(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x160(%rbp)
jmp    14bf <main+0x39f>
xor    %eax,%eax
add    $0x170,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0x110,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0x80(%rsp)
movaps 0xebe(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movabs $0x3ff0000000000000,%rax
mov    %rax,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
mov    %rax,0xd0(%rsp)
movaps 0xe9d(%rip),%xmm0
movaps %xmm0,0xe0(%rsp)
movaps 0xe9e(%rip),%xmm0
movaps %xmm0,0xf0(%rsp)
movaps 0xe9f(%rip),%xmm0
movaps %xmm0,0x100(%rsp)
movsd  0xe0(%rsp),%xmm2
movsd  %xmm2,0x18(%rsp)
movsd  0xe8(%rsp),%xmm3
movsd  %xmm3,0x8(%rsp)
movsd  0xf0(%rsp),%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x80(%rsp),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x20(%rsp),%xmm0
movsd  0x88(%rsp),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorpd  %xmm1,%xmm1
cmpnlesd %xmm2,%xmm1
movsd  0xe41(%rip),%xmm0
andnpd %xmm0,%xmm1
movlpd %xmm1,0x20(%rsp)
lea    0xe58(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0x98(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
movsd  0xa0(%rsp),%xmm2
mulsd  0x8(%rsp),%xmm2
addsd  %xmm0,%xmm2
addsd  0x10(%rsp),%xmm2
xorpd  %xmm1,%xmm1
cmpnlesd %xmm2,%xmm1
movsd  0xde2(%rip),%xmm0
andnpd %xmm0,%xmm1
movlpd %xmm1,0x30(%rsp)
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0xb0(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
addsd  0x40(%rsp),%xmm0
movsd  0xb8(%rsp),%xmm2
mulsd  0x8(%rsp),%xmm2
addsd  %xmm0,%xmm2
addsd  0x10(%rsp),%xmm2
xorpd  %xmm1,%xmm1
cmpnlesd %xmm2,%xmm1
movsd  0xd8a(%rip),%xmm0
andnpd %xmm0,%xmm1
movlpd %xmm1,0x40(%rsp)
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0x18(%rsp),%xmm0
mulsd  0xc8(%rsp),%xmm0
addsd  0x50(%rsp),%xmm0
movapd %xmm0,%xmm1
movsd  0x8(%rsp),%xmm0
mulsd  0xd0(%rsp),%xmm0
addsd  %xmm1,%xmm0
addsd  0x10(%rsp),%xmm0
xorpd  %xmm1,%xmm1
cmpnlesd %xmm0,%xmm1
movsd  0xd2e(%rip),%xmm0
andnpd %xmm0,%xmm1
movlpd %xmm1,0x50(%rsp)
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0xf8(%rsp),%xmm2
movsd  %xmm2,0x18(%rsp)
movsd  0x100(%rsp),%xmm3
movsd  %xmm3,0x8(%rsp)
movsd  0x108(%rsp),%xmm1
movsd  %xmm1,0x10(%rsp)
movsd  0x80(%rsp),%xmm0
mulsd  %xmm2,%xmm0
addsd  0x28(%rsp),%xmm0
movsd  0x88(%rsp),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
xorpd  %xmm1,%xmm1
cmpnlesd %xmm2,%xmm1
movsd  0xcaf(%rip),%xmm0
andnpd %xmm0,%xmm1
movlpd %xmm1,0x28(%rsp)
movsd  0xca5(%rip),%xmm0
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0x98(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
addsd  0x38(%rsp),%xmm0
movsd  0xa0(%rsp),%xmm2
mulsd  0x8(%rsp),%xmm2
addsd  %xmm0,%xmm2
addsd  0x10(%rsp),%xmm2
xorpd  %xmm1,%xmm1
cmpnlesd %xmm2,%xmm1
movsd  0xc4f(%rip),%xmm0
andnpd %xmm0,%xmm1
movlpd %xmm1,0x38(%rsp)
mov    %rbx,%rdi
mov    $0x2,%esi
movsd  0xc3d(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0xb0(%rsp),%xmm0
mulsd  0x18(%rsp),%xmm0
addsd  0x48(%rsp),%xmm0
movsd  0xb8(%rsp),%xmm2
mulsd  0x8(%rsp),%xmm2
addsd  %xmm0,%xmm2
addsd  0x10(%rsp),%xmm2
xorpd  %xmm1,%xmm1
cmpnlesd %xmm2,%xmm1
movsd  0xbef(%rip),%xmm0
andnpd %xmm0,%xmm1
movlpd %xmm1,0x48(%rsp)
mov    %rbx,%rdi
mov    $0x3,%esi
movsd  0xbdd(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0x18(%rsp),%xmm0
mulsd  0xc8(%rsp),%xmm0
addsd  0x58(%rsp),%xmm0
movapd %xmm0,%xmm1
movsd  0x8(%rsp),%xmm0
mulsd  0xd0(%rsp),%xmm0
addsd  %xmm1,%xmm0
addsd  0x10(%rsp),%xmm0
xorpd  %xmm1,%xmm1
cmpnlesd %xmm0,%xmm1
movsd  0xb8b(%rip),%xmm0
andnpd %xmm0,%xmm1
movlpd %xmm1,0x58(%rsp)
mov    %rbx,%rdi
mov    $0x4,%esi
movsd  0xb79(%rip),%xmm0
mov    $0x2,%al
call   1030 <printf@plt>
movsd  0x20(%rsp),%xmm0
mulsd  0xb6c(%rip),%xmm0
addsd  0x60(%rsp),%xmm0
movsd  0x28(%rsp),%xmm1
mulsd  0xb60(%rip),%xmm1
addsd  %xmm0,%xmm1
addsd  0xb5c(%rip),%xmm1
xorpd  %xmm0,%xmm0
cmpnlesd %xmm1,%xmm0
movsd  0xb2b(%rip),%xmm1
andnpd %xmm1,%xmm0
movlpd %xmm0,0x60(%rsp)
lea    0xb4f(%rip),%rbx
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  0x30(%rsp),%xmm0
mulsd  0xb0d(%rip),%xmm0
addsd  0x68(%rsp),%xmm0
movsd  0x38(%rsp),%xmm1
mulsd  0xb01(%rip),%xmm1
addsd  %xmm0,%xmm1
addsd  0xafd(%rip),%xmm1
xorpd  %xmm0,%xmm0
cmpnlesd %xmm1,%xmm0
movsd  0xacc(%rip),%xmm1
andnpd %xmm1,%xmm0
movlpd %xmm0,0x68(%rsp)
mov    %rbx,%rdi
mov    $0x2,%esi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  0x40(%rsp),%xmm0
mulsd  0xab5(%rip),%xmm0
addsd  0x70(%rsp),%xmm0
movsd  0x48(%rsp),%xmm1
mulsd  0xaa9(%rip),%xmm1
addsd  %xmm0,%xmm1
addsd  0xaa5(%rip),%xmm1
xorpd  %xmm0,%xmm0
cmpnlesd %xmm1,%xmm0
movsd  0xa74(%rip),%xmm1
andnpd %xmm1,%xmm0
movlpd %xmm0,0x70(%rsp)
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x1,%al
call   1030 <printf@plt>
movsd  0xa63(%rip),%xmm0
mulsd  0x50(%rsp),%xmm0
addsd  0x78(%rsp),%xmm0
movsd  0xa57(%rip),%xmm1
mulsd  0x58(%rsp),%xmm1
addsd  %xmm0,%xmm1
addsd  0xa4d(%rip),%xmm1
xorpd  %xmm0,%xmm0
cmpnlesd %xmm1,%xmm0
movsd  0xa1c(%rip),%xmm1
andnpd %xmm1,%xmm0
movlpd %xmm0,0x78(%rsp)
mov    %rbx,%rdi
mov    $0x4,%esi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x110,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
@.str = [13 x i8] c"%d.z%d = %f\0A\00"
@.str.1 = [10 x i8] c"y%d = %f\0A\00"
define i32 @main() {
%1 = alloca [4 x [3 x double]]
%2 = alloca [2 x [3 x double]]
%3 = alloca [4 x [2 x double]]
%4 = alloca [4 x double]
%5 = bitcast [4 x [3 x double]]* %1 to i8*
%6 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 1, i64 1
%7 = bitcast double* %6 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %7
%8 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 2, i64 0
store double 1.000000e+00, double* %8
%9 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 2, i64 2
%10 = bitcast double* %9 to <2 x double>*
store <2 x double> <double 1.000000e+00, double 1.000000e+00>, <2 x double>* %10
%11 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 3, i64 1
store double 1.000000e+00, double* %11
%12 = bitcast [2 x [3 x double]]* %2 to i8*
%13 = bitcast [2 x [3 x double]]* %2 to <2 x double>*
store <2 x double> <double 8.000000e-01, double 1.000000e+00>, <2 x double>* %13
%14 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 0, i64 2
%15 = bitcast double* %14 to <2 x double>*
store <2 x double> <double -3.000000e-01, double 1.300000e+00>, <2 x double>* %15
%16 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 1, i64 1
%17 = bitcast double* %16 to <2 x double>*
store <2 x double> <double 6.000000e-01, double -1.500000e+00>, <2 x double>* %17
%18 = bitcast [4 x [2 x double]]* %3 to i8*
%19 = bitcast [4 x double]* %4 to i8*
%20 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 0, i64 2
%21 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 0, i64 0
%22 = load double, double* %21
%23 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 0, i64 1
%24 = load double, double* %23
%25 = load double, double* %20
%26 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 0, i64 0
%27 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 0, i64 0
%28 = load double, double* %27
%29 = load double, double* %26
%30 = tail call double @llvm.fmuladd.f64(double %22, double %28, double %29)
%31 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 0, i64 1
%32 = load double, double* %31
%33 = tail call double @llvm.fmuladd.f64(double %24, double %32, double %30)
%34 = fadd double %25, %33
%35 = fcmp ult double %34, 0.000000e+00
%36 = select i1 %35, double 0.000000e+00, double 1.000000e+00
store double %36, double* %26
%37 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 1, double 1.000000e+00, double %36)
%38 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 1, i64 0
%39 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 1, i64 0
%40 = load double, double* %39
%41 = load double, double* %38
%42 = tail call double @llvm.fmuladd.f64(double %22, double %40, double %41)
%43 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 1, i64 1
%44 = load double, double* %43
%45 = tail call double @llvm.fmuladd.f64(double %24, double %44, double %42)
%46 = fadd double %25, %45
%47 = fcmp ult double %46, 0.000000e+00
%48 = select i1 %47, double 0.000000e+00, double 1.000000e+00
store double %48, double* %38
%49 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 2, double 1.000000e+00, double %48)
%50 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 2, i64 0
%51 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 2, i64 0
%52 = load double, double* %51
%53 = load double, double* %50
%54 = tail call double @llvm.fmuladd.f64(double %22, double %52, double %53)
%55 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 2, i64 1
%56 = load double, double* %55
%57 = tail call double @llvm.fmuladd.f64(double %24, double %56, double %54)
%58 = fadd double %25, %57
%59 = fcmp ult double %58, 0.000000e+00
%60 = select i1 %59, double 0.000000e+00, double 1.000000e+00
store double %60, double* %50
%61 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 3, double 1.000000e+00, double %60)
%62 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 3, i64 0
%63 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 3, i64 0
%64 = load double, double* %63
%65 = load double, double* %62
%66 = tail call double @llvm.fmuladd.f64(double %22, double %64, double %65)
%67 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 3, i64 1
%68 = load double, double* %67
%69 = tail call double @llvm.fmuladd.f64(double %24, double %68, double %66)
%70 = fadd double %25, %69
%71 = fcmp ult double %70, 0.000000e+00
%72 = select i1 %71, double 0.000000e+00, double 1.000000e+00
store double %72, double* %62
%73 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 4, double 1.000000e+00, double %72)
%74 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 1, i64 2
%75 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 1, i64 0
%76 = load double, double* %75
%77 = getelementptr inbounds [2 x [3 x double]], [2 x [3 x double]]* %2, i64 0, i64 1, i64 1
%78 = load double, double* %77
%79 = load double, double* %74
%80 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 0, i64 1
%81 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 0, i64 0
%82 = load double, double* %81
%83 = load double, double* %80
%84 = tail call double @llvm.fmuladd.f64(double %76, double %82, double %83)
%85 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 0, i64 1
%86 = load double, double* %85
%87 = tail call double @llvm.fmuladd.f64(double %78, double %86, double %84)
%88 = fadd double %79, %87
%89 = fcmp ult double %88, 0.000000e+00
%90 = select i1 %89, double 0.000000e+00, double 1.000000e+00
store double %90, double* %80
%91 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 1, double 2.000000e+00, double %90)
%92 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 1, i64 1
%93 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 1, i64 0
%94 = load double, double* %93
%95 = load double, double* %92
%96 = tail call double @llvm.fmuladd.f64(double %76, double %94, double %95)
%97 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 1, i64 1
%98 = load double, double* %97
%99 = tail call double @llvm.fmuladd.f64(double %78, double %98, double %96)
%100 = fadd double %79, %99
%101 = fcmp ult double %100, 0.000000e+00
%102 = select i1 %101, double 0.000000e+00, double 1.000000e+00
store double %102, double* %92
%103 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 2, double 2.000000e+00, double %102)
%104 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 2, i64 1
%105 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 2, i64 0
%106 = load double, double* %105
%107 = load double, double* %104
%108 = tail call double @llvm.fmuladd.f64(double %76, double %106, double %107)
%109 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 2, i64 1
%110 = load double, double* %109
%111 = tail call double @llvm.fmuladd.f64(double %78, double %110, double %108)
%112 = fadd double %79, %111
%113 = fcmp ult double %112, 0.000000e+00
%114 = select i1 %113, double 0.000000e+00, double 1.000000e+00
store double %114, double* %104
%115 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 3, double 2.000000e+00, double %114)
%116 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 3, i64 1
%117 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 3, i64 0
%118 = load double, double* %117
%119 = load double, double* %116
%120 = tail call double @llvm.fmuladd.f64(double %76, double %118, double %119)
%121 = getelementptr inbounds [4 x [3 x double]], [4 x [3 x double]]* %1, i64 0, i64 3, i64 1
%122 = load double, double* %121
%123 = tail call double @llvm.fmuladd.f64(double %78, double %122, double %120)
%124 = fadd double %79, %123
%125 = fcmp ult double %124, 0.000000e+00
%126 = select i1 %125, double 0.000000e+00, double 1.000000e+00
store double %126, double* %116
%127 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str, i64 0, i64 0), i32 4, double 2.000000e+00, double %126)
%128 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 0
%129 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 0, i64 0
%130 = load double, double* %129
%131 = load double, double* %128
%132 = tail call double @llvm.fmuladd.f64(double %130, double 1.100000e+00, double %131)
%133 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 0, i64 1
%134 = load double, double* %133
%135 = tail call double @llvm.fmuladd.f64(double %134, double -1.200000e+00, double %132)
%136 = fadd double %135, -5.000000e-01
%137 = fcmp ult double %136, 0.000000e+00
%138 = select i1 %137, double 0.000000e+00, double 1.000000e+00
store double %138, double* %128
%139 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 1, double %138)
%140 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 1
%141 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 1, i64 0
%142 = load double, double* %141
%143 = load double, double* %140
%144 = tail call double @llvm.fmuladd.f64(double %142, double 1.100000e+00, double %143)
%145 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 1, i64 1
%146 = load double, double* %145
%147 = tail call double @llvm.fmuladd.f64(double %146, double -1.200000e+00, double %144)
%148 = fadd double %147, -5.000000e-01
%149 = fcmp ult double %148, 0.000000e+00
%150 = select i1 %149, double 0.000000e+00, double 1.000000e+00
store double %150, double* %140
%151 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 2, double %150)
%152 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 2
%153 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 2, i64 0
%154 = load double, double* %153
%155 = load double, double* %152
%156 = tail call double @llvm.fmuladd.f64(double %154, double 1.100000e+00, double %155)
%157 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 2, i64 1
%158 = load double, double* %157
%159 = tail call double @llvm.fmuladd.f64(double %158, double -1.200000e+00, double %156)
%160 = fadd double %159, -5.000000e-01
%161 = fcmp ult double %160, 0.000000e+00
%162 = select i1 %161, double 0.000000e+00, double 1.000000e+00
store double %162, double* %152
%163 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 3, double %162)
%164 = getelementptr inbounds [4 x double], [4 x double]* %4, i64 0, i64 3
%165 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 3, i64 0
%166 = load double, double* %165
%167 = load double, double* %164
%168 = tail call double @llvm.fmuladd.f64(double %166, double 1.100000e+00, double %167)
%169 = getelementptr inbounds [4 x [2 x double]], [4 x [2 x double]]* %3, i64 0, i64 3, i64 1
%170 = load double, double* %169
%171 = tail call double @llvm.fmuladd.f64(double %170, double -1.200000e+00, double %168)
%172 = fadd double %171, -5.000000e-01
%173 = fcmp ult double %172, 0.000000e+00
%174 = select i1 %173, double 0.000000e+00, double 1.000000e+00
store double %174, double* %164
%175 = tail call i32 (i8*, i32, double, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0), i32 4, double %174)
ret i32 0
}