void Row_Transformation(double *A, double x, int row1, int row2, int ncols) {
  int i;
  double *pA1, *pA2;
  if (row1 != row2) {
    pA1 = A + row1 * ncols;
    pA2 = A + row2 * ncols;
    for (i = 0; i < ncols; i++)
      *pA2++ += x * *pA1++;
  } else {
    pA1 = A + row1 * ncols;
    for (i = 0; i < ncols; i++)
      *pA1++ += x * *pA1;
  }
}


x86 assembly (clang, -O0):
<Row_Transformation>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     11b1 <Row_Transformation+0xb1>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11ac <Row_Transformation+0xac>
movsd  -0x10(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
movsd  (%rax),%xmm2
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x30(%rbp)
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    115b <Row_Transformation+0x5b>
jmp    121c <Row_Transformation+0x11c>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1217 <Row_Transformation+0x117>
movsd  -0x10(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11d1 <Row_Transformation+0xd1>
jmp    121c <Row_Transformation+0x11c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<Row_Transformation>:
push   %r14
push   %rbx
cmp    %edx,%esi
jne    1243 <Row_Transformation+0x143>
test   %ecx,%ecx
jle    143d <Row_Transformation+0x33d>
imul   %ecx,%esi
movslq %esi,%rdx
lea    (%rdi,%rdx,8),%rax
lea    -0x1(%rcx),%r8d
xor    %r9d,%r9d
cmp    $0x3,%r8d
jb     1214 <Row_Transformation+0x114>
add    $0x1,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r9),%rsi
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     1441 <Row_Transformation+0x341>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rdi,%rdx,8),%rdx
add    $0x30,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rdi,8),%xmm2
movupd -0x20(%rdx,%rdi,8),%xmm3
movupd -0x10(%rdx,%rdi,8),%xmm4
movupd (%rdx,%rdi,8),%xmm5
movapd %xmm1,%xmm6
mulpd  %xmm2,%xmm6
addpd  %xmm2,%xmm6
movapd %xmm1,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm6,-0x30(%rdx,%rdi,8)
movupd %xmm2,-0x20(%rdx,%rdi,8)
movapd %xmm1,%xmm2
mulpd  %xmm4,%xmm2
addpd  %xmm4,%xmm2
movapd %xmm1,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rdx,%rdi,8)
movupd %xmm3,(%rdx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1170 <Row_Transformation+0x70>
test   $0x1,%bl
je     1207 <Row_Transformation+0x107>
movupd (%rax,%rdi,8),%xmm2
movupd 0x10(%rax,%rdi,8),%xmm3
movapd %xmm1,%xmm4
mulpd  %xmm2,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm3,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm4,(%rax,%rdi,8)
movupd %xmm1,0x10(%rax,%rdi,8)
cmp    %r9,%r8
je     143d <Row_Transformation+0x33d>
lea    (%rax,%r9,8),%rax
sub    %r9d,%ecx
xor    %edx,%edx
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %edx,%ecx
jne    1220 <Row_Transformation+0x120>
jmp    143d <Row_Transformation+0x33d>
test   %ecx,%ecx
jle    143d <Row_Transformation+0x33d>
imul   %ecx,%edx
movslq %edx,%r14
lea    (%rdi,%r14,8),%rdx
imul   %ecx,%esi
movslq %esi,%rbx
lea    (%rdi,%rbx,8),%rax
lea    -0x1(%rcx),%r10d
xor    %r8d,%r8d
cmp    $0x3,%r10d
jb     1397 <Row_Transformation+0x297>
lea    (%rbx,%r10,1),%rsi
lea    (%rdi,%rsi,8),%rsi
add    $0x8,%rsi
cmp    %rsi,%rdx
jae    1296 <Row_Transformation+0x196>
lea    (%r14,%r10,1),%rsi
lea    (%rdi,%rsi,8),%rsi
add    $0x8,%rsi
cmp    %rsi,%rax
jb     1397 <Row_Transformation+0x297>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r8),%rsi
mov    %rsi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1451 <Row_Transformation+0x351>
mov    %r9,%r11
and    $0xfffffffffffffffe,%r11
lea    (%rdi,%r14,8),%rsi
add    $0x30,%rsi
lea    (%rdi,%rbx,8),%rbx
add    $0x30,%rbx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movupd -0x30(%rbx,%rdi,8),%xmm2
movupd -0x20(%rbx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%rsi,%rdi,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%rsi,%rdi,8),%xmm2
movupd -0x10(%rsi,%rdi,8),%xmm5
movupd (%rsi,%rdi,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%rsi,%rdi,8)
movupd %xmm3,-0x20(%rsi,%rdi,8)
movupd -0x10(%rbx,%rdi,8),%xmm2
movupd (%rbx,%rdi,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%rsi,%rdi,8)
movupd %xmm3,(%rsi,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%r11
jne    12e0 <Row_Transformation+0x1e0>
test   $0x1,%r9b
je     1386 <Row_Transformation+0x286>
movupd (%rax,%rdi,8),%xmm2
movupd 0x10(%rax,%rdi,8),%xmm3
movupd (%rdx,%rdi,8),%xmm4
movupd 0x10(%rdx,%rdi,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rdx,%rdi,8)
movupd %xmm3,0x10(%rdx,%rdi,8)
cmp    %r8,%r10
je     143d <Row_Transformation+0x33d>
lea    (%rdx,%r8,8),%rdx
lea    (%rax,%r8,8),%rax
mov    %ecx,%edi
sub    %r8d,%edi
mov    %r8d,%esi
not    %esi
add    %ecx,%esi
and    $0x3,%edi
je     13d2 <Row_Transformation+0x2d2>
neg    %edi
xor    %ebx,%ebx
nopl   0x0(%rax)
movsd  (%rax),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx),%xmm1
movsd  %xmm1,(%rdx)
add    $0x8,%rdx
add    $0x8,%rax
add    $0xffffffff,%ebx
cmp    %ebx,%edi
jne    13b0 <Row_Transformation+0x2b0>
sub    %ebx,%r8d
cmp    $0x3,%esi
jb     143d <Row_Transformation+0x33d>
sub    %r8d,%ecx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rsi,8),%xmm1
movsd  %xmm1,(%rdx,%rsi,8)
movsd  0x8(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rdx,%rsi,8),%xmm1
movsd  %xmm1,0x8(%rdx,%rsi,8)
movsd  0x10(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x10(%rdx,%rsi,8),%xmm1
movsd  %xmm1,0x10(%rdx,%rsi,8)
movsd  0x18(%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x18(%rdx,%rsi,8),%xmm1
movsd  %xmm1,0x18(%rdx,%rsi,8)
add    $0x4,%rsi
cmp    %esi,%ecx
jne    13e0 <Row_Transformation+0x2e0>
pop    %rbx
pop    %r14
ret
xor    %edi,%edi
test   $0x1,%bl
jne    11dd <Row_Transformation+0xdd>
jmp    1207 <Row_Transformation+0x107>
xor    %edi,%edi
test   $0x1,%r9b
jne    1355 <Row_Transformation+0x255>
jmp    1386 <Row_Transformation+0x286>

LLVM IR (-O0):
define void @Row_Transformation(double* %0, double %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca double*
%7 = alloca double
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double*
%13 = alloca double*
store double* %0, double** %6
store double %1, double* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
%14 = load i32, i32* %8
%15 = load i32, i32* %9
%16 = icmp ne i32 %14, %15
br i1 %16, label %17, label %47
17: ; preds = %5
%18 = load double*, double** %6
%19 = load i32, i32* %8
%20 = load i32, i32* %10
%21 = mul nsw i32 %19, %20
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds double, double* %18, i64 %22
store double* %23, double** %12
%24 = load double*, double** %6
%25 = load i32, i32* %9
%26 = load i32, i32* %10
%27 = mul nsw i32 %25, %26
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds double, double* %24, i64 %28
store double* %29, double** %13
store i32 0, i32* %11
br label %30
30: ; preds = %43, %17
%31 = load i32, i32* %11
%32 = load i32, i32* %10
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %46
34: ; preds = %30
%35 = load double, double* %7
%36 = load double*, double** %12
%37 = getelementptr inbounds double, double* %36, i32 1
store double* %37, double** %12
%38 = load double, double* %36
%39 = load double*, double** %13
%40 = getelementptr inbounds double, double* %39, i32 1
store double* %40, double** %13
%41 = load double, double* %39
%42 = call double @llvm.fmuladd.f64(double %35, double %38, double %41)
store double %42, double* %39
br label %43
43: ; preds = %34
%44 = load i32, i32* %11
%45 = add nsw i32 %44, 1
store i32 %45, i32* %11
br label %30
46: ; preds = %30
br label %70
47: ; preds = %5
%48 = load double*, double** %6
%49 = load i32, i32* %8
%50 = load i32, i32* %10
%51 = mul nsw i32 %49, %50
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %48, i64 %52
store double* %53, double** %12
store i32 0, i32* %11
br label %54
54: ; preds = %66, %47
%55 = load i32, i32* %11
%56 = load i32, i32* %10
%57 = icmp slt i32 %55, %56
br i1 %57, label %58, label %69
58: ; preds = %54
%59 = load double, double* %7
%60 = load double*, double** %12
%61 = load double, double* %60
%62 = load double*, double** %12
%63 = getelementptr inbounds double, double* %62, i32 1
store double* %63, double** %12
%64 = load double, double* %62
%65 = call double @llvm.fmuladd.f64(double %59, double %61, double %64)
store double %65, double* %62
br label %66
66: ; preds = %58
%67 = load i32, i32* %11
%68 = add nsw i32 %67, 1
store i32 %68, i32* %11
br label %54
69: ; preds = %54
br label %70
70: ; preds = %69, %46
ret void
}

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