#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 matdivc(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("matdivc: nonconformability of matrices \n");
  }
}


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

x86 assembly (clang, -O2):
<matdivc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x40(%rsp),%r14d
mov    0x38(%rsp),%r12d
xor    %r11d,%r11d
cmp    %r9d,%r8d
mov    %r9,-0x68(%rsp)
mov    %r14d,-0x6c(%rsp)
jne    127a <matdivc+0x16a>
cmp    %r14d,%r12d
jne    127a <matdivc+0x16a>
mov    $0x1,%r11d
test   %ecx,%ecx
jle    127a <matdivc+0x16a>
mov    %ecx,%eax
cmp    $0x1,%ecx
jne    11af <matdivc+0x9f>
xor    %ecx,%ecx
mov    %rcx,%rbp
not    %rbp
test   $0x1,%al
je     1177 <matdivc+0x67>
movsd  (%rsi,%rcx,8),%xmm0
divsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
or     $0x1,%rcx
add    %rax,%rbp
je     127a <matdivc+0x16a>
movsd  (%rsi,%rcx,8),%xmm0
divsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
movsd  0x8(%rsi,%rcx,8),%xmm0
divsd  0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1180 <matdivc+0x70>
jmp    127a <matdivc+0x16a>
lea    (%rdi,%rax,8),%rcx
lea    (%rsi,%rax,8),%rbp
cmp    %rdi,%rbp
seta   %r10b
lea    (%rdx,%rax,8),%rbp
cmp    %rsi,%rcx
seta   %r14b
cmp    %rdi,%rbp
seta   %bl
cmp    %rdx,%rcx
seta   %r9b
xor    %ecx,%ecx
test   %r14b,%r10b
jne    1bbd <matdivc+0xaad>
and    %r9b,%bl
mov    -0x68(%rsp),%r9
mov    -0x6c(%rsp),%r14d
jne    115a <matdivc+0x4a>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
lea    -0x2(%rcx),%rbp
mov    %rbp,%r10
shr    %r10
add    $0x1,%r10
test   %rbp,%rbp
je     1bcc <matdivc+0xabc>
mov    %r10,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd (%rsi,%rbx,8),%xmm0
movupd (%rdx,%rbx,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rbx,8)
movupd 0x10(%rsi,%rbx,8),%xmm0
movupd 0x10(%rdx,%rbx,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,0x10(%rdi,%rbx,8)
add    $0x4,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1220 <matdivc+0x110>
test   $0x1,%r10b
je     126c <matdivc+0x15c>
movupd (%rsi,%rbx,8),%xmm0
movupd (%rdx,%rbx,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rbx,8)
cmp    %rax,%rcx
mov    -0x68(%rsp),%r9
jne    115a <matdivc+0x4a>
cmp    %r9d,%r8d
mov    %r12d,-0x18(%rsp)
jne    14b9 <matdivc+0x3a9>
cmp    $0x1,%r14d
jne    14b9 <matdivc+0x3a9>
test   %r12d,%r12d
jle    171c <matdivc+0x60c>
mov    %r8d,%r11d
lea    (%rdi,%r11,8),%rcx
lea    (%rsi,%r11,8),%rax
lea    (%rdx,%r11,8),%rbp
mov    %rbp,-0x40(%rsp)
mov    %r11d,%r9d
and    $0xfffffffe,%r9d
lea    -0x2(%r9),%rbp
mov    %rbp,-0x20(%rsp)
shr    %rbp
add    $0x1,%rbp
cmp    %rdi,%rax
seta   %al
mov    %rcx,-0x38(%rsp)
cmp    %rsi,%rcx
seta   %cl
and    %al,%cl
mov    %cl,-0x48(%rsp)
mov    %rbp,%rax
mov    %rbp,-0x28(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x30(%rsp)
mov    %r11,%r13
neg    %r13
lea    0x10(%rdi),%rax
mov    %rax,-0x8(%rsp)
lea    0x10(%rsi),%rax
mov    %rax,-0x10(%rsp)
lea    0x8(%rsi),%rax
mov    %rax,-0x50(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,-0x58(%rsp)
lea    0x8(%rdx),%rax
mov    %rax,-0x60(%rsp)
xor    %r10d,%r10d
xor    %r15d,%r15d
jmp    133d <matdivc+0x22d>
nopl   0x0(%rax)
add    $0x1,%r10d
cmp    %r12d,%r10d
je     14ae <matdivc+0x39e>
test   %r8d,%r8d
jle    1330 <matdivc+0x220>
movslq %r15d,%r15
cmp    $0x1,%r8d
je     1372 <matdivc+0x262>
lea    (%rdi,%r15,8),%rax
mov    -0x38(%rsp),%rcx
lea    (%rcx,%r15,8),%rcx
cmp    -0x40(%rsp),%rax
setb   %al
cmp    %rdx,%rcx
seta   %cl
and    %al,%cl
or     -0x48(%rsp),%cl
je     1407 <matdivc+0x2f7>
xor    %eax,%eax
test   $0x1,%r11b
jne    1380 <matdivc+0x270>
mov    %rax,%rbp
jmp    139c <matdivc+0x28c>
nop
movsd  (%rsi,%r15,8),%xmm0
divsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%r15,8)
add    $0x1,%r15
mov    %rax,%rbp
or     $0x1,%rbp
not    %rax
cmp    %r13,%rax
je     1330 <matdivc+0x220>
mov    -0x50(%rsp),%rax
lea    (%rax,%r15,8),%rax
mov    -0x58(%rsp),%rcx
lea    (%rcx,%r15,8),%rbx
mov    %r11,%r14
sub    %rbp,%r14
mov    -0x60(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rbp,8),%xmm0
divsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
movsd  (%rax,%rbp,8),%xmm0
divsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r14
jne    13d0 <matdivc+0x2c0>
add    %rbp,%r15
mov    -0x6c(%rsp),%r14d
jmp    1330 <matdivc+0x220>
cmpq   $0x0,-0x20(%rsp)
je     14a3 <matdivc+0x393>
mov    -0x8(%rsp),%rax
lea    (%rax,%r15,8),%r14
mov    -0x10(%rsp),%rax
lea    (%rax,%r15,8),%r12
mov    -0x30(%rsp),%rbx
xor    %eax,%eax
nopl   0x0(%rax)
movupd -0x10(%r12,%rax,8),%xmm0
movupd (%rdx,%rax,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,-0x10(%r14,%rax,8)
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%rdx,%rax,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rbx
jne    1430 <matdivc+0x320>
testb  $0x1,-0x28(%rsp)
je     1485 <matdivc+0x375>
lea    (%rax,%r15,1),%rcx
movupd (%rsi,%rcx,8),%xmm0
movupd (%rdx,%rax,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rcx,8)
add    %r9,%r15
mov    %r9,%rax
cmp    %r11,%r9
mov    -0x18(%rsp),%r12d
mov    -0x6c(%rsp),%r14d
je     1330 <matdivc+0x220>
jmp    1374 <matdivc+0x264>
xor    %eax,%eax
testb  $0x1,-0x28(%rsp)
jne    146e <matdivc+0x35e>
jmp    1485 <matdivc+0x375>
mov    $0x1,%r11d
mov    -0x68(%rsp),%r9
cmp    %r9d,%r8d
jne    16f9 <matdivc+0x5e9>
cmp    $0x1,%r12d
jne    16f9 <matdivc+0x5e9>
test   %r14d,%r14d
jle    172d <matdivc+0x61d>
mov    %r8d,%r11d
lea    (%rdi,%r11,8),%rcx
lea    (%rdx,%r11,8),%rax
lea    (%rsi,%r11,8),%rbp
mov    %rbp,-0x40(%rsp)
mov    %r11d,%r9d
and    $0xfffffffe,%r9d
lea    -0x2(%r9),%rbp
mov    %rbp,-0x20(%rsp)
shr    %rbp
add    $0x1,%rbp
cmp    %rdi,%rax
seta   %al
mov    %rcx,-0x38(%rsp)
cmp    %rdx,%rcx
seta   %cl
and    %al,%cl
mov    %cl,-0x48(%rsp)
mov    %rbp,%rax
mov    %rbp,-0x28(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x30(%rsp)
mov    %r11,%r13
neg    %r13
lea    0x10(%rdi),%rax
mov    %rax,-0x8(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,-0x10(%rsp)
lea    0x8(%rdx),%rax
mov    %rax,-0x50(%rsp)
lea    0x8(%rdi),%rax
mov    %rax,-0x58(%rsp)
lea    0x8(%rsi),%rax
mov    %rax,-0x60(%rsp)
xor    %r10d,%r10d
xor    %r15d,%r15d
jmp    157d <matdivc+0x46d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10d
cmp    %r14d,%r10d
je     16ee <matdivc+0x5de>
test   %r8d,%r8d
jle    1570 <matdivc+0x460>
movslq %r15d,%r15
cmp    $0x1,%r8d
je     15b2 <matdivc+0x4a2>
lea    (%rdi,%r15,8),%rax
mov    -0x38(%rsp),%rcx
lea    (%rcx,%r15,8),%rcx
cmp    -0x40(%rsp),%rax
setb   %al
cmp    %rsi,%rcx
seta   %cl
and    %al,%cl
or     -0x48(%rsp),%cl
je     1647 <matdivc+0x537>
xor    %eax,%eax
test   $0x1,%r11b
jne    15c0 <matdivc+0x4b0>
mov    %rax,%rbp
jmp    15dc <matdivc+0x4cc>
nop
movsd  (%rdx,%r15,8),%xmm0
divsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%r15,8)
add    $0x1,%r15
mov    %rax,%rbp
or     $0x1,%rbp
not    %rax
cmp    %r13,%rax
je     1570 <matdivc+0x460>
mov    -0x50(%rsp),%rax
lea    (%rax,%r15,8),%rax
mov    -0x58(%rsp),%rcx
lea    (%rcx,%r15,8),%rbx
mov    %r11,%r14
sub    %rbp,%r14
mov    -0x60(%rsp),%rcx
lea    (%rcx,%rbp,8),%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rbp,8),%xmm0
divsd  -0x8(%rcx,%rbp,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rbp,8)
movsd  (%rax,%rbp,8),%xmm0
divsd  (%rcx,%rbp,8),%xmm0
movsd  %xmm0,(%rbx,%rbp,8)
add    $0x2,%rbp
cmp    %rbp,%r14
jne    1610 <matdivc+0x500>
add    %rbp,%r15
mov    -0x6c(%rsp),%r14d
jmp    1570 <matdivc+0x460>
cmpq   $0x0,-0x20(%rsp)
je     16e3 <matdivc+0x5d3>
mov    -0x8(%rsp),%rax
lea    (%rax,%r15,8),%r14
mov    -0x10(%rsp),%rax
lea    (%rax,%r15,8),%r12
mov    -0x30(%rsp),%rbx
xor    %eax,%eax
nopl   0x0(%rax)
movupd -0x10(%r12,%rax,8),%xmm0
movupd (%rsi,%rax,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,-0x10(%r14,%rax,8)
movupd (%r12,%rax,8),%xmm0
movupd 0x10(%rsi,%rax,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%r14,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rbx
jne    1670 <matdivc+0x560>
testb  $0x1,-0x28(%rsp)
je     16c5 <matdivc+0x5b5>
lea    (%rax,%r15,1),%rcx
movupd (%rdx,%rcx,8),%xmm0
movupd (%rsi,%rax,8),%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rcx,8)
add    %r9,%r15
mov    %r9,%rax
cmp    %r11,%r9
mov    -0x18(%rsp),%r12d
mov    -0x6c(%rsp),%r14d
je     1570 <matdivc+0x460>
jmp    15b4 <matdivc+0x4a4>
xor    %eax,%eax
testb  $0x1,-0x28(%rsp)
jne    16ae <matdivc+0x59e>
jmp    16c5 <matdivc+0x5b5>
mov    $0x1,%r11d
mov    -0x68(%rsp),%r9
cmp    $0x1,%r9d
jne    1967 <matdivc+0x857>
cmp    %r14d,%r12d
jne    1967 <matdivc+0x857>
test   %r12d,%r12d
jg     1740 <matdivc+0x630>
mov    $0x1,%r11d
jmp    1967 <matdivc+0x857>
mov    $0x1,%r11d
cmp    $0x1,%r9d
je     1703 <matdivc+0x5f3>
jmp    1967 <matdivc+0x857>
cmp    $0x1,%r9d
jne    1bac <matdivc+0xa9c>
cmp    %r14d,%r12d
jne    1bac <matdivc+0xa9c>
lea    -0x1(%r8),%r10d
lea    0x1(%r10),%rbp
lea    (%rsi,%r10,8),%rax
add    $0x8,%rax
mov    %r12d,%ecx
mov    %rbp,-0x48(%rsp)
mov    %rbp,%r12
and    $0xfffffffffffffffe,%r12
lea    -0x2(%r12),%rbp
mov    %rbp,-0x50(%rsp)
shr    %rbp
add    $0x1,%rbp
cmp    %rdi,%rax
seta   %al
lea    (%rdi,%r10,8),%r13
add    $0x8,%r13
cmp    %rsi,%r13
seta   %bl
mov    %ecx,%r11d
and    %al,%bl
mov    %bl,-0x40(%rsp)
mov    %rbp,%rax
mov    %rbp,-0x58(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,-0x20(%rsp)
mov    %r8d,%eax
neg    %eax
mov    %eax,-0x38(%rsp)
lea    0x10(%rdi),%rax
mov    %rax,-0x28(%rsp)
lea    0x10(%rsi),%rax
mov    %rax,-0x30(%rsp)
xor    %r14d,%r14d
xor    %ebx,%ebx
mov    %r13,-0x60(%rsp)
jmp    17dd <matdivc+0x6cd>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r14
cmp    %r11,%r14
je     1952 <matdivc+0x842>
test   %r8d,%r8d
jle    17d0 <matdivc+0x6c0>
xor    %eax,%eax
movslq %ebx,%rbx
test   %r10d,%r10d
je     18d0 <matdivc+0x7c0>
lea    (%rdx,%r14,8),%r9
lea    (%rdx,%r14,8),%rbp
add    $0x8,%rbp
lea    (%rdi,%rbx,8),%rcx
lea    0x0(,%rbx,8),%r15
add    %r13,%r15
cmp    %rbp,%rcx
setb   %bpl
cmp    %r15,%r9
setb   %cl
and    %bpl,%cl
or     -0x40(%rsp),%cl
jne    18d0 <matdivc+0x7c0>
cmpq   $0x0,-0x50(%rsp)
je     1940 <matdivc+0x830>
movsd  (%rdx,%r14,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    -0x28(%rsp),%rax
lea    (%rax,%rbx,8),%r15
mov    -0x30(%rsp),%rax
lea    (%rax,%rbx,8),%r13
mov    -0x20(%rsp),%r9
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x10(%r13,%rax,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%r15,%rax,8)
movupd 0x0(%r13,%rax,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r15,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%r9
jne    1860 <matdivc+0x750>
testb  $0x1,-0x58(%rsp)
je     18af <matdivc+0x79f>
add    %rbx,%rax
movupd (%rsi,%rax,8),%xmm0
movsd  (%rdx,%r14,8),%xmm1
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rax,8)
add    %r12,%rbx
mov    %r12d,%eax
cmp    %r12,-0x48(%rsp)
mov    -0x60(%rsp),%r13
je     17d0 <matdivc+0x6c0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8d,%ecx
sub    %eax,%ecx
test   $0x1,%cl
jne    18e0 <matdivc+0x7d0>
mov    %eax,%ecx
jmp    18f7 <matdivc+0x7e7>
xchg   %ax,%ax
movsd  (%rsi,%rbx,8),%xmm0
divsd  (%rdx,%r14,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
add    $0x1,%rbx
lea    0x1(%rax),%ecx
not    %eax
cmp    -0x38(%rsp),%eax
je     17d0 <matdivc+0x6c0>
mov    %r8d,%eax
sub    %ecx,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rbx,8),%xmm0
divsd  (%rdx,%r14,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
movsd  0x8(%rsi,%rbx,8),%xmm0
divsd  (%rdx,%r14,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rbx,8)
add    $0x2,%rbx
add    $0xfffffffe,%eax
jne    1910 <matdivc+0x800>
jmp    17d0 <matdivc+0x6c0>
xor    %eax,%eax
testb  $0x1,-0x58(%rsp)
jne    1894 <matdivc+0x784>
jmp    18af <matdivc+0x79f>
mov    $0x1,%r11d
mov    -0x68(%rsp),%r9
mov    -0x18(%rsp),%r12d
mov    -0x6c(%rsp),%r14d
cmp    $0x1,%r8d
jne    1b86 <matdivc+0xa76>
cmp    %r14d,%r12d
jne    1b86 <matdivc+0xa76>
test   %r12d,%r12d
jle    1b8b <matdivc+0xa7b>
lea    -0x1(%r9),%r14d
lea    0x1(%r14),%r8
lea    (%rdx,%r14,8),%rax
add    $0x8,%rax
mov    %r8,-0x40(%rsp)
and    $0xfffffffffffffffe,%r8
lea    -0x2(%r8),%rcx
mov    %rcx,-0x18(%rsp)
shr    %rcx
add    $0x1,%rcx
cmp    %rdi,%rax
seta   %al
lea    (%rdi,%r14,8),%r11
add    $0x8,%r11
cmp    %rdx,%r11
seta   %bl
mov    %r12d,%r13d
and    %al,%bl
mov    %bl,-0x38(%rsp)
mov    %rcx,%rax
mov    %rcx,-0x48(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x50(%rsp)
mov    %r9d,%eax
neg    %eax
mov    %eax,-0x6c(%rsp)
lea    0x10(%rdi),%rax
mov    %rax,-0x58(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,-0x60(%rsp)
xor    %r12d,%r12d
xor    %r15d,%r15d
jmp    1a0d <matdivc+0x8fd>
nopl   (%rax)
add    $0x1,%r12
cmp    %r13,%r12
je     1b8b <matdivc+0xa7b>
test   %r9d,%r9d
jle    1a00 <matdivc+0x8f0>
xor    %eax,%eax
movslq %r15d,%r15
test   %r14d,%r14d
je     1b00 <matdivc+0x9f0>
lea    (%rsi,%r12,8),%r10
lea    (%rsi,%r12,8),%rcx
add    $0x8,%rcx
lea    (%rdi,%r15,8),%rbp
lea    (%r11,%r15,8),%rbx
cmp    %rcx,%rbp
setb   %cl
cmp    %rbx,%r10
setb   %bl
and    %cl,%bl
or     -0x38(%rsp),%bl
je     1a52 <matdivc+0x942>
mov    -0x68(%rsp),%r9
jmp    1b00 <matdivc+0x9f0>
mov    %r11,%rcx
cmpq   $0x0,-0x18(%rsp)
je     1b74 <matdivc+0xa64>
movsd  (%rsi,%r12,8),%xmm0
unpcklpd %xmm0,%xmm0
mov    -0x58(%rsp),%rax
lea    (%rax,%r15,8),%r10
mov    -0x60(%rsp),%rax
lea    (%rax,%r15,8),%rbx
mov    -0x50(%rsp),%r11
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x10(%rbx,%rax,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%r10,%rax,8)
movupd (%rbx,%rax,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r10,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%r11
jne    1a90 <matdivc+0x980>
testb  $0x1,-0x48(%rsp)
je     1adc <matdivc+0x9cc>
add    %r15,%rax
movupd (%rdx,%rax,8),%xmm0
movsd  (%rsi,%r12,8),%xmm1
unpcklpd %xmm1,%xmm1
divpd  %xmm1,%xmm0
movupd %xmm0,(%rdi,%rax,8)
add    %r8,%r15
mov    %r8d,%eax
cmp    %r8,-0x40(%rsp)
mov    -0x68(%rsp),%r9
mov    %rcx,%r11
je     1a00 <matdivc+0x8f0>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9d,%ecx
sub    %eax,%ecx
test   $0x1,%cl
jne    1b10 <matdivc+0xa00>
mov    %eax,%ebx
jmp    1b29 <matdivc+0xa19>
xchg   %ax,%ax
movsd  (%rdx,%r15,8),%xmm0
divsd  (%rsi,%r12,8),%xmm0
movsd  %xmm0,(%rdi,%r15,8)
add    $0x1,%r15
lea    0x1(%rax),%ebx
not    %eax
cmp    -0x6c(%rsp),%eax
je     1a00 <matdivc+0x8f0>
mov    %r9d,%eax
sub    %ebx,%eax
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%r15,8),%xmm0
divsd  (%rsi,%r12,8),%xmm0
movsd  %xmm0,(%rdi,%r15,8)
movsd  0x8(%rdx,%r15,8),%xmm0
divsd  (%rsi,%r12,8),%xmm0
movsd  %xmm0,0x8(%rdi,%r15,8)
add    $0x2,%r15
add    $0xfffffffe,%eax
jne    1b40 <matdivc+0xa30>
jmp    1a00 <matdivc+0x8f0>
xor    %eax,%eax
testb  $0x1,-0x48(%rsp)
jne    1ac1 <matdivc+0x9b1>
jmp    1adc <matdivc+0x9cc>
test   %r11d,%r11d
je     1b96 <matdivc+0xa86>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x463(%rip),%rdi
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <puts@plt>
cmp    $0x1,%r8d
jne    1b8b <matdivc+0xa7b>
cmp    %r14d,%r12d
je     1983 <matdivc+0x873>
jmp    1b8b <matdivc+0xa7b>
mov    -0x68(%rsp),%r9
mov    -0x6c(%rsp),%r14d
jmp    115a <matdivc+0x4a>
xor    %ebx,%ebx
test   $0x1,%r10b
jne    1259 <matdivc+0x149>
jmp    126c <matdivc+0x15c>

LLVM IR (-O0):
@.str = [41 x i8] c"matdivc: nonconformability of matrices \0A\00"
define void @matdivc(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 = fdiv 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 = fdiv 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 = fdiv 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 = fdiv 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 = fdiv 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"matdivc: nonconformability of matrices \00"
define void @matdivc(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 %111
12: ; preds = %8
%13 = icmp sgt i32 %3, 0
br i1 %13, label %14, label %111
14: ; preds = %12
%15 = zext i32 %3 to i64
%16 = icmp eq i32 %3, 1
br i1 %16, label %77, 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 %77, label %28
28: ; preds = %17
%29 = and i64 %15, 4294967294
%30 = add nsw i64 %29, -2
%31 = lshr exact i64 %30, 1
%32 = add nuw i64 %31, 1
%33 = and i64 %32, 1
%34 = icmp eq i64 %30, 0
br i1 %34, label %62, label %35
35: ; preds = %28
%36 = and i64 %32, -2
br label %37
37: ; preds = %37, %35
%38 = phi i64 [ 0, %35 ], [ %59, %37 ]
%39 = phi i64 [ 0, %35 ], [ %60, %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* %2, i64 %38
%44 = bitcast double* %43 to <2 x double>*
%45 = load <2 x double>, <2 x double>* %44
%46 = fdiv <2 x double> %42, %45
%47 = getelementptr inbounds double, double* %0, i64 %38
%48 = bitcast double* %47 to <2 x double>*
store <2 x double> %46, <2 x double>* %48
%49 = or i64 %38, 2
%50 = getelementptr inbounds double, double* %1, i64 %49
%51 = bitcast double* %50 to <2 x double>*
%52 = load <2 x double>, <2 x double>* %51
%53 = getelementptr inbounds double, double* %2, i64 %49
%54 = bitcast double* %53 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = fdiv <2 x double> %52, %55
%57 = getelementptr inbounds double, double* %0, i64 %49
%58 = bitcast double* %57 to <2 x double>*
store <2 x double> %56, <2 x double>* %58
%59 = add nuw i64 %38, 4
%60 = add nuw i64 %39, 2
%61 = icmp eq i64 %60, %36
br i1 %61, label %62, label %37
62: ; preds = %37, %28
%63 = phi i64 [ 0, %28 ], [ %59, %37 ]
%64 = icmp eq i64 %33, 0
br i1 %64, label %75, label %65
65: ; preds = %62
%66 = getelementptr inbounds double, double* %1, i64 %63
%67 = bitcast double* %66 to <2 x double>*
%68 = load <2 x double>, <2 x double>* %67
%69 = getelementptr inbounds double, double* %2, i64 %63
%70 = bitcast double* %69 to <2 x double>*
%71 = load <2 x double>, <2 x double>* %70
%72 = fdiv <2 x double> %68, %71
%73 = getelementptr inbounds double, double* %0, i64 %63
%74 = bitcast double* %73 to <2 x double>*
store <2 x double> %72, <2 x double>* %74
br label %75
75: ; preds = %62, %65
%76 = icmp eq i64 %29, %15
br i1 %76, label %111, label %77
77: ; preds = %17, %14, %75
%78 = phi i64 [ 0, %17 ], [ 0, %14 ], [ %29, %75 ]
%79 = xor i64 %78, -1
%80 = and i64 %15, 1
%81 = icmp eq i64 %80, 0
br i1 %81, label %90, label %82
82: ; preds = %77
%83 = getelementptr inbounds double, double* %1, i64 %78
%84 = load double, double* %83
%85 = getelementptr inbounds double, double* %2, i64 %78
%86 = load double, double* %85
%87 = fdiv double %84, %86
%88 = getelementptr inbounds double, double* %0, i64 %78
store double %87, double* %88
%89 = or i64 %78, 1
br label %90
90: ; preds = %82, %77
%91 = phi i64 [ %78, %77 ], [ %89, %82 ]
%92 = sub nsw i64 0, %15
%93 = icmp eq i64 %79, %92
br i1 %93, label %111, label %94
94: ; preds = %90, %94
%95 = phi i64 [ %109, %94 ], [ %91, %90 ]
%96 = getelementptr inbounds double, double* %1, i64 %95
%97 = load double, double* %96
%98 = getelementptr inbounds double, double* %2, i64 %95
%99 = load double, double* %98
%100 = fdiv double %97, %99
%101 = getelementptr inbounds double, double* %0, i64 %95
store double %100, double* %101
%102 = add nuw nsw i64 %95, 1
%103 = getelementptr inbounds double, double* %1, i64 %102
%104 = load double, double* %103
%105 = getelementptr inbounds double, double* %2, i64 %102
%106 = load double, double* %105
%107 = fdiv double %104, %106
%108 = getelementptr inbounds double, double* %0, i64 %102
store double %107, double* %108
%109 = add nuw nsw i64 %95, 2
%110 = icmp eq i64 %109, %15
br i1 %110, label %111, label %94
111: ; preds = %90, %94, %75, %12, %8
%112 = phi i32 [ 0, %8 ], [ 1, %12 ], [ 1, %75 ], [ 1, %94 ], [ 1, %90 ]
%113 = icmp eq i32 %7, 1
%114 = and i1 %9, %113
br i1 %114, label %115, label %240
115: ; preds = %111
%116 = icmp sgt i32 %6, 0
br i1 %116, label %117, label %369
117: ; preds = %115
%118 = icmp sgt i32 %4, 0
%119 = zext i32 %4 to i64
%120 = getelementptr double, double* %0, i64 %119
%121 = getelementptr double, double* %1, i64 %119
%122 = getelementptr double, double* %2, i64 %119
%123 = and i64 %119, 4294967294
%124 = add nsw i64 %123, -2
%125 = lshr exact i64 %124, 1
%126 = add nuw i64 %125, 1
%127 = icmp eq i32 %4, 1
%128 = icmp ugt double* %121, %0
%129 = icmp ugt double* %120, %1
%130 = and i1 %128, %129
%131 = and i64 %119, 4294967294
%132 = and i64 %126, 1
%133 = icmp eq i64 %124, 0
%134 = and i64 %126, -2
%135 = icmp eq i64 %132, 0
%136 = icmp eq i64 %131, %119
%137 = and i64 %119, 1
%138 = icmp eq i64 %137, 0
%139 = sub nsw i64 0, %119
br label %140
140: ; preds = %117, %236
%141 = phi i32 [ 0, %117 ], [ %238, %236 ]
%142 = phi i32 [ 0, %117 ], [ %237, %236 ]
br i1 %118, label %143, label %236
143: ; preds = %140
%144 = sext i32 %142 to i64
br i1 %127, label %195, label %145
145: ; preds = %143
%146 = getelementptr double, double* %0, i64 %144
%147 = getelementptr double, double* %120, i64 %144
%148 = icmp ult double* %146, %122
%149 = icmp ugt double* %147, %2
%150 = and i1 %148, %149
%151 = or i1 %130, %150
br i1 %151, label %195, label %152
152: ; preds = %145
%153 = add nsw i64 %131, %144
br i1 %133, label %181, label %154
154: ; preds = %152, %154
%155 = phi i64 [ %178, %154 ], [ 0, %152 ]
%156 = phi i64 [ %179, %154 ], [ 0, %152 ]
%157 = add i64 %155, %144
%158 = getelementptr inbounds double, double* %1, i64 %157
%159 = bitcast double* %158 to <2 x double>*
%160 = load <2 x double>, <2 x double>* %159
%161 = getelementptr inbounds double, double* %2, i64 %155
%162 = bitcast double* %161 to <2 x double>*
%163 = load <2 x double>, <2 x double>* %162
%164 = fdiv <2 x double> %160, %163
%165 = getelementptr inbounds double, double* %0, i64 %157
%166 = bitcast double* %165 to <2 x double>*
store <2 x double> %164, <2 x double>* %166
%167 = or i64 %155, 2
%168 = add i64 %167, %144
%169 = getelementptr inbounds double, double* %1, i64 %168
%170 = bitcast double* %169 to <2 x double>*
%171 = load <2 x double>, <2 x double>* %170
%172 = getelementptr inbounds double, double* %2, i64 %167
%173 = bitcast double* %172 to <2 x double>*
%174 = load <2 x double>, <2 x double>* %173
%175 = fdiv <2 x double> %171, %174
%176 = getelementptr inbounds double, double* %0, i64 %168
%177 = bitcast double* %176 to <2 x double>*
store <2 x double> %175, <2 x double>* %177
%178 = add nuw i64 %155, 4
%179 = add nuw i64 %156, 2
%180 = icmp eq i64 %179, %134
br i1 %180, label %181, label %154
181: ; preds = %154, %152
%182 = phi i64 [ 0, %152 ], [ %178, %154 ]
br i1 %135, label %194, label %183
183: ; preds = %181
%184 = add i64 %182, %144
%185 = getelementptr inbounds double, double* %1, i64 %184
%186 = bitcast double* %185 to <2 x double>*
%187 = load <2 x double>, <2 x double>* %186
%188 = getelementptr inbounds double, double* %2, i64 %182
%189 = bitcast double* %188 to <2 x double>*
%190 = load <2 x double>, <2 x double>* %189
%191 = fdiv <2 x double> %187, %190
%192 = getelementptr inbounds double, double* %0, i64 %184
%193 = bitcast double* %192 to <2 x double>*
store <2 x double> %191, <2 x double>* %193
br label %194
194: ; preds = %181, %183
br i1 %136, label %233, label %195
195: ; preds = %145, %143, %194
%196 = phi i64 [ %144, %145 ], [ %144, %143 ], [ %153, %194 ]
%197 = phi i64 [ 0, %145 ], [ 0, %143 ], [ %131, %194 ]
%198 = xor i64 %197, -1
br i1 %138, label %208, label %199
199: ; preds = %195
%200 = getelementptr inbounds double, double* %1, i64 %196
%201 = load double, double* %200
%202 = getelementptr inbounds double, double* %2, i64 %197
%203 = load double, double* %202
%204 = fdiv double %201, %203
%205 = getelementptr inbounds double, double* %0, i64 %196
store double %204, double* %205
%206 = add nsw i64 %196, 1
%207 = or i64 %197, 1
br label %208
208: ; preds = %199, %195
%209 = phi i64 [ undef, %195 ], [ %206, %199 ]
%210 = phi i64 [ %196, %195 ], [ %206, %199 ]
%211 = phi i64 [ %197, %195 ], [ %207, %199 ]
%212 = icmp eq i64 %198, %139
br i1 %212, label %233, label %213
213: ; preds = %208, %213
%214 = phi i64 [ %230, %213 ], [ %210, %208 ]
%215 = phi i64 [ %231, %213 ], [ %211, %208 ]
%216 = getelementptr inbounds double, double* %1, i64 %214
%217 = load double, double* %216
%218 = getelementptr inbounds double, double* %2, i64 %215
%219 = load double, double* %218
%220 = fdiv double %217, %219
%221 = getelementptr inbounds double, double* %0, i64 %214
store double %220, double* %221
%222 = add nsw i64 %214, 1
%223 = add nuw nsw i64 %215, 1
%224 = getelementptr inbounds double, double* %1, i64 %222
%225 = load double, double* %224
%226 = getelementptr inbounds double, double* %2, i64 %223
%227 = load double, double* %226
%228 = fdiv double %225, %227
%229 = getelementptr inbounds double, double* %0, i64 %222
store double %228, double* %229
%230 = add nsw i64 %214, 2
%231 = add nuw nsw i64 %215, 2
%232 = icmp eq i64 %231, %119
br i1 %232, label %233, label %213
233: ; preds = %208, %213, %194
%234 = phi i64 [ %153, %194 ], [ %209, %208 ], [ %230, %213 ]
%235 = trunc i64 %234 to i32
br label %236
236: ; preds = %233, %140
%237 = phi i32 [ %142, %140 ], [ %235, %233 ]
%238 = add nuw nsw i32 %141, 1
%239 = icmp eq i32 %238, %6
br i1 %239, label %240, label %140
240: ; preds = %236, %111
%241 = phi i32 [ %112, %111 ], [ 1, %236 ]
%242 = icmp eq i32 %6, 1
%243 = and i1 %9, %242
br i1 %243, label %244, label %369
244: ; preds = %240
%245 = icmp sgt i32 %7, 0
br i1 %245, label %246, label %373
246: ; preds = %244
%247 = icmp sgt i32 %4, 0
%248 = zext i32 %4 to i64
%249 = getelementptr double, double* %0, i64 %248
%250 = getelementptr double, double* %2, i64 %248
%251 = getelementptr double, double* %1, i64 %248
%252 = and i64 %248, 4294967294
%253 = add nsw i64 %252, -2
%254 = lshr exact i64 %253, 1
%255 = add nuw i64 %254, 1
%256 = icmp eq i32 %4, 1
%257 = icmp ugt double* %250, %0
%258 = icmp ugt double* %249, %2
%259 = and i1 %257, %258
%260 = and i64 %248, 4294967294
%261 = and i64 %255, 1
%262 = icmp eq i64 %253, 0
%263 = and i64 %255, -2
%264 = icmp eq i64 %261, 0
%265 = icmp eq i64 %260, %248
%266 = and i64 %248, 1
%267 = icmp eq i64 %266, 0
%268 = sub nsw i64 0, %248
br label %269
269: ; preds = %246, %365
%270 = phi i32 [ 0, %246 ], [ %367, %365 ]
%271 = phi i32 [ 0, %246 ], [ %366, %365 ]
br i1 %247, label %272, label %365
272: ; preds = %269
%273 = sext i32 %271 to i64
br i1 %256, label %324, label %274
274: ; preds = %272
%275 = getelementptr double, double* %0, i64 %273
%276 = getelementptr double, double* %249, i64 %273
%277 = icmp ult double* %275, %251
%278 = icmp ugt double* %276, %1
%279 = and i1 %277, %278
%280 = or i1 %259, %279
br i1 %280, label %324, label %281
281: ; preds = %274
%282 = add nsw i64 %260, %273
br i1 %262, label %310, label %283
283: ; preds = %281, %283
%284 = phi i64 [ %307, %283 ], [ 0, %281 ]
%285 = phi i64 [ %308, %283 ], [ 0, %281 ]
%286 = add i64 %284, %273
%287 = getelementptr inbounds double, double* %2, i64 %286
%288 = bitcast double* %287 to <2 x double>*
%289 = load <2 x double>, <2 x double>* %288
%290 = getelementptr inbounds double, double* %1, i64 %284
%291 = bitcast double* %290 to <2 x double>*
%292 = load <2 x double>, <2 x double>* %291
%293 = fdiv <2 x double> %289, %292
%294 = getelementptr inbounds double, double* %0, i64 %286
%295 = bitcast double* %294 to <2 x double>*
store <2 x double> %293, <2 x double>* %295
%296 = or i64 %284, 2
%297 = add i64 %296, %273
%298 = getelementptr inbounds double, double* %2, i64 %297
%299 = bitcast double* %298 to <2 x double>*
%300 = load <2 x double>, <2 x double>* %299
%301 = getelementptr inbounds double, double* %1, i64 %296
%302 = bitcast double* %301 to <2 x double>*
%303 = load <2 x double>, <2 x double>* %302
%304 = fdiv <2 x double> %300, %303
%305 = getelementptr inbounds double, double* %0, i64 %297
%306 = bitcast double* %305 to <2 x double>*
store <2 x double> %304, <2 x double>* %306
%307 = add nuw i64 %284, 4
%308 = add nuw i64 %285, 2
%309 = icmp eq i64 %308, %263
br i1 %309, label %310, label %283
310: ; preds = %283, %281
%311 = phi i64 [ 0, %281 ], [ %307, %283 ]
br i1 %264, label %323, label %312
312: ; preds = %310
%313 = add i64 %311, %273
%314 = getelementptr inbounds double, double* %2, i64 %313
%315 = bitcast double* %314 to <2 x double>*
%316 = load <2 x double>, <2 x double>* %315
%317 = getelementptr inbounds double, double* %1, i64 %311
%318 = bitcast double* %317 to <2 x double>*
%319 = load <2 x double>, <2 x double>* %318
%320 = fdiv <2 x double> %316, %319
%321 = getelementptr inbounds double, double* %0, i64 %313
%322 = bitcast double* %321 to <2 x double>*
store <2 x double> %320, <2 x double>* %322
br label %323
323: ; preds = %310, %312
br i1 %265, label %362, label %324
324: ; preds = %274, %272, %323
%325 = phi i64 [ %273, %274 ], [ %273, %272 ], [ %282, %323 ]
%326 = phi i64 [ 0, %274 ], [ 0, %272 ], [ %260, %323 ]
%327 = xor i64 %326, -1
br i1 %267, label %337, label %328
328: ; preds = %324
%329 = getelementptr inbounds double, double* %2, i64 %325
%330 = load double, double* %329
%331 = getelementptr inbounds double, double* %1, i64 %326
%332 = load double, double* %331
%333 = fdiv double %330, %332
%334 = getelementptr inbounds double, double* %0, i64 %325
store double %333, double* %334
%335 = add nsw i64 %325, 1
%336 = or i64 %326, 1
br label %337
337: ; preds = %328, %324
%338 = phi i64 [ undef, %324 ], [ %335, %328 ]
%339 = phi i64 [ %325, %324 ], [ %335, %328 ]
%340 = phi i64 [ %326, %324 ], [ %336, %328 ]
%341 = icmp eq i64 %327, %268
br i1 %341, label %362, label %342
342: ; preds = %337, %342
%343 = phi i64 [ %359, %342 ], [ %339, %337 ]
%344 = phi i64 [ %360, %342 ], [ %340, %337 ]
%345 = getelementptr inbounds double, double* %2, i64 %343
%346 = load double, double* %345
%347 = getelementptr inbounds double, double* %1, i64 %344
%348 = load double, double* %347
%349 = fdiv double %346, %348
%350 = getelementptr inbounds double, double* %0, i64 %343
store double %349, double* %350
%351 = add nsw i64 %343, 1
%352 = add nuw nsw i64 %344, 1
%353 = getelementptr inbounds double, double* %2, i64 %351
%354 = load double, double* %353
%355 = getelementptr inbounds double, double* %1, i64 %352
%356 = load double, double* %355
%357 = fdiv double %354, %356
%358 = getelementptr inbounds double, double* %0, i64 %351
store double %357, double* %358
%359 = add nsw i64 %343, 2
%360 = add nuw nsw i64 %344, 2
%361 = icmp eq i64 %360, %248
br i1 %361, label %362, label %342
362: ; preds = %337, %342, %323
%363 = phi i64 [ %282, %323 ], [ %338, %337 ], [ %359, %342 ]
%364 = trunc i64 %363 to i32
br label %365
365: ; preds = %362, %269
%366 = phi i32 [ %271, %269 ], [ %364, %362 ]
%367 = add nuw nsw i32 %270, 1
%368 = icmp eq i32 %367, %7
br i1 %368, label %369, label %269
369: ; preds = %365, %115, %240
%370 = phi i32 [ %241, %240 ], [ 1, %115 ], [ 1, %365 ]
%371 = icmp eq i32 %5, 1
%372 = and i1 %371, %10
br i1 %372, label %376, label %508
373: ; preds = %244
%374 = icmp eq i32 %5, 1
%375 = and i1 %374, %10
br i1 %375, label %378, label %512
376: ; preds = %369
%377 = icmp sgt i32 %6, 0
br i1 %377, label %378, label %508
378: ; preds = %373, %376
%379 = icmp sgt i32 %4, 0
%380 = zext i32 %6 to i64
%381 = add i32 %4, -1
%382 = zext i32 %381 to i64
%383 = add nuw nsw i64 %382, 1
%384 = getelementptr double, double* %0, i64 %383
%385 = getelementptr double, double* %1, i64 %383
%386 = zext i32 %381 to i64
%387 = add nuw nsw i64 %386, 1
%388 = and i64 %387, 8589934590
%389 = add nsw i64 %388, -2
%390 = lshr exact i64 %389, 1
%391 = add nuw i64 %390, 1
%392 = icmp eq i32 %381, 0
%393 = icmp ugt double* %385, %0
%394 = icmp ugt double* %384, %1
%395 = and i1 %393, %394
%396 = and i64 %387, 8589934590
%397 = trunc i64 %396 to i32
%398 = and i64 %391, 1
%399 = icmp eq i64 %389, 0
%400 = and i64 %391, -2
%401 = icmp eq i64 %398, 0
%402 = icmp eq i64 %387, %396
%403 = sub i32 0, %4
br label %404
404: ; preds = %378, %504
%405 = phi i64 [ 0, %378 ], [ %506, %504 ]
%406 = phi i32 [ 0, %378 ], [ %505, %504 ]
%407 = getelementptr double, double* %2, i64 %405
%408 = add nuw i64 %405, 1
%409 = getelementptr double, double* %2, i64 %408
br i1 %379, label %410, label %504
410: ; preds = %404
%411 = getelementptr inbounds double, double* %2, i64 %405
%412 = sext i32 %406 to i64
br i1 %392, label %464, label %413
413: ; preds = %410
%414 = getelementptr double, double* %0, i64 %412
%415 = getelementptr double, double* %384, i64 %412
%416 = icmp ult double* %414, %409
%417 = icmp ult double* %407, %415
%418 = and i1 %416, %417
%419 = or i1 %395, %418
br i1 %419, label %464, label %420
420: ; preds = %413
%421 = add nsw i64 %396, %412
br i1 %399, label %450, label %422
422: ; preds = %420
%423 = load double, double* %411
%424 = insertelement <2 x double> poison, double %423, i64 0
%425 = shufflevector <2 x double> %424, <2 x double> poison, <2 x i32> zeroinitializer
%426 = load double, double* %411
%427 = insertelement <2 x double> poison, double %426, i64 0
%428 = shufflevector <2 x double> %427, <2 x double> poison, <2 x i32> zeroinitializer
br label %429
429: ; preds = %429, %422
%430 = phi i64 [ 0, %422 ], [ %447, %429 ]
%431 = phi i64 [ 0, %422 ], [ %448, %429 ]
%432 = add i64 %430, %412
%433 = getelementptr inbounds double, double* %1, i64 %432
%434 = bitcast double* %433 to <2 x double>*
%435 = load <2 x double>, <2 x double>* %434
%436 = fdiv <2 x double> %435, %425
%437 = getelementptr inbounds double, double* %0, i64 %432
%438 = bitcast double* %437 to <2 x double>*
store <2 x double> %436, <2 x double>* %438
%439 = or i64 %430, 2
%440 = add i64 %439, %412
%441 = getelementptr inbounds double, double* %1, i64 %440
%442 = bitcast double* %441 to <2 x double>*
%443 = load <2 x double>, <2 x double>* %442
%444 = fdiv <2 x double> %443, %428
%445 = getelementptr inbounds double, double* %0, i64 %440
%446 = bitcast double* %445 to <2 x double>*
store <2 x double> %444, <2 x double>* %446
%447 = add nuw i64 %430, 4
%448 = add nuw i64 %431, 2
%449 = icmp eq i64 %448, %400
br i1 %449, label %450, label %429
450: ; preds = %429, %420
%451 = phi i64 [ 0, %420 ], [ %447, %429 ]
br i1 %401, label %463, label %452
452: ; preds = %450
%453 = add i64 %451, %412
%454 = getelementptr inbounds double, double* %1, i64 %453
%455 = bitcast double* %454 to <2 x double>*
%456 = load <2 x double>, <2 x double>* %455
%457 = load double, double* %411
%458 = insertelement <2 x double> poison, double %457, i64 0
%459 = shufflevector <2 x double> %458, <2 x double> poison, <2 x i32> zeroinitializer
%460 = fdiv <2 x double> %456, %459
%461 = getelementptr inbounds double, double* %0, i64 %453
%462 = bitcast double* %461 to <2 x double>*
store <2 x double> %460, <2 x double>* %462
br label %463
463: ; preds = %450, %452
br i1 %402, label %501, label %464
464: ; preds = %413, %410, %463
%465 = phi i64 [ %412, %413 ], [ %412, %410 ], [ %421, %463 ]
%466 = phi i32 [ 0, %413 ], [ 0, %410 ], [ %397, %463 ]
%467 = sub i32 %4, %466
%468 = xor i32 %466, -1
%469 = and i32 %467, 1
%470 = icmp eq i32 %469, 0
br i1 %470, label %479, label %471
471: ; preds = %464
%472 = getelementptr inbounds double, double* %1, i64 %465
%473 = load double, double* %472
%474 = load double, double* %411
%475 = fdiv double %473, %474
%476 = getelementptr inbounds double, double* %0, i64 %465
store double %475, double* %476
%477 = add nsw i64 %465, 1
%478 = add nuw nsw i32 %466, 1
br label %479
479: ; preds = %471, %464
%480 = phi i64 [ undef, %464 ], [ %477, %471 ]
%481 = phi i64 [ %465, %464 ], [ %477, %471 ]
%482 = phi i32 [ %466, %464 ], [ %478, %471 ]
%483 = icmp eq i32 %468, %403
br i1 %483, label %501, label %484
484: ; preds = %479, %484
%485 = phi i64 [ %498, %484 ], [ %481, %479 ]
%486 = phi i32 [ %499, %484 ], [ %482, %479 ]
%487 = getelementptr inbounds double, double* %1, i64 %485
%488 = load double, double* %487
%489 = load double, double* %411
%490 = fdiv double %488, %489
%491 = getelementptr inbounds double, double* %0, i64 %485
store double %490, double* %491
%492 = add nsw i64 %485, 1
%493 = getelementptr inbounds double, double* %1, i64 %492
%494 = load double, double* %493
%495 = load double, double* %411
%496 = fdiv double %494, %495
%497 = getelementptr inbounds double, double* %0, i64 %492
store double %496, double* %497
%498 = add nsw i64 %485, 2
%499 = add nuw nsw i32 %486, 2
%500 = icmp eq i32 %499, %4
br i1 %500, label %501, label %484
501: ; preds = %479, %484, %463
%502 = phi i64 [ %421, %463 ], [ %480, %479 ], [ %498, %484 ]
%503 = trunc i64 %502 to i32
br label %504
504: ; preds = %501, %404
%505 = phi i32 [ %406, %404 ], [ %503, %501 ]
%506 = add nuw nsw i64 %405, 1
%507 = icmp eq i64 %506, %380
br i1 %507, label %508, label %404
508: ; preds = %504, %376, %369
%509 = phi i32 [ %370, %369 ], [ 1, %376 ], [ 1, %504 ]
%510 = icmp eq i32 %4, 1
%511 = and i1 %510, %10
br i1 %511, label %515, label %647
512: ; preds = %373
%513 = icmp eq i32 %4, 1
%514 = and i1 %513, %10
br i1 %514, label %517, label %651
515: ; preds = %508
%516 = icmp sgt i32 %6, 0
br i1 %516, label %517, label %651
517: ; preds = %512, %515
%518 = icmp sgt i32 %5, 0
%519 = zext i32 %6 to i64
%520 = add i32 %5, -1
%521 = zext i32 %520 to i64
%522 = add nuw nsw i64 %521, 1
%523 = getelementptr double, double* %0, i64 %522
%524 = getelementptr double, double* %2, i64 %522
%525 = zext i32 %520 to i64
%526 = add nuw nsw i64 %525, 1
%527 = and i64 %526, 8589934590
%528 = add nsw i64 %527, -2
%529 = lshr exact i64 %528, 1
%530 = add nuw i64 %529, 1
%531 = icmp eq i32 %520, 0
%532 = icmp ugt double* %524, %0
%533 = icmp ugt double* %523, %2
%534 = and i1 %532, %533
%535 = and i64 %526, 8589934590
%536 = trunc i64 %535 to i32
%537 = and i64 %530, 1
%538 = icmp eq i64 %528, 0
%539 = and i64 %530, -2
%540 = icmp eq i64 %537, 0
%541 = icmp eq i64 %526, %535
%542 = sub i32 0, %5
br label %543
543: ; preds = %517, %643
%544 = phi i64 [ 0, %517 ], [ %645, %643 ]
%545 = phi i32 [ 0, %517 ], [ %644, %643 ]
%546 = getelementptr double, double* %1, i64 %544
%547 = add nuw i64 %544, 1
%548 = getelementptr double, double* %1, i64 %547
br i1 %518, label %549, label %643
549: ; preds = %543
%550 = getelementptr inbounds double, double* %1, i64 %544
%551 = sext i32 %545 to i64
br i1 %531, label %603, label %552
552: ; preds = %549
%553 = getelementptr double, double* %0, i64 %551
%554 = getelementptr double, double* %523, i64 %551
%555 = icmp ult double* %553, %548
%556 = icmp ult double* %546, %554
%557 = and i1 %555, %556
%558 = or i1 %534, %557
br i1 %558, label %603, label %559
559: ; preds = %552
%560 = add nsw i64 %535, %551
br i1 %538, label %589, label %561
561: ; preds = %559
%562 = load double, double* %550
%563 = insertelement <2 x double> poison, double %562, i64 0
%564 = shufflevector <2 x double> %563, <2 x double> poison, <2 x i32> zeroinitializer
%565 = load double, double* %550
%566 = insertelement <2 x double> poison, double %565, i64 0
%567 = shufflevector <2 x double> %566, <2 x double> poison, <2 x i32> zeroinitializer
br label %568
568: ; preds = %568, %561
%569 = phi i64 [ 0, %561 ], [ %586, %568 ]
%570 = phi i64 [ 0, %561 ], [ %587, %568 ]
%571 = add i64 %569, %551
%572 = getelementptr inbounds double, double* %2, i64 %571
%573 = bitcast double* %572 to <2 x double>*
%574 = load <2 x double>, <2 x double>* %573
%575 = fdiv <2 x double> %574, %564
%576 = getelementptr inbounds double, double* %0, i64 %571
%577 = bitcast double* %576 to <2 x double>*
store <2 x double> %575, <2 x double>* %577
%578 = or i64 %569, 2
%579 = add i64 %578, %551
%580 = getelementptr inbounds double, double* %2, i64 %579
%581 = bitcast double* %580 to <2 x double>*
%582 = load <2 x double>, <2 x double>* %581
%583 = fdiv <2 x double> %582, %567
%584 = getelementptr inbounds double, double* %0, i64 %579
%585 = bitcast double* %584 to <2 x double>*
store <2 x double> %583, <2 x double>* %585
%586 = add nuw i64 %569, 4
%587 = add nuw i64 %570, 2
%588 = icmp eq i64 %587, %539
br i1 %588, label %589, label %568
589: ; preds = %568, %559
%590 = phi i64 [ 0, %559 ], [ %586, %568 ]
br i1 %540, label %602, label %591
591: ; preds = %589
%592 = add i64 %590, %551
%593 = getelementptr inbounds double, double* %2, i64 %592
%594 = bitcast double* %593 to <2 x double>*
%595 = load <2 x double>, <2 x double>* %594
%596 = load double, double* %550
%597 = insertelement <2 x double> poison, double %596, i64 0
%598 = shufflevector <2 x double> %597, <2 x double> poison, <2 x i32> zeroinitializer
%599 = fdiv <2 x double> %595, %598
%600 = getelementptr inbounds double, double* %0, i64 %592
%601 = bitcast double* %600 to <2 x double>*
store <2 x double> %599, <2 x double>* %601
br label %602
602: ; preds = %589, %591
br i1 %541, label %640, label %603
603: ; preds = %552, %549, %602
%604 = phi i64 [ %551, %552 ], [ %551, %549 ], [ %560, %602 ]
%605 = phi i32 [ 0, %552 ], [ 0, %549 ], [ %536, %602 ]
%606 = sub i32 %5, %605
%607 = xor i32 %605, -1
%608 = and i32 %606, 1
%609 = icmp eq i32 %608, 0
br i1 %609, label %618, label %610
610: ; preds = %603
%611 = getelementptr inbounds double, double* %2, i64 %604
%612 = load double, double* %611
%613 = load double, double* %550
%614 = fdiv double %612, %613
%615 = getelementptr inbounds double, double* %0, i64 %604
store double %614, double* %615
%616 = add nsw i64 %604, 1
%617 = add nuw nsw i32 %605, 1
br label %618
618: ; preds = %610, %603
%619 = phi i64 [ undef, %603 ], [ %616, %610 ]
%620 = phi i64 [ %604, %603 ], [ %616, %610 ]
%621 = phi i32 [ %605, %603 ], [ %617, %610 ]
%622 = icmp eq i32 %607, %542
br i1 %622, label %640, label %623
623: ; preds = %618, %623
%624 = phi i64 [ %637, %623 ], [ %620, %618 ]
%625 = phi i32 [ %638, %623 ], [ %621, %618 ]
%626 = getelementptr inbounds double, double* %2, i64 %624
%627 = load double, double* %626
%628 = load double, double* %550
%629 = fdiv double %627, %628
%630 = getelementptr inbounds double, double* %0, i64 %624
store double %629, double* %630
%631 = add nsw i64 %624, 1
%632 = getelementptr inbounds double, double* %2, i64 %631
%633 = load double, double* %632
%634 = load double, double* %550
%635 = fdiv double %633, %634
%636 = getelementptr inbounds double, double* %0, i64 %631
store double %635, double* %636
%637 = add nsw i64 %624, 2
%638 = add nuw nsw i32 %625, 2
%639 = icmp eq i32 %638, %5
br i1 %639, label %640, label %623
640: ; preds = %618, %623, %602
%641 = phi i64 [ %560, %602 ], [ %619, %618 ], [ %637, %623 ]
%642 = trunc i64 %641 to i32
br label %643
643: ; preds = %640, %543
%644 = phi i32 [ %545, %543 ], [ %642, %640 ]
%645 = add nuw nsw i64 %544, 1
%646 = icmp eq i64 %645, %519
br i1 %646, label %651, label %543
647: ; preds = %508
%648 = icmp eq i32 %509, 0
br i1 %648, label %649, label %651
649: ; preds = %647
%650 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([40 x i8], [40 x i8]* @str, i64 0, i64 0))
br label %651
651: ; preds = %643, %512, %515, %649, %647
ret void
}