#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*/ free(double *);
int /*<<< orphan*/ mMultiply(double *, double *, double *, int);
scalar_t__ malloc(int);
int /*<<< orphan*/ renormalize(double *, int, int *);
void mPower(double *A, int eA, double *V, int *eV, int m, int n) {
  double *B;
  int eB, i;
  if (n == 1) {
    for (i = 0; i < m * m; i++)
      V[i] = A[i];
    *eV = eA;
    return;
  }
  mPower(A, eA, V, eV, m, n / 2);
  B = (double *)malloc((m * m) * sizeof(double));
  mMultiply(V, V, B, m);
  eB = 2 * (*eV);
  if (B[(m / 2) * m + (m / 2)] > 1.0e140)
    renormalize(B, m, &eB);
  if (n % 2 == 0) {
    for (i = 0; i < m * m; i++)
      V[i] = B[i];
    *eV = eB;
  } else {
    mMultiply(A, B, V, m);
    *eV = eA + eB;
  }
  if (V[(m / 2) * m + (m / 2)] > 1.0e140)
    renormalize(V, m, eV);
  free(B);
}


x86 assembly (clang, -O0):
<mPower>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jne    11c8 <mPower+0x78>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    11ba <mPower+0x6a>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1180 <mPower+0x30>
mov    -0xc(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1368 <mPower+0x218>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%r8d
mov    -0x28(%rbp),%eax
mov    $0x2,%r9d
cltd
idiv   %r9d
mov    -0x48(%rbp),%rdx
mov    %eax,%r9d
call   1060 <mPower@plt>
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1040 <mMultiply@plt>
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
imul   -0x24(%rbp),%ecx
mov    -0x24(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x40(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd94(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1286 <mPower+0x136>
mov    -0x30(%rbp),%rdi
mov    -0x24(%rbp),%esi
lea    -0x34(%rbp),%rdx
call   1070 <renormalize@plt>
mov    -0x28(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    12e9 <mPower+0x199>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x24(%rbp),%ecx
cmp    %ecx,%eax
jge    12db <mPower+0x18b>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12a1 <mPower+0x151>
mov    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1309 <mPower+0x1b9>
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1040 <mMultiply@plt>
mov    -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
imul   -0x24(%rbp),%ecx
mov    -0x24(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x50(%rbp),%rax
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xcbb(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    135f <mPower+0x20f>
mov    -0x18(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x20(%rbp),%rdx
call   1070 <renormalize@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mPower>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8d,%r12d
mov    %rcx,%r15
mov    %rdx,%rbx
mov    %rdi,%rbp
cmp    $0x1,%r9d
jne    121d <mPower+0xcd>
imul   %r12d,%r12d
test   %r12d,%r12d
je     1496 <mPower+0x346>
mov    %r12d,%r9d
cmp    $0x4,%r12d
jb     11ab <mPower+0x5b>
lea    0x0(,%r9,8),%rcx
add    %rbp,%rcx
cmp    %rbx,%rcx
jbe    1394 <mPower+0x244>
lea    (%rbx,%r9,8),%rcx
cmp    %rbp,%rcx
jbe    1394 <mPower+0x244>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r9,%rdx
mov    %r9,%rdi
and    $0x3,%rdi
je     11d5 <mPower+0x85>
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    11c0 <mPower+0x70>
cmp    $0x3,%rdx
jb     1496 <mPower+0x346>
nop
movsd  0x0(%rbp,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%rbp,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    11e0 <mPower+0x90>
jmp    1496 <mPower+0x346>
mov    %r9d,%r14d
shr    $0x1f,%r9d
add    %r14d,%r9d
sar    %r9d
mov    %rbp,%rdi
mov    %esi,0x14(%rsp)
mov    %rbx,%rdx
mov    %r15,%rcx
mov    %r12d,%r8d
call   1060 <mPower@plt>
mov    %r15,0x18(%rsp)
mov    %r12d,%r15d
imul   %r12d,%r12d
lea    0x0(,%r12,8),%edi
call   1050 <malloc@plt>
mov    %rax,%r13
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    %rax,%rdx
mov    %r15d,%ecx
call   1040 <mMultiply@plt>
mov    0x18(%rsp),%rax
mov    (%rax),%eax
add    %eax,%eax
mov    %eax,0x10(%rsp)
mov    %r15d,%eax
shr    $0x1f,%eax
add    %r15d,%eax
sar    %eax
mov    %eax,%ecx
mov    %r15d,0xc(%rsp)
imul   %r15d,%ecx
add    %eax,%ecx
movslq %ecx,%rax
mov    %rax,0x20(%rsp)
movsd  0x0(%r13,%rax,8),%xmm0
ucomisd 0xd58(%rip),%xmm0
jbe    12bb <mPower+0x16b>
lea    0x10(%rsp),%rdx
mov    %r13,%rdi
mov    0xc(%rsp),%esi
call   1070 <renormalize@plt>
test   $0x1,%r14b
jne    1371 <mPower+0x221>
test   %r12d,%r12d
je     1566 <mPower+0x416>
mov    %r12d,%eax
cmp    $0x4,%r12d
jb     12f8 <mPower+0x1a8>
lea    0x0(,%rax,8),%rcx
add    %r13,%rcx
cmp    %rbx,%rcx
jbe    13bd <mPower+0x26d>
lea    (%rbx,%rax,8),%rcx
cmp    %rcx,%r13
jae    13bd <mPower+0x26d>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     1326 <mPower+0x1d6>
nopl   0x0(%rax)
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1310 <mPower+0x1c0>
cmp    $0x3,%rdx
jb     1566 <mPower+0x416>
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
movsd  0x8(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rcx,8)
movsd  0x10(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rcx,8)
movsd  0x18(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1330 <mPower+0x1e0>
jmp    1566 <mPower+0x416>
mov    %rbp,%rdi
mov    %r13,%rsi
mov    %rbx,%rdx
mov    0xc(%rsp),%r15d
mov    %r15d,%ecx
call   1040 <mMultiply@plt>
mov    0x14(%rsp),%eax
add    0x10(%rsp),%eax
jmp    156f <mPower+0x41f>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0xc,%rdi
jae    13ea <mPower+0x29a>
xor    %edi,%edi
jmp    144b <mPower+0x2fb>
mov    %eax,%ecx
and    $0x7ffffffc,%ecx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    149e <mPower+0x34e>
xor    %edi,%edi
jmp    1513 <mPower+0x3c3>
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
movups 0x0(%rbp,%rdi,8),%xmm0
movups 0x10(%rbp,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%rbp,%rdi,8),%xmm0
movups 0x30(%rbp,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%rbp,%rdi,8),%xmm0
movups 0x50(%rbp,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%rbp,%rdi,8),%xmm0
movups 0x70(%rbp,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movups %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rdx
jne    13f0 <mPower+0x2a0>
test   %r8,%r8
je     148d <mPower+0x33d>
lea    (%rbx,%rdi,8),%rax
add    $0x10,%rax
lea    0x10(,%rdi,8),%rdi
add    %rbp,%rdi
shl    $0x5,%r8
xor    %edx,%edx
nopl   0x0(%rax)
movupd -0x10(%rdi,%rdx,1),%xmm0
movups (%rdi,%rdx,1),%xmm1
movupd %xmm0,-0x10(%rax,%rdx,1)
movups %xmm1,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1470 <mPower+0x320>
cmp    %r9,%rcx
jne    11ad <mPower+0x5d>
mov    %esi,(%r15)
jmp    159d <mPower+0x44d>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x0(%r13,%rdi,8),%xmm0
movups 0x10(%r13,%rdi,8),%xmm1
movups %xmm0,(%rbx,%rdi,8)
movups %xmm1,0x10(%rbx,%rdi,8)
movups 0x20(%r13,%rdi,8),%xmm0
movups 0x30(%r13,%rdi,8),%xmm1
movups %xmm0,0x20(%rbx,%rdi,8)
movups %xmm1,0x30(%rbx,%rdi,8)
movups 0x40(%r13,%rdi,8),%xmm0
movups 0x50(%r13,%rdi,8),%xmm1
movups %xmm0,0x40(%rbx,%rdi,8)
movups %xmm1,0x50(%rbx,%rdi,8)
movupd 0x60(%r13,%rdi,8),%xmm0
movups 0x70(%r13,%rdi,8),%xmm1
movupd %xmm0,0x60(%rbx,%rdi,8)
movups %xmm1,0x70(%rbx,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    14b0 <mPower+0x360>
test   %rdx,%rdx
je     155d <mPower+0x40d>
lea    (%rbx,%rdi,8),%rsi
add    $0x10,%rsi
lea    0x10(,%rdi,8),%rdi
add    %r13,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1540 <mPower+0x3f0>
cmp    %rax,%rcx
jne    12fa <mPower+0x1aa>
mov    0x10(%rsp),%eax
mov    0xc(%rsp),%r15d
mov    0x18(%rsp),%rdx
mov    %eax,(%rdx)
mov    0x20(%rsp),%rax
movsd  (%rbx,%rax,8),%xmm0
ucomisd 0xa78(%rip),%xmm0
jbe    1595 <mPower+0x445>
mov    %rbx,%rdi
mov    %r15d,%esi
call   1070 <renormalize@plt>
mov    %r13,%rdi
call   1030 <free@plt>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @mPower(double* %0, i32 %1, double* %2, i32* %3, i32 %4, i32 %5) {
%7 = alloca double*
%8 = alloca i32
%9 = alloca double*
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca double*
%14 = alloca i32
%15 = alloca i32
store double* %0, double** %7
store i32 %1, i32* %8
store double* %2, double** %9
store i32* %3, i32** %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%16 = load i32, i32* %12
%17 = icmp eq i32 %16, 1
br i1 %17, label %18, label %41
18: ; preds = %6
store i32 0, i32* %15
br label %19
19: ; preds = %35, %18
%20 = load i32, i32* %15
%21 = load i32, i32* %11
%22 = load i32, i32* %11
%23 = mul nsw i32 %21, %22
%24 = icmp slt i32 %20, %23
br i1 %24, label %25, label %38
25: ; preds = %19
%26 = load double*, double** %7
%27 = load i32, i32* %15
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds double, double* %26, i64 %28
%30 = load double, double* %29
%31 = load double*, double** %9
%32 = load i32, i32* %15
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds double, double* %31, i64 %33
store double %30, double* %34
br label %35
35: ; preds = %25
%36 = load i32, i32* %15
%37 = add nsw i32 %36, 1
store i32 %37, i32* %15
br label %19
38: ; preds = %19
%39 = load i32, i32* %8
%40 = load i32*, i32** %10
store i32 %39, i32* %40
br label %139
41: ; preds = %6
%42 = load double*, double** %7
%43 = load i32, i32* %8
%44 = load double*, double** %9
%45 = load i32*, i32** %10
%46 = load i32, i32* %11
%47 = load i32, i32* %12
%48 = sdiv i32 %47, 2
%49 = load i32, i32* %11
%50 = load i32, i32* %11
%51 = mul nsw i32 %49, %50
%52 = sext i32 %51 to i64
%53 = mul i64 %52, 8
%54 = trunc i64 %53 to i32
%55 = call i64 @malloc(i32 %54)
%56 = inttoptr i64 %55 to double*
store double* %56, double** %13
%57 = load double*, double** %9
%58 = load double*, double** %9
%59 = load double*, double** %13
%60 = load i32, i32* %11
%61 = call i32 @mMultiply(double* %57, double* %58, double* %59, i32 %60)
%62 = load i32*, i32** %10
%63 = load i32, i32* %62
%64 = mul nsw i32 2, %63
store i32 %64, i32* %14
%65 = load double*, double** %13
%66 = load i32, i32* %11
%67 = sdiv i32 %66, 2
%68 = load i32, i32* %11
%69 = mul nsw i32 %67, %68
%70 = load i32, i32* %11
%71 = sdiv i32 %70, 2
%72 = add nsw i32 %69, %71
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds double, double* %65, i64 %73
%75 = load double, double* %74
%76 = fcmp ogt double %75, 1.000000e+140
br i1 %76, label %77, label %81
77: ; preds = %41
%78 = load double*, double** %13
%79 = load i32, i32* %11
%80 = call i32 @renormalize(double* %78, i32 %79, i32* %14)
br label %81
81: ; preds = %77, %41
%82 = load i32, i32* %12
%83 = srem i32 %82, 2
%84 = icmp eq i32 %83, 0
br i1 %84, label %85, label %108
85: ; preds = %81
store i32 0, i32* %15
br label %86
86: ; preds = %102, %85
%87 = load i32, i32* %15
%88 = load i32, i32* %11
%89 = load i32, i32* %11
%90 = mul nsw i32 %88, %89
%91 = icmp slt i32 %87, %90
br i1 %91, label %92, label %105
92: ; preds = %86
%93 = load double*, double** %13
%94 = load i32, i32* %15
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds double, double* %93, i64 %95
%97 = load double, double* %96
%98 = load double*, double** %9
%99 = load i32, i32* %15
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %98, i64 %100
store double %97, double* %101
br label %102
102: ; preds = %92
%103 = load i32, i32* %15
%104 = add nsw i32 %103, 1
store i32 %104, i32* %15
br label %86
105: ; preds = %86
%106 = load i32, i32* %14
%107 = load i32*, i32** %10
store i32 %106, i32* %107
br label %118
108: ; preds = %81
%109 = load double*, double** %7
%110 = load double*, double** %13
%111 = load double*, double** %9
%112 = load i32, i32* %11
%113 = call i32 @mMultiply(double* %109, double* %110, double* %111, i32 %112)
%114 = load i32, i32* %8
%115 = load i32, i32* %14
%116 = add nsw i32 %114, %115
%117 = load i32*, i32** %10
store i32 %116, i32* %117
br label %118
118: ; preds = %108, %105
%119 = load double*, double** %9
%120 = load i32, i32* %11
%121 = sdiv i32 %120, 2
%122 = load i32, i32* %11
%123 = mul nsw i32 %121, %122
%124 = load i32, i32* %11
%125 = sdiv i32 %124, 2
%126 = add nsw i32 %123, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds double, double* %119, i64 %127
%129 = load double, double* %128
%130 = fcmp ogt double %129, 1.000000e+140
br i1 %130, label %131, label %136
131: ; preds = %118
%132 = load double*, double** %9
%133 = load i32, i32* %11
%134 = load i32*, i32** %10
%135 = call i32 @renormalize(double* %132, i32 %133, i32* %134)
br label %136
136: ; preds = %131, %118
%137 = load double*, double** %13
%138 = call i32 @free(double* %137)
br label %139
139: ; preds = %136, %38
ret void
}

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