#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*/ rsolv(double **, int, double *, double *);
void solveWithQR(double a[][100], int n, double c[], double d[], double b[]) {
  int i, j;
  double sum, tau;
  for (j = 1; j < n; j++) {
    for (sum = 0.0, i = j; i <= n; i++)
      sum += a[i][j] * b[i];
    tau = sum / c[j];
    for (i = j; i <= n; i++)
      b[i] -= tau * a[i][j];
  }
  rsolv(a, n, d, b);
}


x86 assembly (clang, -O0):
<solveWithQR>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    123b <solveWithQR+0x12b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     11a0 <solveWithQR+0x90>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    114c <solveWithQR+0x3c>
movsd  -0x38(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1228 <solveWithQR+0x118>
movsd  -0x40(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0x320,%rcx,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq -0x2c(%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    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11bd <solveWithQR+0xad>
jmp    122d <solveWithQR+0x11d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1132 <solveWithQR+0x22>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    -0x28(%rbp),%rcx
call   1030 <rsolv@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solveWithQR>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,%r11
mov    %rcx,-0x38(%rsp)
mov    %rdx,-0x10(%rsp)
mov    %rdi,-0x48(%rsp)
mov    %esi,-0x4c(%rsp)
cmp    $0x2,%esi
jl     13a3 <solveWithQR+0x293>
mov    -0x4c(%rsp),%r9d
lea    0x1(%r9),%r10
lea    (%r11,%r9,8),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rsp)
mov    %r9,%rax
not    %rax
mov    %rax,-0x28(%rsp)
mov    -0x48(%rsp),%rax
lea    0x328(%rax),%rcx
lea    0xc88(%rax),%r14
mov    $0x1,%esi
xor    %r13d,%r13d
imul   $0x320,%r10,%rdx
add    %rax,%rdx
mov    %rdx,-0x20(%rsp)
movapd 0xe74(%rip),%xmm0
mov    %r9,-0x18(%rsp)
mov    %r10,%rax
mov    %rcx,%r15
mov    %r11,%r8
jmp    11d1 <solveWithQR+0xc1>
nopl   0x0(%rax)
add    $0x1,%rsi
add    $0x1,%r13
add    $0x8,%r8
add    $0x328,%r15
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%r9
add    $0x328,%r14
add    $0x8,%rcx
cmp    -0x18(%rsp),%rsi
je     13a3 <solveWithQR+0x293>
mov    %r9,%rbp
and    $0xfffffffffffffffc,%rbp
mov    %r13,%r12
not    %r12
add    %r10,%r12
lea    (%r11,%rsi,8),%rdx
mov    %rdx,-0x40(%rsp)
imul   $0x328,%r13,%rdx
mov    -0x48(%rsp),%rdi
add    %rdi,%rdx
add    $0x328,%rdx
mov    %rdx,-0x8(%rsp)
mov    -0x20(%rsp),%rdx
lea    (%rdx,%r13,8),%rdi
add    $0xfffffffffffffcf0,%rdi
xorpd  %xmm1,%xmm1
mov    %r15,%rdx
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm2
mulsd  (%r8,%rbx,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rbx
add    $0x320,%rdx
cmp    %rbx,%rax
jne    1230 <solveWithQR+0x120>
xorpd  %xmm0,%xmm1
mov    -0x10(%rsp),%rdx
divsd  (%rdx,%rsi,8),%xmm1
mov    %rsi,%rdx
cmp    $0x4,%r12
jb     1310 <solveWithQR+0x200>
cmp    %rdi,-0x40(%rsp)
jae    1283 <solveWithQR+0x173>
mov    %rsi,%rdx
mov    -0x8(%rsp),%rdi
cmp    -0x30(%rsp),%rdi
jb     1310 <solveWithQR+0x200>
mov    %r12,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x40(%rsp)
add    %rsi,%rdx
movapd %xmm1,%xmm2
unpcklpd %xmm1,%xmm2
mov    %r14,%rdi
xor    %ebx,%ebx
nop
movsd  -0x960(%rdi),%xmm3
ff
movhpd -0x640(%rdi),%xmm3
ff
movsd  -0x320(%rdi),%xmm4
ff
movhpd (%rdi),%xmm4
movupd 0x8(%r8,%rbx,8),%xmm5
movupd 0x18(%r8,%rbx,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,0x8(%r8,%rbx,8)
movupd %xmm4,0x18(%r8,%rbx,8)
add    $0x4,%rbx
add    $0xc80,%rdi
cmp    %rbx,%rbp
jne    12a0 <solveWithQR+0x190>
cmp    -0x40(%rsp),%r12
je     11a0 <solveWithQR+0x90>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r10d,%edi
sub    %edx,%edi
mov    %rdx,%rbx
test   $0x1,%dil
je     1343 <solveWithQR+0x233>
imul   $0x320,%rdx,%rdi
add    -0x48(%rsp),%rdi
movsd  (%rdi,%rsi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r11,%rdx,8),%xmm2
movsd  %xmm2,(%r11,%rdx,8)
lea    0x1(%rdx),%rbx
not    %rdx
cmp    -0x28(%rsp),%rdx
je     11a0 <solveWithQR+0x90>
imul   $0x320,%rbx,%rdx
add    %rcx,%rdx
nopl   0x0(%rax,%rax,1)
movsd  -0x320(%rdx),%xmm2
ff
mulsd  %xmm1,%xmm2
addsd  (%r11,%rbx,8),%xmm2
movsd  %xmm2,(%r11,%rbx,8)
movsd  (%rdx),%xmm2
mulsd  %xmm1,%xmm2
addsd  0x8(%r11,%rbx,8),%xmm2
movsd  %xmm2,0x8(%r11,%rbx,8)
add    $0x2,%rbx
add    $0x640,%rdx
cmp    %rbx,%r10
jne    1360 <solveWithQR+0x250>
jmp    11a0 <solveWithQR+0x90>
mov    -0x48(%rsp),%rdi
mov    -0x4c(%rsp),%esi
mov    -0x38(%rsp),%rdx
mov    %r11,%rcx
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <rsolv@plt>

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

LLVM IR (-O2):
define void @solveWithQR([100 x double]* %0, i32 %1, double* nocapture %2, double* %3, double* %4) {
%6 = icmp sgt i32 %1, 1
br i1 %6, label %7, label %119
7: ; preds = %5
%8 = add nuw i32 %1, 1
%9 = zext i32 %1 to i64
%10 = zext i32 %8 to i64
%11 = zext i32 %8 to i64
%12 = getelementptr double, double* %4, i64 %10
%13 = sub nsw i64 0, %10
br label %14
14: ; preds = %115, %7
%15 = phi i64 [ %118, %115 ], [ 0, %7 ]
%16 = phi i64 [ %116, %115 ], [ 1, %7 ]
%17 = xor i64 %15, -1
%18 = add i64 %17, %10
%19 = getelementptr double, double* %4, i64 %16
%20 = mul nuw nsw i64 %15, 101
%21 = add i64 %20, 1
%22 = getelementptr [100 x double], [100 x double]* %0, i64 1, i64 %21
%23 = add i64 %15, -98
%24 = getelementptr [100 x double], [100 x double]* %0, i64 %10, i64 %23
br label %25
25: ; preds = %14, %25
%26 = phi i64 [ %16, %14 ], [ %33, %25 ]
%27 = phi double [ 0.000000e+00, %14 ], [ %32, %25 ]
%28 = getelementptr inbounds [100 x double], [100 x double]* %0, i64 %26, i64 %16
%29 = load double, double* %28
%30 = getelementptr inbounds double, double* %4, i64 %26
%31 = load double, double* %30
%32 = tail call double @llvm.fmuladd.f64(double %29, double %31, double %27)
%33 = add nuw nsw i64 %26, 1
%34 = icmp eq i64 %33, %10
br i1 %34, label %35, label %25
35: ; preds = %25
%36 = getelementptr inbounds double, double* %2, i64 %16
%37 = load double, double* %36
%38 = fneg double %32
%39 = fdiv double %38, %37
%40 = icmp ult i64 %18, 4
br i1 %40, label %84, label %41
41: ; preds = %35
%42 = icmp ult double* %19, %24
%43 = icmp ult double* %22, %12
%44 = and i1 %42, %43
br i1 %44, label %84, label %45
45: ; preds = %41
%46 = and i64 %18, -4
%47 = add i64 %16, %46
%48 = insertelement <2 x double> poison, double %39, i64 0
%49 = shufflevector <2 x double> %48, <2 x double> poison, <2 x i32> zeroinitializer
%50 = insertelement <2 x double> poison, double %39, i64 0
%51 = shufflevector <2 x double> %50, <2 x double> poison, <2 x i32> zeroinitializer
br label %52
52: ; preds = %52, %45
%53 = phi i64 [ 0, %45 ], [ %80, %52 ]
%54 = add i64 %16, %53
%55 = add i64 %54, 1
%56 = add i64 %54, 2
%57 = add i64 %54, 3
%58 = getelementptr inbounds [100 x double], [100 x double]* %0, i64 %54, i64 %16
%59 = getelementptr inbounds [100 x double], [100 x double]* %0, i64 %55, i64 %16
%60 = getelementptr inbounds [100 x double], [100 x double]* %0, i64 %56, i64 %16
%61 = getelementptr inbounds [100 x double], [100 x double]* %0, i64 %57, i64 %16
%62 = load double, double* %58
%63 = load double, double* %59
%64 = insertelement <2 x double> poison, double %62, i64 0
%65 = insertelement <2 x double> %64, double %63, i64 1
%66 = load double, double* %60
%67 = load double, double* %61
%68 = insertelement <2 x double> poison, double %66, i64 0
%69 = insertelement <2 x double> %68, double %67, i64 1
%70 = getelementptr inbounds double, double* %4, i64 %54
%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 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %49, <2 x double> %65, <2 x double> %72)
%77 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %51, <2 x double> %69, <2 x double> %75)
%78 = bitcast double* %70 to <2 x double>*
store <2 x double> %76, <2 x double>* %78
%79 = bitcast double* %73 to <2 x double>*
store <2 x double> %77, <2 x double>* %79
%80 = add nuw i64 %53, 4
%81 = icmp eq i64 %80, %46
br i1 %81, label %82, label %52
82: ; preds = %52
%83 = icmp eq i64 %18, %46
br i1 %83, label %115, label %84
84: ; preds = %41, %35, %82
%85 = phi i64 [ %16, %41 ], [ %16, %35 ], [ %47, %82 ]
%86 = sub i64 %10, %85
%87 = xor i64 %85, -1
%88 = and i64 %86, 1
%89 = icmp eq i64 %88, 0
br i1 %89, label %97, label %90
90: ; preds = %84
%91 = getelementptr inbounds [100 x double], [100 x double]* %0, i64 %85, i64 %16
%92 = load double, double* %91
%93 = getelementptr inbounds double, double* %4, i64 %85
%94 = load double, double* %93
%95 = tail call double @llvm.fmuladd.f64(double %39, double %92, double %94)
store double %95, double* %93
%96 = add nuw nsw i64 %85, 1
br label %97
97: ; preds = %90, %84
%98 = phi i64 [ %85, %84 ], [ %96, %90 ]
%99 = icmp eq i64 %87, %13
br i1 %99, label %115, label %100
100: ; preds = %97, %100
%101 = phi i64 [ %113, %100 ], [ %98, %97 ]
%102 = getelementptr inbounds [100 x double], [100 x double]* %0, i64 %101, i64 %16
%103 = load double, double* %102
%104 = getelementptr inbounds double, double* %4, i64 %101
%105 = load double, double* %104
%106 = tail call double @llvm.fmuladd.f64(double %39, double %103, double %105)
store double %106, double* %104
%107 = add nuw nsw i64 %101, 1
%108 = getelementptr inbounds [100 x double], [100 x double]* %0, i64 %107, i64 %16
%109 = load double, double* %108
%110 = getelementptr inbounds double, double* %4, i64 %107
%111 = load double, double* %110
%112 = tail call double @llvm.fmuladd.f64(double %39, double %109, double %111)
store double %112, double* %110
%113 = add nuw nsw i64 %101, 2
%114 = icmp eq i64 %113, %11
br i1 %114, label %115, label %100
115: ; preds = %97, %100, %82
%116 = add nuw nsw i64 %16, 1
%117 = icmp eq i64 %116, %9
%118 = add i64 %15, 1
br i1 %117, label %119, label %14
119: ; preds = %115, %5
%120 = bitcast [100 x double]* %0 to double**
%121 = tail call i32 @rsolv(double** %120, i32 %1, double* %3, double* %4)
ret void
}