#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 *);
scalar_t__ malloc(int);
void snip1d(double *data, int size, int width) {
  int i;
  int p;
  double *w;
  i = (int)(0.5 * width);
  w = (double *)malloc(size * sizeof(double));
  for (p = width; p > 0; p--) {
    for (i = p; i < (size - p); i++) {
      w[i] = (((data[i]) < (0.5 * (data[i - p] + data[i + p])))
                  ? (data[i])
                  : (0.5 * (data[i - p] + data[i + p])));
    }
    for (i = p; i < (size - p); i++) {
      data[i] = w[i];
    }
  }
  free(w);
}


x86 assembly (clang, -O0):
<snip1d>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
cvtsi2sdl -0x10(%rbp),%xmm1
movsd  0xec1(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x14(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    1289 <snip1d+0x169>
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1237 <snip1d+0x117>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm2
movsd  0xe43(%rip),%xmm0
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    11e2 <snip1d+0xc2>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    1217 <snip1d+0xf7>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x18(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm1
movsd  0xdf2(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1173 <snip1d+0x53>
mov    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1276 <snip1d+0x156>
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    123d <snip1d+0x11d>
jmp    127b <snip1d+0x15b>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1163 <snip1d+0x43>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<snip1d>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %edx,%ebp
mov    %esi,%r14d
mov    %rdi,%rbx
lea    0x0(,%r14,8),%edi
call   1040 <malloc@plt>
test   %ebp,%ebp
jle    1598 <snip1d+0x478>
mov    %ebp,%r11d
movslq %r14d,%r15
mov    %r15,%rcx
sub    %r11,%rcx
mov    %rcx,0x80(%rsp)
lea    (%r11,%r11,1),%rcx
mov    %r15,%r14
mov    %rcx,0x78(%rsp)
sub    %rcx,%r14
lea    (%rbx,%r15,8),%rcx
mov    %rcx,0x70(%rsp)
lea    (%rbx,%r11,8),%r12
add    $0x10,%r12
mov    %r11,%rcx
shl    $0x4,%rcx
lea    (%rcx,%rbx,1),%r9
add    $0x10,%r9
lea    0x10(%rax,%r11,8),%r8
lea    (%rbx,%r11,8),%rcx
lea    0x0(,%r11,8),%rdx
mov    %rbx,%rsi
sub    %rdx,%rsi
lea    (%rax,%r11,8),%r10
add    $0x70,%r10
lea    -0x4(%r14),%r13
lea    0x10(%rbx),%rdx
mov    %rdx,0x68(%rsp)
lea    0x10(%rax),%rdx
mov    %rdx,0x60(%rsp)
movsd  0xe42(%rip),%xmm0
movapd 0xe2a(%rip),%xmm1
xor    %edi,%edi
mov    %r14,0x40(%rsp)
mov    %r14,%rbp
mov    %r15,0x28(%rsp)
jmp    1225 <snip1d+0x105>
nopw   0x0(%rax,%rax,1)
lea    -0x1(%r11),%rdx
add    $0x1,%rdi
add    $0x2,%rbp
add    $0xfffffffffffffff8,%r12
add    $0xfffffffffffffff0,%r9
add    $0xfffffffffffffff8,%r8
add    $0xfffffffffffffff8,%rcx
add    $0x8,%rsi
add    $0xfffffffffffffff8,%r10
add    $0x2,%r13
cmp    $0x1,%r11
mov    %rdx,%r11
jle    1598 <snip1d+0x478>
mov    %r15,%r14
sub    %r11,%r14
cmp    %r14,%r11
jge    11f0 <snip1d+0xd0>
mov    %rbp,0x30(%rsp)
mov    0x40(%rsp),%rdx
lea    (%rdx,%rdi,2),%rbp
lea    (%rax,%r11,8),%rdx
mov    %rdx,0x50(%rsp)
mov    0x80(%rsp),%rdx
mov    %rdi,0x38(%rsp)
add    %rdi,%rdx
lea    (%rax,%rdx,8),%rdi
mov    %rdi,0x20(%rsp)
lea    (%rbx,%r11,8),%rdi
mov    %rdi,0x58(%rsp)
lea    (%rbx,%rdx,8),%rdx
mov    %rdx,0x48(%rsp)
mov    %r11,%r15
mov    %rbp,%rdx
mov    %rbp,0x8(%rsp)
cmp    $0x4,%rbp
jb     13b0 <snip1d+0x290>
mov    0x38(%rsp),%rdx
add    %rdx,%rdx
mov    0x78(%rsp),%rdi
sub    %rdx,%rdi
lea    (%rbx,%rdi,8),%rdx
mov    0x8(%rsp),%rdi
lea    (%rbx,%rdi,8),%r15
mov    0x50(%rsp),%rbp
cmp    0x70(%rsp),%rbp
mov    %r11,0x10(%rsp)
mov    %r13,0x18(%rsp)
setb   %r13b
mov    0x20(%rsp),%rdi
cmp    %rdi,%rdx
setb   %r11b
cmp    %r15,%rbp
setb   %dl
cmp    %rbx,%rdi
seta   0x7(%rsp)
cmp    0x48(%rsp),%rbp
setb   %bpl
cmp    %rdi,0x58(%rsp)
setb   %dil
mov    0x10(%rsp),%r15
test   %r11b,%r13b
mov    0x18(%rsp),%r13
mov    0x10(%rsp),%r11
jne    13b0 <snip1d+0x290>
mov    %r11,%r15
and    0x7(%rsp),%dl
jne    13b0 <snip1d+0x290>
mov    %r11,%r15
and    %dil,%bpl
jne    13b0 <snip1d+0x290>
mov    0x30(%rsp),%rdx
and    $0xfffffffffffffffc,%rdx
mov    0x8(%rsp),%rdi
and    $0xfffffffffffffffc,%rdi
lea    (%r11,%rdi,1),%r15
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%r12,%r13,8),%xmm2
movupd (%r12,%r13,8),%xmm3
movupd (%rbx,%r13,8),%xmm4
movupd 0x10(%rbx,%r13,8),%xmm5
movupd -0x10(%r9,%r13,8),%xmm6
addpd  %xmm4,%xmm6
movupd (%r9,%r13,8),%xmm4
addpd  %xmm5,%xmm4
mulpd  %xmm1,%xmm6
minpd  %xmm6,%xmm2
mulpd  %xmm1,%xmm4
minpd  %xmm4,%xmm3
movupd %xmm2,-0x10(%r8,%r13,8)
movupd %xmm3,(%r8,%r13,8)
add    $0x4,%r13
cmp    %r13,%rdx
jne    1340 <snip1d+0x220>
cmp    %rdi,0x8(%rsp)
mov    0x10(%rsp),%r11
mov    0x18(%rsp),%r13
je     13d9 <snip1d+0x2b9>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%r15,8),%xmm2
movsd  (%rsi,%r15,8),%xmm3
addsd  (%rcx,%r15,8),%xmm3
mulsd  %xmm0,%xmm3
minsd  %xmm3,%xmm2
movsd  %xmm2,(%rax,%r15,8)
add    $0x1,%r15
cmp    %r14,%r15
jl     13b0 <snip1d+0x290>
cmp    %r14,%r11
mov    0x38(%rsp),%rdi
mov    0x30(%rsp),%rbp
mov    0x28(%rsp),%r15
jge    11f0 <snip1d+0xd0>
mov    %r11,%rdx
cmpq   $0x4,0x8(%rsp)
jb     1580 <snip1d+0x460>
mov    0x58(%rsp),%rdx
cmp    0x20(%rsp),%rdx
jae    1424 <snip1d+0x304>
mov    %r11,%rdx
mov    0x48(%rsp),%r15
cmp    %r15,0x50(%rsp)
mov    0x28(%rsp),%r15
jb     1580 <snip1d+0x460>
mov    %r13,%rbp
shr    $0x2,%rbp
mov    0x40(%rsp),%rdx
lea    (%rdx,%rdi,2),%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %rdi,0x20(%rsp)
cmp    $0xc,%rdx
mov    %r11,0x10(%rsp)
mov    %r13,0x18(%rsp)
jae    1465 <snip1d+0x345>
xor    %r15d,%r15d
mov    0x8(%rsp),%rdi
jmp    14ec <snip1d+0x3cc>
lea    0x1(%rbp),%rdx
and    $0xfffffffffffffffc,%rdx
xor    %r15d,%r15d
mov    0x8(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x70(%r10,%r15,8),%xmm2
movups -0x60(%r10,%r15,8),%xmm3
movups %xmm2,(%rcx,%r15,8)
movups %xmm3,0x10(%rcx,%r15,8)
movups -0x50(%r10,%r15,8),%xmm2
movups -0x40(%r10,%r15,8),%xmm3
movups %xmm2,0x20(%rcx,%r15,8)
movups %xmm3,0x30(%rcx,%r15,8)
movups -0x30(%r10,%r15,8),%xmm2
movups -0x20(%r10,%r15,8),%xmm3
movups %xmm2,0x40(%rcx,%r15,8)
movups %xmm3,0x50(%rcx,%r15,8)
movupd -0x10(%r10,%r15,8),%xmm2
movupd (%r10,%r15,8),%xmm3
movupd %xmm2,0x60(%rcx,%r15,8)
movupd %xmm3,0x70(%rcx,%r15,8)
add    $0x10,%r15
add    $0xfffffffffffffffc,%rdx
jne    1480 <snip1d+0x360>
mov    %rdi,%rdx
and    $0xfffffffffffffffc,%rdx
testb  $0x3,0x20(%rsp)
je     1551 <snip1d+0x431>
add    $0x1,%bpl
movzbl %bpl,%r13d
and    $0x3,%r13d
shl    $0x5,%r13
add    0x10(%rsp),%r15
mov    0x68(%rsp),%rdi
lea    (%rdi,%r15,8),%r11
mov    0x60(%rsp),%rdi
lea    (%rdi,%r15,8),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rdi,%rbp,1),%xmm2
movupd (%rdi,%rbp,1),%xmm3
movupd %xmm2,-0x10(%r11,%rbp,1)
movupd %xmm3,(%r11,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r13
jne    1530 <snip1d+0x410>
cmp    %rdx,0x8(%rsp)
mov    0x28(%rsp),%r15
mov    0x10(%rsp),%r11
mov    0x18(%rsp),%r13
mov    0x38(%rsp),%rdi
mov    0x30(%rsp),%rbp
je     11f0 <snip1d+0xd0>
add    %r11,%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm2
movsd  %xmm2,(%rbx,%rdx,8)
add    $0x1,%rdx
cmp    %r14,%rdx
jl     1580 <snip1d+0x460>
jmp    11f0 <snip1d+0xd0>
mov    %rax,%rdi
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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