#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 *);
void mataddc(double z[], double x[], double y[], int size, int m1, int m2,
             int n1, int n2) {
  int i, j;
  int flag = 0;
  if (m1 == m2 && n1 == n2) {
    for (i = 0; i <= size - 1; i++) {
      z[i] = x[i] + y[i];
    }
    flag = 1;
  }
  if (m1 == m2 && n2 == 1) {
    size = 0;
    for (j = 0; j <= n1 - 1; j++) {
      for (i = 0; i <= m1 - 1; i++) {
        z[size] = x[size] + y[i];
        size = size + 1;
      }
    }
    flag = 1;
  }
  if (m1 == m2 && n1 == 1) {
    size = 0;
    for (j = 0; j <= n2 - 1; j++) {
      for (i = 0; i <= m1 - 1; i++) {
        z[size] = y[size] + x[i];
        size = size + 1;
      }
    }
    flag = 1;
  }
  if (n1 == n2 && m2 == 1) {
    size = 0;
    for (i = 0; i <= n1 - 1; i++) {
      for (j = 0; j <= m1 - 1; j++) {
        z[size] = x[size] + y[i];
        size = size + 1;
      }
    }
    flag = 1;
  }
  if (n1 == n2 && m1 == 1) {
    size = 0;
    for (i = 0; i <= n1 - 1; i++) {
      for (j = 0; j <= m2 - 1; j++) {
        z[size] = y[size] + x[i];
        size = size + 1;
      }
    }
    flag = 1;
  }
  if (flag == 0) {
    printf("mataddc: nonconformability of matrices \n");
  }
}


x86 assembly (clang, -O0):
<mataddc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    11a8 <mataddc+0x98>
mov    0x10(%rbp),%eax
cmp    0x18(%rbp),%eax
jne    11a8 <mataddc+0x98>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     11a1 <mataddc+0x91>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    115b <mataddc+0x4b>
movl   $0x1,-0x30(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    124d <mataddc+0x13d>
cmpl   $0x1,0x18(%rbp)
jne    124d <mataddc+0x13d>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1246 <mataddc+0x136>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1233 <mataddc+0x123>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e4 <mataddc+0xd4>
jmp    1238 <mataddc+0x128>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11cc <mataddc+0xbc>
movl   $0x1,-0x30(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    12f2 <mataddc+0x1e2>
cmpl   $0x1,0x10(%rbp)
jne    12f2 <mataddc+0x1e2>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12eb <mataddc+0x1db>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12d8 <mataddc+0x1c8>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1289 <mataddc+0x179>
jmp    12dd <mataddc+0x1cd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1271 <mataddc+0x161>
movl   $0x1,-0x30(%rbp)
mov    0x10(%rbp),%eax
cmp    0x18(%rbp),%eax
jne    1397 <mataddc+0x287>
cmpl   $0x1,-0x24(%rbp)
jne    1397 <mataddc+0x287>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1390 <mataddc+0x280>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     137d <mataddc+0x26d>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    132e <mataddc+0x21e>
jmp    1382 <mataddc+0x272>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1316 <mataddc+0x206>
movl   $0x1,-0x30(%rbp)
mov    0x10(%rbp),%eax
cmp    0x18(%rbp),%eax
jne    143c <mataddc+0x32c>
cmpl   $0x1,-0x20(%rbp)
jne    143c <mataddc+0x32c>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1435 <mataddc+0x325>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1422 <mataddc+0x312>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13d3 <mataddc+0x2c3>
jmp    1427 <mataddc+0x317>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13bb <mataddc+0x2ab>
movl   $0x1,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jne    1452 <mataddc+0x342>
lea    0xbb3(%rip),%rdi
call   1030 <printf@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mataddc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x40(%rsp),%eax
mov    %eax,-0x7c(%rsp)
mov    0x38(%rsp),%r15d
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
mov    %rax,-0x8(%rsp)
xor    %r11d,%r11d
cmp    %r9d,%r8d
jne    1307 <mataddc+0x1f7>
cmp    -0x7c(%rsp),%r15d
jne    1307 <mataddc+0x1f7>
mov    $0x1,%r11d
test   %ecx,%ecx
jle    1307 <mataddc+0x1f7>
mov    %ecx,%r14d
cmp    $0x4,%ecx
jae    1203 <mataddc+0xf3>
xor    %ecx,%ecx
mov    %rcx,%rbp
not    %rbp
add    %r14,%rbp
mov    %r14,%rax
and    $0x3,%rax
je     1199 <mataddc+0x89>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm0
addsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1180 <mataddc+0x70>
cmp    $0x3,%rbp
jb     1307 <mataddc+0x1f7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rsi,%rcx,8),%xmm0
addsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
movsd  0x8(%rsi,%rcx,8),%xmm0
addsd  0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rcx,8)
movsd  0x10(%rsi,%rcx,8),%xmm0
addsd  0x10(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rcx,8)
movsd  0x18(%rsi,%rcx,8),%xmm0
addsd  0x18(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r14
jne    11b0 <mataddc+0xa0>
jmp    1307 <mataddc+0x1f7>
lea    (%rdi,%r14,8),%rcx
lea    (%rsi,%r14,8),%rax
cmp    %rdi,%rax
seta   %r10b
lea    (%rdx,%r14,8),%rax
cmp    %rsi,%rcx
seta   %bl
cmp    %rdi,%rax
seta   %al
cmp    %rdx,%rcx
seta   %bpl
xor    %ecx,%ecx
test   %bl,%r10b
jne    1169 <mataddc+0x59>
and    %bpl,%al
jne    1169 <mataddc+0x59>
mov    %r14d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     1d6f <mataddc+0xc5f>
mov    %r10,%rbx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rbx
xor    %ebp,%ebp
nopl   (%rax)
movupd (%rsi,%rbp,8),%xmm0
movupd 0x10(%rsi,%rbp,8),%xmm1
movupd (%rdx,%rbp,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdx,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rbp,8)
movupd %xmm0,0x10(%rdi,%rbp,8)
movupd 0x20(%rsi,%rbp,8),%xmm0
movupd 0x30(%rsi,%rbp,8),%xmm1
movupd 0x20(%rdx,%rbp,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%rdx,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,0x20(%rdi,%rbp,8)
movupd %xmm0,0x30(%rdi,%rbp,8)
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rbx
jne    1270 <mataddc+0x160>
test   $0x1,%r10b
je     12fe <mataddc+0x1ee>
movupd (%rsi,%rbp,8),%xmm0
movupd 0x10(%rsi,%rbp,8),%xmm1
movupd (%rdx,%rbp,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdx,%rbp,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rbp,8)
movupd %xmm0,0x10(%rdi,%rbp,8)
cmp    %r14,%rcx
jne    1169 <mataddc+0x59>
cmp    %r9d,%r8d
mov    %r9,-0x28(%rsp)
mov    %r15d,-0x30(%rsp)
jne    15a0 <mataddc+0x490>
cmpl   $0x1,-0x7c(%rsp)
jne    15a0 <mataddc+0x490>
test   %r15d,%r15d
jle    183d <mataddc+0x72d>
mov    %r8d,%r10d
lea    (%rdi,%r10,8),%rcx
lea    (%rsi,%r10,8),%rax
lea    (%rdx,%r10,8),%rbp
mov    %rbp,-0x50(%rsp)
mov    %r10d,%ebp
and    $0xfffffffc,%ebp
mov    %rbp,-0x78(%rsp)
add    $0xfffffffffffffffc,%rbp
mov    %rbp,-0x38(%rsp)
shr    $0x2,%rbp
add    $0x1,%rbp
cmp    %rdi,%rax
seta   %al
mov    %rcx,-0x48(%rsp)
cmp    %rsi,%rcx
seta   %cl
and    %al,%cl
mov    %cl,-0x58(%rsp)
mov    %rbp,%rax
mov    %rbp,-0x40(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rbp
mov    %rbp,-0x10(%rsp)
mov    %r10,%rbx
neg    %rbx
lea    0x30(%rdi),%rax
mov    %rax,-0x18(%rsp)
lea    0x30(%rsi),%rax
mov    %rax,-0x20(%rsp)
lea    0x8(%rsi),%rax
mov    %rax,-0x60(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,-0x68(%rsp)
lea    0x8(%rdx),%rax
mov    %rax,-0x70(%rsp)
xor    %r11d,%r11d
xor    %r12d,%r12d
jmp    13dd <mataddc+0x2cd>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11d
cmp    %r15d,%r11d
je     159a <mataddc+0x48a>
test   %r8d,%r8d
jle    13d0 <mataddc+0x2c0>
movslq %r12d,%r12
cmp    $0x4,%r8d
jb     1412 <mataddc+0x302>
lea    (%rdi,%r12,8),%rax
mov    -0x48(%rsp),%rcx
lea    (%rcx,%r12,8),%rcx
cmp    -0x50(%rsp),%rax
setb   %al
cmp    %rdx,%rcx
seta   %cl
and    %al,%cl
or     -0x58(%rsp),%cl
je     14a8 <mataddc+0x398>
xor    %eax,%eax
test   $0x1,%r10b
jne    1420 <mataddc+0x310>
mov    %rax,%rbp
jmp    143c <mataddc+0x32c>
nop
movsd  (%rsi,%r12,8),%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%r12,8)
add    $0x1,%r12
mov    %rax,%rbp
or     $0x1,%rbp
not    %rax
cmp    %rbx,%rax
je     13d0 <mataddc+0x2c0>
mov    %r15d,%r13d
mov    %rbx,%r15
mov    -0x60(%rsp),%rax
lea    (%rax,%r12,8),%rax
mov    -0x68(%rsp),%rcx
lea    (%rcx,%r12,8),%rbx
mov    %r10,%r14
sub    %rbp,%r14
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
xor    %ebp,%ebp
nopl   (%rax)
movsd  -0x8(%rax,%rbp,8),%xmm0
addsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
movsd  (%rax,%rbp,8),%xmm0
addsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r14
jne    1470 <mataddc+0x360>
add    %rbp,%r12
mov    %r15,%rbx
mov    %r13d,%r15d
jmp    13d0 <mataddc+0x2c0>
cmpq   $0x0,-0x38(%rsp)
je     158f <mataddc+0x47f>
mov    -0x18(%rsp),%rax
lea    (%rax,%r12,8),%r14
mov    -0x20(%rsp),%rax
lea    (%rax,%r12,8),%r13
mov    -0x10(%rsp),%r15
xor    %eax,%eax
nopl   (%rax)
movupd -0x30(%r13,%rax,8),%xmm0
movupd -0x20(%r13,%rax,8),%xmm1
movupd (%rdx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r14,%rax,8)
movupd %xmm0,-0x20(%r14,%rax,8)
movupd -0x10(%r13,%rax,8),%xmm0
movupd 0x0(%r13,%rax,8),%xmm1
movupd 0x20(%rdx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%rdx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r14,%rax,8)
movupd %xmm0,(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r15
jne    14d0 <mataddc+0x3c0>
testb  $0x1,-0x40(%rsp)
je     156c <mataddc+0x45c>
lea    (%rax,%r12,1),%rcx
movupd (%rsi,%rcx,8),%xmm0
movupd 0x10(%rsi,%rcx,8),%xmm1
movupd (%rdx,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rdx,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm0,0x10(%rdi,%rcx,8)
mov    -0x78(%rsp),%rcx
add    %rcx,%r12
mov    %rcx,%rax
cmp    %r10,%rcx
mov    -0x28(%rsp),%r9
mov    -0x30(%rsp),%r15d
je     13d0 <mataddc+0x2c0>
jmp    1414 <mataddc+0x304>
xor    %eax,%eax
testb  $0x1,-0x40(%rsp)
jne    153f <mataddc+0x42f>
jmp    156c <mataddc+0x45c>
mov    $0x1,%r11d
cmp    %r9d,%r8d
jne    1843 <mataddc+0x733>
cmp    $0x1,%r15d
jne    1843 <mataddc+0x733>
cmpl   $0x0,-0x7c(%rsp)
jle    1868 <mataddc+0x758>
mov    %r8d,%r10d
lea    (%rdi,%r10,8),%rcx
lea    (%rdx,%r10,8),%rax
lea    (%rsi,%r10,8),%rbp
mov    %rbp,-0x50(%rsp)
mov    %r10d,%ebp
and    $0xfffffffc,%ebp
mov    %rbp,-0x78(%rsp)
add    $0xfffffffffffffffc,%rbp
mov    %rbp,-0x38(%rsp)
shr    $0x2,%rbp
add    $0x1,%rbp
cmp    %rdi,%rax
seta   %al
mov    %rcx,-0x48(%rsp)
cmp    %rdx,%rcx
seta   %cl
and    %al,%cl
mov    %cl,-0x58(%rsp)
mov    %rbp,%rax
mov    %rbp,-0x40(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rbp
mov    %rbp,-0x10(%rsp)
mov    %r10,%r13
neg    %r13
lea    0x30(%rdi),%rax
mov    %rax,-0x18(%rsp)
lea    0x30(%rdx),%rax
mov    %rax,-0x20(%rsp)
lea    0x8(%rdx),%rax
mov    %rax,-0x60(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,-0x68(%rsp)
lea    0x8(%rsi),%rax
mov    %rax,-0x70(%rsp)
xor    %r11d,%r11d
xor    %r12d,%r12d
jmp    166f <mataddc+0x55f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11d
cmp    -0x7c(%rsp),%r11d
je     183d <mataddc+0x72d>
test   %r8d,%r8d
jle    1660 <mataddc+0x550>
movslq %r12d,%r12
cmp    $0x4,%r8d
jb     16a4 <mataddc+0x594>
lea    (%rdi,%r12,8),%rax
mov    -0x48(%rsp),%rcx
lea    (%rcx,%r12,8),%rcx
cmp    -0x50(%rsp),%rax
setb   %al
cmp    %rsi,%rcx
seta   %cl
and    %al,%cl
or     -0x58(%rsp),%cl
je     1742 <mataddc+0x632>
xor    %eax,%eax
test   $0x1,%r10b
jne    16c0 <mataddc+0x5b0>
mov    %rax,%rbp
jmp    16dc <mataddc+0x5cc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%r12,8),%xmm0
addsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%r12,8)
add    $0x1,%r12
mov    %rax,%rbp
or     $0x1,%rbp
not    %rax
cmp    %r13,%rax
je     1660 <mataddc+0x550>
mov    -0x60(%rsp),%rax
lea    (%rax,%r12,8),%rax
mov    -0x68(%rsp),%rcx
lea    (%rcx,%r12,8),%rbx
mov    %r10,%r14
sub    %rbp,%r14
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rbp,8),%xmm0
addsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
movsd  (%rax,%rbp,8),%xmm0
addsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r14
jne    1710 <mataddc+0x600>
add    %rbp,%r12
jmp    1660 <mataddc+0x550>
mov    %r13,%rbx
cmpq   $0x0,-0x38(%rsp)
je     1832 <mataddc+0x722>
mov    -0x18(%rsp),%rax
lea    (%rax,%r12,8),%r14
mov    -0x20(%rsp),%rax
lea    (%rax,%r12,8),%r13
mov    -0x10(%rsp),%r15
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movupd -0x30(%r13,%rax,8),%xmm0
movupd -0x20(%r13,%rax,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x30(%r14,%rax,8)
movupd %xmm0,-0x20(%r14,%rax,8)
movupd -0x10(%r13,%rax,8),%xmm0
movupd 0x0(%r13,%rax,8),%xmm1
movupd 0x20(%rsi,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x30(%rsi,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,-0x10(%r14,%rax,8)
movupd %xmm0,(%r14,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%r15
jne    1770 <mataddc+0x660>
testb  $0x1,-0x40(%rsp)
je     180c <mataddc+0x6fc>
lea    (%rax,%r12,1),%rcx
movupd (%rdx,%rcx,8),%xmm0
movupd 0x10(%rdx,%rcx,8),%xmm1
movupd (%rsi,%rax,8),%xmm2
addpd  %xmm0,%xmm2
movupd 0x10(%rsi,%rax,8),%xmm0
addpd  %xmm1,%xmm0
movupd %xmm2,(%rdi,%rcx,8)
movupd %xmm0,0x10(%rdi,%rcx,8)
mov    -0x78(%rsp),%rcx
add    %rcx,%r12
mov    %rcx,%rax
cmp    %r10,%rcx
mov    -0x28(%rsp),%r9
mov    -0x30(%rsp),%r15d
mov    %rbx,%r13
je     1660 <mataddc+0x550>
jmp    16a6 <mataddc+0x596>
xor    %eax,%eax
testb  $0x1,-0x40(%rsp)
jne    17df <mataddc+0x6cf>
jmp    180c <mataddc+0x6fc>
mov    $0x1,%r11d
cmp    $0x1,%r9d
jne    1ad4 <mataddc+0x9c4>
cmp    -0x7c(%rsp),%r15d
jne    1ad4 <mataddc+0x9c4>
test   %r15d,%r15d
jg     187d <mataddc+0x76d>
mov    $0x1,%r11d
jmp    1ad4 <mataddc+0x9c4>
cmp    $0x1,%r9d
jne    1d5c <mataddc+0xc4c>
cmp    -0x7c(%rsp),%r15d
jne    1d5c <mataddc+0xc4c>
lea    -0x1(%r8),%r9d
lea    0x1(%r9),%rcx
lea    (%rsi,%r9,8),%rax
add    $0x8,%rax
mov    %rcx,-0x58(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x60(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x68(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    %rdi,%rax
seta   %al
lea    (%rdi,%r9,8),%rbp
add    $0x8,%rbp
mov    %rbp,-0x48(%rsp)
cmp    %rsi,%rbp
seta   %bl
mov    %r15d,%r10d
and    %al,%bl
mov    %bl,-0x50(%rsp)
mov    %rcx,%rax
mov    %rcx,-0x70(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rcx
mov    %rcx,-0x78(%rsp)
mov    %r8d,%r14d
neg    %r14d
lea    0x30(%rdi),%rax
mov    %rax,-0x38(%rsp)
lea    0x30(%rsi),%rax
mov    %rax,-0x40(%rsp)
xor    %eax,%eax
xor    %r15d,%r15d
jmp    191d <mataddc+0x80d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r10,%rax
je     1ac4 <mataddc+0x9b4>
test   %r8d,%r8d
jle    1910 <mataddc+0x800>
xor    %ebx,%ebx
movslq %r15d,%r15
cmp    $0x3,%r9d
jb     1a40 <mataddc+0x930>
lea    (%rdx,%rax,8),%r11
lea    (%rdx,%rax,8),%r13
add    $0x8,%r13
lea    (%rdi,%r15,8),%rcx
mov    -0x48(%rsp),%rbp
lea    0x0(,%r15,8),%r12
add    %rbp,%r12
cmp    %r13,%rcx
setb   %bpl
cmp    %r12,%r11
setb   %cl
and    %bpl,%cl
or     -0x50(%rsp),%cl
jne    1a40 <mataddc+0x930>
cmpq   $0x0,-0x68(%rsp)
je     1ab2 <mataddc+0x9a2>
movsd  (%rdx,%rax,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    -0x38(%rsp),%rcx
lea    (%rcx,%r15,8),%r12
mov    -0x40(%rsp),%rcx
lea    (%rcx,%r15,8),%r13
mov    -0x78(%rsp),%r11
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd -0x30(%r13,%rbx,8),%xmm1
movupd -0x20(%r13,%rbx,8),%xmm2
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,-0x30(%r12,%rbx,8)
movupd %xmm2,-0x20(%r12,%rbx,8)
movupd -0x10(%r13,%rbx,8),%xmm1
movupd 0x0(%r13,%rbx,8),%xmm2
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%r12,%rbx,8)
movupd %xmm2,(%r12,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r11
jne    19a0 <mataddc+0x890>
testb  $0x1,-0x70(%rsp)
je     1a22 <mataddc+0x912>
add    %r15,%rbx
movupd (%rsi,%rbx,8),%xmm0
movupd 0x10(%rsi,%rbx,8),%xmm1
movsd  (%rdx,%rax,8),%xmm2
unpcklpd %xmm2,%xmm2
addpd  %xmm2,%xmm0
addpd  %xmm1,%xmm2
movupd %xmm0,(%rdi,%rbx,8)
movupd %xmm2,0x10(%rdi,%rbx,8)
mov    -0x60(%rsp),%rcx
add    %rcx,%r15
mov    %ecx,%ebx
cmp    %rcx,-0x58(%rsp)
je     1910 <mataddc+0x800>
nopw   0x0(%rax,%rax,1)
mov    %r8d,%ecx
sub    %ebx,%ecx
test   $0x1,%cl
jne    1a50 <mataddc+0x940>
mov    %ebx,%ecx
jmp    1a68 <mataddc+0x958>
xchg   %ax,%ax
movsd  (%rsi,%r15,8),%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%r15,8)
add    $0x1,%r15
lea    0x1(%rbx),%ecx
not    %ebx
cmp    %r14d,%ebx
je     1910 <mataddc+0x800>
mov    %r8d,%ebx
sub    %ecx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%r15,8),%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%r15,8)
movsd  0x8(%rsi,%r15,8),%xmm0
addsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%r15,8)
add    $0x2,%r15
add    $0xfffffffe,%ebx
jne    1a80 <mataddc+0x970>
jmp    1910 <mataddc+0x800>
xor    %ebx,%ebx
testb  $0x1,-0x70(%rsp)
jne    19f8 <mataddc+0x8e8>
jmp    1a22 <mataddc+0x912>
mov    $0x1,%r11d
mov    -0x28(%rsp),%r9
mov    -0x30(%rsp),%r15d
cmp    $0x1,%r8d
jne    1d36 <mataddc+0xc26>
cmp    -0x7c(%rsp),%r15d
jne    1d36 <mataddc+0xc26>
test   %r15d,%r15d
jle    1d3b <mataddc+0xc2b>
lea    -0x1(%r9),%r12d
lea    0x1(%r12),%rcx
lea    (%rdx,%r12,8),%rax
add    $0x8,%rax
mov    %rcx,-0x30(%rsp)
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x48(%rsp)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x50(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
cmp    %rdi,%rax
seta   %al
lea    (%rdi,%r12,8),%r14
add    $0x8,%r14
cmp    %rdx,%r14
seta   %bl
mov    %r15d,%r8d
mov    %ebx,%r15d
and    %al,%r15b
mov    %rcx,%rax
mov    %rcx,-0x58(%rsp)
and    %rcx,-0x8(%rsp)
mov    %r9d,%eax
neg    %eax
mov    %eax,-0x7c(%rsp)
lea    0x30(%rdi),%rax
mov    %rax,-0x70(%rsp)
lea    0x30(%rdx),%rax
mov    %rax,-0x78(%rsp)
xor    %r10d,%r10d
xor    %r13d,%r13d
mov    %r14,-0x60(%rsp)
mov    %r15b,-0x68(%rsp)
jmp    1b8d <mataddc+0xa7d>
nopl   0x0(%rax)
add    $0x1,%r10
cmp    %r8,%r10
je     1d3b <mataddc+0xc2b>
test   %r9d,%r9d
jle    1b80 <mataddc+0xa70>
xor    %ebx,%ebx
movslq %r13d,%r13
cmp    $0x3,%r12d
jb     1cb0 <mataddc+0xba0>
lea    (%rsi,%r10,8),%r11
lea    (%rsi,%r10,8),%rcx
add    $0x8,%rcx
lea    (%rdi,%r13,8),%rbp
lea    (%r14,%r13,8),%rax
cmp    %rcx,%rbp
setb   %cl
cmp    %rax,%r11
setb   %al
and    %cl,%al
or     %r15b,%al
jne    1cb0 <mataddc+0xba0>
cmpq   $0x0,-0x50(%rsp)
je     1d24 <mataddc+0xc14>
movsd  (%rsi,%r10,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    -0x70(%rsp),%rax
lea    (%rax,%r13,8),%r11
mov    -0x78(%rsp),%rax
lea    (%rax,%r13,8),%r14
mov    -0x8(%rsp),%r15
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r14,%rbx,8),%xmm1
movupd -0x20(%r14,%rbx,8),%xmm2
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,-0x30(%r11,%rbx,8)
movupd %xmm2,-0x20(%r11,%rbx,8)
movupd -0x10(%r14,%rbx,8),%xmm1
movupd (%r14,%rbx,8),%xmm2
addpd  %xmm0,%xmm1
addpd  %xmm0,%xmm2
movupd %xmm1,-0x10(%r11,%rbx,8)
movupd %xmm2,(%r11,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r15
jne    1c00 <mataddc+0xaf0>
testb  $0x1,-0x58(%rsp)
je     1c82 <mataddc+0xb72>
add    %r13,%rbx
movupd (%rdx,%rbx,8),%xmm0
movupd 0x10(%rdx,%rbx,8),%xmm1
movsd  (%rsi,%r10,8),%xmm2
unpcklpd %xmm2,%xmm2
addpd  %xmm2,%xmm0
addpd  %xmm1,%xmm2
movupd %xmm0,(%rdi,%rbx,8)
movupd %xmm2,0x10(%rdi,%rbx,8)
mov    -0x48(%rsp),%rax
add    %rax,%r13
mov    %eax,%ebx
cmp    %rax,-0x30(%rsp)
mov    -0x28(%rsp),%r9
mov    -0x60(%rsp),%r14
mov    -0x68(%rsp),%r15b
je     1b80 <mataddc+0xa70>
cs nopw 0x0(%rax,%rax,1)
mov    %r9d,%eax
sub    %ebx,%eax
test   $0x1,%al
jne    1cc0 <mataddc+0xbb0>
mov    %ebx,%eax
jmp    1cd9 <mataddc+0xbc9>
nopl   (%rax)
movsd  (%rdx,%r13,8),%xmm0
addsd  (%rsi,%r10,8),%xmm0
movsd  %xmm0,(%rdi,%r13,8)
add    $0x1,%r13
lea    0x1(%rbx),%eax
not    %ebx
cmp    -0x7c(%rsp),%ebx
je     1b80 <mataddc+0xa70>
mov    %r9d,%ebx
sub    %eax,%ebx
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%r13,8),%xmm0
addsd  (%rsi,%r10,8),%xmm0
movsd  %xmm0,(%rdi,%r13,8)
movsd  0x8(%rdx,%r13,8),%xmm0
addsd  (%rsi,%r10,8),%xmm0
movsd  %xmm0,0x8(%rdi,%r13,8)
add    $0x2,%r13
add    $0xfffffffe,%ebx
jne    1cf0 <mataddc+0xbe0>
jmp    1b80 <mataddc+0xa70>
xor    %ebx,%ebx
testb  $0x1,-0x58(%rsp)
jne    1c57 <mataddc+0xb47>
jmp    1c82 <mataddc+0xb72>
test   %r11d,%r11d
je     1d46 <mataddc+0xc36>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x2b3(%rip),%rdi
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <puts@plt>
cmp    $0x1,%r8d
jne    1d3b <mataddc+0xc2b>
cmp    -0x7c(%rsp),%r15d
je     1af2 <mataddc+0x9e2>
jmp    1d3b <mataddc+0xc2b>
xor    %ebp,%ebp
test   $0x1,%r10b
jne    12d5 <mataddc+0x1c5>
jmp    12fe <mataddc+0x1ee>

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

LLVM IR (-O2):
@str = [40 x i8] c"mataddc: nonconformability of matrices \00"
define void @mataddc(double* nocapture writeonly %0, double* nocapture %1, double* nocapture %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7) {
%9 = icmp eq i32 %4, %5
%10 = icmp eq i32 %6, %7
%11 = and i1 %9, %10
br i1 %11, label %12, label %156
12: ; preds = %8
%13 = icmp sgt i32 %3, 0
br i1 %13, label %14, label %156
14: ; preds = %12
%15 = zext i32 %3 to i64
%16 = icmp ult i32 %3, 4
br i1 %16, label %104, label %17
17: ; preds = %14
%18 = getelementptr double, double* %0, i64 %15
%19 = getelementptr double, double* %1, i64 %15
%20 = getelementptr double, double* %2, i64 %15
%21 = icmp ugt double* %19, %0
%22 = icmp ugt double* %18, %1
%23 = and i1 %21, %22
%24 = icmp ugt double* %20, %0
%25 = icmp ugt double* %18, %2
%26 = and i1 %24, %25
%27 = or i1 %23, %26
br i1 %27, label %104, label %28
28: ; preds = %17
%29 = and i64 %15, 4294967292
%30 = add nsw i64 %29, -4
%31 = lshr exact i64 %30, 2
%32 = add nuw nsw i64 %31, 1
%33 = and i64 %32, 1
%34 = icmp eq i64 %30, 0
br i1 %34, label %80, label %35
35: ; preds = %28
%36 = and i64 %32, 9223372036854775806
br label %37
37: ; preds = %37, %35
%38 = phi i64 [ 0, %35 ], [ %77, %37 ]
%39 = phi i64 [ 0, %35 ], [ %78, %37 ]
%40 = getelementptr inbounds double, double* %1, i64 %38
%41 = bitcast double* %40 to <2 x double>*
%42 = load <2 x double>, <2 x double>* %41
%43 = getelementptr inbounds double, double* %40, i64 2
%44 = bitcast double* %43 to <2 x double>*
%45 = load <2 x double>, <2 x double>* %44
%46 = getelementptr inbounds double, double* %2, i64 %38
%47 = bitcast double* %46 to <2 x double>*
%48 = load <2 x double>, <2 x double>* %47
%49 = getelementptr inbounds double, double* %46, i64 2
%50 = bitcast double* %49 to <2 x double>*
%51 = load <2 x double>, <2 x double>* %50
%52 = fadd <2 x double> %42, %48
%53 = fadd <2 x double> %45, %51
%54 = getelementptr inbounds double, double* %0, i64 %38
%55 = bitcast double* %54 to <2 x double>*
store <2 x double> %52, <2 x double>* %55
%56 = getelementptr inbounds double, double* %54, i64 2
%57 = bitcast double* %56 to <2 x double>*
store <2 x double> %53, <2 x double>* %57
%58 = or i64 %38, 4
%59 = getelementptr inbounds double, double* %1, i64 %58
%60 = bitcast double* %59 to <2 x double>*
%61 = load <2 x double>, <2 x double>* %60
%62 = getelementptr inbounds double, double* %59, i64 2
%63 = bitcast double* %62 to <2 x double>*
%64 = load <2 x double>, <2 x double>* %63
%65 = getelementptr inbounds double, double* %2, i64 %58
%66 = bitcast double* %65 to <2 x double>*
%67 = load <2 x double>, <2 x double>* %66
%68 = getelementptr inbounds double, double* %65, i64 2
%69 = bitcast double* %68 to <2 x double>*
%70 = load <2 x double>, <2 x double>* %69
%71 = fadd <2 x double> %61, %67
%72 = fadd <2 x double> %64, %70
%73 = getelementptr inbounds double, double* %0, i64 %58
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> %71, <2 x double>* %74
%75 = getelementptr inbounds double, double* %73, i64 2
%76 = bitcast double* %75 to <2 x double>*
store <2 x double> %72, <2 x double>* %76
%77 = add nuw i64 %38, 8
%78 = add i64 %39, 2
%79 = icmp eq i64 %78, %36
br i1 %79, label %80, label %37
80: ; preds = %37, %28
%81 = phi i64 [ 0, %28 ], [ %77, %37 ]
%82 = icmp eq i64 %33, 0
br i1 %82, label %102, label %83
83: ; preds = %80
%84 = getelementptr inbounds double, double* %1, i64 %81
%85 = bitcast double* %84 to <2 x double>*
%86 = load <2 x double>, <2 x double>* %85
%87 = getelementptr inbounds double, double* %84, i64 2
%88 = bitcast double* %87 to <2 x double>*
%89 = load <2 x double>, <2 x double>* %88
%90 = getelementptr inbounds double, double* %2, i64 %81
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = getelementptr inbounds double, double* %90, i64 2
%94 = bitcast double* %93 to <2 x double>*
%95 = load <2 x double>, <2 x double>* %94
%96 = fadd <2 x double> %86, %92
%97 = fadd <2 x double> %89, %95
%98 = getelementptr inbounds double, double* %0, i64 %81
%99 = bitcast double* %98 to <2 x double>*
store <2 x double> %96, <2 x double>* %99
%100 = getelementptr inbounds double, double* %98, i64 2
%101 = bitcast double* %100 to <2 x double>*
store <2 x double> %97, <2 x double>* %101
br label %102
102: ; preds = %80, %83
%103 = icmp eq i64 %29, %15
br i1 %103, label %156, label %104
104: ; preds = %17, %14, %102
%105 = phi i64 [ 0, %17 ], [ 0, %14 ], [ %29, %102 ]
%106 = xor i64 %105, -1
%107 = add nsw i64 %106, %15
%108 = and i64 %15, 3
%109 = icmp eq i64 %108, 0
br i1 %109, label %122, label %110
110: ; preds = %104, %110
%111 = phi i64 [ %119, %110 ], [ %105, %104 ]
%112 = phi i64 [ %120, %110 ], [ 0, %104 ]
%113 = getelementptr inbounds double, double* %1, i64 %111
%114 = load double, double* %113
%115 = getelementptr inbounds double, double* %2, i64 %111
%116 = load double, double* %115
%117 = fadd double %114, %116
%118 = getelementptr inbounds double, double* %0, i64 %111
store double %117, double* %118
%119 = add nuw nsw i64 %111, 1
%120 = add i64 %112, 1
%121 = icmp eq i64 %120, %108
br i1 %121, label %122, label %110
122: ; preds = %110, %104
%123 = phi i64 [ %105, %104 ], [ %119, %110 ]
%124 = icmp ult i64 %107, 3
br i1 %124, label %156, label %125
125: ; preds = %122, %125
%126 = phi i64 [ %154, %125 ], [ %123, %122 ]
%127 = getelementptr inbounds double, double* %1, i64 %126
%128 = load double, double* %127
%129 = getelementptr inbounds double, double* %2, i64 %126
%130 = load double, double* %129
%131 = fadd double %128, %130
%132 = getelementptr inbounds double, double* %0, i64 %126
store double %131, double* %132
%133 = add nuw nsw i64 %126, 1
%134 = getelementptr inbounds double, double* %1, i64 %133
%135 = load double, double* %134
%136 = getelementptr inbounds double, double* %2, i64 %133
%137 = load double, double* %136
%138 = fadd double %135, %137
%139 = getelementptr inbounds double, double* %0, i64 %133
store double %138, double* %139
%140 = add nuw nsw i64 %126, 2
%141 = getelementptr inbounds double, double* %1, i64 %140
%142 = load double, double* %141
%143 = getelementptr inbounds double, double* %2, i64 %140
%144 = load double, double* %143
%145 = fadd double %142, %144
%146 = getelementptr inbounds double, double* %0, i64 %140
store double %145, double* %146
%147 = add nuw nsw i64 %126, 3
%148 = getelementptr inbounds double, double* %1, i64 %147
%149 = load double, double* %148
%150 = getelementptr inbounds double, double* %2, i64 %147
%151 = load double, double* %150
%152 = fadd double %149, %151
%153 = getelementptr inbounds double, double* %0, i64 %147
store double %152, double* %153
%154 = add nuw nsw i64 %126, 4
%155 = icmp eq i64 %154, %15
br i1 %155, label %156, label %125
156: ; preds = %122, %125, %102, %12, %8
%157 = phi i32 [ 0, %8 ], [ 1, %12 ], [ 1, %102 ], [ 1, %125 ], [ 1, %122 ]
%158 = icmp eq i32 %7, 1
%159 = and i1 %9, %158
br i1 %159, label %160, label %312
160: ; preds = %156
%161 = icmp sgt i32 %6, 0
br i1 %161, label %162, label %468
162: ; preds = %160
%163 = icmp sgt i32 %4, 0
%164 = zext i32 %4 to i64
%165 = getelementptr double, double* %0, i64 %164
%166 = getelementptr double, double* %1, i64 %164
%167 = getelementptr double, double* %2, i64 %164
%168 = and i64 %164, 4294967292
%169 = add nsw i64 %168, -4
%170 = lshr exact i64 %169, 2
%171 = add nuw nsw i64 %170, 1
%172 = icmp ult i32 %4, 4
%173 = icmp ugt double* %166, %0
%174 = icmp ugt double* %165, %1
%175 = and i1 %173, %174
%176 = and i64 %164, 4294967292
%177 = and i64 %171, 1
%178 = icmp eq i64 %169, 0
%179 = and i64 %171, 9223372036854775806
%180 = icmp eq i64 %177, 0
%181 = icmp eq i64 %176, %164
%182 = and i64 %164, 1
%183 = icmp eq i64 %182, 0
%184 = sub nsw i64 0, %164
br label %185
185: ; preds = %162, %308
%186 = phi i32 [ 0, %162 ], [ %310, %308 ]
%187 = phi i32 [ 0, %162 ], [ %309, %308 ]
br i1 %163, label %188, label %308
188: ; preds = %185
%189 = sext i32 %187 to i64
br i1 %172, label %267, label %190
190: ; preds = %188
%191 = getelementptr double, double* %0, i64 %189
%192 = getelementptr double, double* %165, i64 %189
%193 = icmp ult double* %191, %167
%194 = icmp ugt double* %192, %2
%195 = and i1 %193, %194
%196 = or i1 %175, %195
br i1 %196, label %267, label %197
197: ; preds = %190
%198 = add nsw i64 %176, %189
br i1 %178, label %244, label %199
199: ; preds = %197, %199
%200 = phi i64 [ %241, %199 ], [ 0, %197 ]
%201 = phi i64 [ %242, %199 ], [ 0, %197 ]
%202 = add i64 %200, %189
%203 = getelementptr inbounds double, double* %1, i64 %202
%204 = bitcast double* %203 to <2 x double>*
%205 = load <2 x double>, <2 x double>* %204
%206 = getelementptr inbounds double, double* %203, i64 2
%207 = bitcast double* %206 to <2 x double>*
%208 = load <2 x double>, <2 x double>* %207
%209 = getelementptr inbounds double, double* %2, i64 %200
%210 = bitcast double* %209 to <2 x double>*
%211 = load <2 x double>, <2 x double>* %210
%212 = getelementptr inbounds double, double* %209, i64 2
%213 = bitcast double* %212 to <2 x double>*
%214 = load <2 x double>, <2 x double>* %213
%215 = fadd <2 x double> %205, %211
%216 = fadd <2 x double> %208, %214
%217 = getelementptr inbounds double, double* %0, i64 %202
%218 = bitcast double* %217 to <2 x double>*
store <2 x double> %215, <2 x double>* %218
%219 = getelementptr inbounds double, double* %217, i64 2
%220 = bitcast double* %219 to <2 x double>*
store <2 x double> %216, <2 x double>* %220
%221 = or i64 %200, 4
%222 = add i64 %221, %189
%223 = getelementptr inbounds double, double* %1, i64 %222
%224 = bitcast double* %223 to <2 x double>*
%225 = load <2 x double>, <2 x double>* %224
%226 = getelementptr inbounds double, double* %223, i64 2
%227 = bitcast double* %226 to <2 x double>*
%228 = load <2 x double>, <2 x double>* %227
%229 = getelementptr inbounds double, double* %2, i64 %221
%230 = bitcast double* %229 to <2 x double>*
%231 = load <2 x double>, <2 x double>* %230
%232 = getelementptr inbounds double, double* %229, i64 2
%233 = bitcast double* %232 to <2 x double>*
%234 = load <2 x double>, <2 x double>* %233
%235 = fadd <2 x double> %225, %231
%236 = fadd <2 x double> %228, %234
%237 = getelementptr inbounds double, double* %0, i64 %222
%238 = bitcast double* %237 to <2 x double>*
store <2 x double> %235, <2 x double>* %238
%239 = getelementptr inbounds double, double* %237, i64 2
%240 = bitcast double* %239 to <2 x double>*
store <2 x double> %236, <2 x double>* %240
%241 = add nuw i64 %200, 8
%242 = add i64 %201, 2
%243 = icmp eq i64 %242, %179
br i1 %243, label %244, label %199
244: ; preds = %199, %197
%245 = phi i64 [ 0, %197 ], [ %241, %199 ]
br i1 %180, label %266, label %246
246: ; preds = %244
%247 = add i64 %245, %189
%248 = getelementptr inbounds double, double* %1, i64 %247
%249 = bitcast double* %248 to <2 x double>*
%250 = load <2 x double>, <2 x double>* %249
%251 = getelementptr inbounds double, double* %248, i64 2
%252 = bitcast double* %251 to <2 x double>*
%253 = load <2 x double>, <2 x double>* %252
%254 = getelementptr inbounds double, double* %2, i64 %245
%255 = bitcast double* %254 to <2 x double>*
%256 = load <2 x double>, <2 x double>* %255
%257 = getelementptr inbounds double, double* %254, i64 2
%258 = bitcast double* %257 to <2 x double>*
%259 = load <2 x double>, <2 x double>* %258
%260 = fadd <2 x double> %250, %256
%261 = fadd <2 x double> %253, %259
%262 = getelementptr inbounds double, double* %0, i64 %247
%263 = bitcast double* %262 to <2 x double>*
store <2 x double> %260, <2 x double>* %263
%264 = getelementptr inbounds double, double* %262, i64 2
%265 = bitcast double* %264 to <2 x double>*
store <2 x double> %261, <2 x double>* %265
br label %266
266: ; preds = %244, %246
br i1 %181, label %305, label %267
267: ; preds = %190, %188, %266
%268 = phi i64 [ %189, %190 ], [ %189, %188 ], [ %198, %266 ]
%269 = phi i64 [ 0, %190 ], [ 0, %188 ], [ %176, %266 ]
%270 = xor i64 %269, -1
br i1 %183, label %280, label %271
271: ; preds = %267
%272 = getelementptr inbounds double, double* %1, i64 %268
%273 = load double, double* %272
%274 = getelementptr inbounds double, double* %2, i64 %269
%275 = load double, double* %274
%276 = fadd double %273, %275
%277 = getelementptr inbounds double, double* %0, i64 %268
store double %276, double* %277
%278 = add nsw i64 %268, 1
%279 = or i64 %269, 1
br label %280
280: ; preds = %271, %267
%281 = phi i64 [ undef, %267 ], [ %278, %271 ]
%282 = phi i64 [ %268, %267 ], [ %278, %271 ]
%283 = phi i64 [ %269, %267 ], [ %279, %271 ]
%284 = icmp eq i64 %270, %184
br i1 %284, label %305, label %285
285: ; preds = %280, %285
%286 = phi i64 [ %302, %285 ], [ %282, %280 ]
%287 = phi i64 [ %303, %285 ], [ %283, %280 ]
%288 = getelementptr inbounds double, double* %1, i64 %286
%289 = load double, double* %288
%290 = getelementptr inbounds double, double* %2, i64 %287
%291 = load double, double* %290
%292 = fadd double %289, %291
%293 = getelementptr inbounds double, double* %0, i64 %286
store double %292, double* %293
%294 = add nsw i64 %286, 1
%295 = add nuw nsw i64 %287, 1
%296 = getelementptr inbounds double, double* %1, i64 %294
%297 = load double, double* %296
%298 = getelementptr inbounds double, double* %2, i64 %295
%299 = load double, double* %298
%300 = fadd double %297, %299
%301 = getelementptr inbounds double, double* %0, i64 %294
store double %300, double* %301
%302 = add nsw i64 %286, 2
%303 = add nuw nsw i64 %287, 2
%304 = icmp eq i64 %303, %164
br i1 %304, label %305, label %285
305: ; preds = %280, %285, %266
%306 = phi i64 [ %198, %266 ], [ %281, %280 ], [ %302, %285 ]
%307 = trunc i64 %306 to i32
br label %308
308: ; preds = %305, %185
%309 = phi i32 [ %187, %185 ], [ %307, %305 ]
%310 = add nuw nsw i32 %186, 1
%311 = icmp eq i32 %310, %6
br i1 %311, label %312, label %185
312: ; preds = %308, %156
%313 = phi i32 [ %157, %156 ], [ 1, %308 ]
%314 = icmp eq i32 %6, 1
%315 = and i1 %9, %314
br i1 %315, label %316, label %468
316: ; preds = %312
%317 = icmp sgt i32 %7, 0
br i1 %317, label %318, label %472
318: ; preds = %316
%319 = icmp sgt i32 %4, 0
%320 = zext i32 %4 to i64
%321 = getelementptr double, double* %0, i64 %320
%322 = getelementptr double, double* %2, i64 %320
%323 = getelementptr double, double* %1, i64 %320
%324 = and i64 %320, 4294967292
%325 = add nsw i64 %324, -4
%326 = lshr exact i64 %325, 2
%327 = add nuw nsw i64 %326, 1
%328 = icmp ult i32 %4, 4
%329 = icmp ugt double* %322, %0
%330 = icmp ugt double* %321, %2
%331 = and i1 %329, %330
%332 = and i64 %320, 4294967292
%333 = and i64 %327, 1
%334 = icmp eq i64 %325, 0
%335 = and i64 %327, 9223372036854775806
%336 = icmp eq i64 %333, 0
%337 = icmp eq i64 %332, %320
%338 = and i64 %320, 1
%339 = icmp eq i64 %338, 0
%340 = sub nsw i64 0, %320
br label %341
341: ; preds = %318, %464
%342 = phi i32 [ 0, %318 ], [ %466, %464 ]
%343 = phi i32 [ 0, %318 ], [ %465, %464 ]
br i1 %319, label %344, label %464
344: ; preds = %341
%345 = sext i32 %343 to i64
br i1 %328, label %423, label %346
346: ; preds = %344
%347 = getelementptr double, double* %0, i64 %345
%348 = getelementptr double, double* %321, i64 %345
%349 = icmp ult double* %347, %323
%350 = icmp ugt double* %348, %1
%351 = and i1 %349, %350
%352 = or i1 %331, %351
br i1 %352, label %423, label %353
353: ; preds = %346
%354 = add nsw i64 %332, %345
br i1 %334, label %400, label %355
355: ; preds = %353, %355
%356 = phi i64 [ %397, %355 ], [ 0, %353 ]
%357 = phi i64 [ %398, %355 ], [ 0, %353 ]
%358 = add i64 %356, %345
%359 = getelementptr inbounds double, double* %2, i64 %358
%360 = bitcast double* %359 to <2 x double>*
%361 = load <2 x double>, <2 x double>* %360
%362 = getelementptr inbounds double, double* %359, i64 2
%363 = bitcast double* %362 to <2 x double>*
%364 = load <2 x double>, <2 x double>* %363
%365 = getelementptr inbounds double, double* %1, i64 %356
%366 = bitcast double* %365 to <2 x double>*
%367 = load <2 x double>, <2 x double>* %366
%368 = getelementptr inbounds double, double* %365, i64 2
%369 = bitcast double* %368 to <2 x double>*
%370 = load <2 x double>, <2 x double>* %369
%371 = fadd <2 x double> %361, %367
%372 = fadd <2 x double> %364, %370
%373 = getelementptr inbounds double, double* %0, i64 %358
%374 = bitcast double* %373 to <2 x double>*
store <2 x double> %371, <2 x double>* %374
%375 = getelementptr inbounds double, double* %373, i64 2
%376 = bitcast double* %375 to <2 x double>*
store <2 x double> %372, <2 x double>* %376
%377 = or i64 %356, 4
%378 = add i64 %377, %345
%379 = getelementptr inbounds double, double* %2, i64 %378
%380 = bitcast double* %379 to <2 x double>*
%381 = load <2 x double>, <2 x double>* %380
%382 = getelementptr inbounds double, double* %379, i64 2
%383 = bitcast double* %382 to <2 x double>*
%384 = load <2 x double>, <2 x double>* %383
%385 = getelementptr inbounds double, double* %1, i64 %377
%386 = bitcast double* %385 to <2 x double>*
%387 = load <2 x double>, <2 x double>* %386
%388 = getelementptr inbounds double, double* %385, i64 2
%389 = bitcast double* %388 to <2 x double>*
%390 = load <2 x double>, <2 x double>* %389
%391 = fadd <2 x double> %381, %387
%392 = fadd <2 x double> %384, %390
%393 = getelementptr inbounds double, double* %0, i64 %378
%394 = bitcast double* %393 to <2 x double>*
store <2 x double> %391, <2 x double>* %394
%395 = getelementptr inbounds double, double* %393, i64 2
%396 = bitcast double* %395 to <2 x double>*
store <2 x double> %392, <2 x double>* %396
%397 = add nuw i64 %356, 8
%398 = add i64 %357, 2
%399 = icmp eq i64 %398, %335
br i1 %399, label %400, label %355
400: ; preds = %355, %353
%401 = phi i64 [ 0, %353 ], [ %397, %355 ]
br i1 %336, label %422, label %402
402: ; preds = %400
%403 = add i64 %401, %345
%404 = getelementptr inbounds double, double* %2, i64 %403
%405 = bitcast double* %404 to <2 x double>*
%406 = load <2 x double>, <2 x double>* %405
%407 = getelementptr inbounds double, double* %404, i64 2
%408 = bitcast double* %407 to <2 x double>*
%409 = load <2 x double>, <2 x double>* %408
%410 = getelementptr inbounds double, double* %1, i64 %401
%411 = bitcast double* %410 to <2 x double>*
%412 = load <2 x double>, <2 x double>* %411
%413 = getelementptr inbounds double, double* %410, i64 2
%414 = bitcast double* %413 to <2 x double>*
%415 = load <2 x double>, <2 x double>* %414
%416 = fadd <2 x double> %406, %412
%417 = fadd <2 x double> %409, %415
%418 = getelementptr inbounds double, double* %0, i64 %403
%419 = bitcast double* %418 to <2 x double>*
store <2 x double> %416, <2 x double>* %419
%420 = getelementptr inbounds double, double* %418, i64 2
%421 = bitcast double* %420 to <2 x double>*
store <2 x double> %417, <2 x double>* %421
br label %422
422: ; preds = %400, %402
br i1 %337, label %461, label %423
423: ; preds = %346, %344, %422
%424 = phi i64 [ %345, %346 ], [ %345, %344 ], [ %354, %422 ]
%425 = phi i64 [ 0, %346 ], [ 0, %344 ], [ %332, %422 ]
%426 = xor i64 %425, -1
br i1 %339, label %436, label %427
427: ; preds = %423
%428 = getelementptr inbounds double, double* %2, i64 %424
%429 = load double, double* %428
%430 = getelementptr inbounds double, double* %1, i64 %425
%431 = load double, double* %430
%432 = fadd double %429, %431
%433 = getelementptr inbounds double, double* %0, i64 %424
store double %432, double* %433
%434 = add nsw i64 %424, 1
%435 = or i64 %425, 1
br label %436
436: ; preds = %427, %423
%437 = phi i64 [ undef, %423 ], [ %434, %427 ]
%438 = phi i64 [ %424, %423 ], [ %434, %427 ]
%439 = phi i64 [ %425, %423 ], [ %435, %427 ]
%440 = icmp eq i64 %426, %340
br i1 %440, label %461, label %441
441: ; preds = %436, %441
%442 = phi i64 [ %458, %441 ], [ %438, %436 ]
%443 = phi i64 [ %459, %441 ], [ %439, %436 ]
%444 = getelementptr inbounds double, double* %2, i64 %442
%445 = load double, double* %444
%446 = getelementptr inbounds double, double* %1, i64 %443
%447 = load double, double* %446
%448 = fadd double %445, %447
%449 = getelementptr inbounds double, double* %0, i64 %442
store double %448, double* %449
%450 = add nsw i64 %442, 1
%451 = add nuw nsw i64 %443, 1
%452 = getelementptr inbounds double, double* %2, i64 %450
%453 = load double, double* %452
%454 = getelementptr inbounds double, double* %1, i64 %451
%455 = load double, double* %454
%456 = fadd double %453, %455
%457 = getelementptr inbounds double, double* %0, i64 %450
store double %456, double* %457
%458 = add nsw i64 %442, 2
%459 = add nuw nsw i64 %443, 2
%460 = icmp eq i64 %459, %320
br i1 %460, label %461, label %441
461: ; preds = %436, %441, %422
%462 = phi i64 [ %354, %422 ], [ %437, %436 ], [ %458, %441 ]
%463 = trunc i64 %462 to i32
br label %464
464: ; preds = %461, %341
%465 = phi i32 [ %343, %341 ], [ %463, %461 ]
%466 = add nuw nsw i32 %342, 1
%467 = icmp eq i32 %466, %7
br i1 %467, label %468, label %341
468: ; preds = %464, %160, %312
%469 = phi i32 [ %313, %312 ], [ 1, %160 ], [ 1, %464 ]
%470 = icmp eq i32 %5, 1
%471 = and i1 %470, %10
br i1 %471, label %475, label %631
472: ; preds = %316
%473 = icmp eq i32 %5, 1
%474 = and i1 %473, %10
br i1 %474, label %477, label %635
475: ; preds = %468
%476 = icmp sgt i32 %6, 0
br i1 %476, label %477, label %631
477: ; preds = %472, %475
%478 = icmp sgt i32 %4, 0
%479 = zext i32 %6 to i64
%480 = add i32 %4, -1
%481 = zext i32 %480 to i64
%482 = add nuw nsw i64 %481, 1
%483 = getelementptr double, double* %0, i64 %482
%484 = getelementptr double, double* %1, i64 %482
%485 = zext i32 %480 to i64
%486 = add nuw nsw i64 %485, 1
%487 = and i64 %486, 8589934588
%488 = add nsw i64 %487, -4
%489 = lshr exact i64 %488, 2
%490 = add nuw nsw i64 %489, 1
%491 = icmp ult i32 %480, 3
%492 = icmp ugt double* %484, %0
%493 = icmp ugt double* %483, %1
%494 = and i1 %492, %493
%495 = and i64 %486, 8589934588
%496 = trunc i64 %495 to i32
%497 = and i64 %490, 1
%498 = icmp eq i64 %488, 0
%499 = and i64 %490, 9223372036854775806
%500 = icmp eq i64 %497, 0
%501 = icmp eq i64 %486, %495
%502 = sub i32 0, %4
br label %503
503: ; preds = %477, %627
%504 = phi i64 [ 0, %477 ], [ %629, %627 ]
%505 = phi i32 [ 0, %477 ], [ %628, %627 ]
%506 = getelementptr double, double* %2, i64 %504
%507 = add nuw i64 %504, 1
%508 = getelementptr double, double* %2, i64 %507
br i1 %478, label %509, label %627
509: ; preds = %503
%510 = getelementptr inbounds double, double* %2, i64 %504
%511 = sext i32 %505 to i64
br i1 %491, label %587, label %512
512: ; preds = %509
%513 = getelementptr double, double* %0, i64 %511
%514 = getelementptr double, double* %483, i64 %511
%515 = icmp ult double* %513, %508
%516 = icmp ult double* %506, %514
%517 = and i1 %515, %516
%518 = or i1 %494, %517
br i1 %518, label %587, label %519
519: ; preds = %512
%520 = add nsw i64 %495, %511
br i1 %498, label %565, label %521
521: ; preds = %519
%522 = load double, double* %510
%523 = insertelement <2 x double> poison, double %522, i64 0
%524 = shufflevector <2 x double> %523, <2 x double> poison, <2 x i32> zeroinitializer
%525 = insertelement <2 x double> poison, double %522, i64 0
%526 = shufflevector <2 x double> %525, <2 x double> poison, <2 x i32> zeroinitializer
%527 = load double, double* %510
%528 = insertelement <2 x double> poison, double %527, i64 0
%529 = shufflevector <2 x double> %528, <2 x double> poison, <2 x i32> zeroinitializer
%530 = insertelement <2 x double> poison, double %527, i64 0
%531 = shufflevector <2 x double> %530, <2 x double> poison, <2 x i32> zeroinitializer
br label %532
532: ; preds = %532, %521
%533 = phi i64 [ 0, %521 ], [ %562, %532 ]
%534 = phi i64 [ 0, %521 ], [ %563, %532 ]
%535 = add i64 %533, %511
%536 = getelementptr inbounds double, double* %1, i64 %535
%537 = bitcast double* %536 to <2 x double>*
%538 = load <2 x double>, <2 x double>* %537
%539 = getelementptr inbounds double, double* %536, i64 2
%540 = bitcast double* %539 to <2 x double>*
%541 = load <2 x double>, <2 x double>* %540
%542 = fadd <2 x double> %538, %524
%543 = fadd <2 x double> %541, %526
%544 = getelementptr inbounds double, double* %0, i64 %535
%545 = bitcast double* %544 to <2 x double>*
store <2 x double> %542, <2 x double>* %545
%546 = getelementptr inbounds double, double* %544, i64 2
%547 = bitcast double* %546 to <2 x double>*
store <2 x double> %543, <2 x double>* %547
%548 = or i64 %533, 4
%549 = add i64 %548, %511
%550 = getelementptr inbounds double, double* %1, i64 %549
%551 = bitcast double* %550 to <2 x double>*
%552 = load <2 x double>, <2 x double>* %551
%553 = getelementptr inbounds double, double* %550, i64 2
%554 = bitcast double* %553 to <2 x double>*
%555 = load <2 x double>, <2 x double>* %554
%556 = fadd <2 x double> %552, %529
%557 = fadd <2 x double> %555, %531
%558 = getelementptr inbounds double, double* %0, i64 %549
%559 = bitcast double* %558 to <2 x double>*
store <2 x double> %556, <2 x double>* %559
%560 = getelementptr inbounds double, double* %558, i64 2
%561 = bitcast double* %560 to <2 x double>*
store <2 x double> %557, <2 x double>* %561
%562 = add nuw i64 %533, 8
%563 = add i64 %534, 2
%564 = icmp eq i64 %563, %499
br i1 %564, label %565, label %532
565: ; preds = %532, %519
%566 = phi i64 [ 0, %519 ], [ %562, %532 ]
br i1 %500, label %586, label %567
567: ; preds = %565
%568 = add i64 %566, %511
%569 = getelementptr inbounds double, double* %1, i64 %568
%570 = bitcast double* %569 to <2 x double>*
%571 = load <2 x double>, <2 x double>* %570
%572 = getelementptr inbounds double, double* %569, i64 2
%573 = bitcast double* %572 to <2 x double>*
%574 = load <2 x double>, <2 x double>* %573
%575 = load double, double* %510
%576 = insertelement <2 x double> poison, double %575, i64 0
%577 = shufflevector <2 x double> %576, <2 x double> poison, <2 x i32> zeroinitializer
%578 = insertelement <2 x double> poison, double %575, i64 0
%579 = shufflevector <2 x double> %578, <2 x double> poison, <2 x i32> zeroinitializer
%580 = fadd <2 x double> %571, %577
%581 = fadd <2 x double> %574, %579
%582 = getelementptr inbounds double, double* %0, i64 %568
%583 = bitcast double* %582 to <2 x double>*
store <2 x double> %580, <2 x double>* %583
%584 = getelementptr inbounds double, double* %582, i64 2
%585 = bitcast double* %584 to <2 x double>*
store <2 x double> %581, <2 x double>* %585
br label %586
586: ; preds = %565, %567
br i1 %501, label %624, label %587
587: ; preds = %512, %509, %586
%588 = phi i64 [ %511, %512 ], [ %511, %509 ], [ %520, %586 ]
%589 = phi i32 [ 0, %512 ], [ 0, %509 ], [ %496, %586 ]
%590 = sub i32 %4, %589
%591 = xor i32 %589, -1
%592 = and i32 %590, 1
%593 = icmp eq i32 %592, 0
br i1 %593, label %602, label %594
594: ; preds = %587
%595 = getelementptr inbounds double, double* %1, i64 %588
%596 = load double, double* %595
%597 = load double, double* %510
%598 = fadd double %596, %597
%599 = getelementptr inbounds double, double* %0, i64 %588
store double %598, double* %599
%600 = add nsw i64 %588, 1
%601 = add nuw nsw i32 %589, 1
br label %602
602: ; preds = %594, %587
%603 = phi i64 [ undef, %587 ], [ %600, %594 ]
%604 = phi i64 [ %588, %587 ], [ %600, %594 ]
%605 = phi i32 [ %589, %587 ], [ %601, %594 ]
%606 = icmp eq i32 %591, %502
br i1 %606, label %624, label %607
607: ; preds = %602, %607
%608 = phi i64 [ %621, %607 ], [ %604, %602 ]
%609 = phi i32 [ %622, %607 ], [ %605, %602 ]
%610 = getelementptr inbounds double, double* %1, i64 %608
%611 = load double, double* %610
%612 = load double, double* %510
%613 = fadd double %611, %612
%614 = getelementptr inbounds double, double* %0, i64 %608
store double %613, double* %614
%615 = add nsw i64 %608, 1
%616 = getelementptr inbounds double, double* %1, i64 %615
%617 = load double, double* %616
%618 = load double, double* %510
%619 = fadd double %617, %618
%620 = getelementptr inbounds double, double* %0, i64 %615
store double %619, double* %620
%621 = add nsw i64 %608, 2
%622 = add nuw nsw i32 %609, 2
%623 = icmp eq i32 %622, %4
br i1 %623, label %624, label %607
624: ; preds = %602, %607, %586
%625 = phi i64 [ %520, %586 ], [ %603, %602 ], [ %621, %607 ]
%626 = trunc i64 %625 to i32
br label %627
627: ; preds = %624, %503
%628 = phi i32 [ %505, %503 ], [ %626, %624 ]
%629 = add nuw nsw i64 %504, 1
%630 = icmp eq i64 %629, %479
br i1 %630, label %631, label %503
631: ; preds = %627, %475, %468
%632 = phi i32 [ %469, %468 ], [ 1, %475 ], [ 1, %627 ]
%633 = icmp eq i32 %4, 1
%634 = and i1 %633, %10
br i1 %634, label %638, label %794
635: ; preds = %472
%636 = icmp eq i32 %4, 1
%637 = and i1 %636, %10
br i1 %637, label %640, label %798
638: ; preds = %631
%639 = icmp sgt i32 %6, 0
br i1 %639, label %640, label %798
640: ; preds = %635, %638
%641 = icmp sgt i32 %5, 0
%642 = zext i32 %6 to i64
%643 = add i32 %5, -1
%644 = zext i32 %643 to i64
%645 = add nuw nsw i64 %644, 1
%646 = getelementptr double, double* %0, i64 %645
%647 = getelementptr double, double* %2, i64 %645
%648 = zext i32 %643 to i64
%649 = add nuw nsw i64 %648, 1
%650 = and i64 %649, 8589934588
%651 = add nsw i64 %650, -4
%652 = lshr exact i64 %651, 2
%653 = add nuw nsw i64 %652, 1
%654 = icmp ult i32 %643, 3
%655 = icmp ugt double* %647, %0
%656 = icmp ugt double* %646, %2
%657 = and i1 %655, %656
%658 = and i64 %649, 8589934588
%659 = trunc i64 %658 to i32
%660 = and i64 %653, 1
%661 = icmp eq i64 %651, 0
%662 = and i64 %653, 9223372036854775806
%663 = icmp eq i64 %660, 0
%664 = icmp eq i64 %649, %658
%665 = sub i32 0, %5
br label %666
666: ; preds = %640, %790
%667 = phi i64 [ 0, %640 ], [ %792, %790 ]
%668 = phi i32 [ 0, %640 ], [ %791, %790 ]
%669 = getelementptr double, double* %1, i64 %667
%670 = add nuw i64 %667, 1
%671 = getelementptr double, double* %1, i64 %670
br i1 %641, label %672, label %790
672: ; preds = %666
%673 = getelementptr inbounds double, double* %1, i64 %667
%674 = sext i32 %668 to i64
br i1 %654, label %750, label %675
675: ; preds = %672
%676 = getelementptr double, double* %0, i64 %674
%677 = getelementptr double, double* %646, i64 %674
%678 = icmp ult double* %676, %671
%679 = icmp ult double* %669, %677
%680 = and i1 %678, %679
%681 = or i1 %657, %680
br i1 %681, label %750, label %682
682: ; preds = %675
%683 = add nsw i64 %658, %674
br i1 %661, label %728, label %684
684: ; preds = %682
%685 = load double, double* %673
%686 = insertelement <2 x double> poison, double %685, i64 0
%687 = shufflevector <2 x double> %686, <2 x double> poison, <2 x i32> zeroinitializer
%688 = insertelement <2 x double> poison, double %685, i64 0
%689 = shufflevector <2 x double> %688, <2 x double> poison, <2 x i32> zeroinitializer
%690 = load double, double* %673
%691 = insertelement <2 x double> poison, double %690, i64 0
%692 = shufflevector <2 x double> %691, <2 x double> poison, <2 x i32> zeroinitializer
%693 = insertelement <2 x double> poison, double %690, i64 0
%694 = shufflevector <2 x double> %693, <2 x double> poison, <2 x i32> zeroinitializer
br label %695
695: ; preds = %695, %684
%696 = phi i64 [ 0, %684 ], [ %725, %695 ]
%697 = phi i64 [ 0, %684 ], [ %726, %695 ]
%698 = add i64 %696, %674
%699 = getelementptr inbounds double, double* %2, i64 %698
%700 = bitcast double* %699 to <2 x double>*
%701 = load <2 x double>, <2 x double>* %700
%702 = getelementptr inbounds double, double* %699, i64 2
%703 = bitcast double* %702 to <2 x double>*
%704 = load <2 x double>, <2 x double>* %703
%705 = fadd <2 x double> %701, %687
%706 = fadd <2 x double> %704, %689
%707 = getelementptr inbounds double, double* %0, i64 %698
%708 = bitcast double* %707 to <2 x double>*
store <2 x double> %705, <2 x double>* %708
%709 = getelementptr inbounds double, double* %707, i64 2
%710 = bitcast double* %709 to <2 x double>*
store <2 x double> %706, <2 x double>* %710
%711 = or i64 %696, 4
%712 = add i64 %711, %674
%713 = getelementptr inbounds double, double* %2, i64 %712
%714 = bitcast double* %713 to <2 x double>*
%715 = load <2 x double>, <2 x double>* %714
%716 = getelementptr inbounds double, double* %713, i64 2
%717 = bitcast double* %716 to <2 x double>*
%718 = load <2 x double>, <2 x double>* %717
%719 = fadd <2 x double> %715, %692
%720 = fadd <2 x double> %718, %694
%721 = getelementptr inbounds double, double* %0, i64 %712
%722 = bitcast double* %721 to <2 x double>*
store <2 x double> %719, <2 x double>* %722
%723 = getelementptr inbounds double, double* %721, i64 2
%724 = bitcast double* %723 to <2 x double>*
store <2 x double> %720, <2 x double>* %724
%725 = add nuw i64 %696, 8
%726 = add i64 %697, 2
%727 = icmp eq i64 %726, %662
br i1 %727, label %728, label %695
728: ; preds = %695, %682
%729 = phi i64 [ 0, %682 ], [ %725, %695 ]
br i1 %663, label %749, label %730
730: ; preds = %728
%731 = add i64 %729, %674
%732 = getelementptr inbounds double, double* %2, i64 %731
%733 = bitcast double* %732 to <2 x double>*
%734 = load <2 x double>, <2 x double>* %733
%735 = getelementptr inbounds double, double* %732, i64 2
%736 = bitcast double* %735 to <2 x double>*
%737 = load <2 x double>, <2 x double>* %736
%738 = load double, double* %673
%739 = insertelement <2 x double> poison, double %738, i64 0
%740 = shufflevector <2 x double> %739, <2 x double> poison, <2 x i32> zeroinitializer
%741 = insertelement <2 x double> poison, double %738, i64 0
%742 = shufflevector <2 x double> %741, <2 x double> poison, <2 x i32> zeroinitializer
%743 = fadd <2 x double> %734, %740
%744 = fadd <2 x double> %737, %742
%745 = getelementptr inbounds double, double* %0, i64 %731
%746 = bitcast double* %745 to <2 x double>*
store <2 x double> %743, <2 x double>* %746
%747 = getelementptr inbounds double, double* %745, i64 2
%748 = bitcast double* %747 to <2 x double>*
store <2 x double> %744, <2 x double>* %748
br label %749
749: ; preds = %728, %730
br i1 %664, label %787, label %750
750: ; preds = %675, %672, %749
%751 = phi i64 [ %674, %675 ], [ %674, %672 ], [ %683, %749 ]
%752 = phi i32 [ 0, %675 ], [ 0, %672 ], [ %659, %749 ]
%753 = sub i32 %5, %752
%754 = xor i32 %752, -1
%755 = and i32 %753, 1
%756 = icmp eq i32 %755, 0
br i1 %756, label %765, label %757
757: ; preds = %750
%758 = getelementptr inbounds double, double* %2, i64 %751
%759 = load double, double* %758
%760 = load double, double* %673
%761 = fadd double %759, %760
%762 = getelementptr inbounds double, double* %0, i64 %751
store double %761, double* %762
%763 = add nsw i64 %751, 1
%764 = add nuw nsw i32 %752, 1
br label %765
765: ; preds = %757, %750
%766 = phi i64 [ undef, %750 ], [ %763, %757 ]
%767 = phi i64 [ %751, %750 ], [ %763, %757 ]
%768 = phi i32 [ %752, %750 ], [ %764, %757 ]
%769 = icmp eq i32 %754, %665
br i1 %769, label %787, label %770
770: ; preds = %765, %770
%771 = phi i64 [ %784, %770 ], [ %767, %765 ]
%772 = phi i32 [ %785, %770 ], [ %768, %765 ]
%773 = getelementptr inbounds double, double* %2, i64 %771
%774 = load double, double* %773
%775 = load double, double* %673
%776 = fadd double %774, %775
%777 = getelementptr inbounds double, double* %0, i64 %771
store double %776, double* %777
%778 = add nsw i64 %771, 1
%779 = getelementptr inbounds double, double* %2, i64 %778
%780 = load double, double* %779
%781 = load double, double* %673
%782 = fadd double %780, %781
%783 = getelementptr inbounds double, double* %0, i64 %778
store double %782, double* %783
%784 = add nsw i64 %771, 2
%785 = add nuw nsw i32 %772, 2
%786 = icmp eq i32 %785, %5
br i1 %786, label %787, label %770
787: ; preds = %765, %770, %749
%788 = phi i64 [ %683, %749 ], [ %766, %765 ], [ %784, %770 ]
%789 = trunc i64 %788 to i32
br label %790
790: ; preds = %787, %666
%791 = phi i32 [ %668, %666 ], [ %789, %787 ]
%792 = add nuw nsw i64 %667, 1
%793 = icmp eq i64 %792, %642
br i1 %793, label %798, label %666
794: ; preds = %631
%795 = icmp eq i32 %632, 0
br i1 %795, label %796, label %798
796: ; preds = %794
%797 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str, i64 0, i64 0))
br label %798
798: ; preds = %790, %635, %638, %796, %794
ret void
}