#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*/ abort();
int /*<<< orphan*/ printf(char *, int);
void mypowc64(int n, int a, double x[n], int jx, double y[n], int jy) {
  switch (a) {
  case 1:
    for (int i = 0; i < n; i++) {
      y[i] = x[i];
    }
    break;
  case 2:
    for (int i = 0; i < n; i++) {
      y[i] = x[i] * x[i];
    }
    break;
  case 3:
    for (int i = 0; i < n; i++) {
      y[i] = x[i] * x[i] * x[i];
    }
    break;
  case 4:
    for (int i = 0; i < n; i++) {
      y[i] = x[i] * x[i] * x[i] * x[i];
    }
    break;
  case 5:
    for (int i = 0; i < n; i++) {
      y[i] = x[i] * x[i] * x[i] * x[i] * x[i];
    }
    break;
  case 6:
    for (int i = 0; i < n; i++) {
      y[i] = x[i] * x[i] * x[i] * x[i] * x[i] * x[i];
    }
    break;
  case 7:
    for (int i = 0; i < n; i++) {
      y[i] = x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i];
    }
    break;
  case 8:
    for (int i = 0; i < n; i++) {
      y[i] = x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i];
    }
    break;
  case 9:
    for (int i = 0; i < n; i++) {
      y[i] = x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i];
    }
    break;
  case 10:
    for (int i = 0; i < n; i++) {
      y[i] =
          x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i];
    }
    break;
  case 11:
    for (int i = 0; i < n; i++) {
      y[i] = x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i] * x[i] *
             x[i] * x[i];
    }
    break;
  default:
    printf("exponent of %d not supported\n", a);
    abort();
    break;
  }
}


x86 assembly (clang, -O0):
<mypowc64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x58(%rbp)
sub    $0xa,%eax
ja     16f1 <mypowc64+0x5d1>
mov    -0x58(%rbp),%rax
lea    0xea3(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11a1 <mypowc64+0x81>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    116d <mypowc64+0x4d>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11ee <mypowc64+0xce>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11ad <mypowc64+0x8d>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1248 <mypowc64+0x128>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fa <mypowc64+0xda>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12af <mypowc64+0x18f>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1254 <mypowc64+0x134>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1323 <mypowc64+0x203>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12bb <mypowc64+0x19b>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13a4 <mypowc64+0x284>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    132f <mypowc64+0x20f>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1432 <mypowc64+0x312>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13b0 <mypowc64+0x290>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14cd <mypowc64+0x3ad>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    143e <mypowc64+0x31e>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1575 <mypowc64+0x455>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    14d9 <mypowc64+0x3b9>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    162a <mypowc64+0x50a>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1581 <mypowc64+0x461>
jmp    1707 <mypowc64+0x5e7>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16ec <mypowc64+0x5cc>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1636 <mypowc64+0x516>
jmp    1707 <mypowc64+0x5e7>
mov    -0x8(%rbp),%esi
lea    0x931(%rip),%rdi
call   1040 <printf@plt>
mov    $0x0,%al
call   1030 <abort@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mypowc64>:
push   %rax
lea    -0x1(%rsi),%eax
cmp    $0xa,%eax
ja     2292 <mypowc64+0x1172>
lea    0x1ecc(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%r10d
cmp    $0x4,%edi
jb     1167 <mypowc64+0x47>
lea    (%rdx,%r10,8),%rax
cmp    %r8,%rax
jbe    195d <mypowc64+0x83d>
lea    (%r8,%r10,8),%rax
cmp    %rdx,%rax
jbe    195d <mypowc64+0x83d>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %r10,%rsi
mov    %r10,%rdi
and    $0x3,%rdi
je     1195 <mypowc64+0x75>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1180 <mypowc64+0x60>
cmp    $0x3,%rsi
jb     2290 <mypowc64+0x1170>
nop
movsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r8,%rcx,8)
movsd  0x10(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r8,%rcx,8)
movsd  0x18(%rdx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r8,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    11a0 <mypowc64+0x80>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x4,%edi
jb     1209 <mypowc64+0xe9>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    198a <mypowc64+0x86a>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    198a <mypowc64+0x86a>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %rax,%rsi
mov    %rax,%rdi
and    $0x3,%rdi
je     1239 <mypowc64+0x119>
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r8,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1220 <mypowc64+0x100>
cmp    $0x3,%rsi
jb     2290 <mypowc64+0x1170>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x8(%r8,%rcx,8)
movsd  0x10(%rdx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x10(%r8,%rcx,8)
movsd  0x18(%rdx,%rcx,8),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x18(%r8,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1250 <mypowc64+0x130>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x4,%edi
jb     12c9 <mypowc64+0x1a9>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    1a01 <mypowc64+0x8e1>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1a01 <mypowc64+0x8e1>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %rax,%rsi
mov    %rax,%rdi
and    $0x3,%rdi
je     1301 <mypowc64+0x1e1>
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    12e0 <mypowc64+0x1c0>
cmp    $0x3,%rsi
jb     2290 <mypowc64+0x1170>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8,%rcx,8)
movsd  0x10(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r8,%rcx,8)
movsd  0x18(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r8,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1310 <mypowc64+0x1f0>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x4,%edi
jb     13a9 <mypowc64+0x289>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    1aa1 <mypowc64+0x981>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1aa1 <mypowc64+0x981>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     13d4 <mypowc64+0x2b4>
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
or     $0x1,%rcx
add    %rax,%rsi
je     2290 <mypowc64+0x1170>
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    13e0 <mypowc64+0x2c0>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x4,%edi
jb     144f <mypowc64+0x32f>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    1b51 <mypowc64+0xa31>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1b51 <mypowc64+0xa31>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     147e <mypowc64+0x35e>
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
or     $0x1,%rcx
add    %rax,%rsi
je     2290 <mypowc64+0x1170>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1490 <mypowc64+0x370>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x4,%edi
jb     1507 <mypowc64+0x3e7>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    1c15 <mypowc64+0xaf5>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1c15 <mypowc64+0xaf5>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     153a <mypowc64+0x41a>
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
or     $0x1,%rcx
add    %rax,%rsi
je     2290 <mypowc64+0x1170>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1550 <mypowc64+0x430>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x4,%edi
jb     15cf <mypowc64+0x4af>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    1c8f <mypowc64+0xb6f>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1c8f <mypowc64+0xb6f>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     1606 <mypowc64+0x4e6>
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
or     $0x1,%rcx
add    %rax,%rsi
je     2290 <mypowc64+0x1170>
nop
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1610 <mypowc64+0x4f0>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x4,%edi
jb     1697 <mypowc64+0x577>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    1d17 <mypowc64+0xbf7>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1d17 <mypowc64+0xbf7>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     16d2 <mypowc64+0x5b2>
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
or     $0x1,%rcx
add    %rax,%rsi
je     2290 <mypowc64+0x1170>
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    16e0 <mypowc64+0x5c0>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x1,%edi
je     176f <mypowc64+0x64f>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    1d9f <mypowc64+0xc7f>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1d9f <mypowc64+0xc7f>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     17ae <mypowc64+0x68e>
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
or     $0x1,%rcx
add    %rax,%rsi
je     2290 <mypowc64+0x1170>
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    17c0 <mypowc64+0x6a0>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x1,%edi
je     1857 <mypowc64+0x737>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    1e3f <mypowc64+0xd1f>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1e3f <mypowc64+0xd1f>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     189a <mypowc64+0x77a>
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
or     $0x1,%rcx
add    %rax,%rsi
je     2290 <mypowc64+0x1170>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
movsd  0x8(%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    18b0 <mypowc64+0x790>
jmp    2290 <mypowc64+0x1170>
test   %edi,%edi
jle    2290 <mypowc64+0x1170>
mov    %edi,%eax
cmp    $0x1,%edi
jne    193c <mypowc64+0x81c>
xor    %ecx,%ecx
jmp    2250 <mypowc64+0x1130>
lea    (%rdx,%rax,8),%rcx
cmp    %r8,%rcx
jbe    1ee7 <mypowc64+0xdc7>
lea    (%r8,%rax,8),%rcx
cmp    %rdx,%rcx
jbe    1ee7 <mypowc64+0xdc7>
xor    %ecx,%ecx
jmp    2250 <mypowc64+0x1130>
mov    %r10d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0xc,%rax
jae    1f8f <mypowc64+0xe6f>
xor    %esi,%esi
jmp    2014 <mypowc64+0xef4>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     205d <mypowc64+0xf3d>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movupd (%rdx,%rsi,8),%xmm0
movupd 0x10(%rdx,%rsi,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,(%r8,%rsi,8)
movupd %xmm1,0x10(%r8,%rsi,8)
movupd 0x20(%rdx,%rsi,8),%xmm0
movupd 0x30(%rdx,%rsi,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,0x20(%r8,%rsi,8)
movupd %xmm1,0x30(%r8,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    19b0 <mypowc64+0x890>
jmp    205f <mypowc64+0xf3f>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     2093 <mypowc64+0xf73>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd (%rdx,%rsi,8),%xmm0
movupd 0x10(%rdx,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r8,%rsi,8)
movupd %xmm3,0x10(%r8,%rsi,8)
movupd 0x20(%rdx,%rsi,8),%xmm0
movupd 0x30(%rdx,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r8,%rsi,8)
movupd %xmm3,0x30(%r8,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1a30 <mypowc64+0x910>
jmp    2095 <mypowc64+0xf75>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     20d9 <mypowc64+0xfb9>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd (%rdx,%rsi,8),%xmm0
movupd 0x10(%rdx,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r8,%rsi,8)
movupd %xmm3,0x10(%r8,%rsi,8)
movupd 0x20(%rdx,%rsi,8),%xmm0
movupd 0x30(%rdx,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r8,%rsi,8)
movupd %xmm3,0x30(%r8,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1ad0 <mypowc64+0x9b0>
jmp    20db <mypowc64+0xfbb>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     2127 <mypowc64+0x1007>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movupd (%rdx,%rsi,8),%xmm0
movupd 0x10(%rdx,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r8,%rsi,8)
movupd %xmm3,0x10(%r8,%rsi,8)
movupd 0x20(%rdx,%rsi,8),%xmm0
movupd 0x30(%rdx,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r8,%rsi,8)
movupd %xmm3,0x30(%r8,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1b80 <mypowc64+0xa60>
jmp    2129 <mypowc64+0x1009>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0x0(,%rax,8),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movupd (%rdx,%rdi,1),%xmm0
movupd 0x10(%rdx,%rdi,1),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r8,%rdi,1)
movupd %xmm3,0x10(%r8,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1c30 <mypowc64+0xb10>
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
jmp    1509 <mypowc64+0x3e9>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0x0(,%rax,8),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rdx,%rdi,1),%xmm0
movupd 0x10(%rdx,%rdi,1),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r8,%rdi,1)
movupd %xmm3,0x10(%r8,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1cb0 <mypowc64+0xb90>
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
jmp    15d1 <mypowc64+0x4b1>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    0x0(,%rax,8),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd (%rdx,%rdi,1),%xmm0
movupd 0x10(%rdx,%rdi,1),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r8,%rdi,1)
movupd %xmm3,0x10(%r8,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1d30 <mypowc64+0xc10>
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
jmp    1699 <mypowc64+0x579>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
lea    -0x2(%rcx),%rsi
mov    %rsi,%r9
shr    %r9
add    $0x1,%r9
test   %rsi,%rsi
je     217d <mypowc64+0x105d>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%r8,%rsi,8)
movupd 0x10(%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x10(%r8,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1dd0 <mypowc64+0xcb0>
jmp    217f <mypowc64+0x105f>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
lea    -0x2(%rcx),%rsi
mov    %rsi,%r9
shr    %r9
add    $0x1,%r9
test   %rsi,%rsi
je     21c2 <mypowc64+0x10a2>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%r8,%rsi,8)
movupd 0x10(%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x10(%r8,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1e70 <mypowc64+0xd50>
jmp    21c4 <mypowc64+0x10a4>
mov    %eax,%ecx
and    $0xfffffffe,%ecx
lea    -0x2(%rcx),%rsi
mov    %rsi,%r9
shr    %r9
add    $0x1,%r9
test   %rsi,%rsi
je     220b <mypowc64+0x10eb>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movupd (%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%r8,%rsi,8)
movupd 0x10(%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x10(%r8,%rsi,8)
add    $0x4,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1f10 <mypowc64+0xdf0>
jmp    220d <mypowc64+0x10ed>
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
add    $0xfffffffffffffffe,%rax
and    %rax,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdx,%rsi,8),%xmm0
movups 0x10(%rdx,%rsi,8),%xmm1
movups %xmm0,(%r8,%rsi,8)
movups %xmm1,0x10(%r8,%rsi,8)
movups 0x20(%rdx,%rsi,8),%xmm0
movups 0x30(%rdx,%rsi,8),%xmm1
movups %xmm0,0x20(%r8,%rsi,8)
movups %xmm1,0x30(%r8,%rsi,8)
movups 0x40(%rdx,%rsi,8),%xmm0
movups 0x50(%rdx,%rsi,8),%xmm1
movups %xmm0,0x40(%r8,%rsi,8)
movups %xmm1,0x50(%r8,%rsi,8)
movupd 0x60(%rdx,%rsi,8),%xmm0
movupd 0x70(%rdx,%rsi,8),%xmm1
movupd %xmm0,0x60(%r8,%rsi,8)
movupd %xmm1,0x70(%r8,%rsi,8)
add    $0x10,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1fb0 <mypowc64+0xe90>
test   %r9,%r9
je     204f <mypowc64+0xf2f>
lea    (%r8,%rsi,8),%rdi
add    $0x10,%rdi
lea    (%rdx,%rsi,8),%rsi
add    $0x10,%rsi
shl    $0x5,%r9
xor    %eax,%eax
nop
movupd -0x10(%rsi,%rax,1),%xmm0
movupd (%rsi,%rax,1),%xmm1
movupd %xmm0,-0x10(%rdi,%rax,1)
movupd %xmm1,(%rdi,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    2030 <mypowc64+0xf10>
cmp    %r10,%rcx
je     2290 <mypowc64+0x1170>
jmp    1169 <mypowc64+0x49>
xor    %esi,%esi
test   $0x1,%r9b
je     2085 <mypowc64+0xf65>
movupd (%rdx,%rsi,8),%xmm0
movupd 0x10(%rdx,%rsi,8),%xmm1
mulpd  %xmm0,%xmm0
mulpd  %xmm1,%xmm1
movupd %xmm0,(%r8,%rsi,8)
movupd %xmm1,0x10(%r8,%rsi,8)
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
jmp    120b <mypowc64+0xeb>
xor    %esi,%esi
test   $0x1,%r9b
je     20cb <mypowc64+0xfab>
movupd (%rdx,%rsi,8),%xmm0
movupd 0x10(%rdx,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r8,%rsi,8)
movupd %xmm3,0x10(%r8,%rsi,8)
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
jmp    12cb <mypowc64+0x1ab>
xor    %esi,%esi
test   $0x1,%r9b
je     2119 <mypowc64+0xff9>
movupd (%rdx,%rsi,8),%xmm0
movupd 0x10(%rdx,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r8,%rsi,8)
movupd %xmm3,0x10(%r8,%rsi,8)
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
jmp    13ab <mypowc64+0x28b>
xor    %esi,%esi
test   $0x1,%r9b
je     216f <mypowc64+0x104f>
movupd (%rdx,%rsi,8),%xmm0
movupd 0x10(%rdx,%rsi,8),%xmm1
movapd %xmm0,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r8,%rsi,8)
movupd %xmm3,0x10(%r8,%rsi,8)
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
jmp    1451 <mypowc64+0x331>
xor    %esi,%esi
test   $0x1,%r9b
je     21b4 <mypowc64+0x1094>
movupd (%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%r8,%rsi,8)
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
jmp    1771 <mypowc64+0x651>
xor    %esi,%esi
test   $0x1,%r9b
je     21fd <mypowc64+0x10dd>
movupd (%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%r8,%rsi,8)
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
jmp    1859 <mypowc64+0x739>
xor    %esi,%esi
test   $0x1,%r9b
je     224a <mypowc64+0x112a>
movupd (%rdx,%rsi,8),%xmm0
movapd %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,(%r8,%rsi,8)
cmp    %rax,%rcx
je     2290 <mypowc64+0x1170>
nop
movsd  (%rdx,%rcx,8),%xmm0
movapd %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2250 <mypowc64+0x1130>
pop    %rax
ret
lea    0xd93(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
call   1030 <abort@plt>

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

LLVM IR (-O2):
@.str = [30 x i8] c"exponent of %d not supported\0A\00"
define void @mypowc64(i32 %0, i32 %1, double* nocapture %2, i32 %3, double* nocapture writeonly %4, i32 %5) {
switch i32 %1, label %1203 [
i32 1, label %848
i32 2, label %760
i32 3, label %665
i32 4, label %567
i32 5, label %462
i32 6, label %404
i32 7, label %343
i32 8, label %279
i32 9, label %185
i32 10, label %87
i32 11, label %7
]
7: ; preds = %6
%8 = icmp sgt i32 %0, 0
br i1 %8, label %9, label %1206
9: ; preds = %7
%10 = zext i32 %0 to i64
%11 = icmp eq i32 %0, 1
br i1 %11, label %85, label %12
12: ; preds = %9
%13 = getelementptr double, double* %4, i64 %10
%14 = getelementptr double, double* %2, i64 %10
%15 = icmp ugt double* %14, %4
%16 = icmp ugt double* %13, %2
%17 = and i1 %15, %16
br i1 %17, label %85, label %18
18: ; preds = %12
%19 = and i64 %10, 4294967294
%20 = add nsw i64 %19, -2
%21 = lshr exact i64 %20, 1
%22 = add nuw i64 %21, 1
%23 = and i64 %22, 1
%24 = icmp eq i64 %20, 0
br i1 %24, label %64, label %25
25: ; preds = %18
%26 = and i64 %22, -2
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %61, %27 ]
%29 = phi i64 [ 0, %25 ], [ %62, %27 ]
%30 = getelementptr inbounds double, double* %2, i64 %28
%31 = bitcast double* %30 to <2 x double>*
%32 = load <2 x double>, <2 x double>* %31
%33 = fmul <2 x double> %32, %32
%34 = fmul <2 x double> %32, %33
%35 = fmul <2 x double> %32, %34
%36 = fmul <2 x double> %32, %35
%37 = fmul <2 x double> %32, %36
%38 = fmul <2 x double> %32, %37
%39 = fmul <2 x double> %32, %38
%40 = fmul <2 x double> %32, %39
%41 = fmul <2 x double> %32, %40
%42 = fmul <2 x double> %32, %41
%43 = getelementptr inbounds double, double* %4, i64 %28
%44 = bitcast double* %43 to <2 x double>*
store <2 x double> %42, <2 x double>* %44
%45 = or i64 %28, 2
%46 = getelementptr inbounds double, double* %2, i64 %45
%47 = bitcast double* %46 to <2 x double>*
%48 = load <2 x double>, <2 x double>* %47
%49 = fmul <2 x double> %48, %48
%50 = fmul <2 x double> %48, %49
%51 = fmul <2 x double> %48, %50
%52 = fmul <2 x double> %48, %51
%53 = fmul <2 x double> %48, %52
%54 = fmul <2 x double> %48, %53
%55 = fmul <2 x double> %48, %54
%56 = fmul <2 x double> %48, %55
%57 = fmul <2 x double> %48, %56
%58 = fmul <2 x double> %48, %57
%59 = getelementptr inbounds double, double* %4, i64 %45
%60 = bitcast double* %59 to <2 x double>*
store <2 x double> %58, <2 x double>* %60
%61 = add nuw i64 %28, 4
%62 = add nuw i64 %29, 2
%63 = icmp eq i64 %62, %26
br i1 %63, label %64, label %27
64: ; preds = %27, %18
%65 = phi i64 [ 0, %18 ], [ %61, %27 ]
%66 = icmp eq i64 %23, 0
br i1 %66, label %83, label %67
67: ; preds = %64
%68 = getelementptr inbounds double, double* %2, i64 %65
%69 = bitcast double* %68 to <2 x double>*
%70 = load <2 x double>, <2 x double>* %69
%71 = fmul <2 x double> %70, %70
%72 = fmul <2 x double> %70, %71
%73 = fmul <2 x double> %70, %72
%74 = fmul <2 x double> %70, %73
%75 = fmul <2 x double> %70, %74
%76 = fmul <2 x double> %70, %75
%77 = fmul <2 x double> %70, %76
%78 = fmul <2 x double> %70, %77
%79 = fmul <2 x double> %70, %78
%80 = fmul <2 x double> %70, %79
%81 = getelementptr inbounds double, double* %4, i64 %65
%82 = bitcast double* %81 to <2 x double>*
store <2 x double> %80, <2 x double>* %82
br label %83
83: ; preds = %64, %67
%84 = icmp eq i64 %19, %10
br i1 %84, label %1206, label %85
85: ; preds = %12, %9, %83
%86 = phi i64 [ 0, %12 ], [ 0, %9 ], [ %19, %83 ]
br label %1186
87: ; preds = %6
%88 = icmp sgt i32 %0, 0
br i1 %88, label %89, label %1206
89: ; preds = %87
%90 = zext i32 %0 to i64
%91 = icmp eq i32 %0, 1
br i1 %91, label %162, label %92
92: ; preds = %89
%93 = getelementptr double, double* %4, i64 %90
%94 = getelementptr double, double* %2, i64 %90
%95 = icmp ugt double* %94, %4
%96 = icmp ugt double* %93, %2
%97 = and i1 %95, %96
br i1 %97, label %162, label %98
98: ; preds = %92
%99 = and i64 %90, 4294967294
%100 = add nsw i64 %99, -2
%101 = lshr exact i64 %100, 1
%102 = add nuw i64 %101, 1
%103 = and i64 %102, 1
%104 = icmp eq i64 %100, 0
br i1 %104, label %142, label %105
105: ; preds = %98
%106 = and i64 %102, -2
br label %107
107: ; preds = %107, %105
%108 = phi i64 [ 0, %105 ], [ %139, %107 ]
%109 = phi i64 [ 0, %105 ], [ %140, %107 ]
%110 = getelementptr inbounds double, double* %2, i64 %108
%111 = bitcast double* %110 to <2 x double>*
%112 = load <2 x double>, <2 x double>* %111
%113 = fmul <2 x double> %112, %112
%114 = fmul <2 x double> %112, %113
%115 = fmul <2 x double> %112, %114
%116 = fmul <2 x double> %112, %115
%117 = fmul <2 x double> %112, %116
%118 = fmul <2 x double> %112, %117
%119 = fmul <2 x double> %112, %118
%120 = fmul <2 x double> %112, %119
%121 = fmul <2 x double> %112, %120
%122 = getelementptr inbounds double, double* %4, i64 %108
%123 = bitcast double* %122 to <2 x double>*
store <2 x double> %121, <2 x double>* %123
%124 = or i64 %108, 2
%125 = getelementptr inbounds double, double* %2, i64 %124
%126 = bitcast double* %125 to <2 x double>*
%127 = load <2 x double>, <2 x double>* %126
%128 = fmul <2 x double> %127, %127
%129 = fmul <2 x double> %127, %128
%130 = fmul <2 x double> %127, %129
%131 = fmul <2 x double> %127, %130
%132 = fmul <2 x double> %127, %131
%133 = fmul <2 x double> %127, %132
%134 = fmul <2 x double> %127, %133
%135 = fmul <2 x double> %127, %134
%136 = fmul <2 x double> %127, %135
%137 = getelementptr inbounds double, double* %4, i64 %124
%138 = bitcast double* %137 to <2 x double>*
store <2 x double> %136, <2 x double>* %138
%139 = add nuw i64 %108, 4
%140 = add nuw i64 %109, 2
%141 = icmp eq i64 %140, %106
br i1 %141, label %142, label %107
142: ; preds = %107, %98
%143 = phi i64 [ 0, %98 ], [ %139, %107 ]
%144 = icmp eq i64 %103, 0
br i1 %144, label %160, label %145
145: ; preds = %142
%146 = getelementptr inbounds double, double* %2, i64 %143
%147 = bitcast double* %146 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = fmul <2 x double> %148, %148
%150 = fmul <2 x double> %148, %149
%151 = fmul <2 x double> %148, %150
%152 = fmul <2 x double> %148, %151
%153 = fmul <2 x double> %148, %152
%154 = fmul <2 x double> %148, %153
%155 = fmul <2 x double> %148, %154
%156 = fmul <2 x double> %148, %155
%157 = fmul <2 x double> %148, %156
%158 = getelementptr inbounds double, double* %4, i64 %143
%159 = bitcast double* %158 to <2 x double>*
store <2 x double> %157, <2 x double>* %159
br label %160
160: ; preds = %142, %145
%161 = icmp eq i64 %99, %90
br i1 %161, label %1206, label %162
162: ; preds = %92, %89, %160
%163 = phi i64 [ 0, %92 ], [ 0, %89 ], [ %99, %160 ]
%164 = xor i64 %163, -1
%165 = and i64 %90, 1
%166 = icmp eq i64 %165, 0
br i1 %166, label %181, label %167
167: ; preds = %162
%168 = getelementptr inbounds double, double* %2, i64 %163
%169 = load double, double* %168
%170 = fmul double %169, %169
%171 = fmul double %169, %170
%172 = fmul double %169, %171
%173 = fmul double %169, %172
%174 = fmul double %169, %173
%175 = fmul double %169, %174
%176 = fmul double %169, %175
%177 = fmul double %169, %176
%178 = fmul double %169, %177
%179 = getelementptr inbounds double, double* %4, i64 %163
store double %178, double* %179
%180 = or i64 %163, 1
br label %181
181: ; preds = %167, %162
%182 = phi i64 [ %163, %162 ], [ %180, %167 ]
%183 = sub nsw i64 0, %90
%184 = icmp eq i64 %164, %183
br i1 %184, label %1206, label %1157
185: ; preds = %6
%186 = icmp sgt i32 %0, 0
br i1 %186, label %187, label %1206
187: ; preds = %185
%188 = zext i32 %0 to i64
%189 = icmp eq i32 %0, 1
br i1 %189, label %257, label %190
190: ; preds = %187
%191 = getelementptr double, double* %4, i64 %188
%192 = getelementptr double, double* %2, i64 %188
%193 = icmp ugt double* %192, %4
%194 = icmp ugt double* %191, %2
%195 = and i1 %193, %194
br i1 %195, label %257, label %196
196: ; preds = %190
%197 = and i64 %188, 4294967294
%198 = add nsw i64 %197, -2
%199 = lshr exact i64 %198, 1
%200 = add nuw i64 %199, 1
%201 = and i64 %200, 1
%202 = icmp eq i64 %198, 0
br i1 %202, label %238, label %203
203: ; preds = %196
%204 = and i64 %200, -2
br label %205
205: ; preds = %205, %203
%206 = phi i64 [ 0, %203 ], [ %235, %205 ]
%207 = phi i64 [ 0, %203 ], [ %236, %205 ]
%208 = getelementptr inbounds double, double* %2, i64 %206
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = fmul <2 x double> %210, %210
%212 = fmul <2 x double> %210, %211
%213 = fmul <2 x double> %210, %212
%214 = fmul <2 x double> %210, %213
%215 = fmul <2 x double> %210, %214
%216 = fmul <2 x double> %210, %215
%217 = fmul <2 x double> %210, %216
%218 = fmul <2 x double> %210, %217
%219 = getelementptr inbounds double, double* %4, i64 %206
%220 = bitcast double* %219 to <2 x double>*
store <2 x double> %218, <2 x double>* %220
%221 = or i64 %206, 2
%222 = getelementptr inbounds double, double* %2, i64 %221
%223 = bitcast double* %222 to <2 x double>*
%224 = load <2 x double>, <2 x double>* %223
%225 = fmul <2 x double> %224, %224
%226 = fmul <2 x double> %224, %225
%227 = fmul <2 x double> %224, %226
%228 = fmul <2 x double> %224, %227
%229 = fmul <2 x double> %224, %228
%230 = fmul <2 x double> %224, %229
%231 = fmul <2 x double> %224, %230
%232 = fmul <2 x double> %224, %231
%233 = getelementptr inbounds double, double* %4, i64 %221
%234 = bitcast double* %233 to <2 x double>*
store <2 x double> %232, <2 x double>* %234
%235 = add nuw i64 %206, 4
%236 = add nuw i64 %207, 2
%237 = icmp eq i64 %236, %204
br i1 %237, label %238, label %205
238: ; preds = %205, %196
%239 = phi i64 [ 0, %196 ], [ %235, %205 ]
%240 = icmp eq i64 %201, 0
br i1 %240, label %255, label %241
241: ; preds = %238
%242 = getelementptr inbounds double, double* %2, i64 %239
%243 = bitcast double* %242 to <2 x double>*
%244 = load <2 x double>, <2 x double>* %243
%245 = fmul <2 x double> %244, %244
%246 = fmul <2 x double> %244, %245
%247 = fmul <2 x double> %244, %246
%248 = fmul <2 x double> %244, %247
%249 = fmul <2 x double> %244, %248
%250 = fmul <2 x double> %244, %249
%251 = fmul <2 x double> %244, %250
%252 = fmul <2 x double> %244, %251
%253 = getelementptr inbounds double, double* %4, i64 %239
%254 = bitcast double* %253 to <2 x double>*
store <2 x double> %252, <2 x double>* %254
br label %255
255: ; preds = %238, %241
%256 = icmp eq i64 %197, %188
br i1 %256, label %1206, label %257
257: ; preds = %190, %187, %255
%258 = phi i64 [ 0, %190 ], [ 0, %187 ], [ %197, %255 ]
%259 = xor i64 %258, -1
%260 = and i64 %188, 1
%261 = icmp eq i64 %260, 0
br i1 %261, label %275, label %262
262: ; preds = %257
%263 = getelementptr inbounds double, double* %2, i64 %258
%264 = load double, double* %263
%265 = fmul double %264, %264
%266 = fmul double %264, %265
%267 = fmul double %264, %266
%268 = fmul double %264, %267
%269 = fmul double %264, %268
%270 = fmul double %264, %269
%271 = fmul double %264, %270
%272 = fmul double %264, %271
%273 = getelementptr inbounds double, double* %4, i64 %258
store double %272, double* %273
%274 = or i64 %258, 1
br label %275
275: ; preds = %262, %257
%276 = phi i64 [ %258, %257 ], [ %274, %262 ]
%277 = sub nsw i64 0, %188
%278 = icmp eq i64 %259, %277
br i1 %278, label %1206, label %1130
279: ; preds = %6
%280 = icmp sgt i32 %0, 0
br i1 %280, label %281, label %1206
281: ; preds = %279
%282 = zext i32 %0 to i64
%283 = icmp ult i32 %0, 4
br i1 %283, label %322, label %284
284: ; preds = %281
%285 = getelementptr double, double* %4, i64 %282
%286 = getelementptr double, double* %2, i64 %282
%287 = icmp ugt double* %286, %4
%288 = icmp ugt double* %285, %2
%289 = and i1 %287, %288
br i1 %289, label %322, label %290
290: ; preds = %284
%291 = and i64 %282, 4294967292
br label %292
292: ; preds = %292, %290
%293 = phi i64 [ 0, %290 ], [ %318, %292 ]
%294 = getelementptr inbounds double, double* %2, i64 %293
%295 = bitcast double* %294 to <2 x double>*
%296 = load <2 x double>, <2 x double>* %295
%297 = getelementptr inbounds double, double* %294, i64 2
%298 = bitcast double* %297 to <2 x double>*
%299 = load <2 x double>, <2 x double>* %298
%300 = fmul <2 x double> %296, %296
%301 = fmul <2 x double> %299, %299
%302 = fmul <2 x double> %296, %300
%303 = fmul <2 x double> %299, %301
%304 = fmul <2 x double> %296, %302
%305 = fmul <2 x double> %299, %303
%306 = fmul <2 x double> %296, %304
%307 = fmul <2 x double> %299, %305
%308 = fmul <2 x double> %296, %306
%309 = fmul <2 x double> %299, %307
%310 = fmul <2 x double> %296, %308
%311 = fmul <2 x double> %299, %309
%312 = fmul <2 x double> %296, %310
%313 = fmul <2 x double> %299, %311
%314 = getelementptr inbounds double, double* %4, i64 %293
%315 = bitcast double* %314 to <2 x double>*
store <2 x double> %312, <2 x double>* %315
%316 = getelementptr inbounds double, double* %314, i64 2
%317 = bitcast double* %316 to <2 x double>*
store <2 x double> %313, <2 x double>* %317
%318 = add nuw i64 %293, 4
%319 = icmp eq i64 %318, %291
br i1 %319, label %320, label %292
320: ; preds = %292
%321 = icmp eq i64 %291, %282
br i1 %321, label %1206, label %322
322: ; preds = %284, %281, %320
%323 = phi i64 [ 0, %284 ], [ 0, %281 ], [ %291, %320 ]
%324 = xor i64 %323, -1
%325 = and i64 %282, 1
%326 = icmp eq i64 %325, 0
br i1 %326, label %339, label %327
327: ; preds = %322
%328 = getelementptr inbounds double, double* %2, i64 %323
%329 = load double, double* %328
%330 = fmul double %329, %329
%331 = fmul double %329, %330
%332 = fmul double %329, %331
%333 = fmul double %329, %332
%334 = fmul double %329, %333
%335 = fmul double %329, %334
%336 = fmul double %329, %335
%337 = getelementptr inbounds double, double* %4, i64 %323
store double %336, double* %337
%338 = or i64 %323, 1
br label %339
339: ; preds = %327, %322
%340 = phi i64 [ %323, %322 ], [ %338, %327 ]
%341 = sub nsw i64 0, %282
%342 = icmp eq i64 %324, %341
br i1 %342, label %1206, label %1105
343: ; preds = %6
%344 = icmp sgt i32 %0, 0
br i1 %344, label %345, label %1206
345: ; preds = %343
%346 = zext i32 %0 to i64
%347 = icmp ult i32 %0, 4
br i1 %347, label %384, label %348
348: ; preds = %345
%349 = getelementptr double, double* %4, i64 %346
%350 = getelementptr double, double* %2, i64 %346
%351 = icmp ugt double* %350, %4
%352 = icmp ugt double* %349, %2
%353 = and i1 %351, %352
br i1 %353, label %384, label %354
354: ; preds = %348
%355 = and i64 %346, 4294967292
br label %356
356: ; preds = %356, %354
%357 = phi i64 [ 0, %354 ], [ %380, %356 ]
%358 = getelementptr inbounds double, double* %2, i64 %357
%359 = bitcast double* %358 to <2 x double>*
%360 = load <2 x double>, <2 x double>* %359
%361 = getelementptr inbounds double, double* %358, i64 2
%362 = bitcast double* %361 to <2 x double>*
%363 = load <2 x double>, <2 x double>* %362
%364 = fmul <2 x double> %360, %360
%365 = fmul <2 x double> %363, %363
%366 = fmul <2 x double> %360, %364
%367 = fmul <2 x double> %363, %365
%368 = fmul <2 x double> %360, %366
%369 = fmul <2 x double> %363, %367
%370 = fmul <2 x double> %360, %368
%371 = fmul <2 x double> %363, %369
%372 = fmul <2 x double> %360, %370
%373 = fmul <2 x double> %363, %371
%374 = fmul <2 x double> %360, %372
%375 = fmul <2 x double> %363, %373
%376 = getelementptr inbounds double, double* %4, i64 %357
%377 = bitcast double* %376 to <2 x double>*
store <2 x double> %374, <2 x double>* %377
%378 = getelementptr inbounds double, double* %376, i64 2
%379 = bitcast double* %378 to <2 x double>*
store <2 x double> %375, <2 x double>* %379
%380 = add nuw i64 %357, 4
%381 = icmp eq i64 %380, %355
br i1 %381, label %382, label %356
382: ; preds = %356
%383 = icmp eq i64 %355, %346
br i1 %383, label %1206, label %384
384: ; preds = %348, %345, %382
%385 = phi i64 [ 0, %348 ], [ 0, %345 ], [ %355, %382 ]
%386 = xor i64 %385, -1
%387 = and i64 %346, 1
%388 = icmp eq i64 %387, 0
br i1 %388, label %400, label %389
389: ; preds = %384
%390 = getelementptr inbounds double, double* %2, i64 %385
%391 = load double, double* %390
%392 = fmul double %391, %391
%393 = fmul double %391, %392
%394 = fmul double %391, %393
%395 = fmul double %391, %394
%396 = fmul double %391, %395
%397 = fmul double %391, %396
%398 = getelementptr inbounds double, double* %4, i64 %385
store double %397, double* %398
%399 = or i64 %385, 1
br label %400
400: ; preds = %389, %384
%401 = phi i64 [ %385, %384 ], [ %399, %389 ]
%402 = sub nsw i64 0, %346
%403 = icmp eq i64 %386, %402
br i1 %403, label %1206, label %1082
404: ; preds = %6
%405 = icmp sgt i32 %0, 0
br i1 %405, label %406, label %1206
406: ; preds = %404
%407 = zext i32 %0 to i64
%408 = icmp ult i32 %0, 4
br i1 %408, label %443, label %409
409: ; preds = %406
%410 = getelementptr double, double* %4, i64 %407
%411 = getelementptr double, double* %2, i64 %407
%412 = icmp ugt double* %411, %4
%413 = icmp ugt double* %410, %2
%414 = and i1 %412, %413
br i1 %414, label %443, label %415
415: ; preds = %409
%416 = and i64 %407, 4294967292
br label %417
417: ; preds = %417, %415
%418 = phi i64 [ 0, %415 ], [ %439, %417 ]
%419 = getelementptr inbounds double, double* %2, i64 %418
%420 = bitcast double* %419 to <2 x double>*
%421 = load <2 x double>, <2 x double>* %420
%422 = getelementptr inbounds double, double* %419, i64 2
%423 = bitcast double* %422 to <2 x double>*
%424 = load <2 x double>, <2 x double>* %423
%425 = fmul <2 x double> %421, %421
%426 = fmul <2 x double> %424, %424
%427 = fmul <2 x double> %421, %425
%428 = fmul <2 x double> %424, %426
%429 = fmul <2 x double> %421, %427
%430 = fmul <2 x double> %424, %428
%431 = fmul <2 x double> %421, %429
%432 = fmul <2 x double> %424, %430
%433 = fmul <2 x double> %421, %431
%434 = fmul <2 x double> %424, %432
%435 = getelementptr inbounds double, double* %4, i64 %418
%436 = bitcast double* %435 to <2 x double>*
store <2 x double> %433, <2 x double>* %436
%437 = getelementptr inbounds double, double* %435, i64 2
%438 = bitcast double* %437 to <2 x double>*
store <2 x double> %434, <2 x double>* %438
%439 = add nuw i64 %418, 4
%440 = icmp eq i64 %439, %416
br i1 %440, label %441, label %417
441: ; preds = %417
%442 = icmp eq i64 %416, %407
br i1 %442, label %1206, label %443
443: ; preds = %409, %406, %441
%444 = phi i64 [ 0, %409 ], [ 0, %406 ], [ %416, %441 ]
%445 = xor i64 %444, -1
%446 = and i64 %407, 1
%447 = icmp eq i64 %446, 0
br i1 %447, label %458, label %448
448: ; preds = %443
%449 = getelementptr inbounds double, double* %2, i64 %444
%450 = load double, double* %449
%451 = fmul double %450, %450
%452 = fmul double %450, %451
%453 = fmul double %450, %452
%454 = fmul double %450, %453
%455 = fmul double %450, %454
%456 = getelementptr inbounds double, double* %4, i64 %444
store double %455, double* %456
%457 = or i64 %444, 1
br label %458
458: ; preds = %448, %443
%459 = phi i64 [ %444, %443 ], [ %457, %448 ]
%460 = sub nsw i64 0, %407
%461 = icmp eq i64 %445, %460
br i1 %461, label %1206, label %1061
462: ; preds = %6
%463 = icmp sgt i32 %0, 0
br i1 %463, label %464, label %1206
464: ; preds = %462
%465 = zext i32 %0 to i64
%466 = icmp ult i32 %0, 4
br i1 %466, label %549, label %467
467: ; preds = %464
%468 = getelementptr double, double* %4, i64 %465
%469 = getelementptr double, double* %2, i64 %465
%470 = icmp ugt double* %469, %4
%471 = icmp ugt double* %468, %2
%472 = and i1 %470, %471
br i1 %472, label %549, label %473
473: ; preds = %467
%474 = and i64 %465, 4294967292
%475 = add nsw i64 %474, -4
%476 = lshr exact i64 %475, 2
%477 = add nuw nsw i64 %476, 1
%478 = and i64 %477, 1
%479 = icmp eq i64 %475, 0
br i1 %479, label %525, label %480
480: ; preds = %473
%481 = and i64 %477, 9223372036854775806
br label %482
482: ; preds = %482, %480
%483 = phi i64 [ 0, %480 ], [ %522, %482 ]
%484 = phi i64 [ 0, %480 ], [ %523, %482 ]
%485 = getelementptr inbounds double, double* %2, i64 %483
%486 = bitcast double* %485 to <2 x double>*
%487 = load <2 x double>, <2 x double>* %486
%488 = getelementptr inbounds double, double* %485, i64 2
%489 = bitcast double* %488 to <2 x double>*
%490 = load <2 x double>, <2 x double>* %489
%491 = fmul <2 x double> %487, %487
%492 = fmul <2 x double> %490, %490
%493 = fmul <2 x double> %487, %491
%494 = fmul <2 x double> %490, %492
%495 = fmul <2 x double> %487, %493
%496 = fmul <2 x double> %490, %494
%497 = fmul <2 x double> %487, %495
%498 = fmul <2 x double> %490, %496
%499 = getelementptr inbounds double, double* %4, i64 %483
%500 = bitcast double* %499 to <2 x double>*
store <2 x double> %497, <2 x double>* %500
%501 = getelementptr inbounds double, double* %499, i64 2
%502 = bitcast double* %501 to <2 x double>*
store <2 x double> %498, <2 x double>* %502
%503 = or i64 %483, 4
%504 = getelementptr inbounds double, double* %2, i64 %503
%505 = bitcast double* %504 to <2 x double>*
%506 = load <2 x double>, <2 x double>* %505
%507 = getelementptr inbounds double, double* %504, i64 2
%508 = bitcast double* %507 to <2 x double>*
%509 = load <2 x double>, <2 x double>* %508
%510 = fmul <2 x double> %506, %506
%511 = fmul <2 x double> %509, %509
%512 = fmul <2 x double> %506, %510
%513 = fmul <2 x double> %509, %511
%514 = fmul <2 x double> %506, %512
%515 = fmul <2 x double> %509, %513
%516 = fmul <2 x double> %506, %514
%517 = fmul <2 x double> %509, %515
%518 = getelementptr inbounds double, double* %4, i64 %503
%519 = bitcast double* %518 to <2 x double>*
store <2 x double> %516, <2 x double>* %519
%520 = getelementptr inbounds double, double* %518, i64 2
%521 = bitcast double* %520 to <2 x double>*
store <2 x double> %517, <2 x double>* %521
%522 = add nuw i64 %483, 8
%523 = add i64 %484, 2
%524 = icmp eq i64 %523, %481
br i1 %524, label %525, label %482
525: ; preds = %482, %473
%526 = phi i64 [ 0, %473 ], [ %522, %482 ]
%527 = icmp eq i64 %478, 0
br i1 %527, label %547, label %528
528: ; preds = %525
%529 = getelementptr inbounds double, double* %2, i64 %526
%530 = bitcast double* %529 to <2 x double>*
%531 = load <2 x double>, <2 x double>* %530
%532 = getelementptr inbounds double, double* %529, i64 2
%533 = bitcast double* %532 to <2 x double>*
%534 = load <2 x double>, <2 x double>* %533
%535 = fmul <2 x double> %531, %531
%536 = fmul <2 x double> %534, %534
%537 = fmul <2 x double> %531, %535
%538 = fmul <2 x double> %534, %536
%539 = fmul <2 x double> %531, %537
%540 = fmul <2 x double> %534, %538
%541 = fmul <2 x double> %531, %539
%542 = fmul <2 x double> %534, %540
%543 = getelementptr inbounds double, double* %4, i64 %526
%544 = bitcast double* %543 to <2 x double>*
store <2 x double> %541, <2 x double>* %544
%545 = getelementptr inbounds double, double* %543, i64 2
%546 = bitcast double* %545 to <2 x double>*
store <2 x double> %542, <2 x double>* %546
br label %547
547: ; preds = %525, %528
%548 = icmp eq i64 %474, %465
br i1 %548, label %1206, label %549
549: ; preds = %467, %464, %547
%550 = phi i64 [ 0, %467 ], [ 0, %464 ], [ %474, %547 ]
%551 = xor i64 %550, -1
%552 = and i64 %465, 1
%553 = icmp eq i64 %552, 0
br i1 %553, label %563, label %554
554: ; preds = %549
%555 = getelementptr inbounds double, double* %2, i64 %550
%556 = load double, double* %555
%557 = fmul double %556, %556
%558 = fmul double %556, %557
%559 = fmul double %556, %558
%560 = fmul double %556, %559
%561 = getelementptr inbounds double, double* %4, i64 %550
store double %560, double* %561
%562 = or i64 %550, 1
br label %563
563: ; preds = %554, %549
%564 = phi i64 [ %550, %549 ], [ %562, %554 ]
%565 = sub nsw i64 0, %465
%566 = icmp eq i64 %551, %565
br i1 %566, label %1206, label %1042
567: ; preds = %6
%568 = icmp sgt i32 %0, 0
br i1 %568, label %569, label %1206
569: ; preds = %567
%570 = zext i32 %0 to i64
%571 = icmp ult i32 %0, 4
br i1 %571, label %648, label %572
572: ; preds = %569
%573 = getelementptr double, double* %4, i64 %570
%574 = getelementptr double, double* %2, i64 %570
%575 = icmp ugt double* %574, %4
%576 = icmp ugt double* %573, %2
%577 = and i1 %575, %576
br i1 %577, label %648, label %578
578: ; preds = %572
%579 = and i64 %570, 4294967292
%580 = add nsw i64 %579, -4
%581 = lshr exact i64 %580, 2
%582 = add nuw nsw i64 %581, 1
%583 = and i64 %582, 1
%584 = icmp eq i64 %580, 0
br i1 %584, label %626, label %585
585: ; preds = %578
%586 = and i64 %582, 9223372036854775806
br label %587
587: ; preds = %587, %585
%588 = phi i64 [ 0, %585 ], [ %623, %587 ]
%589 = phi i64 [ 0, %585 ], [ %624, %587 ]
%590 = getelementptr inbounds double, double* %2, i64 %588
%591 = bitcast double* %590 to <2 x double>*
%592 = load <2 x double>, <2 x double>* %591
%593 = getelementptr inbounds double, double* %590, i64 2
%594 = bitcast double* %593 to <2 x double>*
%595 = load <2 x double>, <2 x double>* %594
%596 = fmul <2 x double> %592, %592
%597 = fmul <2 x double> %595, %595
%598 = fmul <2 x double> %592, %596
%599 = fmul <2 x double> %595, %597
%600 = fmul <2 x double> %592, %598
%601 = fmul <2 x double> %595, %599
%602 = getelementptr inbounds double, double* %4, i64 %588
%603 = bitcast double* %602 to <2 x double>*
store <2 x double> %600, <2 x double>* %603
%604 = getelementptr inbounds double, double* %602, i64 2
%605 = bitcast double* %604 to <2 x double>*
store <2 x double> %601, <2 x double>* %605
%606 = or i64 %588, 4
%607 = getelementptr inbounds double, double* %2, i64 %606
%608 = bitcast double* %607 to <2 x double>*
%609 = load <2 x double>, <2 x double>* %608
%610 = getelementptr inbounds double, double* %607, i64 2
%611 = bitcast double* %610 to <2 x double>*
%612 = load <2 x double>, <2 x double>* %611
%613 = fmul <2 x double> %609, %609
%614 = fmul <2 x double> %612, %612
%615 = fmul <2 x double> %609, %613
%616 = fmul <2 x double> %612, %614
%617 = fmul <2 x double> %609, %615
%618 = fmul <2 x double> %612, %616
%619 = getelementptr inbounds double, double* %4, i64 %606
%620 = bitcast double* %619 to <2 x double>*
store <2 x double> %617, <2 x double>* %620
%621 = getelementptr inbounds double, double* %619, i64 2
%622 = bitcast double* %621 to <2 x double>*
store <2 x double> %618, <2 x double>* %622
%623 = add nuw i64 %588, 8
%624 = add i64 %589, 2
%625 = icmp eq i64 %624, %586
br i1 %625, label %626, label %587
626: ; preds = %587, %578
%627 = phi i64 [ 0, %578 ], [ %623, %587 ]
%628 = icmp eq i64 %583, 0
br i1 %628, label %646, label %629
629: ; preds = %626
%630 = getelementptr inbounds double, double* %2, i64 %627
%631 = bitcast double* %630 to <2 x double>*
%632 = load <2 x double>, <2 x double>* %631
%633 = getelementptr inbounds double, double* %630, i64 2
%634 = bitcast double* %633 to <2 x double>*
%635 = load <2 x double>, <2 x double>* %634
%636 = fmul <2 x double> %632, %632
%637 = fmul <2 x double> %635, %635
%638 = fmul <2 x double> %632, %636
%639 = fmul <2 x double> %635, %637
%640 = fmul <2 x double> %632, %638
%641 = fmul <2 x double> %635, %639
%642 = getelementptr inbounds double, double* %4, i64 %627
%643 = bitcast double* %642 to <2 x double>*
store <2 x double> %640, <2 x double>* %643
%644 = getelementptr inbounds double, double* %642, i64 2
%645 = bitcast double* %644 to <2 x double>*
store <2 x double> %641, <2 x double>* %645
br label %646
646: ; preds = %626, %629
%647 = icmp eq i64 %579, %570
br i1 %647, label %1206, label %648
648: ; preds = %572, %569, %646
%649 = phi i64 [ 0, %572 ], [ 0, %569 ], [ %579, %646 ]
%650 = xor i64 %649, -1
%651 = and i64 %570, 1
%652 = icmp eq i64 %651, 0
br i1 %652, label %661, label %653
653: ; preds = %648
%654 = getelementptr inbounds double, double* %2, i64 %649
%655 = load double, double* %654
%656 = fmul double %655, %655
%657 = fmul double %655, %656
%658 = fmul double %655, %657
%659 = getelementptr inbounds double, double* %4, i64 %649
store double %658, double* %659
%660 = or i64 %649, 1
br label %661
661: ; preds = %653, %648
%662 = phi i64 [ %649, %648 ], [ %660, %653 ]
%663 = sub nsw i64 0, %570
%664 = icmp eq i64 %650, %663
br i1 %664, label %1206, label %1025
665: ; preds = %6
%666 = icmp sgt i32 %0, 0
br i1 %666, label %667, label %1206
667: ; preds = %665
%668 = zext i32 %0 to i64
%669 = icmp ult i32 %0, 4
br i1 %669, label %740, label %670
670: ; preds = %667
%671 = getelementptr double, double* %4, i64 %668
%672 = getelementptr double, double* %2, i64 %668
%673 = icmp ugt double* %672, %4
%674 = icmp ugt double* %671, %2
%675 = and i1 %673, %674
br i1 %675, label %740, label %676
676: ; preds = %670
%677 = and i64 %668, 4294967292
%678 = add nsw i64 %677, -4
%679 = lshr exact i64 %678, 2
%680 = add nuw nsw i64 %679, 1
%681 = and i64 %680, 1
%682 = icmp eq i64 %678, 0
br i1 %682, label %720, label %683
683: ; preds = %676
%684 = and i64 %680, 9223372036854775806
br label %685
685: ; preds = %685, %683
%686 = phi i64 [ 0, %683 ], [ %717, %685 ]
%687 = phi i64 [ 0, %683 ], [ %718, %685 ]
%688 = getelementptr inbounds double, double* %2, i64 %686
%689 = bitcast double* %688 to <2 x double>*
%690 = load <2 x double>, <2 x double>* %689
%691 = getelementptr inbounds double, double* %688, i64 2
%692 = bitcast double* %691 to <2 x double>*
%693 = load <2 x double>, <2 x double>* %692
%694 = fmul <2 x double> %690, %690
%695 = fmul <2 x double> %693, %693
%696 = fmul <2 x double> %690, %694
%697 = fmul <2 x double> %693, %695
%698 = getelementptr inbounds double, double* %4, i64 %686
%699 = bitcast double* %698 to <2 x double>*
store <2 x double> %696, <2 x double>* %699
%700 = getelementptr inbounds double, double* %698, i64 2
%701 = bitcast double* %700 to <2 x double>*
store <2 x double> %697, <2 x double>* %701
%702 = or i64 %686, 4
%703 = getelementptr inbounds double, double* %2, i64 %702
%704 = bitcast double* %703 to <2 x double>*
%705 = load <2 x double>, <2 x double>* %704
%706 = getelementptr inbounds double, double* %703, i64 2
%707 = bitcast double* %706 to <2 x double>*
%708 = load <2 x double>, <2 x double>* %707
%709 = fmul <2 x double> %705, %705
%710 = fmul <2 x double> %708, %708
%711 = fmul <2 x double> %705, %709
%712 = fmul <2 x double> %708, %710
%713 = getelementptr inbounds double, double* %4, i64 %702
%714 = bitcast double* %713 to <2 x double>*
store <2 x double> %711, <2 x double>* %714
%715 = getelementptr inbounds double, double* %713, i64 2
%716 = bitcast double* %715 to <2 x double>*
store <2 x double> %712, <2 x double>* %716
%717 = add nuw i64 %686, 8
%718 = add i64 %687, 2
%719 = icmp eq i64 %718, %684
br i1 %719, label %720, label %685
720: ; preds = %685, %676
%721 = phi i64 [ 0, %676 ], [ %717, %685 ]
%722 = icmp eq i64 %681, 0
br i1 %722, label %738, label %723
723: ; preds = %720
%724 = getelementptr inbounds double, double* %2, i64 %721
%725 = bitcast double* %724 to <2 x double>*
%726 = load <2 x double>, <2 x double>* %725
%727 = getelementptr inbounds double, double* %724, i64 2
%728 = bitcast double* %727 to <2 x double>*
%729 = load <2 x double>, <2 x double>* %728
%730 = fmul <2 x double> %726, %726
%731 = fmul <2 x double> %729, %729
%732 = fmul <2 x double> %726, %730
%733 = fmul <2 x double> %729, %731
%734 = getelementptr inbounds double, double* %4, i64 %721
%735 = bitcast double* %734 to <2 x double>*
store <2 x double> %732, <2 x double>* %735
%736 = getelementptr inbounds double, double* %734, i64 2
%737 = bitcast double* %736 to <2 x double>*
store <2 x double> %733, <2 x double>* %737
br label %738
738: ; preds = %720, %723
%739 = icmp eq i64 %677, %668
br i1 %739, label %1206, label %740
740: ; preds = %670, %667, %738
%741 = phi i64 [ 0, %670 ], [ 0, %667 ], [ %677, %738 ]
%742 = xor i64 %741, -1
%743 = add nsw i64 %742, %668
%744 = and i64 %668, 3
%745 = icmp eq i64 %744, 0
br i1 %745, label %757, label %746
746: ; preds = %740, %746
%747 = phi i64 [ %754, %746 ], [ %741, %740 ]
%748 = phi i64 [ %755, %746 ], [ 0, %740 ]
%749 = getelementptr inbounds double, double* %2, i64 %747
%750 = load double, double* %749
%751 = fmul double %750, %750
%752 = fmul double %750, %751
%753 = getelementptr inbounds double, double* %4, i64 %747
store double %752, double* %753
%754 = add nuw nsw i64 %747, 1
%755 = add i64 %748, 1
%756 = icmp eq i64 %755, %744
br i1 %756, label %757, label %746
757: ; preds = %746, %740
%758 = phi i64 [ %741, %740 ], [ %754, %746 ]
%759 = icmp ult i64 %743, 3
br i1 %759, label %1206, label %998
760: ; preds = %6
%761 = icmp sgt i32 %0, 0
br i1 %761, label %762, label %1206
762: ; preds = %760
%763 = zext i32 %0 to i64
%764 = icmp ult i32 %0, 4
br i1 %764, label %829, label %765
765: ; preds = %762
%766 = getelementptr double, double* %4, i64 %763
%767 = getelementptr double, double* %2, i64 %763
%768 = icmp ugt double* %767, %4
%769 = icmp ugt double* %766, %2
%770 = and i1 %768, %769
br i1 %770, label %829, label %771
771: ; preds = %765
%772 = and i64 %763, 4294967292
%773 = add nsw i64 %772, -4
%774 = lshr exact i64 %773, 2
%775 = add nuw nsw i64 %774, 1
%776 = and i64 %775, 1
%777 = icmp eq i64 %773, 0
br i1 %777, label %811, label %778
778: ; preds = %771
%779 = and i64 %775, 9223372036854775806
br label %780
780: ; preds = %780, %778
%781 = phi i64 [ 0, %778 ], [ %808, %780 ]
%782 = phi i64 [ 0, %778 ], [ %809, %780 ]
%783 = getelementptr inbounds double, double* %2, i64 %781
%784 = bitcast double* %783 to <2 x double>*
%785 = load <2 x double>, <2 x double>* %784
%786 = getelementptr inbounds double, double* %783, i64 2
%787 = bitcast double* %786 to <2 x double>*
%788 = load <2 x double>, <2 x double>* %787
%789 = fmul <2 x double> %785, %785
%790 = fmul <2 x double> %788, %788
%791 = getelementptr inbounds double, double* %4, i64 %781
%792 = bitcast double* %791 to <2 x double>*
store <2 x double> %789, <2 x double>* %792
%793 = getelementptr inbounds double, double* %791, i64 2
%794 = bitcast double* %793 to <2 x double>*
store <2 x double> %790, <2 x double>* %794
%795 = or i64 %781, 4
%796 = getelementptr inbounds double, double* %2, i64 %795
%797 = bitcast double* %796 to <2 x double>*
%798 = load <2 x double>, <2 x double>* %797
%799 = getelementptr inbounds double, double* %796, i64 2
%800 = bitcast double* %799 to <2 x double>*
%801 = load <2 x double>, <2 x double>* %800
%802 = fmul <2 x double> %798, %798
%803 = fmul <2 x double> %801, %801
%804 = getelementptr inbounds double, double* %4, i64 %795
%805 = bitcast double* %804 to <2 x double>*
store <2 x double> %802, <2 x double>* %805
%806 = getelementptr inbounds double, double* %804, i64 2
%807 = bitcast double* %806 to <2 x double>*
store <2 x double> %803, <2 x double>* %807
%808 = add nuw i64 %781, 8
%809 = add i64 %782, 2
%810 = icmp eq i64 %809, %779
br i1 %810, label %811, label %780
811: ; preds = %780, %771
%812 = phi i64 [ 0, %771 ], [ %808, %780 ]
%813 = icmp eq i64 %776, 0
br i1 %813, label %827, label %814
814: ; preds = %811
%815 = getelementptr inbounds double, double* %2, i64 %812
%816 = bitcast double* %815 to <2 x double>*
%817 = load <2 x double>, <2 x double>* %816
%818 = getelementptr inbounds double, double* %815, i64 2
%819 = bitcast double* %818 to <2 x double>*
%820 = load <2 x double>, <2 x double>* %819
%821 = fmul <2 x double> %817, %817
%822 = fmul <2 x double> %820, %820
%823 = getelementptr inbounds double, double* %4, i64 %812
%824 = bitcast double* %823 to <2 x double>*
store <2 x double> %821, <2 x double>* %824
%825 = getelementptr inbounds double, double* %823, i64 2
%826 = bitcast double* %825 to <2 x double>*
store <2 x double> %822, <2 x double>* %826
br label %827
827: ; preds = %811, %814
%828 = icmp eq i64 %772, %763
br i1 %828, label %1206, label %829
829: ; preds = %765, %762, %827
%830 = phi i64 [ 0, %765 ], [ 0, %762 ], [ %772, %827 ]
%831 = xor i64 %830, -1
%832 = add nsw i64 %831, %763
%833 = and i64 %763, 3
%834 = icmp eq i64 %833, 0
br i1 %834, label %845, label %835
835: ; preds = %829, %835
%836 = phi i64 [ %842, %835 ], [ %830, %829 ]
%837 = phi i64 [ %843, %835 ], [ 0, %829 ]
%838 = getelementptr inbounds double, double* %2, i64 %836
%839 = load double, double* %838
%840 = fmul double %839, %839
%841 = getelementptr inbounds double, double* %4, i64 %836
store double %840, double* %841
%842 = add nuw nsw i64 %836, 1
%843 = add i64 %837, 1
%844 = icmp eq i64 %843, %833
br i1 %844, label %845, label %835
845: ; preds = %835, %829
%846 = phi i64 [ %830, %829 ], [ %842, %835 ]
%847 = icmp ult i64 %832, 3
br i1 %847, label %1206, label %975
848: ; preds = %6
%849 = icmp sgt i32 %0, 0
br i1 %849, label %850, label %1206
850: ; preds = %848
%851 = zext i32 %0 to i64
%852 = icmp ult i32 %0, 4
br i1 %852, label %938, label %853
853: ; preds = %850
%854 = getelementptr double, double* %4, i64 %851
%855 = getelementptr double, double* %2, i64 %851
%856 = icmp ugt double* %855, %4
%857 = icmp ugt double* %854, %2
%858 = and i1 %856, %857
br i1 %858, label %938, label %859
859: ; preds = %853
%860 = and i64 %851, 4294967292
%861 = add nsw i64 %860, -4
%862 = lshr exact i64 %861, 2
%863 = add nuw nsw i64 %862, 1
%864 = and i64 %863, 3
%865 = icmp ult i64 %861, 12
br i1 %865, label %917, label %866
866: ; preds = %859
%867 = and i64 %863, 9223372036854775804
br label %868
868: ; preds = %868, %866
%869 = phi i64 [ 0, %866 ], [ %914, %868 ]
%870 = phi i64 [ 0, %866 ], [ %915, %868 ]
%871 = getelementptr inbounds double, double* %2, i64 %869
%872 = bitcast double* %871 to <2 x double>*
%873 = load <2 x double>, <2 x double>* %872
%874 = getelementptr inbounds double, double* %871, i64 2
%875 = bitcast double* %874 to <2 x double>*
%876 = load <2 x double>, <2 x double>* %875
%877 = getelementptr inbounds double, double* %4, i64 %869
%878 = bitcast double* %877 to <2 x double>*
store <2 x double> %873, <2 x double>* %878
%879 = getelementptr inbounds double, double* %877, i64 2
%880 = bitcast double* %879 to <2 x double>*
store <2 x double> %876, <2 x double>* %880
%881 = or i64 %869, 4
%882 = getelementptr inbounds double, double* %2, i64 %881
%883 = bitcast double* %882 to <2 x double>*
%884 = load <2 x double>, <2 x double>* %883
%885 = getelementptr inbounds double, double* %882, i64 2
%886 = bitcast double* %885 to <2 x double>*
%887 = load <2 x double>, <2 x double>* %886
%888 = getelementptr inbounds double, double* %4, i64 %881
%889 = bitcast double* %888 to <2 x double>*
store <2 x double> %884, <2 x double>* %889
%890 = getelementptr inbounds double, double* %888, i64 2
%891 = bitcast double* %890 to <2 x double>*
store <2 x double> %887, <2 x double>* %891
%892 = or i64 %869, 8
%893 = getelementptr inbounds double, double* %2, i64 %892
%894 = bitcast double* %893 to <2 x double>*
%895 = load <2 x double>, <2 x double>* %894
%896 = getelementptr inbounds double, double* %893, i64 2
%897 = bitcast double* %896 to <2 x double>*
%898 = load <2 x double>, <2 x double>* %897
%899 = getelementptr inbounds double, double* %4, i64 %892
%900 = bitcast double* %899 to <2 x double>*
store <2 x double> %895, <2 x double>* %900
%901 = getelementptr inbounds double, double* %899, i64 2
%902 = bitcast double* %901 to <2 x double>*
store <2 x double> %898, <2 x double>* %902
%903 = or i64 %869, 12
%904 = getelementptr inbounds double, double* %2, i64 %903
%905 = bitcast double* %904 to <2 x double>*
%906 = load <2 x double>, <2 x double>* %905
%907 = getelementptr inbounds double, double* %904, i64 2
%908 = bitcast double* %907 to <2 x double>*
%909 = load <2 x double>, <2 x double>* %908
%910 = getelementptr inbounds double, double* %4, i64 %903
%911 = bitcast double* %910 to <2 x double>*
store <2 x double> %906, <2 x double>* %911
%912 = getelementptr inbounds double, double* %910, i64 2
%913 = bitcast double* %912 to <2 x double>*
store <2 x double> %909, <2 x double>* %913
%914 = add nuw i64 %869, 16
%915 = add nuw i64 %870, 4
%916 = icmp eq i64 %915, %867
br i1 %916, label %917, label %868
917: ; preds = %868, %859
%918 = phi i64 [ 0, %859 ], [ %914, %868 ]
%919 = icmp eq i64 %864, 0
br i1 %919, label %936, label %920
920: ; preds = %917, %920
%921 = phi i64 [ %933, %920 ], [ %918, %917 ]
%922 = phi i64 [ %934, %920 ], [ 0, %917 ]
%923 = getelementptr inbounds double, double* %2, i64 %921
%924 = bitcast double* %923 to <2 x double>*
%925 = load <2 x double>, <2 x double>* %924
%926 = getelementptr inbounds double, double* %923, i64 2
%927 = bitcast double* %926 to <2 x double>*
%928 = load <2 x double>, <2 x double>* %927
%929 = getelementptr inbounds double, double* %4, i64 %921
%930 = bitcast double* %929 to <2 x double>*
store <2 x double> %925, <2 x double>* %930
%931 = getelementptr inbounds double, double* %929, i64 2
%932 = bitcast double* %931 to <2 x double>*
store <2 x double> %928, <2 x double>* %932
%933 = add nuw i64 %921, 4
%934 = add i64 %922, 1
%935 = icmp eq i64 %934, %864
br i1 %935, label %936, label %920
936: ; preds = %920, %917
%937 = icmp eq i64 %860, %851
br i1 %937, label %1206, label %938
938: ; preds = %853, %850, %936
%939 = phi i64 [ 0, %853 ], [ 0, %850 ], [ %860, %936 ]
%940 = xor i64 %939, -1
%941 = add nsw i64 %940, %851
%942 = and i64 %851, 3
%943 = icmp eq i64 %942, 0
br i1 %943, label %953, label %944
944: ; preds = %938, %944
%945 = phi i64 [ %950, %944 ], [ %939, %938 ]
%946 = phi i64 [ %951, %944 ], [ 0, %938 ]
%947 = getelementptr inbounds double, double* %2, i64 %945
%948 = load double, double* %947
%949 = getelementptr inbounds double, double* %4, i64 %945
store double %948, double* %949
%950 = add nuw nsw i64 %945, 1
%951 = add i64 %946, 1
%952 = icmp eq i64 %951, %942
br i1 %952, label %953, label %944
953: ; preds = %944, %938
%954 = phi i64 [ %939, %938 ], [ %950, %944 ]
%955 = icmp ult i64 %941, 3
br i1 %955, label %1206, label %956
956: ; preds = %953, %956
%957 = phi i64 [ %973, %956 ], [ %954, %953 ]
%958 = getelementptr inbounds double, double* %2, i64 %957
%959 = load double, double* %958
%960 = getelementptr inbounds double, double* %4, i64 %957
store double %959, double* %960
%961 = add nuw nsw i64 %957, 1
%962 = getelementptr inbounds double, double* %2, i64 %961
%963 = load double, double* %962
%964 = getelementptr inbounds double, double* %4, i64 %961
store double %963, double* %964
%965 = add nuw nsw i64 %957, 2
%966 = getelementptr inbounds double, double* %2, i64 %965
%967 = load double, double* %966
%968 = getelementptr inbounds double, double* %4, i64 %965
store double %967, double* %968
%969 = add nuw nsw i64 %957, 3
%970 = getelementptr inbounds double, double* %2, i64 %969
%971 = load double, double* %970
%972 = getelementptr inbounds double, double* %4, i64 %969
store double %971, double* %972
%973 = add nuw nsw i64 %957, 4
%974 = icmp eq i64 %973, %851
br i1 %974, label %1206, label %956
975: ; preds = %845, %975
%976 = phi i64 [ %996, %975 ], [ %846, %845 ]
%977 = getelementptr inbounds double, double* %2, i64 %976
%978 = load double, double* %977
%979 = fmul double %978, %978
%980 = getelementptr inbounds double, double* %4, i64 %976
store double %979, double* %980
%981 = add nuw nsw i64 %976, 1
%982 = getelementptr inbounds double, double* %2, i64 %981
%983 = load double, double* %982
%984 = fmul double %983, %983
%985 = getelementptr inbounds double, double* %4, i64 %981
store double %984, double* %985
%986 = add nuw nsw i64 %976, 2
%987 = getelementptr inbounds double, double* %2, i64 %986
%988 = load double, double* %987
%989 = fmul double %988, %988
%990 = getelementptr inbounds double, double* %4, i64 %986
store double %989, double* %990
%991 = add nuw nsw i64 %976, 3
%992 = getelementptr inbounds double, double* %2, i64 %991
%993 = load double, double* %992
%994 = fmul double %993, %993
%995 = getelementptr inbounds double, double* %4, i64 %991
store double %994, double* %995
%996 = add nuw nsw i64 %976, 4
%997 = icmp eq i64 %996, %763
br i1 %997, label %1206, label %975
998: ; preds = %757, %998
%999 = phi i64 [ %1023, %998 ], [ %758, %757 ]
%1000 = getelementptr inbounds double, double* %2, i64 %999
%1001 = load double, double* %1000
%1002 = fmul double %1001, %1001
%1003 = fmul double %1001, %1002
%1004 = getelementptr inbounds double, double* %4, i64 %999
store double %1003, double* %1004
%1005 = add nuw nsw i64 %999, 1
%1006 = getelementptr inbounds double, double* %2, i64 %1005
%1007 = load double, double* %1006
%1008 = fmul double %1007, %1007
%1009 = fmul double %1007, %1008
%1010 = getelementptr inbounds double, double* %4, i64 %1005
store double %1009, double* %1010
%1011 = add nuw nsw i64 %999, 2
%1012 = getelementptr inbounds double, double* %2, i64 %1011
%1013 = load double, double* %1012
%1014 = fmul double %1013, %1013
%1015 = fmul double %1013, %1014
%1016 = getelementptr inbounds double, double* %4, i64 %1011
store double %1015, double* %1016
%1017 = add nuw nsw i64 %999, 3
%1018 = getelementptr inbounds double, double* %2, i64 %1017
%1019 = load double, double* %1018
%1020 = fmul double %1019, %1019
%1021 = fmul double %1019, %1020
%1022 = getelementptr inbounds double, double* %4, i64 %1017
store double %1021, double* %1022
%1023 = add nuw nsw i64 %999, 4
%1024 = icmp eq i64 %1023, %668
br i1 %1024, label %1206, label %998
1025: ; preds = %661, %1025
%1026 = phi i64 [ %1040, %1025 ], [ %662, %661 ]
%1027 = getelementptr inbounds double, double* %2, i64 %1026
%1028 = load double, double* %1027
%1029 = fmul double %1028, %1028
%1030 = fmul double %1028, %1029
%1031 = fmul double %1028, %1030
%1032 = getelementptr inbounds double, double* %4, i64 %1026
store double %1031, double* %1032
%1033 = add nuw nsw i64 %1026, 1
%1034 = getelementptr inbounds double, double* %2, i64 %1033
%1035 = load double, double* %1034
%1036 = fmul double %1035, %1035
%1037 = fmul double %1035, %1036
%1038 = fmul double %1035, %1037
%1039 = getelementptr inbounds double, double* %4, i64 %1033
store double %1038, double* %1039
%1040 = add nuw nsw i64 %1026, 2
%1041 = icmp eq i64 %1040, %570
br i1 %1041, label %1206, label %1025
1042: ; preds = %563, %1042
%1043 = phi i64 [ %1059, %1042 ], [ %564, %563 ]
%1044 = getelementptr inbounds double, double* %2, i64 %1043
%1045 = load double, double* %1044
%1046 = fmul double %1045, %1045
%1047 = fmul double %1045, %1046
%1048 = fmul double %1045, %1047
%1049 = fmul double %1045, %1048
%1050 = getelementptr inbounds double, double* %4, i64 %1043
store double %1049, double* %1050
%1051 = add nuw nsw i64 %1043, 1
%1052 = getelementptr inbounds double, double* %2, i64 %1051
%1053 = load double, double* %1052
%1054 = fmul double %1053, %1053
%1055 = fmul double %1053, %1054
%1056 = fmul double %1053, %1055
%1057 = fmul double %1053, %1056
%1058 = getelementptr inbounds double, double* %4, i64 %1051
store double %1057, double* %1058
%1059 = add nuw nsw i64 %1043, 2
%1060 = icmp eq i64 %1059, %465
br i1 %1060, label %1206, label %1042
1061: ; preds = %458, %1061
%1062 = phi i64 [ %1080, %1061 ], [ %459, %458 ]
%1063 = getelementptr inbounds double, double* %2, i64 %1062
%1064 = load double, double* %1063
%1065 = fmul double %1064, %1064
%1066 = fmul double %1064, %1065
%1067 = fmul double %1064, %1066
%1068 = fmul double %1064, %1067
%1069 = fmul double %1064, %1068
%1070 = getelementptr inbounds double, double* %4, i64 %1062
store double %1069, double* %1070
%1071 = add nuw nsw i64 %1062, 1
%1072 = getelementptr inbounds double, double* %2, i64 %1071
%1073 = load double, double* %1072
%1074 = fmul double %1073, %1073
%1075 = fmul double %1073, %1074
%1076 = fmul double %1073, %1075
%1077 = fmul double %1073, %1076
%1078 = fmul double %1073, %1077
%1079 = getelementptr inbounds double, double* %4, i64 %1071
store double %1078, double* %1079
%1080 = add nuw nsw i64 %1062, 2
%1081 = icmp eq i64 %1080, %407
br i1 %1081, label %1206, label %1061
1082: ; preds = %400, %1082
%1083 = phi i64 [ %1103, %1082 ], [ %401, %400 ]
%1084 = getelementptr inbounds double, double* %2, i64 %1083
%1085 = load double, double* %1084
%1086 = fmul double %1085, %1085
%1087 = fmul double %1085, %1086
%1088 = fmul double %1085, %1087
%1089 = fmul double %1085, %1088
%1090 = fmul double %1085, %1089
%1091 = fmul double %1085, %1090
%1092 = getelementptr inbounds double, double* %4, i64 %1083
store double %1091, double* %1092
%1093 = add nuw nsw i64 %1083, 1
%1094 = getelementptr inbounds double, double* %2, i64 %1093
%1095 = load double, double* %1094
%1096 = fmul double %1095, %1095
%1097 = fmul double %1095, %1096
%1098 = fmul double %1095, %1097
%1099 = fmul double %1095, %1098
%1100 = fmul double %1095, %1099
%1101 = fmul double %1095, %1100
%1102 = getelementptr inbounds double, double* %4, i64 %1093
store double %1101, double* %1102
%1103 = add nuw nsw i64 %1083, 2
%1104 = icmp eq i64 %1103, %346
br i1 %1104, label %1206, label %1082
1105: ; preds = %339, %1105
%1106 = phi i64 [ %1128, %1105 ], [ %340, %339 ]
%1107 = getelementptr inbounds double, double* %2, i64 %1106
%1108 = load double, double* %1107
%1109 = fmul double %1108, %1108
%1110 = fmul double %1108, %1109
%1111 = fmul double %1108, %1110
%1112 = fmul double %1108, %1111
%1113 = fmul double %1108, %1112
%1114 = fmul double %1108, %1113
%1115 = fmul double %1108, %1114
%1116 = getelementptr inbounds double, double* %4, i64 %1106
store double %1115, double* %1116
%1117 = add nuw nsw i64 %1106, 1
%1118 = getelementptr inbounds double, double* %2, i64 %1117
%1119 = load double, double* %1118
%1120 = fmul double %1119, %1119
%1121 = fmul double %1119, %1120
%1122 = fmul double %1119, %1121
%1123 = fmul double %1119, %1122
%1124 = fmul double %1119, %1123
%1125 = fmul double %1119, %1124
%1126 = fmul double %1119, %1125
%1127 = getelementptr inbounds double, double* %4, i64 %1117
store double %1126, double* %1127
%1128 = add nuw nsw i64 %1106, 2
%1129 = icmp eq i64 %1128, %282
br i1 %1129, label %1206, label %1105
1130: ; preds = %275, %1130
%1131 = phi i64 [ %1155, %1130 ], [ %276, %275 ]
%1132 = getelementptr inbounds double, double* %2, i64 %1131
%1133 = load double, double* %1132
%1134 = fmul double %1133, %1133
%1135 = fmul double %1133, %1134
%1136 = fmul double %1133, %1135
%1137 = fmul double %1133, %1136
%1138 = fmul double %1133, %1137
%1139 = fmul double %1133, %1138
%1140 = fmul double %1133, %1139
%1141 = fmul double %1133, %1140
%1142 = getelementptr inbounds double, double* %4, i64 %1131
store double %1141, double* %1142
%1143 = add nuw nsw i64 %1131, 1
%1144 = getelementptr inbounds double, double* %2, i64 %1143
%1145 = load double, double* %1144
%1146 = fmul double %1145, %1145
%1147 = fmul double %1145, %1146
%1148 = fmul double %1145, %1147
%1149 = fmul double %1145, %1148
%1150 = fmul double %1145, %1149
%1151 = fmul double %1145, %1150
%1152 = fmul double %1145, %1151
%1153 = fmul double %1145, %1152
%1154 = getelementptr inbounds double, double* %4, i64 %1143
store double %1153, double* %1154
%1155 = add nuw nsw i64 %1131, 2
%1156 = icmp eq i64 %1155, %188
br i1 %1156, label %1206, label %1130
1157: ; preds = %181, %1157
%1158 = phi i64 [ %1184, %1157 ], [ %182, %181 ]
%1159 = getelementptr inbounds double, double* %2, i64 %1158
%1160 = load double, double* %1159
%1161 = fmul double %1160, %1160
%1162 = fmul double %1160, %1161
%1163 = fmul double %1160, %1162
%1164 = fmul double %1160, %1163
%1165 = fmul double %1160, %1164
%1166 = fmul double %1160, %1165
%1167 = fmul double %1160, %1166
%1168 = fmul double %1160, %1167
%1169 = fmul double %1160, %1168
%1170 = getelementptr inbounds double, double* %4, i64 %1158
store double %1169, double* %1170
%1171 = add nuw nsw i64 %1158, 1
%1172 = getelementptr inbounds double, double* %2, i64 %1171
%1173 = load double, double* %1172
%1174 = fmul double %1173, %1173
%1175 = fmul double %1173, %1174
%1176 = fmul double %1173, %1175
%1177 = fmul double %1173, %1176
%1178 = fmul double %1173, %1177
%1179 = fmul double %1173, %1178
%1180 = fmul double %1173, %1179
%1181 = fmul double %1173, %1180
%1182 = fmul double %1173, %1181
%1183 = getelementptr inbounds double, double* %4, i64 %1171
store double %1182, double* %1183
%1184 = add nuw nsw i64 %1158, 2
%1185 = icmp eq i64 %1184, %90
br i1 %1185, label %1206, label %1157
1186: ; preds = %85, %1186
%1187 = phi i64 [ %1201, %1186 ], [ %86, %85 ]
%1188 = getelementptr inbounds double, double* %2, i64 %1187
%1189 = load double, double* %1188
%1190 = fmul double %1189, %1189
%1191 = fmul double %1189, %1190
%1192 = fmul double %1189, %1191
%1193 = fmul double %1189, %1192
%1194 = fmul double %1189, %1193
%1195 = fmul double %1189, %1194
%1196 = fmul double %1189, %1195
%1197 = fmul double %1189, %1196
%1198 = fmul double %1189, %1197
%1199 = fmul double %1189, %1198
%1200 = getelementptr inbounds double, double* %4, i64 %1187
store double %1199, double* %1200
%1201 = add nuw nsw i64 %1187, 1
%1202 = icmp eq i64 %1201, %10
br i1 %1202, label %1206, label %1186
1203: ; preds = %6
%1204 = tail call i32 @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i32 %1)
%1205 = tail call i32 (...) @abort()
unreachable
1206: ; preds = %1186, %181, %1157, %275, %1130, %339, %1105, %400, %1082, %458, %1061, %563, %1042, %661, %1025, %757, %998, %845, %975, %953, %956, %83, %160, %255, %320, %382, %441, %547, %646, %738, %827, %936, %7, %87, %185, %279, %343, %404, %462, %567, %665, %760, %848
ret void
}