#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 */
double DBL_MAX;
double DBL_MIN;
void capped_linear_conversion(double *in, double *out, int l, double mindiff) {
  double a, b;
  double minV = DBL_MAX;
  double maxV = DBL_MIN;
  for (int i = 0; i < l; i++) {
    if (in[i] >= maxV) {
      maxV = in[i];
    }
    if (in[i] <= minV) {
      minV = in[i];
    }
  }
  double div = ((maxV - minV) < (mindiff) ? (mindiff) : (maxV - minV));
  a = (250.0 - 0.0) / div;
  b = -a * minV;
  for (int i = 0; i < l; i++)
    out[i] = a * in[i] + b;
}


x86 assembly (clang, -O0):
<capped_linear_conversion>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    0x2ec5(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    0x2ead(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11b2 <capped_linear_conversion+0xb2>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x40(%rbp),%xmm0
jb     1171 <capped_linear_conversion+0x71>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     119f <capped_linear_conversion+0x9f>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
jmp    11a4 <capped_linear_conversion+0xa4>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    113b <capped_linear_conversion+0x3b>
movsd  -0x40(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    11da <capped_linear_conversion+0xda>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    11e9 <capped_linear_conversion+0xe9>
movsd  -0x40(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xe05(%rip),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1278 <capped_linear_conversion+0x178>
movsd  -0x28(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1232 <capped_linear_conversion+0x132>
pop    %rbp
ret

x86 assembly (clang, -O2):
<capped_linear_conversion>:
test   %edx,%edx
jle    144d <capped_linear_conversion+0x34d>
mov    0x2ed1(%rip),%rax
movsd  (%rax),%xmm2
mov    0x2ebe(%rip),%rax
movsd  (%rax),%xmm1
mov    %edx,%r8d
lea    -0x1(%r8),%rax
mov    %r8d,%r9d
and    $0x3,%r9d
cmp    $0x3,%rax
jae    1139 <capped_linear_conversion+0x39>
xor    %eax,%eax
jmp    1238 <capped_linear_conversion+0x138>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm4
movsd  0x8(%rdi,%rax,8),%xmm3
movapd %xmm2,%xmm5
cmplesd %xmm4,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm4,%xmm6
andnpd %xmm2,%xmm5
orpd   %xmm6,%xmm5
movapd %xmm4,%xmm2
cmplesd %xmm1,%xmm2
andpd  %xmm2,%xmm4
andnpd %xmm1,%xmm2
orpd   %xmm4,%xmm2
movapd %xmm5,%xmm1
cmplesd %xmm3,%xmm1
movapd %xmm1,%xmm4
andnpd %xmm5,%xmm4
andpd  %xmm3,%xmm1
orpd   %xmm4,%xmm1
movapd %xmm3,%xmm4
cmplesd %xmm2,%xmm4
movapd %xmm4,%xmm5
andnpd %xmm2,%xmm5
andpd  %xmm3,%xmm4
orpd   %xmm5,%xmm4
movsd  0x10(%rdi,%rax,8),%xmm2
movapd %xmm1,%xmm3
cmplesd %xmm2,%xmm3
movapd %xmm3,%xmm5
andnpd %xmm1,%xmm5
andpd  %xmm2,%xmm3
orpd   %xmm5,%xmm3
movapd %xmm2,%xmm5
cmplesd %xmm4,%xmm5
movapd %xmm5,%xmm1
andnpd %xmm4,%xmm1
andpd  %xmm2,%xmm5
orpd   %xmm1,%xmm5
movsd  0x18(%rdi,%rax,8),%xmm4
movapd %xmm3,%xmm2
cmplesd %xmm4,%xmm2
movapd %xmm2,%xmm1
andnpd %xmm3,%xmm1
andpd  %xmm4,%xmm2
orpd   %xmm1,%xmm2
movapd %xmm4,%xmm1
cmplesd %xmm5,%xmm1
movapd %xmm1,%xmm3
andnpd %xmm5,%xmm3
andpd  %xmm4,%xmm1
orpd   %xmm3,%xmm1
add    $0x4,%rax
cmp    %rax,%rcx
jne    1150 <capped_linear_conversion+0x50>
movapd %xmm2,%xmm3
movapd %xmm1,%xmm4
test   %r9,%r9
je     1290 <capped_linear_conversion+0x190>
lea    (%rdi,%rax,8),%rax
xor    %ecx,%ecx
movapd %xmm2,%xmm3
nop
movsd  (%rax,%rcx,8),%xmm5
cmplesd %xmm5,%xmm3
movapd %xmm3,%xmm4
andpd  %xmm5,%xmm4
andnpd %xmm2,%xmm3
orpd   %xmm4,%xmm3
movapd %xmm5,%xmm4
cmplesd %xmm1,%xmm4
andpd  %xmm4,%xmm5
andnpd %xmm1,%xmm4
orpd   %xmm5,%xmm4
add    $0x1,%rcx
movapd %xmm4,%xmm1
movapd %xmm3,%xmm2
cmp    %rcx,%r9
jne    1250 <capped_linear_conversion+0x150>
test   %edx,%edx
jle    144d <capped_linear_conversion+0x34d>
subsd  %xmm4,%xmm3
maxsd  %xmm3,%xmm0
movsd  0xd58(%rip),%xmm1
divsd  %xmm0,%xmm1
movapd 0xd5c(%rip),%xmm0
xorpd  %xmm1,%xmm0
mulsd  %xmm4,%xmm0
cmp    $0x4,%edx
jb     12db <capped_linear_conversion+0x1db>
lea    (%rdi,%r8,8),%rax
cmp    %rsi,%rax
jbe    137c <capped_linear_conversion+0x27c>
lea    (%rsi,%r8,8),%rax
cmp    %rdi,%rax
jbe    137c <capped_linear_conversion+0x27c>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r8,%rax
mov    %r8,%rdx
and    $0x3,%rdx
je     130c <capped_linear_conversion+0x20c>
nop
movsd  (%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%rsi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    12f0 <capped_linear_conversion+0x1f0>
cmp    $0x3,%rax
jb     144d <capped_linear_conversion+0x34d>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%rsi,%rcx,8)
movsd  0x8(%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rsi,%rcx,8)
movsd  0x10(%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x10(%rsi,%rcx,8)
movsd  0x18(%rdi,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x18(%rsi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1320 <capped_linear_conversion+0x220>
jmp    144d <capped_linear_conversion+0x34d>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
lea    -0x4(%rcx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     144e <capped_linear_conversion+0x34e>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rdi,%rax,8),%xmm4
movupd 0x10(%rdi,%rax,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%rsi,%rax,8)
movupd %xmm5,0x10(%rsi,%rax,8)
movupd 0x20(%rdi,%rax,8),%xmm4
movupd 0x30(%rdi,%rax,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,0x20(%rsi,%rax,8)
movupd %xmm5,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rdx
jne    13c0 <capped_linear_conversion+0x2c0>
test   $0x1,%r9b
je     1444 <capped_linear_conversion+0x344>
movupd (%rdi,%rax,8),%xmm4
movupd 0x10(%rdi,%rax,8),%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm2,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%rsi,%rax,8)
movupd %xmm5,0x10(%rsi,%rax,8)
cmp    %r8,%rcx
jne    12dd <capped_linear_conversion+0x1dd>
ret
xor    %eax,%eax
test   $0x1,%r9b
jne    141e <capped_linear_conversion+0x31e>
jmp    1444 <capped_linear_conversion+0x344>

LLVM IR (-O0):
@DBL_MAX = global double 0.000000e+00
@DBL_MIN = global double 0.000000e+00
define void @capped_linear_conversion(double* %0, double* %1, i32 %2, double %3) {
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca i32
%14 = alloca double
%15 = alloca i32
store double* %0, double** %5
store double* %1, double** %6
store i32 %2, i32* %7
store double %3, double* %8
%16 = load double, double* @DBL_MAX
store double %16, double* %11
%17 = load double, double* @DBL_MIN
store double %17, double* %12
store i32 0, i32* %13
br label %18
18: ; preds = %51, %4
%19 = load i32, i32* %13
%20 = load i32, i32* %7
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %54
22: ; preds = %18
%23 = load double*, double** %5
%24 = load i32, i32* %13
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds double, double* %23, i64 %25
%27 = load double, double* %26
%28 = load double, double* %12
%29 = fcmp oge double %27, %28
br i1 %29, label %30, label %36
30: ; preds = %22
%31 = load double*, double** %5
%32 = load i32, i32* %13
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds double, double* %31, i64 %33
%35 = load double, double* %34
store double %35, double* %12
br label %36
36: ; preds = %30, %22
%37 = load double*, double** %5
%38 = load i32, i32* %13
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %37, i64 %39
%41 = load double, double* %40
%42 = load double, double* %11
%43 = fcmp ole double %41, %42
br i1 %43, label %44, label %50
44: ; preds = %36
%45 = load double*, double** %5
%46 = load i32, i32* %13
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double, double* %45, i64 %47
%49 = load double, double* %48
store double %49, double* %11
br label %50
50: ; preds = %44, %36
br label %51
51: ; preds = %50
%52 = load i32, i32* %13
%53 = add nsw i32 %52, 1
store i32 %53, i32* %13
br label %18
54: ; preds = %18
%55 = load double, double* %12
%56 = load double, double* %11
%57 = fsub double %55, %56
%58 = load double, double* %8
%59 = fcmp olt double %57, %58
br i1 %59, label %60, label %62
60: ; preds = %54
%61 = load double, double* %8
br label %66
62: ; preds = %54
%63 = load double, double* %12
%64 = load double, double* %11
%65 = fsub double %63, %64
br label %66
66: ; preds = %62, %60
%67 = phi double [ %61, %60 ], [ %65, %62 ]
store double %67, double* %14
%68 = load double, double* %14
%69 = fdiv double 2.500000e+02, %68
store double %69, double* %9
%70 = load double, double* %9
%71 = fneg double %70
%72 = load double, double* %11
%73 = fmul double %71, %72
store double %73, double* %10
store i32 0, i32* %15
br label %74
74: ; preds = %91, %66
%75 = load i32, i32* %15
%76 = load i32, i32* %7
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %94
78: ; preds = %74
%79 = load double, double* %9
%80 = load double*, double** %5
%81 = load i32, i32* %15
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double, double* %80, i64 %82
%84 = load double, double* %83
%85 = load double, double* %10
%86 = call double @llvm.fmuladd.f64(double %79, double %84, double %85)
%87 = load double*, double** %6
%88 = load i32, i32* %15
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double, double* %87, i64 %89
store double %86, double* %90
br label %91
91: ; preds = %78
%92 = load i32, i32* %15
%93 = add nsw i32 %92, 1
store i32 %93, i32* %15
br label %74
94: ; preds = %74
ret void
}

LLVM IR (-O2):
@DBL_MAX = global double 0.000000e+00
@DBL_MIN = global double 0.000000e+00
define void @capped_linear_conversion(double* nocapture %0, double* nocapture writeonly %1, i32 %2, double %3) {
%5 = icmp sgt i32 %2, 0
br i1 %5, label %6, label %174
6: ; preds = %4
%7 = load double, double* @DBL_MIN
%8 = load double, double* @DBL_MAX
%9 = zext i32 %2 to i64
%10 = add nsw i64 %9, -1
%11 = and i64 %9, 3
%12 = icmp ult i64 %10, 3
br i1 %12, label %15, label %13
13: ; preds = %6
%14 = and i64 %9, 4294967292
br label %139
15: ; preds = %139, %6
%16 = phi double [ undef, %6 ], [ %168, %139 ]
%17 = phi double [ undef, %6 ], [ %170, %139 ]
%18 = phi i64 [ 0, %6 ], [ %171, %139 ]
%19 = phi double [ %8, %6 ], [ %170, %139 ]
%20 = phi double [ %7, %6 ], [ %168, %139 ]
%21 = icmp eq i64 %11, 0
br i1 %21, label %36, label %22
22: ; preds = %15, %22
%23 = phi i64 [ %33, %22 ], [ %18, %15 ]
%24 = phi double [ %32, %22 ], [ %19, %15 ]
%25 = phi double [ %30, %22 ], [ %20, %15 ]
%26 = phi i64 [ %34, %22 ], [ 0, %15 ]
%27 = getelementptr inbounds double, double* %0, i64 %23
%28 = load double, double* %27
%29 = fcmp oge double %28, %25
%30 = select i1 %29, double %28, double %25
%31 = fcmp ole double %28, %24
%32 = select i1 %31, double %28, double %24
%33 = add nuw nsw i64 %23, 1
%34 = add i64 %26, 1
%35 = icmp eq i64 %34, %11
br i1 %35, label %36, label %22
36: ; preds = %22, %15
%37 = phi double [ %16, %15 ], [ %30, %22 ]
%38 = phi double [ %17, %15 ], [ %32, %22 ]
%39 = fsub double %37, %38
%40 = fcmp olt double %39, %3
%41 = select i1 %40, double %3, double %39
%42 = fdiv double 2.500000e+02, %41
%43 = fneg double %42
%44 = fmul double %38, %43
br i1 %5, label %45, label %174
45: ; preds = %36
%46 = zext i32 %2 to i64
%47 = icmp ult i32 %2, 4
br i1 %47, label %120, label %48
48: ; preds = %45
%49 = getelementptr double, double* %1, i64 %9
%50 = getelementptr double, double* %0, i64 %9
%51 = icmp ugt double* %50, %1
%52 = icmp ugt double* %49, %0
%53 = and i1 %51, %52
br i1 %53, label %120, label %54
54: ; preds = %48
%55 = and i64 %9, 4294967292
%56 = insertelement <2 x double> poison, double %42, i64 0
%57 = shufflevector <2 x double> %56, <2 x double> poison, <2 x i32> zeroinitializer
%58 = insertelement <2 x double> poison, double %44, i64 0
%59 = shufflevector <2 x double> %58, <2 x double> poison, <2 x i32> zeroinitializer
%60 = insertelement <2 x double> poison, double %42, i64 0
%61 = shufflevector <2 x double> %60, <2 x double> poison, <2 x i32> zeroinitializer
%62 = insertelement <2 x double> poison, double %44, i64 0
%63 = shufflevector <2 x double> %62, <2 x double> poison, <2 x i32> zeroinitializer
%64 = add nsw i64 %55, -4
%65 = lshr exact i64 %64, 2
%66 = add nuw nsw i64 %65, 1
%67 = and i64 %66, 1
%68 = icmp eq i64 %64, 0
br i1 %68, label %102, label %69
69: ; preds = %54
%70 = and i64 %66, 9223372036854775806
br label %71
71: ; preds = %71, %69
%72 = phi i64 [ 0, %69 ], [ %99, %71 ]
%73 = phi i64 [ 0, %69 ], [ %100, %71 ]
%74 = getelementptr inbounds double, double* %0, i64 %72
%75 = bitcast double* %74 to <2 x double>*
%76 = load <2 x double>, <2 x double>* %75
%77 = getelementptr inbounds double, double* %74, i64 2
%78 = bitcast double* %77 to <2 x double>*
%79 = load <2 x double>, <2 x double>* %78
%80 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %57, <2 x double> %76, <2 x double> %59)
%81 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %61, <2 x double> %79, <2 x double> %63)
%82 = getelementptr inbounds double, double* %1, i64 %72
%83 = bitcast double* %82 to <2 x double>*
store <2 x double> %80, <2 x double>* %83
%84 = getelementptr inbounds double, double* %82, i64 2
%85 = bitcast double* %84 to <2 x double>*
store <2 x double> %81, <2 x double>* %85
%86 = or i64 %72, 4
%87 = getelementptr inbounds double, double* %0, i64 %86
%88 = bitcast double* %87 to <2 x double>*
%89 = load <2 x double>, <2 x double>* %88
%90 = getelementptr inbounds double, double* %87, i64 2
%91 = bitcast double* %90 to <2 x double>*
%92 = load <2 x double>, <2 x double>* %91
%93 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %57, <2 x double> %89, <2 x double> %59)
%94 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %61, <2 x double> %92, <2 x double> %63)
%95 = getelementptr inbounds double, double* %1, i64 %86
%96 = bitcast double* %95 to <2 x double>*
store <2 x double> %93, <2 x double>* %96
%97 = getelementptr inbounds double, double* %95, i64 2
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> %94, <2 x double>* %98
%99 = add nuw i64 %72, 8
%100 = add i64 %73, 2
%101 = icmp eq i64 %100, %70
br i1 %101, label %102, label %71
102: ; preds = %71, %54
%103 = phi i64 [ 0, %54 ], [ %99, %71 ]
%104 = icmp eq i64 %67, 0
br i1 %104, label %118, label %105
105: ; preds = %102
%106 = getelementptr inbounds double, double* %0, i64 %103
%107 = bitcast double* %106 to <2 x double>*
%108 = load <2 x double>, <2 x double>* %107
%109 = getelementptr inbounds double, double* %106, i64 2
%110 = bitcast double* %109 to <2 x double>*
%111 = load <2 x double>, <2 x double>* %110
%112 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %57, <2 x double> %108, <2 x double> %59)
%113 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %61, <2 x double> %111, <2 x double> %63)
%114 = getelementptr inbounds double, double* %1, i64 %103
%115 = bitcast double* %114 to <2 x double>*
store <2 x double> %112, <2 x double>* %115
%116 = getelementptr inbounds double, double* %114, i64 2
%117 = bitcast double* %116 to <2 x double>*
store <2 x double> %113, <2 x double>* %117
br label %118
118: ; preds = %102, %105
%119 = icmp eq i64 %55, %9
br i1 %119, label %174, label %120
120: ; preds = %48, %45, %118
%121 = phi i64 [ 0, %48 ], [ 0, %45 ], [ %55, %118 ]
%122 = xor i64 %121, -1
%123 = add nsw i64 %122, %9
%124 = and i64 %9, 3
%125 = icmp eq i64 %124, 0
br i1 %125, label %136, label %126
126: ; preds = %120, %126
%127 = phi i64 [ %133, %126 ], [ %121, %120 ]
%128 = phi i64 [ %134, %126 ], [ 0, %120 ]
%129 = getelementptr inbounds double, double* %0, i64 %127
%130 = load double, double* %129
%131 = tail call double @llvm.fmuladd.f64(double %42, double %130, double %44)
%132 = getelementptr inbounds double, double* %1, i64 %127
store double %131, double* %132
%133 = add nuw nsw i64 %127, 1
%134 = add i64 %128, 1
%135 = icmp eq i64 %134, %124
br i1 %135, label %136, label %126
136: ; preds = %126, %120
%137 = phi i64 [ %121, %120 ], [ %133, %126 ]
%138 = icmp ult i64 %123, 3
br i1 %138, label %174, label %175
139: ; preds = %139, %13
%140 = phi i64 [ 0, %13 ], [ %171, %139 ]
%141 = phi double [ %8, %13 ], [ %170, %139 ]
%142 = phi double [ %7, %13 ], [ %168, %139 ]
%143 = phi i64 [ 0, %13 ], [ %172, %139 ]
%144 = getelementptr inbounds double, double* %0, i64 %140
%145 = load double, double* %144
%146 = fcmp oge double %145, %142
%147 = select i1 %146, double %145, double %142
%148 = fcmp ole double %145, %141
%149 = select i1 %148, double %145, double %141
%150 = or i64 %140, 1
%151 = getelementptr inbounds double, double* %0, i64 %150
%152 = load double, double* %151
%153 = fcmp oge double %152, %147
%154 = select i1 %153, double %152, double %147
%155 = fcmp ole double %152, %149
%156 = select i1 %155, double %152, double %149
%157 = or i64 %140, 2
%158 = getelementptr inbounds double, double* %0, i64 %157
%159 = load double, double* %158
%160 = fcmp oge double %159, %154
%161 = select i1 %160, double %159, double %154
%162 = fcmp ole double %159, %156
%163 = select i1 %162, double %159, double %156
%164 = or i64 %140, 3
%165 = getelementptr inbounds double, double* %0, i64 %164
%166 = load double, double* %165
%167 = fcmp oge double %166, %161
%168 = select i1 %167, double %166, double %161
%169 = fcmp ole double %166, %163
%170 = select i1 %169, double %166, double %163
%171 = add nuw nsw i64 %140, 4
%172 = add i64 %143, 4
%173 = icmp eq i64 %172, %14
br i1 %173, label %15, label %139
174: ; preds = %136, %175, %118, %4, %36
ret void
175: ; preds = %136, %175
%176 = phi i64 [ %196, %175 ], [ %137, %136 ]
%177 = getelementptr inbounds double, double* %0, i64 %176
%178 = load double, double* %177
%179 = tail call double @llvm.fmuladd.f64(double %42, double %178, double %44)
%180 = getelementptr inbounds double, double* %1, i64 %176
store double %179, double* %180
%181 = add nuw nsw i64 %176, 1
%182 = getelementptr inbounds double, double* %0, i64 %181
%183 = load double, double* %182
%184 = tail call double @llvm.fmuladd.f64(double %42, double %183, double %44)
%185 = getelementptr inbounds double, double* %1, i64 %181
store double %184, double* %185
%186 = add nuw nsw i64 %176, 2
%187 = getelementptr inbounds double, double* %0, i64 %186
%188 = load double, double* %187
%189 = tail call double @llvm.fmuladd.f64(double %42, double %188, double %44)
%190 = getelementptr inbounds double, double* %1, i64 %186
store double %189, double* %190
%191 = add nuw nsw i64 %176, 3
%192 = getelementptr inbounds double, double* %0, i64 %191
%193 = load double, double* %192
%194 = tail call double @llvm.fmuladd.f64(double %42, double %193, double %44)
%195 = getelementptr inbounds double, double* %1, i64 %191
store double %194, double* %195
%196 = add nuw nsw i64 %176, 4
%197 = icmp eq i64 %196, %46
br i1 %197, label %174, label %175
}