#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 */
scalar_t__ floor(int);
void divideFunctions(double sol[], int DIM, double *part1, double *part2,
                     double m, int *psize1, int *psize2) {
  int shared;
  int rest, i, total;
  double *partrest;
  if (m <= 0.5) {
    partrest = part2;
  } else {
    partrest = part1;
    m = 1 - m;
  }
  shared = (int)floor(DIM * m);
  rest = 2 * shared;
  for (i = 0; i < shared; i++) {
    part1[i] = sol[i * 2];
    part2[i] = sol[i * 2 + 1];
  }
  total = DIM - shared;
  for (i = 0; i < total - shared; i++) {
    partrest[i + shared] = sol[i + rest];
  }
  *psize1 = shared;
  *psize2 = DIM - shared;
  if (partrest == part1) {
    int temp = *psize1;
    *psize1 = *psize2;
    *psize2 = temp;
  }
}


x86 assembly (clang, -O0):
<divideFunctions>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movsd  0xec4(%rip),%xmm0
ucomisd -0x28(%rbp),%xmm0
jb     1154 <divideFunctions+0x44>
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    116e <divideFunctions+0x5e>
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
movsd  0xea4(%rip),%xmm0
subsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
cvttsd2si %xmm0,%edi
call   1030 <floor@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    11ef <divideFunctions+0xdf>
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1194 <divideFunctions+0x84>
mov    -0xc(%rbp),%eax
sub    -0x3c(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x48(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jge    1242 <divideFunctions+0x132>
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11ff <divideFunctions+0xef>
mov    -0x3c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0xc(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x50(%rbp),%rax
cmp    -0x18(%rbp),%rax
jne    1283 <divideFunctions+0x173>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x54(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<divideFunctions>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r9,%r15
mov    %rcx,%rbp
mov    %rdx,%rbx
mov    %esi,%r13d
mov    %rdi,%r12
movsd  0xecb(%rip),%xmm1
ucomisd %xmm0,%xmm1
mov    %rcx,%r14
cmovb  %rdx,%r14
mov    %r8,0x10(%rsp)
jae    1157 <divideFunctions+0x47>
movsd  0xeb9(%rip),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %r13d,%xmm1
mulsd  %xmm0,%xmm1
cvttsd2si %xmm1,%edi
call   1030 <floor@plt>
test   %eax,%eax
jle    12d7 <divideFunctions+0x1c7>
mov    %eax,%ecx
cmp    $0x4,%rcx
jae    1183 <divideFunctions+0x73>
xor    %edx,%edx
jmp    1258 <divideFunctions+0x148>
mov    %r15,0x8(%rsp)
lea    0x0(,%rcx,8),%rdx
add    %rbp,%rdx
mov    %rcx,%rdi
shl    $0x4,%rdi
add    %r12,%rdi
cmp    %rbx,%rdx
seta   %r10b
lea    (%rbx,%rcx,8),%rsi
cmp    %rbp,%rsi
seta   %r15b
cmp    %rbx,%rdi
seta   %r11b
cmp    %r12,%rsi
seta   %r8b
cmp    %rbp,%rdi
seta   %dil
cmp    %r12,%rdx
seta   %r9b
xor    %edx,%edx
test   %r15b,%r10b
jne    1253 <divideFunctions+0x143>
and    %r8b,%r11b
mov    0x8(%rsp),%r15
jne    1258 <divideFunctions+0x148>
and    %r9b,%dil
jne    1258 <divideFunctions+0x148>
mov    %eax,%r8d
and    $0x3,%r8d
mov    %rcx,%rdx
sub    %r8,%rdx
lea    0x20(%r12),%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x20(%rdi),%xmm0
movupd -0x10(%rdi),%xmm1
movups (%rdi),%xmm2
movups 0x10(%rdi),%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm1,%xmm4
movaps %xmm2,%xmm5
movlhps %xmm3,%xmm5
unpckhpd %xmm1,%xmm0
unpckhpd %xmm3,%xmm2
movupd %xmm4,(%rbx,%rsi,8)
movups %xmm5,0x10(%rbx,%rsi,8)
movupd %xmm0,0x0(%rbp,%rsi,8)
movups %xmm2,0x10(%rbp,%rsi,8)
add    $0x4,%rsi
add    $0x40,%rdi
cmp    %rsi,%rdx
jne    1200 <divideFunctions+0xf0>
test   %r8,%r8
jne    1258 <divideFunctions+0x148>
jmp    12d7 <divideFunctions+0x1c7>
mov    0x8(%rsp),%r15
mov    %eax,%edi
sub    %edx,%edi
lea    0x1(%rdx),%rsi
test   $0x1,%dil
je     1288 <divideFunctions+0x178>
mov    %rdx,%rdi
shl    $0x4,%rdi
movsd  (%r12,%rdi,1),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  0x8(%r12,%rdi,1),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
mov    %rsi,%rdx
cmp    %rsi,%rcx
je     12d7 <divideFunctions+0x1c7>
mov    %rdx,%rsi
shl    $0x4,%rsi
add    %r12,%rsi
add    $0x18,%rsi
nopl   0x0(%rax,%rax,1)
movsd  -0x18(%rsi),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  -0x10(%rsi),%xmm0
movsd  %xmm0,0x0(%rbp,%rdx,8)
movsd  -0x8(%rsi),%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
movsd  (%rsi),%xmm0
movsd  %xmm0,0x8(%rbp,%rdx,8)
add    $0x2,%rdx
add    $0x20,%rsi
cmp    %rdx,%rcx
jne    12a0 <divideFunctions+0x190>
sub    %eax,%r13d
mov    %r13d,%ecx
sub    %eax,%ecx
test   %ecx,%ecx
jle    1454 <divideFunctions+0x344>
lea    (%rax,%rax,1),%edx
movslq %edx,%r8
movslq %eax,%r9
mov    %ecx,%r11d
cmp    $0x4,%ecx
jb     1322 <divideFunctions+0x212>
lea    (%r14,%r9,8),%rcx
lea    (%r8,%r11,1),%rdx
lea    (%r12,%rdx,8),%rdx
cmp    %rdx,%rcx
jae    13ac <divideFunctions+0x29c>
lea    (%r9,%r11,1),%rcx
lea    (%r14,%rcx,8),%rcx
lea    (%r12,%r8,8),%rdx
cmp    %rcx,%rdx
jae    13ac <divideFunctions+0x29c>
xor    %edi,%edi
mov    %rdi,%rdx
not    %rdx
add    %r11,%rdx
mov    %r11,%rcx
and    $0x3,%rcx
je     1355 <divideFunctions+0x245>
lea    (%r14,%r9,8),%rsi
lea    (%r12,%r8,8),%rbp
xchg   %ax,%ax
movsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rcx
jne    1340 <divideFunctions+0x230>
cmp    $0x3,%rdx
jb     1454 <divideFunctions+0x344>
lea    (%r14,%r9,8),%rcx
add    $0x18,%rcx
lea    (%r12,%r8,8),%rdx
add    $0x18,%rdx
nop
movsd  -0x18(%rdx,%rdi,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rdi,8)
movsd  -0x10(%rdx,%rdi,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rdi,8)
movsd  -0x8(%rdx,%rdi,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdi,8)
movsd  (%rdx,%rdi,8),%xmm0
movsd  %xmm0,(%rcx,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%r11
jne    1370 <divideFunctions+0x260>
jmp    1454 <divideFunctions+0x344>
mov    %r11d,%edi
and    $0xfffffffc,%edi
lea    -0x4(%rdi),%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     147a <divideFunctions+0x36a>
mov    %r10,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r12,%r8,8),%rsi
add    $0x30,%rsi
lea    (%r14,%r9,8),%rcx
add    $0x30,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rsi,%rdx,8),%xmm0
movups -0x20(%rsi,%rdx,8),%xmm1
movups %xmm0,-0x30(%rcx,%rdx,8)
movups %xmm1,-0x20(%rcx,%rdx,8)
movupd -0x10(%rsi,%rdx,8),%xmm0
movupd (%rsi,%rdx,8),%xmm1
movupd %xmm0,-0x10(%rcx,%rdx,8)
movupd %xmm1,(%rcx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rbp
jne    13f0 <divideFunctions+0x2e0>
test   $0x1,%r10b
je     144b <divideFunctions+0x33b>
lea    (%rdx,%r8,1),%rcx
movupd (%r12,%rcx,8),%xmm0
movupd 0x10(%r12,%rcx,8),%xmm1
add    %r9,%rdx
movupd %xmm0,(%r14,%rdx,8)
movupd %xmm1,0x10(%r14,%rdx,8)
cmp    %r11,%rdi
jne    1324 <divideFunctions+0x214>
mov    0x10(%rsp),%rcx
mov    %eax,(%rcx)
mov    %r13d,(%r15)
cmp    %rbx,%r14
jne    146b <divideFunctions+0x35b>
mov    (%rcx),%eax
mov    %r13d,(%rcx)
mov    %eax,(%r15)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%r10b
jne    142a <divideFunctions+0x31a>
jmp    144b <divideFunctions+0x33b>

LLVM IR (-O0):
define void @divideFunctions(double* %0, i32 %1, double* %2, double* %3, double %4, i32* %5, i32* %6) {
%8 = alloca double*
%9 = alloca i32
%10 = alloca double*
%11 = alloca double*
%12 = alloca double
%13 = alloca i32*
%14 = alloca i32*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca double*
%20 = alloca i32
store double* %0, double** %8
store i32 %1, i32* %9
store double* %2, double** %10
store double* %3, double** %11
store double %4, double* %12
store i32* %5, i32** %13
store i32* %6, i32** %14
%21 = load double, double* %12
%22 = fcmp ole double %21, 5.000000e-01
br i1 %22, label %23, label %25
23: ; preds = %7
%24 = load double*, double** %11
store double* %24, double** %19
br label %29
25: ; preds = %7
%26 = load double*, double** %10
store double* %26, double** %19
%27 = load double, double* %12
%28 = fsub double 1.000000e+00, %27
store double %28, double* %12
br label %29
29: ; preds = %25, %23
%30 = load i32, i32* %9
%31 = sitofp i32 %30 to double
%32 = load double, double* %12
%33 = fmul double %31, %32
%34 = fptosi double %33 to i32
%35 = call i64 @floor(i32 %34)
%36 = trunc i64 %35 to i32
store i32 %36, i32* %15
%37 = load i32, i32* %15
%38 = mul nsw i32 2, %37
store i32 %38, i32* %16
store i32 0, i32* %17
br label %39
39: ; preds = %65, %29
%40 = load i32, i32* %17
%41 = load i32, i32* %15
%42 = icmp slt i32 %40, %41
br i1 %42, label %43, label %68
43: ; preds = %39
%44 = load double*, double** %8
%45 = load i32, i32* %17
%46 = mul nsw i32 %45, 2
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double, double* %44, i64 %47
%49 = load double, double* %48
%50 = load double*, double** %10
%51 = load i32, i32* %17
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %50, i64 %52
store double %49, double* %53
%54 = load double*, double** %8
%55 = load i32, i32* %17
%56 = mul nsw i32 %55, 2
%57 = add nsw i32 %56, 1
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %54, i64 %58
%60 = load double, double* %59
%61 = load double*, double** %11
%62 = load i32, i32* %17
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds double, double* %61, i64 %63
store double %60, double* %64
br label %65
65: ; preds = %43
%66 = load i32, i32* %17
%67 = add nsw i32 %66, 1
store i32 %67, i32* %17
br label %39
68: ; preds = %39
%69 = load i32, i32* %9
%70 = load i32, i32* %15
%71 = sub nsw i32 %69, %70
store i32 %71, i32* %18
store i32 0, i32* %17
br label %72
72: ; preds = %92, %68
%73 = load i32, i32* %17
%74 = load i32, i32* %18
%75 = load i32, i32* %15
%76 = sub nsw i32 %74, %75
%77 = icmp slt i32 %73, %76
br i1 %77, label %78, label %95
78: ; preds = %72
%79 = load double*, double** %8
%80 = load i32, i32* %17
%81 = load i32, i32* %16
%82 = add nsw i32 %80, %81
%83 = sext i32 %82 to i64
%84 = getelementptr inbounds double, double* %79, i64 %83
%85 = load double, double* %84
%86 = load double*, double** %19
%87 = load i32, i32* %17
%88 = load i32, i32* %15
%89 = add nsw i32 %87, %88
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds double, double* %86, i64 %90
store double %85, double* %91
br label %92
92: ; preds = %78
%93 = load i32, i32* %17
%94 = add nsw i32 %93, 1
store i32 %94, i32* %17
br label %72
95: ; preds = %72
%96 = load i32, i32* %15
%97 = load i32*, i32** %13
store i32 %96, i32* %97
%98 = load i32, i32* %9
%99 = load i32, i32* %15
%100 = sub nsw i32 %98, %99
%101 = load i32*, i32** %14
store i32 %100, i32* %101
%102 = load double*, double** %19
%103 = load double*, double** %10
%104 = icmp eq double* %102, %103
br i1 %104, label %105, label %113
105: ; preds = %95
%106 = load i32*, i32** %13
%107 = load i32, i32* %106
store i32 %107, i32* %20
%108 = load i32*, i32** %14
%109 = load i32, i32* %108
%110 = load i32*, i32** %13
store i32 %109, i32* %110
%111 = load i32, i32* %20
%112 = load i32*, i32** %14
store i32 %111, i32* %112
br label %113
113: ; preds = %105, %95
ret void
}

LLVM IR (-O2):
define void @divideFunctions(double* nocapture %0, i32 %1, double* writeonly %2, double* writeonly %3, double %4, i32* nocapture %5, i32* nocapture writeonly %6) {
%8 = fcmp ugt double %4, 5.000000e-01
%9 = fsub double 1.000000e+00, %4
%10 = select i1 %8, double* %2, double* %3
%11 = select i1 %8, double %9, double %4
%12 = sitofp i32 %1 to double
%13 = fmul double %11, %12
%14 = fptosi double %13 to i32
%15 = tail call i64 @floor(i32 %14)
%16 = trunc i64 %15 to i32
%17 = shl i32 %16, 1
%18 = icmp sgt i32 %16, 0
br i1 %18, label %19, label %108
19: ; preds = %7
%20 = and i64 %15, 4294967295
%21 = icmp ult i64 %20, 4
br i1 %21, label %68, label %22
22: ; preds = %19
%23 = getelementptr double, double* %2, i64 %20
%24 = getelementptr double, double* %3, i64 %20
%25 = shl nuw nsw i64 %20, 1
%26 = getelementptr double, double* %0, i64 %25
%27 = icmp ugt double* %24, %2
%28 = icmp ugt double* %23, %3
%29 = and i1 %27, %28
%30 = icmp ugt double* %26, %2
%31 = icmp ugt double* %23, %0
%32 = and i1 %30, %31
%33 = or i1 %29, %32
%34 = icmp ugt double* %26, %3
%35 = icmp ugt double* %24, %0
%36 = and i1 %34, %35
%37 = or i1 %33, %36
br i1 %37, label %68, label %38
38: ; preds = %22
%39 = and i64 %15, 3
%40 = sub nsw i64 %20, %39
br label %41
41: ; preds = %41, %38
%42 = phi i64 [ 0, %38 ], [ %64, %41 ]
%43 = shl nuw nsw i64 %42, 1
%44 = shl i64 %42, 1
%45 = or i64 %44, 4
%46 = getelementptr inbounds double, double* %0, i64 %43
%47 = getelementptr inbounds double, double* %0, i64 %45
%48 = bitcast double* %46 to <4 x double>*
%49 = bitcast double* %47 to <4 x double>*
%50 = load <4 x double>, <4 x double>* %48
%51 = load <4 x double>, <4 x double>* %49
%52 = shufflevector <4 x double> %50, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%53 = shufflevector <4 x double> %51, <4 x double> poison, <2 x i32> <i32 0, i32 2>
%54 = shufflevector <4 x double> %50, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%55 = shufflevector <4 x double> %51, <4 x double> poison, <2 x i32> <i32 1, i32 3>
%56 = getelementptr inbounds double, double* %2, i64 %42
%57 = bitcast double* %56 to <2 x double>*
store <2 x double> %52, <2 x double>* %57
%58 = getelementptr inbounds double, double* %56, i64 2
%59 = bitcast double* %58 to <2 x double>*
store <2 x double> %53, <2 x double>* %59
%60 = getelementptr inbounds double, double* %3, i64 %42
%61 = bitcast double* %60 to <2 x double>*
store <2 x double> %54, <2 x double>* %61
%62 = getelementptr inbounds double, double* %60, i64 2
%63 = bitcast double* %62 to <2 x double>*
store <2 x double> %55, <2 x double>* %63
%64 = add nuw i64 %42, 4
%65 = icmp eq i64 %64, %40
br i1 %65, label %66, label %41
66: ; preds = %41
%67 = icmp eq i64 %39, 0
br i1 %67, label %108, label %68
68: ; preds = %22, %19, %66
%69 = phi i64 [ 0, %22 ], [ 0, %19 ], [ %40, %66 ]
%70 = sub i64 %15, %69
%71 = add nsw i64 %69, 1
%72 = and i64 %70, 1
%73 = icmp eq i64 %72, 0
br i1 %73, label %84, label %74
74: ; preds = %68
%75 = shl nuw nsw i64 %69, 1
%76 = getelementptr inbounds double, double* %0, i64 %75
%77 = load double, double* %76
%78 = getelementptr inbounds double, double* %2, i64 %69
store double %77, double* %78
%79 = or i64 %75, 1
%80 = getelementptr inbounds double, double* %0, i64 %79
%81 = load double, double* %80
%82 = getelementptr inbounds double, double* %3, i64 %69
store double %81, double* %82
%83 = add nuw nsw i64 %69, 1
br label %84
84: ; preds = %74, %68
%85 = phi i64 [ %69, %68 ], [ %83, %74 ]
%86 = icmp eq i64 %20, %71
br i1 %86, label %108, label %87
87: ; preds = %84, %87
%88 = phi i64 [ %106, %87 ], [ %85, %84 ]
%89 = shl nuw nsw i64 %88, 1
%90 = getelementptr inbounds double, double* %0, i64 %89
%91 = load double, double* %90
%92 = getelementptr inbounds double, double* %2, i64 %88
store double %91, double* %92
%93 = or i64 %89, 1
%94 = getelementptr inbounds double, double* %0, i64 %93
%95 = load double, double* %94
%96 = getelementptr inbounds double, double* %3, i64 %88
store double %95, double* %96
%97 = add nuw nsw i64 %88, 1
%98 = shl nuw nsw i64 %97, 1
%99 = getelementptr inbounds double, double* %0, i64 %98
%100 = load double, double* %99
%101 = getelementptr inbounds double, double* %2, i64 %97
store double %100, double* %101
%102 = or i64 %98, 1
%103 = getelementptr inbounds double, double* %0, i64 %102
%104 = load double, double* %103
%105 = getelementptr inbounds double, double* %3, i64 %97
store double %104, double* %105
%106 = add nuw nsw i64 %88, 2
%107 = icmp eq i64 %106, %20
br i1 %107, label %108, label %87
108: ; preds = %84, %87, %66, %7
%109 = sub nsw i32 %1, %16
%110 = sub i32 %109, %16
%111 = icmp sgt i32 %110, 0
br i1 %111, label %112, label %233
112: ; preds = %108
%113 = sext i32 %17 to i64
%114 = shl i64 %15, 32
%115 = ashr exact i64 %114, 32
%116 = zext i32 %110 to i64
%117 = icmp ult i32 %110, 4
br i1 %117, label %186, label %118
118: ; preds = %112
%119 = getelementptr double, double* %10, i64 %115
%120 = add nsw i64 %115, %116
%121 = getelementptr double, double* %10, i64 %120
%122 = getelementptr double, double* %0, i64 %113
%123 = add nsw i64 %113, %116
%124 = getelementptr double, double* %0, i64 %123
%125 = icmp ult double* %119, %124
%126 = icmp ult double* %122, %121
%127 = and i1 %125, %126
br i1 %127, label %186, label %128
128: ; preds = %118
%129 = and i64 %116, 4294967292
%130 = add nsw i64 %129, -4
%131 = lshr exact i64 %130, 2
%132 = add nuw nsw i64 %131, 1
%133 = and i64 %132, 1
%134 = icmp eq i64 %130, 0
br i1 %134, label %168, label %135
135: ; preds = %128
%136 = and i64 %132, 9223372036854775806
br label %137
137: ; preds = %137, %135
%138 = phi i64 [ 0, %135 ], [ %165, %137 ]
%139 = phi i64 [ 0, %135 ], [ %166, %137 ]
%140 = add nsw i64 %138, %113
%141 = getelementptr inbounds double, double* %0, i64 %140
%142 = bitcast double* %141 to <2 x double>*
%143 = load <2 x double>, <2 x double>* %142
%144 = getelementptr inbounds double, double* %141, i64 2
%145 = bitcast double* %144 to <2 x double>*
%146 = load <2 x double>, <2 x double>* %145
%147 = add nsw i64 %138, %115
%148 = getelementptr inbounds double, double* %10, i64 %147
%149 = bitcast double* %148 to <2 x double>*
store <2 x double> %143, <2 x double>* %149
%150 = getelementptr inbounds double, double* %148, i64 2
%151 = bitcast double* %150 to <2 x double>*
store <2 x double> %146, <2 x double>* %151
%152 = or i64 %138, 4
%153 = add nsw i64 %152, %113
%154 = getelementptr inbounds double, double* %0, i64 %153
%155 = bitcast double* %154 to <2 x double>*
%156 = load <2 x double>, <2 x double>* %155
%157 = getelementptr inbounds double, double* %154, i64 2
%158 = bitcast double* %157 to <2 x double>*
%159 = load <2 x double>, <2 x double>* %158
%160 = add nsw i64 %152, %115
%161 = getelementptr inbounds double, double* %10, i64 %160
%162 = bitcast double* %161 to <2 x double>*
store <2 x double> %156, <2 x double>* %162
%163 = getelementptr inbounds double, double* %161, i64 2
%164 = bitcast double* %163 to <2 x double>*
store <2 x double> %159, <2 x double>* %164
%165 = add nuw i64 %138, 8
%166 = add i64 %139, 2
%167 = icmp eq i64 %166, %136
br i1 %167, label %168, label %137
168: ; preds = %137, %128
%169 = phi i64 [ 0, %128 ], [ %165, %137 ]
%170 = icmp eq i64 %133, 0
br i1 %170, label %184, label %171
171: ; preds = %168
%172 = add nsw i64 %169, %113
%173 = getelementptr inbounds double, double* %0, i64 %172
%174 = bitcast double* %173 to <2 x double>*
%175 = load <2 x double>, <2 x double>* %174
%176 = getelementptr inbounds double, double* %173, i64 2
%177 = bitcast double* %176 to <2 x double>*
%178 = load <2 x double>, <2 x double>* %177
%179 = add nsw i64 %169, %115
%180 = getelementptr inbounds double, double* %10, i64 %179
%181 = bitcast double* %180 to <2 x double>*
store <2 x double> %175, <2 x double>* %181
%182 = getelementptr inbounds double, double* %180, i64 2
%183 = bitcast double* %182 to <2 x double>*
store <2 x double> %178, <2 x double>* %183
br label %184
184: ; preds = %168, %171
%185 = icmp eq i64 %129, %116
br i1 %185, label %233, label %186
186: ; preds = %118, %112, %184
%187 = phi i64 [ 0, %118 ], [ 0, %112 ], [ %129, %184 ]
%188 = xor i64 %187, -1
%189 = add nsw i64 %188, %116
%190 = and i64 %116, 3
%191 = icmp eq i64 %190, 0
br i1 %191, label %203, label %192
192: ; preds = %186, %192
%193 = phi i64 [ %200, %192 ], [ %187, %186 ]
%194 = phi i64 [ %201, %192 ], [ 0, %186 ]
%195 = add nsw i64 %193, %113
%196 = getelementptr inbounds double, double* %0, i64 %195
%197 = load double, double* %196
%198 = add nsw i64 %193, %115
%199 = getelementptr inbounds double, double* %10, i64 %198
store double %197, double* %199
%200 = add nuw nsw i64 %193, 1
%201 = add i64 %194, 1
%202 = icmp eq i64 %201, %190
br i1 %202, label %203, label %192
203: ; preds = %192, %186
%204 = phi i64 [ %187, %186 ], [ %200, %192 ]
%205 = icmp ult i64 %189, 3
br i1 %205, label %233, label %206
206: ; preds = %203, %206
%207 = phi i64 [ %231, %206 ], [ %204, %203 ]
%208 = add nsw i64 %207, %113
%209 = getelementptr inbounds double, double* %0, i64 %208
%210 = load double, double* %209
%211 = add nsw i64 %207, %115
%212 = getelementptr inbounds double, double* %10, i64 %211
store double %210, double* %212
%213 = add nuw nsw i64 %207, 1
%214 = add nsw i64 %213, %113
%215 = getelementptr inbounds double, double* %0, i64 %214
%216 = load double, double* %215
%217 = add nsw i64 %213, %115
%218 = getelementptr inbounds double, double* %10, i64 %217
store double %216, double* %218
%219 = add nuw nsw i64 %207, 2
%220 = add nsw i64 %219, %113
%221 = getelementptr inbounds double, double* %0, i64 %220
%222 = load double, double* %221
%223 = add nsw i64 %219, %115
%224 = getelementptr inbounds double, double* %10, i64 %223
store double %222, double* %224
%225 = add nuw nsw i64 %207, 3
%226 = add nsw i64 %225, %113
%227 = getelementptr inbounds double, double* %0, i64 %226
%228 = load double, double* %227
%229 = add nsw i64 %225, %115
%230 = getelementptr inbounds double, double* %10, i64 %229
store double %228, double* %230
%231 = add nuw nsw i64 %207, 4
%232 = icmp eq i64 %231, %116
br i1 %232, label %233, label %206
233: ; preds = %203, %206, %184, %108
store i32 %16, i32* %5
store i32 %109, i32* %6
%234 = icmp eq double* %10, %2
br i1 %234, label %235, label %237
235: ; preds = %233
%236 = load i32, i32* %5
store i32 %109, i32* %5
store i32 %236, i32* %6
br label %237
237: ; preds = %235, %233
ret void
}