void __getrd_kernel_sequential(double *Dinv, double *R, double *A, double *b,
                               double *C, int n, int m) {
  int i, j;
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      if (i == j) {
        Dinv[i] = 1.0 / A[i + i * n];
        R[i + i * n] = 0.0;
      } else {
        R[i + j * n] = A[i + j * n];
      }
    }
  }
  for (i = 0; i < n; i++) {
    C[i] = Dinv[i] * b[i];
  }
}


x86 assembly (clang, -O0):
<__getrd_kernel_sequential>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11f4 <__getrd_kernel_sequential+0xf4>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    11e1 <__getrd_kernel_sequential+0xe1>
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    119e <__getrd_kernel_sequential+0x9e>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xe94(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    11ce <__getrd_kernel_sequential+0xce>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x2c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    11d3 <__getrd_kernel_sequential+0xd3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1139 <__getrd_kernel_sequential+0x39>
jmp    11e6 <__getrd_kernel_sequential+0xe6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1126 <__getrd_kernel_sequential+0x26>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    123c <__getrd_kernel_sequential+0x13c>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fb <__getrd_kernel_sequential+0xfb>
pop    %rbp
ret

x86 assembly (clang, -O2):
<__getrd_kernel_sequential>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %r9d,%r9d
jle    134c <__getrd_kernel_sequential+0x24c>
mov    %r9d,%r10d
lea    0x0(,%r10,8),%r11
xor    %r13d,%r13d
movsd  0xed8(%rip),%xmm0
mov    %rsi,%r14
mov    %rdx,%r15
jmp    1141 <__getrd_kernel_sequential+0x41>
add    $0x1,%r13
add    $0x8,%r15
add    $0x8,%r14
cmp    %r10,%r13
je     1197 <__getrd_kernel_sequential+0x97>
mov    %r13d,%eax
imul   %r9d,%eax
movslq %eax,%r12
add    %r13,%r12
xor    %ebx,%ebx
xor    %eax,%eax
jmp    1178 <__getrd_kernel_sequential+0x78>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rbx,1),%xmm1
movsd  %xmm1,(%r14,%rbx,1)
add    $0x1,%rax
add    %r11,%rbx
cmp    %rax,%r10
je     1130 <__getrd_kernel_sequential+0x30>
cmp    %rax,%r13
jne    1160 <__getrd_kernel_sequential+0x60>
movapd %xmm0,%xmm1
divsd  (%rdx,%r12,8),%xmm1
movsd  %xmm1,(%rdi,%r13,8)
movq   $0x0,(%rsi,%r12,8)
jmp    116c <__getrd_kernel_sequential+0x6c>
test   %r9d,%r9d
jle    134c <__getrd_kernel_sequential+0x24c>
cmp    $0x4,%r9d
jae    1247 <__getrd_kernel_sequential+0x147>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %r10,%rax
mov    %r10,%rsi
and    $0x3,%rsi
je     11da <__getrd_kernel_sequential+0xda>
xchg   %ax,%ax
movsd  (%rdi,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%r8,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    11c0 <__getrd_kernel_sequential+0xc0>
cmp    $0x3,%rax
jb     134c <__getrd_kernel_sequential+0x24c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
movsd  %xmm0,(%r8,%rdx,8)
movsd  0x8(%rdi,%rdx,8),%xmm0
mulsd  0x8(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r8,%rdx,8)
movsd  0x10(%rdi,%rdx,8),%xmm0
mulsd  0x10(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r8,%rdx,8)
movsd  0x18(%rdi,%rdx,8),%xmm0
mulsd  0x18(%rcx,%rdx,8),%xmm0
movsd  %xmm0,0x18(%r8,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r10
jne    11f0 <__getrd_kernel_sequential+0xf0>
jmp    134c <__getrd_kernel_sequential+0x24c>
lea    (%r8,%r10,8),%rdx
lea    (%rdi,%r10,8),%rax
cmp    %r8,%rax
seta   %r9b
lea    (%rcx,%r10,8),%rax
cmp    %rdi,%rdx
seta   %bl
cmp    %r8,%rax
seta   %al
cmp    %rcx,%rdx
seta   %sil
xor    %edx,%edx
test   %bl,%r9b
jne    11ac <__getrd_kernel_sequential+0xac>
and    %sil,%al
jne    11ac <__getrd_kernel_sequential+0xac>
mov    %r10d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rax
mov    %rax,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rax,%rax
je     1356 <__getrd_kernel_sequential+0x256>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd (%rcx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rcx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r8,%rax,8)
movupd %xmm0,0x10(%r8,%rax,8)
movupd 0x20(%rdi,%rax,8),%xmm0
movupd 0x30(%rdi,%rax,8),%xmm1
movupd 0x20(%rcx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x30(%rcx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,0x20(%r8,%rax,8)
movupd %xmm0,0x30(%r8,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rsi
jne    12b0 <__getrd_kernel_sequential+0x1b0>
test   $0x1,%bl
je     1343 <__getrd_kernel_sequential+0x243>
movupd (%rdi,%rax,8),%xmm0
movupd 0x10(%rdi,%rax,8),%xmm1
movupd (%rcx,%rax,8),%xmm2
mulpd  %xmm0,%xmm2
movupd 0x10(%rcx,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm2,(%r8,%rax,8)
movupd %xmm0,0x10(%r8,%rax,8)
cmp    %r10,%rdx
jne    11ac <__getrd_kernel_sequential+0xac>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret
xor    %eax,%eax
test   $0x1,%bl
jne    1318 <__getrd_kernel_sequential+0x218>
jmp    1343 <__getrd_kernel_sequential+0x243>

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

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