#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 mypowc32(int n, int a, float x[n], int jx, float 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;
  }
  return;
}


x86 assembly (clang, -O0):
<mypowc32>:
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 <mypowc32+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 <mypowc32+0x81>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    116d <mypowc32+0x4d>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11ee <mypowc32+0xce>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11ad <mypowc32+0x8d>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1248 <mypowc32+0x128>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fa <mypowc32+0xda>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12af <mypowc32+0x18f>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1254 <mypowc32+0x134>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1323 <mypowc32+0x203>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12bb <mypowc32+0x19b>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13a4 <mypowc32+0x284>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    132f <mypowc32+0x20f>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1432 <mypowc32+0x312>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13b0 <mypowc32+0x290>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    14cd <mypowc32+0x3ad>
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    143e <mypowc32+0x31e>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1575 <mypowc32+0x455>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    14d9 <mypowc32+0x3b9>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    162a <mypowc32+0x50a>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1581 <mypowc32+0x461>
jmp    1707 <mypowc32+0x5e7>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16ec <mypowc32+0x5cc>
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1636 <mypowc32+0x516>
jmp    1707 <mypowc32+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):
<mypowc32>:
push   %rax
lea    -0x1(%rsi),%eax
cmp    $0xa,%eax
ja     2141 <mypowc32+0x1021>
lea    0x1ecc(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%r10d
cmp    $0x8,%edi
jb     1167 <mypowc32+0x47>
lea    (%rdx,%r10,4),%rax
cmp    %r8,%rax
jbe    193b <mypowc32+0x81b>
lea    (%r8,%r10,4),%rax
cmp    %rdx,%rax
jbe    193b <mypowc32+0x81b>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %r10,%rsi
mov    %r10,%rdi
and    $0x3,%rdi
je     1195 <mypowc32+0x75>
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%r8,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1180 <mypowc32+0x60>
cmp    $0x3,%rsi
jb     213f <mypowc32+0x101f>
nop
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%r8,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%r8,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%r8,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r10
jne    11a0 <mypowc32+0x80>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x8,%edi
jb     1209 <mypowc32+0xe9>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    1968 <mypowc32+0x848>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    1968 <mypowc32+0x848>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %rax,%rsi
mov    %rax,%rdi
and    $0x3,%rdi
je     1239 <mypowc32+0x119>
nopl   (%rax)
movss  (%rdx,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
movss  %xmm0,(%r8,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1220 <mypowc32+0x100>
cmp    $0x3,%rsi
jb     213f <mypowc32+0x101f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdx,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
movss  %xmm0,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
movss  %xmm0,0x4(%r8,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
movss  %xmm0,0x8(%r8,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
movss  %xmm0,0xc(%r8,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1250 <mypowc32+0x130>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x8,%edi
jb     12c9 <mypowc32+0x1a9>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    19d5 <mypowc32+0x8b5>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    19d5 <mypowc32+0x8b5>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %rax,%rsi
mov    %rax,%rdi
and    $0x3,%rdi
je     1300 <mypowc32+0x1e0>
nopl   (%rax)
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    12e0 <mypowc32+0x1c0>
cmp    $0x3,%rsi
jb     213f <mypowc32+0x101f>
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r8,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x8(%r8,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0xc(%r8,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1310 <mypowc32+0x1f0>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x8,%edi
jb     13a5 <mypowc32+0x285>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    1a5d <mypowc32+0x93d>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    1a5d <mypowc32+0x93d>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     13cf <mypowc32+0x2af>
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
or     $0x1,%rcx
add    %rax,%rsi
je     213f <mypowc32+0x101f>
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r8,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    13e0 <mypowc32+0x2c0>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x8,%edi
jb     144d <mypowc32+0x32d>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    1af9 <mypowc32+0x9d9>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    1af9 <mypowc32+0x9d9>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     147b <mypowc32+0x35b>
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
or     $0x1,%rcx
add    %rax,%rsi
je     213f <mypowc32+0x101f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r8,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1490 <mypowc32+0x370>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x8,%edi
jb     1505 <mypowc32+0x3e5>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    1b95 <mypowc32+0xa75>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    1b95 <mypowc32+0xa75>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     1537 <mypowc32+0x417>
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
or     $0x1,%rcx
add    %rax,%rsi
je     213f <mypowc32+0x101f>
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r8,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1540 <mypowc32+0x420>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x8,%edi
jb     15bd <mypowc32+0x49d>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    1bff <mypowc32+0xadf>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    1bff <mypowc32+0xadf>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     15f3 <mypowc32+0x4d3>
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
or     $0x1,%rcx
add    %rax,%rsi
je     213f <mypowc32+0x101f>
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r8,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1600 <mypowc32+0x4e0>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x8,%edi
jb     1685 <mypowc32+0x565>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    1c75 <mypowc32+0xb55>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    1c75 <mypowc32+0xb55>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     16bf <mypowc32+0x59f>
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
or     $0x1,%rcx
add    %rax,%rsi
je     213f <mypowc32+0x101f>
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r8,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    16d0 <mypowc32+0x5b0>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x4,%edi
jb     175d <mypowc32+0x63d>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    1ceb <mypowc32+0xbcb>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    1ceb <mypowc32+0xbcb>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     179b <mypowc32+0x67b>
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
or     $0x1,%rcx
add    %rax,%rsi
je     213f <mypowc32+0x101f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r8,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    17b0 <mypowc32+0x690>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x4,%edi
jb     1845 <mypowc32+0x725>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    1d79 <mypowc32+0xc59>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    1d79 <mypowc32+0xc59>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
test   $0x1,%al
je     1887 <mypowc32+0x767>
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
or     $0x1,%rcx
add    %rax,%rsi
je     213f <mypowc32+0x101f>
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,0x4(%r8,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1890 <mypowc32+0x770>
jmp    213f <mypowc32+0x101f>
test   %edi,%edi
jle    213f <mypowc32+0x101f>
mov    %edi,%eax
cmp    $0x4,%edi
jae    191a <mypowc32+0x7fa>
xor    %ecx,%ecx
jmp    2100 <mypowc32+0xfe0>
lea    (%rdx,%rax,4),%rcx
cmp    %r8,%rcx
jbe    1dff <mypowc32+0xcdf>
lea    (%r8,%rax,4),%rcx
cmp    %rdx,%rcx
jbe    1dff <mypowc32+0xcdf>
xor    %ecx,%ecx
jmp    2100 <mypowc32+0xfe0>
mov    %r10d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1e95 <mypowc32+0xd75>
xor    %esi,%esi
jmp    1f10 <mypowc32+0xdf0>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1f59 <mypowc32+0xe39>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
mulps  %xmm0,%xmm0
mulps  %xmm1,%xmm1
movups %xmm0,(%r8,%rsi,4)
movups %xmm1,0x10(%r8,%rsi,4)
movups 0x20(%rdx,%rsi,4),%xmm0
movups 0x30(%rdx,%rsi,4),%xmm1
mulps  %xmm0,%xmm0
mulps  %xmm1,%xmm1
movups %xmm0,0x20(%r8,%rsi,4)
movups %xmm1,0x30(%r8,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1990 <mypowc32+0x870>
jmp    1f5b <mypowc32+0xe3b>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1f89 <mypowc32+0xe69>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r8,%rsi,4)
movups %xmm3,0x10(%r8,%rsi,4)
movups 0x20(%rdx,%rsi,4),%xmm0
movups 0x30(%rdx,%rsi,4),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x20(%r8,%rsi,4)
movups %xmm3,0x30(%r8,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1a00 <mypowc32+0x8e0>
jmp    1f8b <mypowc32+0xe6b>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1fc5 <mypowc32+0xea5>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r8,%rsi,4)
movups %xmm3,0x10(%r8,%rsi,4)
movups 0x20(%rdx,%rsi,4),%xmm0
movups 0x30(%rdx,%rsi,4),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x20(%r8,%rsi,4)
movups %xmm3,0x30(%r8,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1a90 <mypowc32+0x970>
jmp    1fc7 <mypowc32+0xea7>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     2007 <mypowc32+0xee7>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nop
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r8,%rsi,4)
movups %xmm3,0x10(%r8,%rsi,4)
movups 0x20(%rdx,%rsi,4),%xmm0
movups 0x30(%rdx,%rsi,4),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,0x20(%r8,%rsi,4)
movups %xmm3,0x30(%r8,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1b20 <mypowc32+0xa00>
jmp    2009 <mypowc32+0xee9>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    0x0(,%rax,4),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rdi,1),%xmm0
movups 0x10(%rdx,%rdi,1),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r8,%rdi,1)
movups %xmm3,0x10(%r8,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1bb0 <mypowc32+0xa90>
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
jmp    1507 <mypowc32+0x3e7>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    0x0(,%rax,4),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rdx,%rdi,1),%xmm0
movups 0x10(%rdx,%rdi,1),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r8,%rdi,1)
movups %xmm3,0x10(%r8,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1c20 <mypowc32+0xb00>
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
jmp    15bf <mypowc32+0x49f>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    0x0(,%rax,4),%rsi
and    $0xffffffffffffffe0,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rdi,1),%xmm0
movups 0x10(%rdx,%rdi,1),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r8,%rdi,1)
movups %xmm3,0x10(%r8,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rsi
jne    1c90 <mypowc32+0xb70>
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
jmp    1687 <mypowc32+0x567>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     204f <mypowc32+0xf2f>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,(%r8,%rsi,4)
movups 0x10(%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,0x10(%r8,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1d20 <mypowc32+0xc00>
jmp    2051 <mypowc32+0xf31>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     2089 <mypowc32+0xf69>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
nop
movups (%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,(%r8,%rsi,4)
movups 0x10(%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,0x10(%r8,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1da0 <mypowc32+0xc80>
jmp    208b <mypowc32+0xf6b>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     20c6 <mypowc32+0xfa6>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,(%r8,%rsi,4)
movups 0x10(%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,0x10(%r8,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1e30 <mypowc32+0xd10>
jmp    20c8 <mypowc32+0xfa8>
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
add    $0xfffffffffffffffe,%rax
and    %rax,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movups %xmm0,(%r8,%rsi,4)
movups %xmm1,0x10(%r8,%rsi,4)
movups 0x20(%rdx,%rsi,4),%xmm0
movups 0x30(%rdx,%rsi,4),%xmm1
movups %xmm0,0x20(%r8,%rsi,4)
movups %xmm1,0x30(%r8,%rsi,4)
movups 0x40(%rdx,%rsi,4),%xmm0
movups 0x50(%rdx,%rsi,4),%xmm1
movups %xmm0,0x40(%r8,%rsi,4)
movups %xmm1,0x50(%r8,%rsi,4)
movups 0x60(%rdx,%rsi,4),%xmm0
movups 0x70(%rdx,%rsi,4),%xmm1
movups %xmm0,0x60(%r8,%rsi,4)
movups %xmm1,0x70(%r8,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1eb0 <mypowc32+0xd90>
test   %r9,%r9
je     1f4b <mypowc32+0xe2b>
lea    (%r8,%rsi,4),%rdi
add    $0x10,%rdi
lea    (%rdx,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r9
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rax,1),%xmm0
movups (%rsi,%rax,1),%xmm1
movups %xmm0,-0x10(%rdi,%rax,1)
movups %xmm1,(%rdi,%rax,1)
add    $0x20,%rax
cmp    %rax,%r9
jne    1f30 <mypowc32+0xe10>
cmp    %r10,%rcx
je     213f <mypowc32+0x101f>
jmp    1169 <mypowc32+0x49>
xor    %esi,%esi
test   $0x1,%r9b
je     1f7b <mypowc32+0xe5b>
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
mulps  %xmm0,%xmm0
mulps  %xmm1,%xmm1
movups %xmm0,(%r8,%rsi,4)
movups %xmm1,0x10(%r8,%rsi,4)
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
jmp    120b <mypowc32+0xeb>
xor    %esi,%esi
test   $0x1,%r9b
je     1fb7 <mypowc32+0xe97>
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r8,%rsi,4)
movups %xmm3,0x10(%r8,%rsi,4)
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
jmp    12cb <mypowc32+0x1ab>
xor    %esi,%esi
test   $0x1,%r9b
je     1ff9 <mypowc32+0xed9>
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r8,%rsi,4)
movups %xmm3,0x10(%r8,%rsi,4)
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
jmp    13a7 <mypowc32+0x287>
xor    %esi,%esi
test   $0x1,%r9b
je     2041 <mypowc32+0xf21>
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movaps %xmm0,%xmm2
mulps  %xmm0,%xmm2
movaps %xmm1,%xmm3
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
mulps  %xmm0,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,(%r8,%rsi,4)
movups %xmm3,0x10(%r8,%rsi,4)
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
jmp    144f <mypowc32+0x32f>
xor    %esi,%esi
test   $0x1,%r9b
je     207b <mypowc32+0xf5b>
movups (%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,(%r8,%rsi,4)
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
jmp    175f <mypowc32+0x63f>
xor    %esi,%esi
test   $0x1,%r9b
je     20b8 <mypowc32+0xf98>
movups (%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,(%r8,%rsi,4)
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
jmp    1847 <mypowc32+0x727>
xor    %esi,%esi
test   $0x1,%r9b
je     20f8 <mypowc32+0xfd8>
movups (%rdx,%rsi,4),%xmm0
movaps %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
mulps  %xmm0,%xmm1
movups %xmm1,(%r8,%rsi,4)
cmp    %rax,%rcx
je     213f <mypowc32+0x101f>
nopl   (%rax)
movss  (%rdx,%rcx,4),%xmm0
movaps %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r8,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    2100 <mypowc32+0xfe0>
pop    %rax
ret
lea    0xee4(%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 @mypowc32(i32 %0, i32 %1, float* %2, i32 %3, float* %4, i32 %5) {
%7 = alloca i32
%8 = alloca i32
%9 = alloca float*
%10 = alloca i32
%11 = alloca float*
%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 float* %2, float** %9
store i32 %3, i32* %10
store float* %4, float** %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 float*, float** %9
%36 = load i32, i32* %13
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds float, float* %35, i64 %37
%39 = load float, float* %38
%40 = load float*, float** %11
%41 = load i32, i32* %13
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %40, i64 %42
store float %39, float* %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 float*, float** %9
%55 = load i32, i32* %14
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds float, float* %54, i64 %56
%58 = load float, float* %57
%59 = load float*, float** %9
%60 = load i32, i32* %14
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
%63 = load float, float* %62
%64 = fmul float %58, %63
%65 = load float*, float** %11
%66 = load i32, i32* %14
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %65, i64 %67
store float %64, float* %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 float*, float** %9
%80 = load i32, i32* %15
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %79, i64 %81
%83 = load float, float* %82
%84 = load float*, float** %9
%85 = load i32, i32* %15
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds float, float* %84, i64 %86
%88 = load float, float* %87
%89 = fmul float %83, %88
%90 = load float*, float** %9
%91 = load i32, i32* %15
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float, float* %90, i64 %92
%94 = load float, float* %93
%95 = fmul float %89, %94
%96 = load float*, float** %11
%97 = load i32, i32* %15
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds float, float* %96, i64 %98
store float %95, float* %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 float*, float** %9
%111 = load i32, i32* %16
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds float, float* %110, i64 %112
%114 = load float, float* %113
%115 = load float*, float** %9
%116 = load i32, i32* %16
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %115, i64 %117
%119 = load float, float* %118
%120 = fmul float %114, %119
%121 = load float*, float** %9
%122 = load i32, i32* %16
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %121, i64 %123
%125 = load float, float* %124
%126 = fmul float %120, %125
%127 = load float*, float** %9
%128 = load i32, i32* %16
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds float, float* %127, i64 %129
%131 = load float, float* %130
%132 = fmul float %126, %131
%133 = load float*, float** %11
%134 = load i32, i32* %16
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %133, i64 %135
store float %132, float* %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 float*, float** %9
%148 = load i32, i32* %17
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float, float* %147, i64 %149
%151 = load float, float* %150
%152 = load float*, float** %9
%153 = load i32, i32* %17
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
%156 = load float, float* %155
%157 = fmul float %151, %156
%158 = load float*, float** %9
%159 = load i32, i32* %17
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds float, float* %158, i64 %160
%162 = load float, float* %161
%163 = fmul float %157, %162
%164 = load float*, float** %9
%165 = load i32, i32* %17
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %164, i64 %166
%168 = load float, float* %167
%169 = fmul float %163, %168
%170 = load float*, float** %9
%171 = load i32, i32* %17
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds float, float* %170, i64 %172
%174 = load float, float* %173
%175 = fmul float %169, %174
%176 = load float*, float** %11
%177 = load i32, i32* %17
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds float, float* %176, i64 %178
store float %175, float* %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 float*, float** %9
%191 = load i32, i32* %18
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds float, float* %190, i64 %192
%194 = load float, float* %193
%195 = load float*, float** %9
%196 = load i32, i32* %18
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %195, i64 %197
%199 = load float, float* %198
%200 = fmul float %194, %199
%201 = load float*, float** %9
%202 = load i32, i32* %18
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* %201, i64 %203
%205 = load float, float* %204
%206 = fmul float %200, %205
%207 = load float*, float** %9
%208 = load i32, i32* %18
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds float, float* %207, i64 %209
%211 = load float, float* %210
%212 = fmul float %206, %211
%213 = load float*, float** %9
%214 = load i32, i32* %18
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds float, float* %213, i64 %215
%217 = load float, float* %216
%218 = fmul float %212, %217
%219 = load float*, float** %9
%220 = load i32, i32* %18
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float, float* %219, i64 %221
%223 = load float, float* %222
%224 = fmul float %218, %223
%225 = load float*, float** %11
%226 = load i32, i32* %18
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float, float* %225, i64 %227
store float %224, float* %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 float*, float** %9
%240 = load i32, i32* %19
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds float, float* %239, i64 %241
%243 = load float, float* %242
%244 = load float*, float** %9
%245 = load i32, i32* %19
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds float, float* %244, i64 %246
%248 = load float, float* %247
%249 = fmul float %243, %248
%250 = load float*, float** %9
%251 = load i32, i32* %19
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds float, float* %250, i64 %252
%254 = load float, float* %253
%255 = fmul float %249, %254
%256 = load float*, float** %9
%257 = load i32, i32* %19
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds float, float* %256, i64 %258
%260 = load float, float* %259
%261 = fmul float %255, %260
%262 = load float*, float** %9
%263 = load i32, i32* %19
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds float, float* %262, i64 %264
%266 = load float, float* %265
%267 = fmul float %261, %266
%268 = load float*, float** %9
%269 = load i32, i32* %19
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds float, float* %268, i64 %270
%272 = load float, float* %271
%273 = fmul float %267, %272
%274 = load float*, float** %9
%275 = load i32, i32* %19
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds float, float* %274, i64 %276
%278 = load float, float* %277
%279 = fmul float %273, %278
%280 = load float*, float** %11
%281 = load i32, i32* %19
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds float, float* %280, i64 %282
store float %279, float* %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 float*, float** %9
%295 = load i32, i32* %20
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds float, float* %294, i64 %296
%298 = load float, float* %297
%299 = load float*, float** %9
%300 = load i32, i32* %20
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float, float* %299, i64 %301
%303 = load float, float* %302
%304 = fmul float %298, %303
%305 = load float*, float** %9
%306 = load i32, i32* %20
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds float, float* %305, i64 %307
%309 = load float, float* %308
%310 = fmul float %304, %309
%311 = load float*, float** %9
%312 = load i32, i32* %20
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds float, float* %311, i64 %313
%315 = load float, float* %314
%316 = fmul float %310, %315
%317 = load float*, float** %9
%318 = load i32, i32* %20
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds float, float* %317, i64 %319
%321 = load float, float* %320
%322 = fmul float %316, %321
%323 = load float*, float** %9
%324 = load i32, i32* %20
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds float, float* %323, i64 %325
%327 = load float, float* %326
%328 = fmul float %322, %327
%329 = load float*, float** %9
%330 = load i32, i32* %20
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds float, float* %329, i64 %331
%333 = load float, float* %332
%334 = fmul float %328, %333
%335 = load float*, float** %9
%336 = load i32, i32* %20
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float, float* %335, i64 %337
%339 = load float, float* %338
%340 = fmul float %334, %339
%341 = load float*, float** %11
%342 = load i32, i32* %20
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds float, float* %341, i64 %343
store float %340, float* %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 float*, float** %9
%356 = load i32, i32* %21
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds float, float* %355, i64 %357
%359 = load float, float* %358
%360 = load float*, float** %9
%361 = load i32, i32* %21
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds float, float* %360, i64 %362
%364 = load float, float* %363
%365 = fmul float %359, %364
%366 = load float*, float** %9
%367 = load i32, i32* %21
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds float, float* %366, i64 %368
%370 = load float, float* %369
%371 = fmul float %365, %370
%372 = load float*, float** %9
%373 = load i32, i32* %21
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds float, float* %372, i64 %374
%376 = load float, float* %375
%377 = fmul float %371, %376
%378 = load float*, float** %9
%379 = load i32, i32* %21
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds float, float* %378, i64 %380
%382 = load float, float* %381
%383 = fmul float %377, %382
%384 = load float*, float** %9
%385 = load i32, i32* %21
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds float, float* %384, i64 %386
%388 = load float, float* %387
%389 = fmul float %383, %388
%390 = load float*, float** %9
%391 = load i32, i32* %21
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds float, float* %390, i64 %392
%394 = load float, float* %393
%395 = fmul float %389, %394
%396 = load float*, float** %9
%397 = load i32, i32* %21
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds float, float* %396, i64 %398
%400 = load float, float* %399
%401 = fmul float %395, %400
%402 = load float*, float** %9
%403 = load i32, i32* %21
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds float, float* %402, i64 %404
%406 = load float, float* %405
%407 = fmul float %401, %406
%408 = load float*, float** %11
%409 = load i32, i32* %21
%410 = sext i32 %409 to i64
%411 = getelementptr inbounds float, float* %408, i64 %410
store float %407, float* %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 float*, float** %9
%423 = load i32, i32* %22
%424 = sext i32 %423 to i64
%425 = getelementptr inbounds float, float* %422, i64 %424
%426 = load float, float* %425
%427 = load float*, float** %9
%428 = load i32, i32* %22
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds float, float* %427, i64 %429
%431 = load float, float* %430
%432 = fmul float %426, %431
%433 = load float*, float** %9
%434 = load i32, i32* %22
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds float, float* %433, i64 %435
%437 = load float, float* %436
%438 = fmul float %432, %437
%439 = load float*, float** %9
%440 = load i32, i32* %22
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds float, float* %439, i64 %441
%443 = load float, float* %442
%444 = fmul float %438, %443
%445 = load float*, float** %9
%446 = load i32, i32* %22
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds float, float* %445, i64 %447
%449 = load float, float* %448
%450 = fmul float %444, %449
%451 = load float*, float** %9
%452 = load i32, i32* %22
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds float, float* %451, i64 %453
%455 = load float, float* %454
%456 = fmul float %450, %455
%457 = load float*, float** %9
%458 = load i32, i32* %22
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds float, float* %457, i64 %459
%461 = load float, float* %460
%462 = fmul float %456, %461
%463 = load float*, float** %9
%464 = load i32, i32* %22
%465 = sext i32 %464 to i64
%466 = getelementptr inbounds float, float* %463, i64 %465
%467 = load float, float* %466
%468 = fmul float %462, %467
%469 = load float*, float** %9
%470 = load i32, i32* %22
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds float, float* %469, i64 %471
%473 = load float, float* %472
%474 = fmul float %468, %473
%475 = load float*, float** %9
%476 = load i32, i32* %22
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds float, float* %475, i64 %477
%479 = load float, float* %478
%480 = fmul float %474, %479
%481 = load float*, float** %11
%482 = load i32, i32* %22
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds float, float* %481, i64 %483
store float %480, float* %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 float*, float** %9
%496 = load i32, i32* %23
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds float, float* %495, i64 %497
%499 = load float, float* %498
%500 = load float*, float** %9
%501 = load i32, i32* %23
%502 = sext i32 %501 to i64
%503 = getelementptr inbounds float, float* %500, i64 %502
%504 = load float, float* %503
%505 = fmul float %499, %504
%506 = load float*, float** %9
%507 = load i32, i32* %23
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds float, float* %506, i64 %508
%510 = load float, float* %509
%511 = fmul float %505, %510
%512 = load float*, float** %9
%513 = load i32, i32* %23
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds float, float* %512, i64 %514
%516 = load float, float* %515
%517 = fmul float %511, %516
%518 = load float*, float** %9
%519 = load i32, i32* %23
%520 = sext i32 %519 to i64
%521 = getelementptr inbounds float, float* %518, i64 %520
%522 = load float, float* %521
%523 = fmul float %517, %522
%524 = load float*, float** %9
%525 = load i32, i32* %23
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds float, float* %524, i64 %526
%528 = load float, float* %527
%529 = fmul float %523, %528
%530 = load float*, float** %9
%531 = load i32, i32* %23
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds float, float* %530, i64 %532
%534 = load float, float* %533
%535 = fmul float %529, %534
%536 = load float*, float** %9
%537 = load i32, i32* %23
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds float, float* %536, i64 %538
%540 = load float, float* %539
%541 = fmul float %535, %540
%542 = load float*, float** %9
%543 = load i32, i32* %23
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds float, float* %542, i64 %544
%546 = load float, float* %545
%547 = fmul float %541, %546
%548 = load float*, float** %9
%549 = load i32, i32* %23
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds float, float* %548, i64 %550
%552 = load float, float* %551
%553 = fmul float %547, %552
%554 = load float*, float** %9
%555 = load i32, i32* %23
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds float, float* %554, i64 %556
%558 = load float, float* %557
%559 = fmul float %553, %558
%560 = load float*, float** %11
%561 = load i32, i32* %23
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds float, float* %560, i64 %562
store float %559, float* %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 @mypowc32(i32 %0, i32 %1, float* nocapture %2, i32 %3, float* 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 ult i32 %0, 4
br i1 %11, label %85, label %12
12: ; preds = %9
%13 = getelementptr float, float* %4, i64 %10
%14 = getelementptr float, float* %2, i64 %10
%15 = icmp ugt float* %14, %4
%16 = icmp ugt float* %13, %2
%17 = and i1 %15, %16
br i1 %17, label %85, label %18
18: ; preds = %12
%19 = and i64 %10, 4294967292
%20 = add nsw i64 %19, -4
%21 = lshr exact i64 %20, 2
%22 = add nuw nsw 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, 9223372036854775806
br label %27
27: ; preds = %27, %25
%28 = phi i64 [ 0, %25 ], [ %61, %27 ]
%29 = phi i64 [ 0, %25 ], [ %62, %27 ]
%30 = getelementptr inbounds float, float* %2, i64 %28
%31 = bitcast float* %30 to <4 x float>*
%32 = load <4 x float>, <4 x float>* %31
%33 = fmul <4 x float> %32, %32
%34 = fmul <4 x float> %32, %33
%35 = fmul <4 x float> %32, %34
%36 = fmul <4 x float> %32, %35
%37 = fmul <4 x float> %32, %36
%38 = fmul <4 x float> %32, %37
%39 = fmul <4 x float> %32, %38
%40 = fmul <4 x float> %32, %39
%41 = fmul <4 x float> %32, %40
%42 = fmul <4 x float> %32, %41
%43 = getelementptr inbounds float, float* %4, i64 %28
%44 = bitcast float* %43 to <4 x float>*
store <4 x float> %42, <4 x float>* %44
%45 = or i64 %28, 4
%46 = getelementptr inbounds float, float* %2, i64 %45
%47 = bitcast float* %46 to <4 x float>*
%48 = load <4 x float>, <4 x float>* %47
%49 = fmul <4 x float> %48, %48
%50 = fmul <4 x float> %48, %49
%51 = fmul <4 x float> %48, %50
%52 = fmul <4 x float> %48, %51
%53 = fmul <4 x float> %48, %52
%54 = fmul <4 x float> %48, %53
%55 = fmul <4 x float> %48, %54
%56 = fmul <4 x float> %48, %55
%57 = fmul <4 x float> %48, %56
%58 = fmul <4 x float> %48, %57
%59 = getelementptr inbounds float, float* %4, i64 %45
%60 = bitcast float* %59 to <4 x float>*
store <4 x float> %58, <4 x float>* %60
%61 = add nuw i64 %28, 8
%62 = add 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 float, float* %2, i64 %65
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = fmul <4 x float> %70, %70
%72 = fmul <4 x float> %70, %71
%73 = fmul <4 x float> %70, %72
%74 = fmul <4 x float> %70, %73
%75 = fmul <4 x float> %70, %74
%76 = fmul <4 x float> %70, %75
%77 = fmul <4 x float> %70, %76
%78 = fmul <4 x float> %70, %77
%79 = fmul <4 x float> %70, %78
%80 = fmul <4 x float> %70, %79
%81 = getelementptr inbounds float, float* %4, i64 %65
%82 = bitcast float* %81 to <4 x float>*
store <4 x float> %80, <4 x float>* %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 ult i32 %0, 4
br i1 %91, label %162, label %92
92: ; preds = %89
%93 = getelementptr float, float* %4, i64 %90
%94 = getelementptr float, float* %2, i64 %90
%95 = icmp ugt float* %94, %4
%96 = icmp ugt float* %93, %2
%97 = and i1 %95, %96
br i1 %97, label %162, label %98
98: ; preds = %92
%99 = and i64 %90, 4294967292
%100 = add nsw i64 %99, -4
%101 = lshr exact i64 %100, 2
%102 = add nuw nsw 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, 9223372036854775806
br label %107
107: ; preds = %107, %105
%108 = phi i64 [ 0, %105 ], [ %139, %107 ]
%109 = phi i64 [ 0, %105 ], [ %140, %107 ]
%110 = getelementptr inbounds float, float* %2, i64 %108
%111 = bitcast float* %110 to <4 x float>*
%112 = load <4 x float>, <4 x float>* %111
%113 = fmul <4 x float> %112, %112
%114 = fmul <4 x float> %112, %113
%115 = fmul <4 x float> %112, %114
%116 = fmul <4 x float> %112, %115
%117 = fmul <4 x float> %112, %116
%118 = fmul <4 x float> %112, %117
%119 = fmul <4 x float> %112, %118
%120 = fmul <4 x float> %112, %119
%121 = fmul <4 x float> %112, %120
%122 = getelementptr inbounds float, float* %4, i64 %108
%123 = bitcast float* %122 to <4 x float>*
store <4 x float> %121, <4 x float>* %123
%124 = or i64 %108, 4
%125 = getelementptr inbounds float, float* %2, i64 %124
%126 = bitcast float* %125 to <4 x float>*
%127 = load <4 x float>, <4 x float>* %126
%128 = fmul <4 x float> %127, %127
%129 = fmul <4 x float> %127, %128
%130 = fmul <4 x float> %127, %129
%131 = fmul <4 x float> %127, %130
%132 = fmul <4 x float> %127, %131
%133 = fmul <4 x float> %127, %132
%134 = fmul <4 x float> %127, %133
%135 = fmul <4 x float> %127, %134
%136 = fmul <4 x float> %127, %135
%137 = getelementptr inbounds float, float* %4, i64 %124
%138 = bitcast float* %137 to <4 x float>*
store <4 x float> %136, <4 x float>* %138
%139 = add nuw i64 %108, 8
%140 = add 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 float, float* %2, i64 %143
%147 = bitcast float* %146 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = fmul <4 x float> %148, %148
%150 = fmul <4 x float> %148, %149
%151 = fmul <4 x float> %148, %150
%152 = fmul <4 x float> %148, %151
%153 = fmul <4 x float> %148, %152
%154 = fmul <4 x float> %148, %153
%155 = fmul <4 x float> %148, %154
%156 = fmul <4 x float> %148, %155
%157 = fmul <4 x float> %148, %156
%158 = getelementptr inbounds float, float* %4, i64 %143
%159 = bitcast float* %158 to <4 x float>*
store <4 x float> %157, <4 x float>* %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 float, float* %2, i64 %163
%169 = load float, float* %168
%170 = fmul float %169, %169
%171 = fmul float %169, %170
%172 = fmul float %169, %171
%173 = fmul float %169, %172
%174 = fmul float %169, %173
%175 = fmul float %169, %174
%176 = fmul float %169, %175
%177 = fmul float %169, %176
%178 = fmul float %169, %177
%179 = getelementptr inbounds float, float* %4, i64 %163
store float %178, float* %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 ult i32 %0, 4
br i1 %189, label %257, label %190
190: ; preds = %187
%191 = getelementptr float, float* %4, i64 %188
%192 = getelementptr float, float* %2, i64 %188
%193 = icmp ugt float* %192, %4
%194 = icmp ugt float* %191, %2
%195 = and i1 %193, %194
br i1 %195, label %257, label %196
196: ; preds = %190
%197 = and i64 %188, 4294967292
%198 = add nsw i64 %197, -4
%199 = lshr exact i64 %198, 2
%200 = add nuw nsw 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, 9223372036854775806
br label %205
205: ; preds = %205, %203
%206 = phi i64 [ 0, %203 ], [ %235, %205 ]
%207 = phi i64 [ 0, %203 ], [ %236, %205 ]
%208 = getelementptr inbounds float, float* %2, i64 %206
%209 = bitcast float* %208 to <4 x float>*
%210 = load <4 x float>, <4 x float>* %209
%211 = fmul <4 x float> %210, %210
%212 = fmul <4 x float> %210, %211
%213 = fmul <4 x float> %210, %212
%214 = fmul <4 x float> %210, %213
%215 = fmul <4 x float> %210, %214
%216 = fmul <4 x float> %210, %215
%217 = fmul <4 x float> %210, %216
%218 = fmul <4 x float> %210, %217
%219 = getelementptr inbounds float, float* %4, i64 %206
%220 = bitcast float* %219 to <4 x float>*
store <4 x float> %218, <4 x float>* %220
%221 = or i64 %206, 4
%222 = getelementptr inbounds float, float* %2, i64 %221
%223 = bitcast float* %222 to <4 x float>*
%224 = load <4 x float>, <4 x float>* %223
%225 = fmul <4 x float> %224, %224
%226 = fmul <4 x float> %224, %225
%227 = fmul <4 x float> %224, %226
%228 = fmul <4 x float> %224, %227
%229 = fmul <4 x float> %224, %228
%230 = fmul <4 x float> %224, %229
%231 = fmul <4 x float> %224, %230
%232 = fmul <4 x float> %224, %231
%233 = getelementptr inbounds float, float* %4, i64 %221
%234 = bitcast float* %233 to <4 x float>*
store <4 x float> %232, <4 x float>* %234
%235 = add nuw i64 %206, 8
%236 = add 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 float, float* %2, i64 %239
%243 = bitcast float* %242 to <4 x float>*
%244 = load <4 x float>, <4 x float>* %243
%245 = fmul <4 x float> %244, %244
%246 = fmul <4 x float> %244, %245
%247 = fmul <4 x float> %244, %246
%248 = fmul <4 x float> %244, %247
%249 = fmul <4 x float> %244, %248
%250 = fmul <4 x float> %244, %249
%251 = fmul <4 x float> %244, %250
%252 = fmul <4 x float> %244, %251
%253 = getelementptr inbounds float, float* %4, i64 %239
%254 = bitcast float* %253 to <4 x float>*
store <4 x float> %252, <4 x float>* %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 float, float* %2, i64 %258
%264 = load float, float* %263
%265 = fmul float %264, %264
%266 = fmul float %264, %265
%267 = fmul float %264, %266
%268 = fmul float %264, %267
%269 = fmul float %264, %268
%270 = fmul float %264, %269
%271 = fmul float %264, %270
%272 = fmul float %264, %271
%273 = getelementptr inbounds float, float* %4, i64 %258
store float %272, float* %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, 8
br i1 %283, label %322, label %284
284: ; preds = %281
%285 = getelementptr float, float* %4, i64 %282
%286 = getelementptr float, float* %2, i64 %282
%287 = icmp ugt float* %286, %4
%288 = icmp ugt float* %285, %2
%289 = and i1 %287, %288
br i1 %289, label %322, label %290
290: ; preds = %284
%291 = and i64 %282, 4294967288
br label %292
292: ; preds = %292, %290
%293 = phi i64 [ 0, %290 ], [ %318, %292 ]
%294 = getelementptr inbounds float, float* %2, i64 %293
%295 = bitcast float* %294 to <4 x float>*
%296 = load <4 x float>, <4 x float>* %295
%297 = getelementptr inbounds float, float* %294, i64 4
%298 = bitcast float* %297 to <4 x float>*
%299 = load <4 x float>, <4 x float>* %298
%300 = fmul <4 x float> %296, %296
%301 = fmul <4 x float> %299, %299
%302 = fmul <4 x float> %296, %300
%303 = fmul <4 x float> %299, %301
%304 = fmul <4 x float> %296, %302
%305 = fmul <4 x float> %299, %303
%306 = fmul <4 x float> %296, %304
%307 = fmul <4 x float> %299, %305
%308 = fmul <4 x float> %296, %306
%309 = fmul <4 x float> %299, %307
%310 = fmul <4 x float> %296, %308
%311 = fmul <4 x float> %299, %309
%312 = fmul <4 x float> %296, %310
%313 = fmul <4 x float> %299, %311
%314 = getelementptr inbounds float, float* %4, i64 %293
%315 = bitcast float* %314 to <4 x float>*
store <4 x float> %312, <4 x float>* %315
%316 = getelementptr inbounds float, float* %314, i64 4
%317 = bitcast float* %316 to <4 x float>*
store <4 x float> %313, <4 x float>* %317
%318 = add nuw i64 %293, 8
%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 float, float* %2, i64 %323
%329 = load float, float* %328
%330 = fmul float %329, %329
%331 = fmul float %329, %330
%332 = fmul float %329, %331
%333 = fmul float %329, %332
%334 = fmul float %329, %333
%335 = fmul float %329, %334
%336 = fmul float %329, %335
%337 = getelementptr inbounds float, float* %4, i64 %323
store float %336, float* %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, 8
br i1 %347, label %384, label %348
348: ; preds = %345
%349 = getelementptr float, float* %4, i64 %346
%350 = getelementptr float, float* %2, i64 %346
%351 = icmp ugt float* %350, %4
%352 = icmp ugt float* %349, %2
%353 = and i1 %351, %352
br i1 %353, label %384, label %354
354: ; preds = %348
%355 = and i64 %346, 4294967288
br label %356
356: ; preds = %356, %354
%357 = phi i64 [ 0, %354 ], [ %380, %356 ]
%358 = getelementptr inbounds float, float* %2, i64 %357
%359 = bitcast float* %358 to <4 x float>*
%360 = load <4 x float>, <4 x float>* %359
%361 = getelementptr inbounds float, float* %358, i64 4
%362 = bitcast float* %361 to <4 x float>*
%363 = load <4 x float>, <4 x float>* %362
%364 = fmul <4 x float> %360, %360
%365 = fmul <4 x float> %363, %363
%366 = fmul <4 x float> %360, %364
%367 = fmul <4 x float> %363, %365
%368 = fmul <4 x float> %360, %366
%369 = fmul <4 x float> %363, %367
%370 = fmul <4 x float> %360, %368
%371 = fmul <4 x float> %363, %369
%372 = fmul <4 x float> %360, %370
%373 = fmul <4 x float> %363, %371
%374 = fmul <4 x float> %360, %372
%375 = fmul <4 x float> %363, %373
%376 = getelementptr inbounds float, float* %4, i64 %357
%377 = bitcast float* %376 to <4 x float>*
store <4 x float> %374, <4 x float>* %377
%378 = getelementptr inbounds float, float* %376, i64 4
%379 = bitcast float* %378 to <4 x float>*
store <4 x float> %375, <4 x float>* %379
%380 = add nuw i64 %357, 8
%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 float, float* %2, i64 %385
%391 = load float, float* %390
%392 = fmul float %391, %391
%393 = fmul float %391, %392
%394 = fmul float %391, %393
%395 = fmul float %391, %394
%396 = fmul float %391, %395
%397 = fmul float %391, %396
%398 = getelementptr inbounds float, float* %4, i64 %385
store float %397, float* %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, 8
br i1 %408, label %443, label %409
409: ; preds = %406
%410 = getelementptr float, float* %4, i64 %407
%411 = getelementptr float, float* %2, i64 %407
%412 = icmp ugt float* %411, %4
%413 = icmp ugt float* %410, %2
%414 = and i1 %412, %413
br i1 %414, label %443, label %415
415: ; preds = %409
%416 = and i64 %407, 4294967288
br label %417
417: ; preds = %417, %415
%418 = phi i64 [ 0, %415 ], [ %439, %417 ]
%419 = getelementptr inbounds float, float* %2, i64 %418
%420 = bitcast float* %419 to <4 x float>*
%421 = load <4 x float>, <4 x float>* %420
%422 = getelementptr inbounds float, float* %419, i64 4
%423 = bitcast float* %422 to <4 x float>*
%424 = load <4 x float>, <4 x float>* %423
%425 = fmul <4 x float> %421, %421
%426 = fmul <4 x float> %424, %424
%427 = fmul <4 x float> %421, %425
%428 = fmul <4 x float> %424, %426
%429 = fmul <4 x float> %421, %427
%430 = fmul <4 x float> %424, %428
%431 = fmul <4 x float> %421, %429
%432 = fmul <4 x float> %424, %430
%433 = fmul <4 x float> %421, %431
%434 = fmul <4 x float> %424, %432
%435 = getelementptr inbounds float, float* %4, i64 %418
%436 = bitcast float* %435 to <4 x float>*
store <4 x float> %433, <4 x float>* %436
%437 = getelementptr inbounds float, float* %435, i64 4
%438 = bitcast float* %437 to <4 x float>*
store <4 x float> %434, <4 x float>* %438
%439 = add nuw i64 %418, 8
%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 float, float* %2, i64 %444
%450 = load float, float* %449
%451 = fmul float %450, %450
%452 = fmul float %450, %451
%453 = fmul float %450, %452
%454 = fmul float %450, %453
%455 = fmul float %450, %454
%456 = getelementptr inbounds float, float* %4, i64 %444
store float %455, float* %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, 8
br i1 %466, label %549, label %467
467: ; preds = %464
%468 = getelementptr float, float* %4, i64 %465
%469 = getelementptr float, float* %2, i64 %465
%470 = icmp ugt float* %469, %4
%471 = icmp ugt float* %468, %2
%472 = and i1 %470, %471
br i1 %472, label %549, label %473
473: ; preds = %467
%474 = and i64 %465, 4294967288
%475 = add nsw i64 %474, -8
%476 = lshr exact i64 %475, 3
%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, 4611686018427387902
br label %482
482: ; preds = %482, %480
%483 = phi i64 [ 0, %480 ], [ %522, %482 ]
%484 = phi i64 [ 0, %480 ], [ %523, %482 ]
%485 = getelementptr inbounds float, float* %2, i64 %483
%486 = bitcast float* %485 to <4 x float>*
%487 = load <4 x float>, <4 x float>* %486
%488 = getelementptr inbounds float, float* %485, i64 4
%489 = bitcast float* %488 to <4 x float>*
%490 = load <4 x float>, <4 x float>* %489
%491 = fmul <4 x float> %487, %487
%492 = fmul <4 x float> %490, %490
%493 = fmul <4 x float> %487, %491
%494 = fmul <4 x float> %490, %492
%495 = fmul <4 x float> %487, %493
%496 = fmul <4 x float> %490, %494
%497 = fmul <4 x float> %487, %495
%498 = fmul <4 x float> %490, %496
%499 = getelementptr inbounds float, float* %4, i64 %483
%500 = bitcast float* %499 to <4 x float>*
store <4 x float> %497, <4 x float>* %500
%501 = getelementptr inbounds float, float* %499, i64 4
%502 = bitcast float* %501 to <4 x float>*
store <4 x float> %498, <4 x float>* %502
%503 = or i64 %483, 8
%504 = getelementptr inbounds float, float* %2, i64 %503
%505 = bitcast float* %504 to <4 x float>*
%506 = load <4 x float>, <4 x float>* %505
%507 = getelementptr inbounds float, float* %504, i64 4
%508 = bitcast float* %507 to <4 x float>*
%509 = load <4 x float>, <4 x float>* %508
%510 = fmul <4 x float> %506, %506
%511 = fmul <4 x float> %509, %509
%512 = fmul <4 x float> %506, %510
%513 = fmul <4 x float> %509, %511
%514 = fmul <4 x float> %506, %512
%515 = fmul <4 x float> %509, %513
%516 = fmul <4 x float> %506, %514
%517 = fmul <4 x float> %509, %515
%518 = getelementptr inbounds float, float* %4, i64 %503
%519 = bitcast float* %518 to <4 x float>*
store <4 x float> %516, <4 x float>* %519
%520 = getelementptr inbounds float, float* %518, i64 4
%521 = bitcast float* %520 to <4 x float>*
store <4 x float> %517, <4 x float>* %521
%522 = add nuw i64 %483, 16
%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 float, float* %2, i64 %526
%530 = bitcast float* %529 to <4 x float>*
%531 = load <4 x float>, <4 x float>* %530
%532 = getelementptr inbounds float, float* %529, i64 4
%533 = bitcast float* %532 to <4 x float>*
%534 = load <4 x float>, <4 x float>* %533
%535 = fmul <4 x float> %531, %531
%536 = fmul <4 x float> %534, %534
%537 = fmul <4 x float> %531, %535
%538 = fmul <4 x float> %534, %536
%539 = fmul <4 x float> %531, %537
%540 = fmul <4 x float> %534, %538
%541 = fmul <4 x float> %531, %539
%542 = fmul <4 x float> %534, %540
%543 = getelementptr inbounds float, float* %4, i64 %526
%544 = bitcast float* %543 to <4 x float>*
store <4 x float> %541, <4 x float>* %544
%545 = getelementptr inbounds float, float* %543, i64 4
%546 = bitcast float* %545 to <4 x float>*
store <4 x float> %542, <4 x float>* %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 float, float* %2, i64 %550
%556 = load float, float* %555
%557 = fmul float %556, %556
%558 = fmul float %556, %557
%559 = fmul float %556, %558
%560 = fmul float %556, %559
%561 = getelementptr inbounds float, float* %4, i64 %550
store float %560, float* %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, 8
br i1 %571, label %648, label %572
572: ; preds = %569
%573 = getelementptr float, float* %4, i64 %570
%574 = getelementptr float, float* %2, i64 %570
%575 = icmp ugt float* %574, %4
%576 = icmp ugt float* %573, %2
%577 = and i1 %575, %576
br i1 %577, label %648, label %578
578: ; preds = %572
%579 = and i64 %570, 4294967288
%580 = add nsw i64 %579, -8
%581 = lshr exact i64 %580, 3
%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, 4611686018427387902
br label %587
587: ; preds = %587, %585
%588 = phi i64 [ 0, %585 ], [ %623, %587 ]
%589 = phi i64 [ 0, %585 ], [ %624, %587 ]
%590 = getelementptr inbounds float, float* %2, i64 %588
%591 = bitcast float* %590 to <4 x float>*
%592 = load <4 x float>, <4 x float>* %591
%593 = getelementptr inbounds float, float* %590, i64 4
%594 = bitcast float* %593 to <4 x float>*
%595 = load <4 x float>, <4 x float>* %594
%596 = fmul <4 x float> %592, %592
%597 = fmul <4 x float> %595, %595
%598 = fmul <4 x float> %592, %596
%599 = fmul <4 x float> %595, %597
%600 = fmul <4 x float> %592, %598
%601 = fmul <4 x float> %595, %599
%602 = getelementptr inbounds float, float* %4, i64 %588
%603 = bitcast float* %602 to <4 x float>*
store <4 x float> %600, <4 x float>* %603
%604 = getelementptr inbounds float, float* %602, i64 4
%605 = bitcast float* %604 to <4 x float>*
store <4 x float> %601, <4 x float>* %605
%606 = or i64 %588, 8
%607 = getelementptr inbounds float, float* %2, i64 %606
%608 = bitcast float* %607 to <4 x float>*
%609 = load <4 x float>, <4 x float>* %608
%610 = getelementptr inbounds float, float* %607, i64 4
%611 = bitcast float* %610 to <4 x float>*
%612 = load <4 x float>, <4 x float>* %611
%613 = fmul <4 x float> %609, %609
%614 = fmul <4 x float> %612, %612
%615 = fmul <4 x float> %609, %613
%616 = fmul <4 x float> %612, %614
%617 = fmul <4 x float> %609, %615
%618 = fmul <4 x float> %612, %616
%619 = getelementptr inbounds float, float* %4, i64 %606
%620 = bitcast float* %619 to <4 x float>*
store <4 x float> %617, <4 x float>* %620
%621 = getelementptr inbounds float, float* %619, i64 4
%622 = bitcast float* %621 to <4 x float>*
store <4 x float> %618, <4 x float>* %622
%623 = add nuw i64 %588, 16
%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 float, float* %2, i64 %627
%631 = bitcast float* %630 to <4 x float>*
%632 = load <4 x float>, <4 x float>* %631
%633 = getelementptr inbounds float, float* %630, i64 4
%634 = bitcast float* %633 to <4 x float>*
%635 = load <4 x float>, <4 x float>* %634
%636 = fmul <4 x float> %632, %632
%637 = fmul <4 x float> %635, %635
%638 = fmul <4 x float> %632, %636
%639 = fmul <4 x float> %635, %637
%640 = fmul <4 x float> %632, %638
%641 = fmul <4 x float> %635, %639
%642 = getelementptr inbounds float, float* %4, i64 %627
%643 = bitcast float* %642 to <4 x float>*
store <4 x float> %640, <4 x float>* %643
%644 = getelementptr inbounds float, float* %642, i64 4
%645 = bitcast float* %644 to <4 x float>*
store <4 x float> %641, <4 x float>* %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 float, float* %2, i64 %649
%655 = load float, float* %654
%656 = fmul float %655, %655
%657 = fmul float %655, %656
%658 = fmul float %655, %657
%659 = getelementptr inbounds float, float* %4, i64 %649
store float %658, float* %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, 8
br i1 %669, label %740, label %670
670: ; preds = %667
%671 = getelementptr float, float* %4, i64 %668
%672 = getelementptr float, float* %2, i64 %668
%673 = icmp ugt float* %672, %4
%674 = icmp ugt float* %671, %2
%675 = and i1 %673, %674
br i1 %675, label %740, label %676
676: ; preds = %670
%677 = and i64 %668, 4294967288
%678 = add nsw i64 %677, -8
%679 = lshr exact i64 %678, 3
%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, 4611686018427387902
br label %685
685: ; preds = %685, %683
%686 = phi i64 [ 0, %683 ], [ %717, %685 ]
%687 = phi i64 [ 0, %683 ], [ %718, %685 ]
%688 = getelementptr inbounds float, float* %2, i64 %686
%689 = bitcast float* %688 to <4 x float>*
%690 = load <4 x float>, <4 x float>* %689
%691 = getelementptr inbounds float, float* %688, i64 4
%692 = bitcast float* %691 to <4 x float>*
%693 = load <4 x float>, <4 x float>* %692
%694 = fmul <4 x float> %690, %690
%695 = fmul <4 x float> %693, %693
%696 = fmul <4 x float> %690, %694
%697 = fmul <4 x float> %693, %695
%698 = getelementptr inbounds float, float* %4, i64 %686
%699 = bitcast float* %698 to <4 x float>*
store <4 x float> %696, <4 x float>* %699
%700 = getelementptr inbounds float, float* %698, i64 4
%701 = bitcast float* %700 to <4 x float>*
store <4 x float> %697, <4 x float>* %701
%702 = or i64 %686, 8
%703 = getelementptr inbounds float, float* %2, i64 %702
%704 = bitcast float* %703 to <4 x float>*
%705 = load <4 x float>, <4 x float>* %704
%706 = getelementptr inbounds float, float* %703, i64 4
%707 = bitcast float* %706 to <4 x float>*
%708 = load <4 x float>, <4 x float>* %707
%709 = fmul <4 x float> %705, %705
%710 = fmul <4 x float> %708, %708
%711 = fmul <4 x float> %705, %709
%712 = fmul <4 x float> %708, %710
%713 = getelementptr inbounds float, float* %4, i64 %702
%714 = bitcast float* %713 to <4 x float>*
store <4 x float> %711, <4 x float>* %714
%715 = getelementptr inbounds float, float* %713, i64 4
%716 = bitcast float* %715 to <4 x float>*
store <4 x float> %712, <4 x float>* %716
%717 = add nuw i64 %686, 16
%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 float, float* %2, i64 %721
%725 = bitcast float* %724 to <4 x float>*
%726 = load <4 x float>, <4 x float>* %725
%727 = getelementptr inbounds float, float* %724, i64 4
%728 = bitcast float* %727 to <4 x float>*
%729 = load <4 x float>, <4 x float>* %728
%730 = fmul <4 x float> %726, %726
%731 = fmul <4 x float> %729, %729
%732 = fmul <4 x float> %726, %730
%733 = fmul <4 x float> %729, %731
%734 = getelementptr inbounds float, float* %4, i64 %721
%735 = bitcast float* %734 to <4 x float>*
store <4 x float> %732, <4 x float>* %735
%736 = getelementptr inbounds float, float* %734, i64 4
%737 = bitcast float* %736 to <4 x float>*
store <4 x float> %733, <4 x float>* %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 float, float* %2, i64 %747
%750 = load float, float* %749
%751 = fmul float %750, %750
%752 = fmul float %750, %751
%753 = getelementptr inbounds float, float* %4, i64 %747
store float %752, float* %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, 8
br i1 %764, label %829, label %765
765: ; preds = %762
%766 = getelementptr float, float* %4, i64 %763
%767 = getelementptr float, float* %2, i64 %763
%768 = icmp ugt float* %767, %4
%769 = icmp ugt float* %766, %2
%770 = and i1 %768, %769
br i1 %770, label %829, label %771
771: ; preds = %765
%772 = and i64 %763, 4294967288
%773 = add nsw i64 %772, -8
%774 = lshr exact i64 %773, 3
%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, 4611686018427387902
br label %780
780: ; preds = %780, %778
%781 = phi i64 [ 0, %778 ], [ %808, %780 ]
%782 = phi i64 [ 0, %778 ], [ %809, %780 ]
%783 = getelementptr inbounds float, float* %2, i64 %781
%784 = bitcast float* %783 to <4 x float>*
%785 = load <4 x float>, <4 x float>* %784
%786 = getelementptr inbounds float, float* %783, i64 4
%787 = bitcast float* %786 to <4 x float>*
%788 = load <4 x float>, <4 x float>* %787
%789 = fmul <4 x float> %785, %785
%790 = fmul <4 x float> %788, %788
%791 = getelementptr inbounds float, float* %4, i64 %781
%792 = bitcast float* %791 to <4 x float>*
store <4 x float> %789, <4 x float>* %792
%793 = getelementptr inbounds float, float* %791, i64 4
%794 = bitcast float* %793 to <4 x float>*
store <4 x float> %790, <4 x float>* %794
%795 = or i64 %781, 8
%796 = getelementptr inbounds float, float* %2, i64 %795
%797 = bitcast float* %796 to <4 x float>*
%798 = load <4 x float>, <4 x float>* %797
%799 = getelementptr inbounds float, float* %796, i64 4
%800 = bitcast float* %799 to <4 x float>*
%801 = load <4 x float>, <4 x float>* %800
%802 = fmul <4 x float> %798, %798
%803 = fmul <4 x float> %801, %801
%804 = getelementptr inbounds float, float* %4, i64 %795
%805 = bitcast float* %804 to <4 x float>*
store <4 x float> %802, <4 x float>* %805
%806 = getelementptr inbounds float, float* %804, i64 4
%807 = bitcast float* %806 to <4 x float>*
store <4 x float> %803, <4 x float>* %807
%808 = add nuw i64 %781, 16
%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 float, float* %2, i64 %812
%816 = bitcast float* %815 to <4 x float>*
%817 = load <4 x float>, <4 x float>* %816
%818 = getelementptr inbounds float, float* %815, i64 4
%819 = bitcast float* %818 to <4 x float>*
%820 = load <4 x float>, <4 x float>* %819
%821 = fmul <4 x float> %817, %817
%822 = fmul <4 x float> %820, %820
%823 = getelementptr inbounds float, float* %4, i64 %812
%824 = bitcast float* %823 to <4 x float>*
store <4 x float> %821, <4 x float>* %824
%825 = getelementptr inbounds float, float* %823, i64 4
%826 = bitcast float* %825 to <4 x float>*
store <4 x float> %822, <4 x float>* %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 float, float* %2, i64 %836
%839 = load float, float* %838
%840 = fmul float %839, %839
%841 = getelementptr inbounds float, float* %4, i64 %836
store float %840, float* %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, 8
br i1 %852, label %938, label %853
853: ; preds = %850
%854 = getelementptr float, float* %4, i64 %851
%855 = getelementptr float, float* %2, i64 %851
%856 = icmp ugt float* %855, %4
%857 = icmp ugt float* %854, %2
%858 = and i1 %856, %857
br i1 %858, label %938, label %859
859: ; preds = %853
%860 = and i64 %851, 4294967288
%861 = add nsw i64 %860, -8
%862 = lshr exact i64 %861, 3
%863 = add nuw nsw i64 %862, 1
%864 = and i64 %863, 3
%865 = icmp ult i64 %861, 24
br i1 %865, label %917, label %866
866: ; preds = %859
%867 = and i64 %863, 4611686018427387900
br label %868
868: ; preds = %868, %866
%869 = phi i64 [ 0, %866 ], [ %914, %868 ]
%870 = phi i64 [ 0, %866 ], [ %915, %868 ]
%871 = getelementptr inbounds float, float* %2, i64 %869
%872 = bitcast float* %871 to <4 x float>*
%873 = load <4 x float>, <4 x float>* %872
%874 = getelementptr inbounds float, float* %871, i64 4
%875 = bitcast float* %874 to <4 x float>*
%876 = load <4 x float>, <4 x float>* %875
%877 = getelementptr inbounds float, float* %4, i64 %869
%878 = bitcast float* %877 to <4 x float>*
store <4 x float> %873, <4 x float>* %878
%879 = getelementptr inbounds float, float* %877, i64 4
%880 = bitcast float* %879 to <4 x float>*
store <4 x float> %876, <4 x float>* %880
%881 = or i64 %869, 8
%882 = getelementptr inbounds float, float* %2, i64 %881
%883 = bitcast float* %882 to <4 x float>*
%884 = load <4 x float>, <4 x float>* %883
%885 = getelementptr inbounds float, float* %882, i64 4
%886 = bitcast float* %885 to <4 x float>*
%887 = load <4 x float>, <4 x float>* %886
%888 = getelementptr inbounds float, float* %4, i64 %881
%889 = bitcast float* %888 to <4 x float>*
store <4 x float> %884, <4 x float>* %889
%890 = getelementptr inbounds float, float* %888, i64 4
%891 = bitcast float* %890 to <4 x float>*
store <4 x float> %887, <4 x float>* %891
%892 = or i64 %869, 16
%893 = getelementptr inbounds float, float* %2, i64 %892
%894 = bitcast float* %893 to <4 x float>*
%895 = load <4 x float>, <4 x float>* %894
%896 = getelementptr inbounds float, float* %893, i64 4
%897 = bitcast float* %896 to <4 x float>*
%898 = load <4 x float>, <4 x float>* %897
%899 = getelementptr inbounds float, float* %4, i64 %892
%900 = bitcast float* %899 to <4 x float>*
store <4 x float> %895, <4 x float>* %900
%901 = getelementptr inbounds float, float* %899, i64 4
%902 = bitcast float* %901 to <4 x float>*
store <4 x float> %898, <4 x float>* %902
%903 = or i64 %869, 24
%904 = getelementptr inbounds float, float* %2, i64 %903
%905 = bitcast float* %904 to <4 x float>*
%906 = load <4 x float>, <4 x float>* %905
%907 = getelementptr inbounds float, float* %904, i64 4
%908 = bitcast float* %907 to <4 x float>*
%909 = load <4 x float>, <4 x float>* %908
%910 = getelementptr inbounds float, float* %4, i64 %903
%911 = bitcast float* %910 to <4 x float>*
store <4 x float> %906, <4 x float>* %911
%912 = getelementptr inbounds float, float* %910, i64 4
%913 = bitcast float* %912 to <4 x float>*
store <4 x float> %909, <4 x float>* %913
%914 = add nuw i64 %869, 32
%915 = add 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 float, float* %2, i64 %921
%924 = bitcast float* %923 to <4 x float>*
%925 = load <4 x float>, <4 x float>* %924
%926 = getelementptr inbounds float, float* %923, i64 4
%927 = bitcast float* %926 to <4 x float>*
%928 = load <4 x float>, <4 x float>* %927
%929 = getelementptr inbounds float, float* %4, i64 %921
%930 = bitcast float* %929 to <4 x float>*
store <4 x float> %925, <4 x float>* %930
%931 = getelementptr inbounds float, float* %929, i64 4
%932 = bitcast float* %931 to <4 x float>*
store <4 x float> %928, <4 x float>* %932
%933 = add nuw i64 %921, 8
%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 float, float* %2, i64 %945
%948 = load float, float* %947
%949 = getelementptr inbounds float, float* %4, i64 %945
store float %948, float* %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 float, float* %2, i64 %957
%959 = load float, float* %958
%960 = getelementptr inbounds float, float* %4, i64 %957
store float %959, float* %960
%961 = add nuw nsw i64 %957, 1
%962 = getelementptr inbounds float, float* %2, i64 %961
%963 = load float, float* %962
%964 = getelementptr inbounds float, float* %4, i64 %961
store float %963, float* %964
%965 = add nuw nsw i64 %957, 2
%966 = getelementptr inbounds float, float* %2, i64 %965
%967 = load float, float* %966
%968 = getelementptr inbounds float, float* %4, i64 %965
store float %967, float* %968
%969 = add nuw nsw i64 %957, 3
%970 = getelementptr inbounds float, float* %2, i64 %969
%971 = load float, float* %970
%972 = getelementptr inbounds float, float* %4, i64 %969
store float %971, float* %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 float, float* %2, i64 %976
%978 = load float, float* %977
%979 = fmul float %978, %978
%980 = getelementptr inbounds float, float* %4, i64 %976
store float %979, float* %980
%981 = add nuw nsw i64 %976, 1
%982 = getelementptr inbounds float, float* %2, i64 %981
%983 = load float, float* %982
%984 = fmul float %983, %983
%985 = getelementptr inbounds float, float* %4, i64 %981
store float %984, float* %985
%986 = add nuw nsw i64 %976, 2
%987 = getelementptr inbounds float, float* %2, i64 %986
%988 = load float, float* %987
%989 = fmul float %988, %988
%990 = getelementptr inbounds float, float* %4, i64 %986
store float %989, float* %990
%991 = add nuw nsw i64 %976, 3
%992 = getelementptr inbounds float, float* %2, i64 %991
%993 = load float, float* %992
%994 = fmul float %993, %993
%995 = getelementptr inbounds float, float* %4, i64 %991
store float %994, float* %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 float, float* %2, i64 %999
%1001 = load float, float* %1000
%1002 = fmul float %1001, %1001
%1003 = fmul float %1001, %1002
%1004 = getelementptr inbounds float, float* %4, i64 %999
store float %1003, float* %1004
%1005 = add nuw nsw i64 %999, 1
%1006 = getelementptr inbounds float, float* %2, i64 %1005
%1007 = load float, float* %1006
%1008 = fmul float %1007, %1007
%1009 = fmul float %1007, %1008
%1010 = getelementptr inbounds float, float* %4, i64 %1005
store float %1009, float* %1010
%1011 = add nuw nsw i64 %999, 2
%1012 = getelementptr inbounds float, float* %2, i64 %1011
%1013 = load float, float* %1012
%1014 = fmul float %1013, %1013
%1015 = fmul float %1013, %1014
%1016 = getelementptr inbounds float, float* %4, i64 %1011
store float %1015, float* %1016
%1017 = add nuw nsw i64 %999, 3
%1018 = getelementptr inbounds float, float* %2, i64 %1017
%1019 = load float, float* %1018
%1020 = fmul float %1019, %1019
%1021 = fmul float %1019, %1020
%1022 = getelementptr inbounds float, float* %4, i64 %1017
store float %1021, float* %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 float, float* %2, i64 %1026
%1028 = load float, float* %1027
%1029 = fmul float %1028, %1028
%1030 = fmul float %1028, %1029
%1031 = fmul float %1028, %1030
%1032 = getelementptr inbounds float, float* %4, i64 %1026
store float %1031, float* %1032
%1033 = add nuw nsw i64 %1026, 1
%1034 = getelementptr inbounds float, float* %2, i64 %1033
%1035 = load float, float* %1034
%1036 = fmul float %1035, %1035
%1037 = fmul float %1035, %1036
%1038 = fmul float %1035, %1037
%1039 = getelementptr inbounds float, float* %4, i64 %1033
store float %1038, float* %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 float, float* %2, i64 %1043
%1045 = load float, float* %1044
%1046 = fmul float %1045, %1045
%1047 = fmul float %1045, %1046
%1048 = fmul float %1045, %1047
%1049 = fmul float %1045, %1048
%1050 = getelementptr inbounds float, float* %4, i64 %1043
store float %1049, float* %1050
%1051 = add nuw nsw i64 %1043, 1
%1052 = getelementptr inbounds float, float* %2, i64 %1051
%1053 = load float, float* %1052
%1054 = fmul float %1053, %1053
%1055 = fmul float %1053, %1054
%1056 = fmul float %1053, %1055
%1057 = fmul float %1053, %1056
%1058 = getelementptr inbounds float, float* %4, i64 %1051
store float %1057, float* %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 float, float* %2, i64 %1062
%1064 = load float, float* %1063
%1065 = fmul float %1064, %1064
%1066 = fmul float %1064, %1065
%1067 = fmul float %1064, %1066
%1068 = fmul float %1064, %1067
%1069 = fmul float %1064, %1068
%1070 = getelementptr inbounds float, float* %4, i64 %1062
store float %1069, float* %1070
%1071 = add nuw nsw i64 %1062, 1
%1072 = getelementptr inbounds float, float* %2, i64 %1071
%1073 = load float, float* %1072
%1074 = fmul float %1073, %1073
%1075 = fmul float %1073, %1074
%1076 = fmul float %1073, %1075
%1077 = fmul float %1073, %1076
%1078 = fmul float %1073, %1077
%1079 = getelementptr inbounds float, float* %4, i64 %1071
store float %1078, float* %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 float, float* %2, i64 %1083
%1085 = load float, float* %1084
%1086 = fmul float %1085, %1085
%1087 = fmul float %1085, %1086
%1088 = fmul float %1085, %1087
%1089 = fmul float %1085, %1088
%1090 = fmul float %1085, %1089
%1091 = fmul float %1085, %1090
%1092 = getelementptr inbounds float, float* %4, i64 %1083
store float %1091, float* %1092
%1093 = add nuw nsw i64 %1083, 1
%1094 = getelementptr inbounds float, float* %2, i64 %1093
%1095 = load float, float* %1094
%1096 = fmul float %1095, %1095
%1097 = fmul float %1095, %1096
%1098 = fmul float %1095, %1097
%1099 = fmul float %1095, %1098
%1100 = fmul float %1095, %1099
%1101 = fmul float %1095, %1100
%1102 = getelementptr inbounds float, float* %4, i64 %1093
store float %1101, float* %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 float, float* %2, i64 %1106
%1108 = load float, float* %1107
%1109 = fmul float %1108, %1108
%1110 = fmul float %1108, %1109
%1111 = fmul float %1108, %1110
%1112 = fmul float %1108, %1111
%1113 = fmul float %1108, %1112
%1114 = fmul float %1108, %1113
%1115 = fmul float %1108, %1114
%1116 = getelementptr inbounds float, float* %4, i64 %1106
store float %1115, float* %1116
%1117 = add nuw nsw i64 %1106, 1
%1118 = getelementptr inbounds float, float* %2, i64 %1117
%1119 = load float, float* %1118
%1120 = fmul float %1119, %1119
%1121 = fmul float %1119, %1120
%1122 = fmul float %1119, %1121
%1123 = fmul float %1119, %1122
%1124 = fmul float %1119, %1123
%1125 = fmul float %1119, %1124
%1126 = fmul float %1119, %1125
%1127 = getelementptr inbounds float, float* %4, i64 %1117
store float %1126, float* %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 float, float* %2, i64 %1131
%1133 = load float, float* %1132
%1134 = fmul float %1133, %1133
%1135 = fmul float %1133, %1134
%1136 = fmul float %1133, %1135
%1137 = fmul float %1133, %1136
%1138 = fmul float %1133, %1137
%1139 = fmul float %1133, %1138
%1140 = fmul float %1133, %1139
%1141 = fmul float %1133, %1140
%1142 = getelementptr inbounds float, float* %4, i64 %1131
store float %1141, float* %1142
%1143 = add nuw nsw i64 %1131, 1
%1144 = getelementptr inbounds float, float* %2, i64 %1143
%1145 = load float, float* %1144
%1146 = fmul float %1145, %1145
%1147 = fmul float %1145, %1146
%1148 = fmul float %1145, %1147
%1149 = fmul float %1145, %1148
%1150 = fmul float %1145, %1149
%1151 = fmul float %1145, %1150
%1152 = fmul float %1145, %1151
%1153 = fmul float %1145, %1152
%1154 = getelementptr inbounds float, float* %4, i64 %1143
store float %1153, float* %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 float, float* %2, i64 %1158
%1160 = load float, float* %1159
%1161 = fmul float %1160, %1160
%1162 = fmul float %1160, %1161
%1163 = fmul float %1160, %1162
%1164 = fmul float %1160, %1163
%1165 = fmul float %1160, %1164
%1166 = fmul float %1160, %1165
%1167 = fmul float %1160, %1166
%1168 = fmul float %1160, %1167
%1169 = fmul float %1160, %1168
%1170 = getelementptr inbounds float, float* %4, i64 %1158
store float %1169, float* %1170
%1171 = add nuw nsw i64 %1158, 1
%1172 = getelementptr inbounds float, float* %2, i64 %1171
%1173 = load float, float* %1172
%1174 = fmul float %1173, %1173
%1175 = fmul float %1173, %1174
%1176 = fmul float %1173, %1175
%1177 = fmul float %1173, %1176
%1178 = fmul float %1173, %1177
%1179 = fmul float %1173, %1178
%1180 = fmul float %1173, %1179
%1181 = fmul float %1173, %1180
%1182 = fmul float %1173, %1181
%1183 = getelementptr inbounds float, float* %4, i64 %1171
store float %1182, float* %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 float, float* %2, i64 %1187
%1189 = load float, float* %1188
%1190 = fmul float %1189, %1189
%1191 = fmul float %1189, %1190
%1192 = fmul float %1189, %1191
%1193 = fmul float %1189, %1192
%1194 = fmul float %1189, %1193
%1195 = fmul float %1189, %1194
%1196 = fmul float %1189, %1195
%1197 = fmul float %1189, %1196
%1198 = fmul float %1189, %1197
%1199 = fmul float %1189, %1198
%1200 = getelementptr inbounds float, float* %4, i64 %1187
store float %1199, float* %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
}