#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 */
double internal_abs(double);
double internal_pow(int, int);
int /*<<< orphan*/ printf(char *);
int check_stability(double a[], int n) {
  int lines = 2 * n - 1;
  int columns = n;
  double m[lines][n];
  int i, j;
  double current_stability[n];
  for (i = 0; i < n; i++) {
    current_stability[i] = a[i];
  }
  double sum = 0;
  for (i = 0; i < n; i++) {
    sum += a[i];
  }
  if (sum <= 0) {
    printf("[DEBUG] the first constraint of Jury criteria failed: (F(1) > 0)");
    return 0;
  }
  sum = 0;
  for (i = 0; i < n; i++) {
    sum += a[i] * internal_pow(-1, n - 1 - i);
  }
  sum = sum * internal_pow(-1, n - 1);
  if (sum <= 0) {
    printf("[DEBUG] the second constraint of Jury criteria "
           "failed: (F(-1)*(-1)^n > 0)");
    return 0;
  }
  if (internal_abs(a[n - 1]) > a[0]) {
    printf("[DEBUG] the third constraint of Jury criteria "
           "failed: (abs(a0) < a_{n}*z^{n})");
    return 0;
  }
  for (i = 0; i < lines; i++) {
    for (j = 0; j < columns; j++) {
      m[i][j] = 0;
    }
  }
  for (i = 0; i < lines; i++) {
    for (j = 0; j < columns; j++) {
      if (i == 0) {
        m[i][j] = a[j];
        continue;
      }
      if (i % 2 != 0) {
        int x;
        for (x = 0; x < columns; x++) {
          m[i][x] = m[i - 1][columns - x - 1];
        }
        columns = columns - 1;
        j = columns;
      } else {
        m[i][j] = m[i - 2][j] - (m[i - 2][columns] / m[i - 2][0]) * m[i - 1][j];
      }
    }
  }
  int first_is_positive = m[0][0] >= 0 ? 1 : 0;
  for (i = 0; i < lines; i++) {
    if (i % 2 == 0) {
      int line_is_positive = m[i][0] >= 0 ? 1 : 0;
      if (first_is_positive != line_is_positive) {
        return 0;
      }
      continue;
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<check_stability>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    -0x14(%rbp),%ecx
mov    %ecx,%eax
lea    -0x1(%rax,%rax,1),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
mov    -0x14(%rbp),%eax
mov    %rax,-0x78(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x28(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x70(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x30(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11ea <check_stability+0xba>
mov    -0x68(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11b6 <check_stability+0x86>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    122a <check_stability+0xfa>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11f9 <check_stability+0xc9>
xorps  %xmm0,%xmm0
ucomisd -0x50(%rbp),%xmm0
jb     1257 <check_stability+0x127>
lea    0xdc1(%rip),%rdi
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x54(%rbp)
jmp    164f <check_stability+0x51f>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12bf <check_stability+0x18f>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
sub    -0x3c(%rbp),%esi
mov    $0xffffffff,%edi
call   1040 <internal_pow@plt>
movaps %xmm0,%xmm2
movsd  -0x80(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1266 <check_stability+0x136>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    $0xffffffff,%edi
call   1040 <internal_pow@plt>
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x50(%rbp),%xmm0
jb     131d <check_stability+0x1ed>
lea    0xd3c(%rip),%rdi
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x54(%rbp)
jmp    164f <check_stability+0x51f>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <internal_abs@plt>
mov    -0x10(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    1361 <check_stability+0x231>
lea    0xd42(%rip),%rdi
call   1050 <printf@plt>
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x54(%rbp)
jmp    164f <check_stability+0x51f>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    13cb <check_stability+0x29b>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13b8 <check_stability+0x288>
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rdx
movslq -0x3c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    137b <check_stability+0x24b>
jmp    13bd <check_stability+0x28d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1368 <check_stability+0x238>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1595 <check_stability+0x465>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1582 <check_stability+0x452>
cmpl   $0x0,-0x3c(%rbp)
jne    142d <check_stability+0x2fd>
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rdx
mov    -0x10(%rbp),%rcx
movslq -0x40(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x3c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1574 <check_stability+0x444>
mov    -0x3c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     14be <check_stability+0x38e>
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14aa <check_stability+0x37a>
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rdx
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
mov    -0x1c(%rbp),%esi
sub    -0x58(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x3c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1448 <check_stability+0x318>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    156f <check_stability+0x43f>
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rdx
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x40(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm1
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x1c(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x40(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm2
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rcx
movq   %rcx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x3c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1574 <check_stability+0x444>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13e5 <check_stability+0x2b5>
jmp    1587 <check_stability+0x457>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13d2 <check_stability+0x2a2>
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rcx
imul   $0x0,%rcx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
mov    $0x1,%ecx
ucomisd %xmm1,%xmm0
cmovae %ecx,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1641 <check_stability+0x511>
mov    -0x3c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    162e <check_stability+0x4fe>
mov    -0x70(%rbp),%rax
mov    -0x78(%rbp),%rdx
movslq -0x3c(%rbp),%rcx
imul   %rdx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
xor    %eax,%eax
mov    $0x1,%ecx
ucomisd %xmm1,%xmm0
cmovae %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x60(%rbp),%eax
je     1629 <check_stability+0x4f9>
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x54(%rbp)
jmp    164f <check_stability+0x51f>
jmp    1633 <check_stability+0x503>
jmp    1633 <check_stability+0x503>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15c1 <check_stability+0x491>
movl   $0x1,-0x4(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<check_stability>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdi,%r13
lea    (%rsi,%rsi,1),%r8d
add    $0xffffffff,%r8d
mov    %esi,%r15d
mov    %r8,%rax
imul   %r15,%rax
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
lea    0xe7e(%rip),%rdi
test   %esi,%esi
jle    12dc <check_stability+0x19c>
lea    -0x1(%r15),%rcx
mov    %r15d,%eax
and    $0x7,%eax
cmp    $0x7,%rcx
jae    11a2 <check_stability+0x62>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    11f1 <check_stability+0xb1>
mov    %r15d,%edx
and    $0xfffffff8,%edx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
xchg   %ax,%ax
addsd  0x0(%r13,%rcx,8),%xmm0
addsd  0x8(%r13,%rcx,8),%xmm0
addsd  0x10(%r13,%rcx,8),%xmm0
addsd  0x18(%r13,%rcx,8),%xmm0
addsd  0x20(%r13,%rcx,8),%xmm0
addsd  0x28(%r13,%rcx,8),%xmm0
addsd  0x30(%r13,%rcx,8),%xmm0
addsd  0x38(%r13,%rcx,8),%xmm0
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    11b0 <check_stability+0x70>
test   %rax,%rax
je     121e <check_stability+0xde>
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  (%rcx,%rdx,8),%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1210 <check_stability+0xd0>
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jae    12dc <check_stability+0x19c>
mov    %r8,-0x48(%rbp)
mov    %rsi,-0x40(%rbp)
test   %esi,%esi
jle    1289 <check_stability+0x149>
mov    -0x40(%rbp),%rax
lea    -0x1(%rax),%r14d
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm1,-0x38(%rbp)
movsd  0x0(%r13,%rbx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    $0xffffffff,%edi
mov    %r14d,%esi
call   1040 <internal_pow@plt>
movsd  -0x38(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm0
addsd  %xmm0,%xmm1
add    $0x1,%rbx
add    $0xffffffff,%r14d
cmp    %rbx,%r15
jne    1250 <check_stability+0x110>
movsd  %xmm1,-0x38(%rbp)
mov    %r15,-0x58(%rbp)
mov    -0x40(%rbp),%r14
lea    -0x1(%r14),%ebx
mov    $0xffffffff,%edi
mov    %ebx,%esi
call   1040 <internal_pow@plt>
mulsd  -0x38(%rbp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
jae    12d5 <check_stability+0x195>
movslq %ebx,%rax
movsd  0x0(%r13,%rax,8),%xmm0
call   1030 <internal_abs@plt>
ucomisd 0x0(%r13),%xmm0
jbe    12f2 <check_stability+0x1b2>
lea    0xdb8(%rip),%rdi
jmp    12dc <check_stability+0x19c>
lea    0xd65(%rip),%rdi
call   1050 <printf@plt>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r14d,%r14d
jle    15c7 <check_stability+0x487>
mov    -0x48(%rbp),%rax
cmp    $0x2,%eax
mov    $0x1,%r14d
cmovge %eax,%r14d
mov    -0x58(%rbp),%rcx
lea    0x0(,%rcx,8),%rax
mov    %rax,-0x30(%rbp)
lea    -0x1(%r14),%rax
mov    %r14,-0x50(%rbp)
and    $0x7,%r14d
cmp    $0x7,%rax
mov    %r12,-0x60(%rbp)
jae    133d <check_stability+0x1fd>
xor    %eax,%eax
mov    -0x30(%rbp),%r15
jmp    13f8 <check_stability+0x2b8>
mov    -0x50(%rbp),%rax
and    $0x7ffffff8,%eax
mov    %rax,-0x50(%rbp)
shl    $0x6,%rcx
mov    %rcx,-0x68(%rbp)
xor    %eax,%eax
mov    -0x30(%rbp),%r15
nopl   0x0(%rax,%rax,1)
mov    %rax,-0x38(%rbp)
mov    %r12,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
lea    (%r12,%r15,1),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
add    %r15,%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
add    %r15,%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
add    %r15,%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
add    %r15,%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
add    %r15,%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
add    %r15,%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
mov    -0x38(%rbp),%rax
add    $0x8,%rax
add    -0x68(%rbp),%r12
cmp    %rax,-0x50(%rbp)
jne    1360 <check_stability+0x220>
imul   -0x58(%rbp),%rax
mov    -0x60(%rbp),%r12
lea    (%r12,%rax,8),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1060 <memset@plt>
add    %r15,%rbx
add    $0xffffffffffffffff,%r14
jne    1410 <check_stability+0x2d0>
mov    -0x40(%rbp),%r15
test   %r15d,%r15d
mov    -0x48(%rbp),%rax
jle    15c7 <check_stability+0x487>
cmp    $0x2,%eax
mov    $0x1,%r8d
cmovge %eax,%r8d
lea    0x8(%r12),%rcx
xor    %r14d,%r14d
jmp    1461 <check_stability+0x321>
xchg   %ax,%ax
add    $0x1,%r14
add    -0x30(%rbp),%rcx
cmp    %r8,%r14
je     1561 <check_stability+0x421>
test   %r15d,%r15d
jle    1450 <check_stability+0x310>
lea    -0x1(%r14),%rax
mov    -0x58(%rbp),%rdx
imul   %rdx,%rax
lea    (%r12,%rax,8),%rdi
mov    %r14,%rax
imul   %rdx,%rax
lea    (%r12,%rax,8),%r9
lea    -0x2(%r14),%rax
imul   %rdx,%rax
lea    (%r12,%rax,8),%r10
xor    %ebx,%ebx
jmp    14b8 <check_stability+0x378>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rax
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%ebx
cmp    %r15d,%ebx
jge    1450 <check_stability+0x310>
test   %r14,%r14
je     14a0 <check_stability+0x360>
test   $0x1,%r14b
jne    14f0 <check_stability+0x3b0>
movslq %ebx,%rax
movsd  (%r10,%rax,8),%xmm0
movslq %r15d,%rdx
movsd  (%r10,%rdx,8),%xmm1
divsd  (%r10),%xmm1
mulsd  (%rdi,%rax,8),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r9,%rax,8)
jmp    14b0 <check_stability+0x370>
nopl   0x0(%rax,%rax,1)
test   %r15d,%r15d
jle    1555 <check_stability+0x415>
mov    %r15d,%r11d
cmp    $0x1,%r15d
jne    1502 <check_stability+0x3c2>
xor    %eax,%eax
jmp    153a <check_stability+0x3fa>
mov    %r11d,%ebx
and    $0xfffffffe,%ebx
lea    -0x2(%r15),%edx
xor    %eax,%eax
xchg   %ax,%ax
lea    0x1(%rdx),%esi
movslq %esi,%rsi
movsd  (%rdi,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
movslq %edx,%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
add    $0x2,%rax
add    $0xfffffffe,%edx
cmp    %rax,%rbx
jne    1510 <check_stability+0x3d0>
test   $0x1,%r11b
je     1555 <check_stability+0x415>
mov    %eax,%edx
not    %edx
add    %r15d,%edx
movslq %edx,%rdx
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
add    $0xffffffff,%r15d
mov    %r15d,%ebx
jmp    14b0 <check_stability+0x370>
cmpl   $0x0,-0x40(%rbp)
jle    15c7 <check_stability+0x487>
movsd  (%r12),%xmm0
mov    -0x48(%rbp),%rax
cmp    $0x2,%eax
mov    $0x1,%ecx
cmovge %eax,%ecx
xor    %edx,%edx
xorpd  %xmm1,%xmm1
mov    -0x30(%rbp),%rsi
jmp    15a5 <check_stability+0x465>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
add    %rsi,%r12
mov    $0x1,%eax
cmp    %rdx,%rcx
je     12e3 <check_stability+0x1a3>
test   $0x1,%dl
jne    1590 <check_stability+0x450>
ucomisd %xmm1,%xmm0
setb   %al
movsd  (%r12),%xmm2
ucomisd %xmm1,%xmm2
setae  %bl
cmp    %bl,%al
jne    1590 <check_stability+0x450>
jmp    12e1 <check_stability+0x1a1>
mov    $0x1,%eax
jmp    12e3 <check_stability+0x1a3>

LLVM IR (-O0):
@.str = [65 x i8] c"[DEBUG] the first constraint of Jury criteria failed: (F(1) > 0)\00"
@.str.1 = [74 x i8] c"[DEBUG] the second constraint of Jury criteria failed: (F(-1)*(-1)^n > 0)\00"
@.str.2 = [78 x i8] c"[DEBUG] the third constraint of Jury criteria failed: (abs(a0) < a_{n}*z^{n})\00"
define i32 @check_stability(double* %0, i32 %1) {
%3 = alloca i32
%4 = alloca double*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i64
%11 = alloca i32
%12 = alloca i32
%13 = alloca i64
%14 = alloca double
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
store double* %0, double** %4
store i32 %1, i32* %5
%19 = load i32, i32* %5
%20 = mul nsw i32 2, %19
%21 = sub nsw i32 %20, 1
store i32 %21, i32* %6
%22 = load i32, i32* %5
store i32 %22, i32* %7
%23 = load i32, i32* %6
%24 = zext i32 %23 to i64
%25 = load i32, i32* %5
%26 = zext i32 %25 to i64
%27 = call i8* @llvm.stacksave()
store i8* %27, i8** %8
%28 = mul nuw i64 %24, %26
%29 = alloca double, i64 %28
store i64 %24, i64* %9
store i64 %26, i64* %10
%30 = load i32, i32* %5
%31 = zext i32 %30 to i64
%32 = alloca double, i64 %31
store i64 %31, i64* %13
store i32 0, i32* %11
br label %33
33: ; preds = %46, %2
%34 = load i32, i32* %11
%35 = load i32, i32* %5
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %49
37: ; preds = %33
%38 = load double*, double** %4
%39 = load i32, i32* %11
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds double, double* %38, i64 %40
%42 = load double, double* %41
%43 = load i32, i32* %11
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds double, double* %32, i64 %44
store double %42, double* %45
br label %46
46: ; preds = %37
%47 = load i32, i32* %11
%48 = add nsw i32 %47, 1
store i32 %48, i32* %11
br label %33
49: ; preds = %33
store double 0.000000e+00, double* %14
store i32 0, i32* %11
br label %50
50: ; preds = %62, %49
%51 = load i32, i32* %11
%52 = load i32, i32* %5
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %65
54: ; preds = %50
%55 = load double*, double** %4
%56 = load i32, i32* %11
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds double, double* %55, i64 %57
%59 = load double, double* %58
%60 = load double, double* %14
%61 = fadd double %60, %59
store double %61, double* %14
br label %62
62: ; preds = %54
%63 = load i32, i32* %11
%64 = add nsw i32 %63, 1
store i32 %64, i32* %11
br label %50
65: ; preds = %50
%66 = load double, double* %14
%67 = fcmp ole double %66, 0.000000e+00
br i1 %67, label %68, label %70
68: ; preds = %65
%69 = call i32 @printf(i8* getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0))
store i32 0, i32* %3
store i32 1, i32* %15
br label %291
70: ; preds = %65
store double 0.000000e+00, double* %14
store i32 0, i32* %11
br label %71
71: ; preds = %88, %70
%72 = load i32, i32* %11
%73 = load i32, i32* %5
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %91
75: ; preds = %71
%76 = load double*, double** %4
%77 = load i32, i32* %11
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %76, i64 %78
%80 = load double, double* %79
%81 = load i32, i32* %5
%82 = sub nsw i32 %81, 1
%83 = load i32, i32* %11
%84 = sub nsw i32 %82, %83
%85 = call double @internal_pow(i32 -1, i32 %84)
%86 = load double, double* %14
%87 = call double @llvm.fmuladd.f64(double %80, double %85, double %86)
store double %87, double* %14
br label %88
88: ; preds = %75
%89 = load i32, i32* %11
%90 = add nsw i32 %89, 1
store i32 %90, i32* %11
br label %71
91: ; preds = %71
%92 = load double, double* %14
%93 = load i32, i32* %5
%94 = sub nsw i32 %93, 1
%95 = call double @internal_pow(i32 -1, i32 %94)
%96 = fmul double %92, %95
store double %96, double* %14
%97 = load double, double* %14
%98 = fcmp ole double %97, 0.000000e+00
br i1 %98, label %99, label %101
99: ; preds = %91
%100 = call i32 @printf(i8* getelementptr inbounds ([74 x i8], [74 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %3
store i32 1, i32* %15
br label %291
101: ; preds = %91
%102 = load double*, double** %4
%103 = load i32, i32* %5
%104 = sub nsw i32 %103, 1
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %102, i64 %105
%107 = load double, double* %106
%108 = call double @internal_abs(double %107)
%109 = load double*, double** %4
%110 = getelementptr inbounds double, double* %109, i64 0
%111 = load double, double* %110
%112 = fcmp ogt double %108, %111
br i1 %112, label %113, label %115
113: ; preds = %101
%114 = call i32 @printf(i8* getelementptr inbounds ([78 x i8], [78 x i8]* @.str.2, i64 0, i64 0))
store i32 0, i32* %3
store i32 1, i32* %15
br label %291
115: ; preds = %101
store i32 0, i32* %11
br label %116
116: ; preds = %137, %115
%117 = load i32, i32* %11
%118 = load i32, i32* %6
%119 = icmp slt i32 %117, %118
br i1 %119, label %120, label %140
120: ; preds = %116
store i32 0, i32* %12
br label %121
121: ; preds = %133, %120
%122 = load i32, i32* %12
%123 = load i32, i32* %7
%124 = icmp slt i32 %122, %123
br i1 %124, label %125, label %136
125: ; preds = %121
%126 = load i32, i32* %11
%127 = sext i32 %126 to i64
%128 = mul nsw i64 %127, %26
%129 = getelementptr inbounds double, double* %29, i64 %128
%130 = load i32, i32* %12
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %129, i64 %131
store double 0.000000e+00, double* %132
br label %133
133: ; preds = %125
%134 = load i32, i32* %12
%135 = add nsw i32 %134, 1
store i32 %135, i32* %12
br label %121
136: ; preds = %121
br label %137
137: ; preds = %136
%138 = load i32, i32* %11
%139 = add nsw i32 %138, 1
store i32 %139, i32* %11
br label %116
140: ; preds = %116
store i32 0, i32* %11
br label %141
141: ; preds = %252, %140
%142 = load i32, i32* %11
%143 = load i32, i32* %6
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %255
145: ; preds = %141
store i32 0, i32* %12
br label %146
146: ; preds = %248, %145
%147 = load i32, i32* %12
%148 = load i32, i32* %7
%149 = icmp slt i32 %147, %148
br i1 %149, label %150, label %251
150: ; preds = %146
%151 = load i32, i32* %11
%152 = icmp eq i32 %151, 0
br i1 %152, label %153, label %166
153: ; preds = %150
%154 = load double*, double** %4
%155 = load i32, i32* %12
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds double, double* %154, i64 %156
%158 = load double, double* %157
%159 = load i32, i32* %11
%160 = sext i32 %159 to i64
%161 = mul nsw i64 %160, %26
%162 = getelementptr inbounds double, double* %29, i64 %161
%163 = load i32, i32* %12
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
store double %158, double* %165
br label %248
166: ; preds = %150
%167 = load i32, i32* %11
%168 = srem i32 %167, 2
%169 = icmp ne i32 %168, 0
br i1 %169, label %170, label %202
170: ; preds = %166
store i32 0, i32* %16
br label %171
171: ; preds = %195, %170
%172 = load i32, i32* %16
%173 = load i32, i32* %7
%174 = icmp slt i32 %172, %173
br i1 %174, label %175, label %198
175: ; preds = %171
%176 = load i32, i32* %11
%177 = sub nsw i32 %176, 1
%178 = sext i32 %177 to i64
%179 = mul nsw i64 %178, %26
%180 = getelementptr inbounds double, double* %29, i64 %179
%181 = load i32, i32* %7
%182 = load i32, i32* %16
%183 = sub nsw i32 %181, %182
%184 = sub nsw i32 %183, 1
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %180, i64 %185
%187 = load double, double* %186
%188 = load i32, i32* %11
%189 = sext i32 %188 to i64
%190 = mul nsw i64 %189, %26
%191 = getelementptr inbounds double, double* %29, i64 %190
%192 = load i32, i32* %16
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
store double %187, double* %194
br label %195
195: ; preds = %175
%196 = load i32, i32* %16
%197 = add nsw i32 %196, 1
store i32 %197, i32* %16
br label %171
198: ; preds = %171
%199 = load i32, i32* %7
%200 = sub nsw i32 %199, 1
store i32 %200, i32* %7
%201 = load i32, i32* %7
store i32 %201, i32* %12
br label %247
202: ; preds = %166
%203 = load i32, i32* %11
%204 = sub nsw i32 %203, 2
%205 = sext i32 %204 to i64
%206 = mul nsw i64 %205, %26
%207 = getelementptr inbounds double, double* %29, i64 %206
%208 = load i32, i32* %12
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds double, double* %207, i64 %209
%211 = load double, double* %210
%212 = load i32, i32* %11
%213 = sub nsw i32 %212, 2
%214 = sext i32 %213 to i64
%215 = mul nsw i64 %214, %26
%216 = getelementptr inbounds double, double* %29, i64 %215
%217 = load i32, i32* %7
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
%220 = load double, double* %219
%221 = load i32, i32* %11
%222 = sub nsw i32 %221, 2
%223 = sext i32 %222 to i64
%224 = mul nsw i64 %223, %26
%225 = getelementptr inbounds double, double* %29, i64 %224
%226 = getelementptr inbounds double, double* %225, i64 0
%227 = load double, double* %226
%228 = fdiv double %220, %227
%229 = load i32, i32* %11
%230 = sub nsw i32 %229, 1
%231 = sext i32 %230 to i64
%232 = mul nsw i64 %231, %26
%233 = getelementptr inbounds double, double* %29, i64 %232
%234 = load i32, i32* %12
%235 = sext i32 %234 to i64
%236 = getelementptr inbounds double, double* %233, i64 %235
%237 = load double, double* %236
%238 = fneg double %228
%239 = call double @llvm.fmuladd.f64(double %238, double %237, double %211)
%240 = load i32, i32* %11
%241 = sext i32 %240 to i64
%242 = mul nsw i64 %241, %26
%243 = getelementptr inbounds double, double* %29, i64 %242
%244 = load i32, i32* %12
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds double, double* %243, i64 %245
store double %239, double* %246
br label %247
247: ; preds = %202, %198
br label %248
248: ; preds = %247, %153
%249 = load i32, i32* %12
%250 = add nsw i32 %249, 1
store i32 %250, i32* %12
br label %146
251: ; preds = %146
br label %252
252: ; preds = %251
%253 = load i32, i32* %11
%254 = add nsw i32 %253, 1
store i32 %254, i32* %11
br label %141
255: ; preds = %141
%256 = mul nsw i64 0, %26
%257 = getelementptr inbounds double, double* %29, i64 %256
%258 = getelementptr inbounds double, double* %257, i64 0
%259 = load double, double* %258
%260 = fcmp oge double %259, 0.000000e+00
%261 = zext i1 %260 to i64
%262 = select i1 %260, i32 1, i32 0
store i32 %262, i32* %17
store i32 0, i32* %11
br label %263
263: ; preds = %287, %255
%264 = load i32, i32* %11
%265 = load i32, i32* %6
%266 = icmp slt i32 %264, %265
br i1 %266, label %267, label %290
267: ; preds = %263
%268 = load i32, i32* %11
%269 = srem i32 %268, 2
%270 = icmp eq i32 %269, 0
br i1 %270, label %271, label %286
271: ; preds = %267
%272 = load i32, i32* %11
%273 = sext i32 %272 to i64
%274 = mul nsw i64 %273, %26
%275 = getelementptr inbounds double, double* %29, i64 %274
%276 = getelementptr inbounds double, double* %275, i64 0
%277 = load double, double* %276
%278 = fcmp oge double %277, 0.000000e+00
%279 = zext i1 %278 to i64
%280 = select i1 %278, i32 1, i32 0
store i32 %280, i32* %18
%281 = load i32, i32* %17
%282 = load i32, i32* %18
%283 = icmp ne i32 %281, %282
br i1 %283, label %284, label %285
284: ; preds = %271
store i32 0, i32* %3
store i32 1, i32* %15
br label %291
285: ; preds = %271
br label %287
286: ; preds = %267
br label %287
287: ; preds = %286, %285
%288 = load i32, i32* %11
%289 = add nsw i32 %288, 1
store i32 %289, i32* %11
br label %263
290: ; preds = %263
store i32 1, i32* %3
store i32 1, i32* %15
br label %291
291: ; preds = %290, %284, %113, %99, %68
%292 = load i8*, i8** %8
%293 = load i32, i32* %3
ret i32 %293
}

LLVM IR (-O2):
@.str = [65 x i8] c"[DEBUG] the first constraint of Jury criteria failed: (F(1) > 0)\00"
@.str.1 = [74 x i8] c"[DEBUG] the second constraint of Jury criteria failed: (F(-1)*(-1)^n > 0)\00"
@.str.2 = [78 x i8] c"[DEBUG] the third constraint of Jury criteria failed: (abs(a0) < a_{n}*z^{n})\00"
define i32 @check_stability(double* nocapture %0, i32 %1) {
%3 = shl nsw i32 %1, 1
%4 = add i32 %3, -1
%5 = zext i32 %4 to i64
%6 = zext i32 %1 to i64
%7 = mul nuw i64 %5, %6
%8 = alloca double, i64 %7
%9 = icmp sgt i32 %1, 0
br i1 %9, label %10, label %269
10: ; preds = %2
%11 = add nsw i64 %6, -1
%12 = and i64 %6, 7
%13 = icmp ult i64 %11, 7
br i1 %13, label %54, label %14
14: ; preds = %10
%15 = and i64 %6, 4294967288
br label %16
16: ; preds = %16, %14
%17 = phi i64 [ 0, %14 ], [ %51, %16 ]
%18 = phi double [ 0.000000e+00, %14 ], [ %50, %16 ]
%19 = phi i64 [ 0, %14 ], [ %52, %16 ]
%20 = getelementptr inbounds double, double* %0, i64 %17
%21 = load double, double* %20
%22 = fadd double %18, %21
%23 = or i64 %17, 1
%24 = getelementptr inbounds double, double* %0, i64 %23
%25 = load double, double* %24
%26 = fadd double %22, %25
%27 = or i64 %17, 2
%28 = getelementptr inbounds double, double* %0, i64 %27
%29 = load double, double* %28
%30 = fadd double %26, %29
%31 = or i64 %17, 3
%32 = getelementptr inbounds double, double* %0, i64 %31
%33 = load double, double* %32
%34 = fadd double %30, %33
%35 = or i64 %17, 4
%36 = getelementptr inbounds double, double* %0, i64 %35
%37 = load double, double* %36
%38 = fadd double %34, %37
%39 = or i64 %17, 5
%40 = getelementptr inbounds double, double* %0, i64 %39
%41 = load double, double* %40
%42 = fadd double %38, %41
%43 = or i64 %17, 6
%44 = getelementptr inbounds double, double* %0, i64 %43
%45 = load double, double* %44
%46 = fadd double %42, %45
%47 = or i64 %17, 7
%48 = getelementptr inbounds double, double* %0, i64 %47
%49 = load double, double* %48
%50 = fadd double %46, %49
%51 = add nuw nsw i64 %17, 8
%52 = add i64 %19, 8
%53 = icmp eq i64 %52, %15
br i1 %53, label %54, label %16
54: ; preds = %16, %10
%55 = phi double [ undef, %10 ], [ %50, %16 ]
%56 = phi i64 [ 0, %10 ], [ %51, %16 ]
%57 = phi double [ 0.000000e+00, %10 ], [ %50, %16 ]
%58 = icmp eq i64 %12, 0
br i1 %58, label %69, label %59
59: ; preds = %54, %59
%60 = phi i64 [ %66, %59 ], [ %56, %54 ]
%61 = phi double [ %65, %59 ], [ %57, %54 ]
%62 = phi i64 [ %67, %59 ], [ 0, %54 ]
%63 = getelementptr inbounds double, double* %0, i64 %60
%64 = load double, double* %63
%65 = fadd double %61, %64
%66 = add nuw nsw i64 %60, 1
%67 = add i64 %62, 1
%68 = icmp eq i64 %67, %12
br i1 %68, label %69, label %59
69: ; preds = %59, %54
%70 = phi double [ %55, %54 ], [ %65, %59 ]
%71 = fcmp ugt double %70, 0.000000e+00
br i1 %71, label %72, label %269
72: ; preds = %69
br i1 %9, label %73, label %85
73: ; preds = %72, %73
%74 = phi i64 [ %83, %73 ], [ 0, %72 ]
%75 = phi double [ %82, %73 ], [ 0.000000e+00, %72 ]
%76 = trunc i64 %74 to i32
%77 = getelementptr inbounds double, double* %0, i64 %74
%78 = load double, double* %77
%79 = xor i32 %76, -1
%80 = add i32 %79, %1
%81 = tail call double @internal_pow(i32 -1, i32 %80)
%82 = tail call double @llvm.fmuladd.f64(double %78, double %81, double %75)
%83 = add nuw nsw i64 %74, 1
%84 = icmp eq i64 %83, %6
br i1 %84, label %85, label %73
85: ; preds = %73, %72
%86 = phi double [ 0.000000e+00, %72 ], [ %82, %73 ]
%87 = add nsw i32 %1, -1
%88 = tail call double @internal_pow(i32 -1, i32 %87)
%89 = fmul double %86, %88
%90 = fcmp ugt double %89, 0.000000e+00
br i1 %90, label %91, label %269
91: ; preds = %85
%92 = sext i32 %87 to i64
%93 = getelementptr inbounds double, double* %0, i64 %92
%94 = load double, double* %93
%95 = tail call double @internal_abs(double %94)
%96 = load double, double* %0
%97 = fcmp ogt double %95, %96
br i1 %97, label %269, label %98
98: ; preds = %91
br i1 %9, label %99, label %272
99: ; preds = %98
%100 = shl nuw nsw i64 %6, 3
%101 = call i32 @llvm.smax.i32(i32 %4, i32 1)
%102 = zext i32 %101 to i64
%103 = add nsw i64 %102, -1
%104 = and i64 %102, 7
%105 = icmp ult i64 %103, 7
br i1 %105, label %108, label %106
106: ; preds = %99
%107 = and i64 %102, 2147483640
br label %123
108: ; preds = %99, %123
%109 = phi i64 [ 0, %99 ], [ %157, %123 ]
br label %110
110: ; preds = %110, %108
%111 = phi i64 [ %109, %108 ], [ %116, %110 ]
%112 = phi i64 [ 0, %108 ], [ %117, %110 ]
%113 = mul nuw nsw i64 %111, %6
%114 = getelementptr double, double* %8, i64 %113
%115 = bitcast double* %114 to i8*
%116 = add nuw nsw i64 %111, 1
%117 = add i64 %112, 1
%118 = icmp eq i64 %117, %104
br i1 %118, label %119, label %110
119: ; preds = %110
br i1 %9, label %120, label %272
120: ; preds = %119
%121 = call i32 @llvm.smax.i32(i32 %4, i32 1)
%122 = zext i32 %121 to i64
br label %160
123: ; preds = %123, %106
%124 = phi i64 [ 0, %106 ], [ %157, %123 ]
%125 = phi i64 [ 0, %106 ], [ %158, %123 ]
%126 = mul nuw nsw i64 %124, %6
%127 = getelementptr double, double* %8, i64 %126
%128 = bitcast double* %127 to i8*
%129 = or i64 %124, 1
%130 = mul nuw nsw i64 %129, %6
%131 = getelementptr double, double* %8, i64 %130
%132 = bitcast double* %131 to i8*
%133 = or i64 %124, 2
%134 = mul nuw nsw i64 %133, %6
%135 = getelementptr double, double* %8, i64 %134
%136 = bitcast double* %135 to i8*
%137 = or i64 %124, 3
%138 = mul nuw nsw i64 %137, %6
%139 = getelementptr double, double* %8, i64 %138
%140 = bitcast double* %139 to i8*
%141 = or i64 %124, 4
%142 = mul nuw nsw i64 %141, %6
%143 = getelementptr double, double* %8, i64 %142
%144 = bitcast double* %143 to i8*
%145 = or i64 %124, 5
%146 = mul nuw nsw i64 %145, %6
%147 = getelementptr double, double* %8, i64 %146
%148 = bitcast double* %147 to i8*
%149 = or i64 %124, 6
%150 = mul nuw nsw i64 %149, %6
%151 = getelementptr double, double* %8, i64 %150
%152 = bitcast double* %151 to i8*
%153 = or i64 %124, 7
%154 = mul nuw nsw i64 %153, %6
%155 = getelementptr double, double* %8, i64 %154
%156 = bitcast double* %155 to i8*
%157 = add nuw nsw i64 %124, 8
%158 = add i64 %125, 8
%159 = icmp eq i64 %158, %107
br i1 %159, label %108, label %123
160: ; preds = %120, %246
%161 = phi i64 [ 0, %120 ], [ %248, %246 ]
%162 = phi i32 [ %1, %120 ], [ %247, %246 ]
%163 = icmp sgt i32 %162, 0
br i1 %163, label %164, label %246
164: ; preds = %160
%165 = icmp eq i64 %161, 0
%166 = and i64 %161, 1
%167 = icmp eq i64 %166, 0
%168 = add nsw i64 %161, -1
%169 = mul nsw i64 %168, %6
%170 = getelementptr inbounds double, double* %8, i64 %169
%171 = mul nuw nsw i64 %161, %6
%172 = getelementptr inbounds double, double* %8, i64 %171
%173 = add nsw i64 %161, -2
%174 = mul nsw i64 %173, %6
%175 = getelementptr inbounds double, double* %8, i64 %174
br label %176
176: ; preds = %164, %241
%177 = phi i32 [ %162, %164 ], [ %243, %241 ]
%178 = phi i32 [ 0, %164 ], [ %244, %241 ]
br i1 %165, label %179, label %184
179: ; preds = %176
%180 = sext i32 %178 to i64
%181 = getelementptr inbounds double, double* %0, i64 %180
%182 = load double, double* %181
%183 = getelementptr inbounds double, double* %8, i64 %180
store double %182, double* %183
br label %241
184: ; preds = %176
br i1 %167, label %227, label %185
185: ; preds = %184
%186 = icmp sgt i32 %177, 0
br i1 %186, label %187, label %225
187: ; preds = %185
%188 = zext i32 %177 to i64
%189 = and i64 %188, 1
%190 = icmp eq i32 %177, 1
br i1 %190, label %214, label %191
191: ; preds = %187
%192 = and i64 %188, 4294967294
br label %193
193: ; preds = %193, %191
%194 = phi i64 [ 0, %191 ], [ %211, %193 ]
%195 = phi i64 [ 0, %191 ], [ %212, %193 ]
%196 = trunc i64 %194 to i32
%197 = xor i32 %196, -1
%198 = add i32 %177, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds double, double* %170, i64 %199
%201 = load double, double* %200
%202 = getelementptr inbounds double, double* %172, i64 %194
store double %201, double* %202
%203 = or i64 %194, 1
%204 = trunc i64 %203 to i32
%205 = xor i32 %204, -1
%206 = add i32 %177, %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds double, double* %170, i64 %207
%209 = load double, double* %208
%210 = getelementptr inbounds double, double* %172, i64 %203
store double %209, double* %210
%211 = add nuw nsw i64 %194, 2
%212 = add i64 %195, 2
%213 = icmp eq i64 %212, %192
br i1 %213, label %214, label %193
214: ; preds = %193, %187
%215 = phi i64 [ 0, %187 ], [ %211, %193 ]
%216 = icmp eq i64 %189, 0
br i1 %216, label %225, label %217
217: ; preds = %214
%218 = trunc i64 %215 to i32
%219 = xor i32 %218, -1
%220 = add i32 %177, %219
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds double, double* %170, i64 %221
%223 = load double, double* %222
%224 = getelementptr inbounds double, double* %172, i64 %215
store double %223, double* %224
br label %225
225: ; preds = %217, %214, %185
%226 = add nsw i32 %177, -1
br label %241
227: ; preds = %184
%228 = sext i32 %178 to i64
%229 = getelementptr inbounds double, double* %175, i64 %228
%230 = load double, double* %229
%231 = sext i32 %177 to i64
%232 = getelementptr inbounds double, double* %175, i64 %231
%233 = load double, double* %232
%234 = load double, double* %175
%235 = getelementptr inbounds double, double* %170, i64 %228
%236 = load double, double* %235
%237 = fneg double %233
%238 = fdiv double %237, %234
%239 = tail call double @llvm.fmuladd.f64(double %238, double %236, double %230)
%240 = getelementptr inbounds double, double* %172, i64 %228
store double %239, double* %240
br label %241
241: ; preds = %225, %227, %179
%242 = phi i32 [ %178, %179 ], [ %226, %225 ], [ %178, %227 ]
%243 = phi i32 [ %177, %179 ], [ %226, %225 ], [ %177, %227 ]
%244 = add nsw i32 %242, 1
%245 = icmp slt i32 %244, %243
br i1 %245, label %176, label %246
246: ; preds = %241, %160
%247 = phi i32 [ %162, %160 ], [ %243, %241 ]
%248 = add nuw nsw i64 %161, 1
%249 = icmp eq i64 %248, %122
br i1 %249, label %250, label %160
250: ; preds = %246
%251 = load double, double* %8
%252 = fcmp ult double %251, 0.000000e+00
br i1 %9, label %253, label %272
253: ; preds = %250
%254 = call i32 @llvm.smax.i32(i32 %4, i32 1)
%255 = zext i32 %254 to i64
br label %256
256: ; preds = %253, %266
%257 = phi i64 [ 0, %253 ], [ %267, %266 ]
%258 = and i64 %257, 1
%259 = icmp eq i64 %258, 0
br i1 %259, label %260, label %266
260: ; preds = %256
%261 = mul nuw nsw i64 %257, %6
%262 = getelementptr inbounds double, double* %8, i64 %261
%263 = load double, double* %262
%264 = fcmp oge double %263, 0.000000e+00
%265 = xor i1 %252, %264
br i1 %265, label %266, label %272
266: ; preds = %256, %260
%267 = add nuw nsw i64 %257, 1
%268 = icmp eq i64 %267, %255
br i1 %268, label %272, label %256
269: ; preds = %91, %85, %69, %2
%270 = phi i8* [ getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), %2 ], [ getelementptr inbounds ([65 x i8], [65 x i8]* @.str, i64 0, i64 0), %69 ], [ getelementptr inbounds ([74 x i8], [74 x i8]* @.str.1, i64 0, i64 0), %85 ], [ getelementptr inbounds ([78 x i8], [78 x i8]* @.str.2, i64 0, i64 0), %91 ]
%271 = tail call i32 @printf(i8* dereferenceable(1) %270)
br label %272
272: ; preds = %266, %260, %269, %98, %119, %250
%273 = phi i32 [ 1, %250 ], [ 1, %119 ], [ 1, %98 ], [ 0, %269 ], [ 1, %266 ], [ 0, %260 ]
ret i32 %273
}