#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*/ HTS_movem(double *, double *, int);
void HTS_mc2b(double *mc, double *b, int m, const double a) {
  if (mc != b) {
    if (a != 0.0) {
      b[m] = mc[m];
      for (m--; m >= 0; m--)
        b[m] = mc[m] - a * b[m + 1];
    } else
      HTS_movem(mc, b, m + 1);
  } else if (a != 0.0)
    for (m--; m >= 0; m--)
      b[m] -= a * b[m + 1];
}


x86 assembly (clang, -O0):
<HTS_mc2b>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
je     11fb <HTS_mc2b+0xeb>
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1153 <HTS_mc2b+0x43>
jp     1153 <HTS_mc2b+0x43>
jmp    11e3 <HTS_mc2b+0xd3>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     11de <HTS_mc2b+0xce>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1176 <HTS_mc2b+0x66>
jmp    11f6 <HTS_mc2b+0xe6>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
add    $0x1,%edx
call   1030 <HTS_movem@plt>
jmp    128b <HTS_mc2b+0x17b>
movsd  -0x20(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1218 <HTS_mc2b+0x108>
jp     1218 <HTS_mc2b+0x108>
jmp    1286 <HTS_mc2b+0x176>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jl     1281 <HTS_mc2b+0x171>
movsd  -0x20(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1221 <HTS_mc2b+0x111>
jmp    1286 <HTS_mc2b+0x176>
jmp    128b <HTS_mc2b+0x17b>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<HTS_mc2b>:
push   %rbp
push   %rbx
mov    %edx,%ecx
xorpd  %xmm1,%xmm1
cmp    %rsi,%rdi
je     1183 <HTS_mc2b+0x73>
ucomisd %xmm1,%xmm0
jne    1129 <HTS_mc2b+0x19>
jnp    11d4 <HTS_mc2b+0xc4>
movslq %ecx,%rax
movsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rsi,%rax,8)
test   %ecx,%ecx
jle    11d1 <HTS_mc2b+0xc1>
xorpd  0xeba(%rip),%xmm0
mov    %ecx,%r9d
cmp    $0x4,%ecx
jae    11e0 <HTS_mc2b+0xd0>
mov    %r9,%rax
add    $0x1,%rax
nopl   0x0(%rax)
lea    -0x2(%rax),%ecx
movsd  -0x8(%rsi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1160 <HTS_mc2b+0x50>
jmp    11d1 <HTS_mc2b+0xc1>
ucomisd %xmm1,%xmm0
jne    118b <HTS_mc2b+0x7b>
jnp    11d1 <HTS_mc2b+0xc1>
test   %ecx,%ecx
jle    11d1 <HTS_mc2b+0xc1>
xorpd  0xe69(%rip),%xmm0
mov    %ecx,%r10d
cmp    $0x4,%ecx
jae    133d <HTS_mc2b+0x22d>
mov    %r10,%rax
add    $0x1,%rax
nopw   0x0(%rax,%rax,1)
lea    -0x2(%rax),%ecx
movsd  -0x8(%rdi,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%rcx,8),%xmm1
movsd  %xmm1,(%rdi,%rcx,8)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     11b0 <HTS_mc2b+0xa0>
pop    %rbx
pop    %rbp
ret
add    $0x1,%ecx
mov    %ecx,%edx
pop    %rbx
pop    %rbp
jmp    1030 <HTS_movem@plt>
lea    -0x1(%r9),%r8
add    $0xffffffff,%ecx
mov    $0x8,%edx
mov    %r8,%rax
mul    %rdx
seto   %r10b
cmp    %r8d,%ecx
jb     1152 <HTS_mc2b+0x42>
mov    %r8,%rbx
shr    $0x20,%rbx
jne    1152 <HTS_mc2b+0x42>
lea    (%rsi,%rcx,8),%rdx
mov    %rdx,%rbx
sub    %rax,%rbx
cmp    %rdx,%rbx
ja     1152 <HTS_mc2b+0x42>
test   %r10b,%r10b
jne    1152 <HTS_mc2b+0x42>
lea    (%rdi,%rcx,8),%rbx
mov    %rbx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
ja     1152 <HTS_mc2b+0x42>
test   %r10b,%r10b
jne    1152 <HTS_mc2b+0x42>
lea    (%rsi,%r9,8),%rbx
mov    %rbx,%rdx
sub    %rax,%rdx
cmp    %rbx,%rdx
ja     1152 <HTS_mc2b+0x42>
test   %r10b,%r10b
jne    1152 <HTS_mc2b+0x42>
lea    0x1(%rcx),%rax
sub    %r9,%rax
lea    (%rsi,%rax,8),%rdx
lea    (%rsi,%rcx,8),%rbx
add    $0x8,%rbx
lea    (%rdi,%rax,8),%r11
lea    (%rdi,%rcx,8),%rcx
add    $0x8,%rcx
lea    0x8(%rsi),%r10
lea    (%rsi,%r9,8),%rax
add    $0x8,%rax
cmp    %rcx,%rdx
setb   %bpl
cmp    %rbx,%r11
setb   %cl
cmp    %rax,%rdx
setb   %al
cmp    %rbx,%r10
setb   %dl
test   %cl,%bpl
jne    1152 <HTS_mc2b+0x42>
and    %dl,%al
jne    1152 <HTS_mc2b+0x42>
mov    %r9d,%r10d
and    $0xfffffffc,%r10d
mov    %r9d,%eax
and    $0x3,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r10,%r11
neg    %r11
mov    $0xffffffff,%ebx
add    %r9,%rbx
lea    (%rsi,%r8,8),%rdx
xor    %ecx,%ecx
shufpd $0x1,%xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rbx,%rcx,1),%ebp
movupd -0x18(%rdi,%rbp,8),%xmm2
movupd -0x8(%rdi,%rbp,8),%xmm3
movupd -0x10(%rdx,%rcx,8),%xmm4
movupd (%rdx,%rcx,8),%xmm5
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm5,-0x8(%rsi,%rbp,8)
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm4,-0x18(%rsi,%rbp,8)
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%r11
jne    12f0 <HTS_mc2b+0x1e0>
cmp    %r9,%r10
jne    1155 <HTS_mc2b+0x45>
jmp    11d1 <HTS_mc2b+0xc1>
lea    -0x1(%r10),%r8
add    $0xffffffff,%ecx
mov    $0x8,%edx
mov    %r8,%rax
mul    %rdx
seto   %dl
cmp    %r8d,%ecx
jb     11a3 <HTS_mc2b+0x93>
mov    %r8,%rsi
shr    $0x20,%rsi
jne    11a3 <HTS_mc2b+0x93>
lea    (%rdi,%rcx,8),%rbp
mov    %rbp,%rsi
sub    %rax,%rsi
cmp    %rbp,%rsi
ja     11a3 <HTS_mc2b+0x93>
test   %dl,%dl
jne    11a3 <HTS_mc2b+0x93>
lea    (%rdi,%r10,8),%rbp
mov    %rbp,%rsi
sub    %rax,%rsi
cmp    %rbp,%rsi
ja     11a3 <HTS_mc2b+0x93>
test   %dl,%dl
jne    11a3 <HTS_mc2b+0x93>
lea    0x1(%rcx),%rax
sub    %r10,%rax
lea    (%rdi,%rax,8),%rax
lea    (%rdi,%r10,8),%rdx
add    $0x8,%rdx
cmp    %rdx,%rax
jae    13cb <HTS_mc2b+0x2bb>
lea    (%rdi,%rcx,8),%rax
add    $0x8,%rax
lea    0x8(%rdi),%rcx
cmp    %rax,%rcx
jb     11a3 <HTS_mc2b+0x93>
mov    %r10d,%r9d
and    $0xfffffffc,%r9d
mov    %r10d,%eax
and    $0x3,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r9,%rdx
neg    %rdx
mov    $0xffffffff,%ecx
add    %r10,%rcx
lea    (%rdi,%r8,8),%rsi
xor    %ebx,%ebx
shufpd $0x1,%xmm1,%xmm1
nopl   0x0(%rax)
lea    (%rcx,%rbx,1),%ebp
movupd -0x10(%rsi,%rbx,8),%xmm2
movupd (%rsi,%rbx,8),%xmm3
movupd -0x18(%rdi,%rbp,8),%xmm4
movupd -0x8(%rdi,%rbp,8),%xmm5
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm3,-0x8(%rdi,%rbp,8)
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,-0x18(%rdi,%rbp,8)
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%rdx
jne    1400 <HTS_mc2b+0x2f0>
cmp    %r10,%r9
jne    11a6 <HTS_mc2b+0x96>
jmp    11d1 <HTS_mc2b+0xc1>

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

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