void vector_up(float equation[], int ivar, int idim, float low_vector[],
               float vector[]) {
  int i;
  vector[ivar] = 0.0;
  for (i = 0; i < ivar; i++) {
    vector[i] = low_vector[i];
    vector[ivar] -= equation[i] * low_vector[i];
  }
  for (i = ivar + 1; i <= idim; i++) {
    vector[i] = low_vector[i - 1];
    vector[ivar] -= equation[i] * low_vector[i - 1];
  }
  vector[ivar] /= equation[ivar];
}


x86 assembly (clang, -O0):
<vector_up>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11a3 <vector_up+0xa3>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    112d <vector_up+0x2d>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     122c <vector_up+0x12c>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ac <vector_up+0xac>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<vector_up>:
movslq %esi,%r10
movl   $0x0,(%r8,%r10,4)
test   %r10d,%r10d
jle    111c <vector_up+0x1c>
mov    %esi,%r9d
cmp    $0x1,%esi
jne    1124 <vector_up+0x24>
xor    %eax,%eax
jmp    1187 <vector_up+0x87>
xorps  %xmm0,%xmm0
jmp    11b2 <vector_up+0xb2>
mov    %r9d,%r11d
and    $0xfffffffe,%r11d
xor    %eax,%eax
nopl   (%rax)
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%r8,%rax,4)
movss  (%rdi,%rax,4),%xmm0
movss  (%r8,%r10,4),%xmm1
mulss  (%rcx,%rax,4),%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,(%r8,%r10,4)
movss  0x4(%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%r8,%rax,4)
movss  0x4(%rdi,%rax,4),%xmm1
movss  (%r8,%r10,4),%xmm0
mulss  0x4(%rcx,%rax,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r8,%r10,4)
add    $0x2,%rax
cmp    %rax,%r11
jne    1130 <vector_up+0x30>
test   $0x1,%r9b
je     11b2 <vector_up+0xb2>
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,(%r8,%rax,4)
movss  (%rdi,%rax,4),%xmm1
movss  (%r8,%r10,4),%xmm0
mulss  (%rcx,%rax,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r8,%r10,4)
cmp    %edx,%esi
jge    125c <vector_up+0x15c>
movslq %edx,%r9
sub    %esi,%edx
mov    %r10,%rsi
not    %rsi
mov    %r10,%rax
test   $0x1,%dl
je     11fb <vector_up+0xfb>
lea    0x1(%r10),%rax
movss  (%rcx,%r10,4),%xmm0
movss  %xmm0,0x4(%r8,%r10,4)
movss  0x4(%rdi,%r10,4),%xmm1
movss  (%r8,%r10,4),%xmm0
mulss  (%rcx,%r10,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r8,%r10,4)
add    %r9,%rsi
je     125c <vector_up+0x15c>
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x4(%r8,%rax,4)
movss  0x4(%rdi,%rax,4),%xmm0
movss  (%r8,%r10,4),%xmm1
mulss  (%rcx,%rax,4),%xmm0
subss  %xmm0,%xmm1
movss  %xmm1,(%r8,%r10,4)
movss  0x4(%rcx,%rax,4),%xmm0
movss  %xmm0,0x8(%r8,%rax,4)
movss  0x8(%rdi,%rax,4),%xmm1
mulss  0x4(%rcx,%rax,4),%xmm1
lea    0x2(%rax),%rdx
movss  (%r8,%r10,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%r8,%r10,4)
mov    %rdx,%rax
cmp    %rdx,%r9
jne    1200 <vector_up+0x100>
divss  (%rdi,%r10,4),%xmm0
movss  %xmm0,(%r8,%r10,4)
ret

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

LLVM IR (-O2):
define void @vector_up(float* nocapture %0, i32 %1, i32 %2, float* nocapture %3, float* nocapture %4) {
%6 = sext i32 %1 to i64
%7 = getelementptr inbounds float, float* %4, i64 %6
store float 0.000000e+00, float* %7
%8 = icmp sgt i32 %1, 0
br i1 %8, label %9, label %29
9: ; preds = %5
%10 = zext i32 %1 to i64
%11 = and i64 %10, 1
%12 = icmp eq i32 %1, 1
br i1 %12, label %15, label %13
13: ; preds = %9
%14 = and i64 %10, 4294967294
br label %54
15: ; preds = %54, %9
%16 = phi float [ undef, %9 ], [ %75, %54 ]
%17 = phi i64 [ 0, %9 ], [ %76, %54 ]
%18 = icmp eq i64 %11, 0
br i1 %18, label %29, label %19
19: ; preds = %15
%20 = getelementptr inbounds float, float* %3, i64 %17
%21 = load float, float* %20
%22 = getelementptr inbounds float, float* %4, i64 %17
store float %21, float* %22
%23 = getelementptr inbounds float, float* %0, i64 %17
%24 = load float, float* %23
%25 = load float, float* %20
%26 = load float, float* %7
%27 = fneg float %24
%28 = tail call float @llvm.fmuladd.f32(float %27, float %25, float %26)
store float %28, float* %7
br label %29
29: ; preds = %19, %15, %5
%30 = phi float [ 0.000000e+00, %5 ], [ %16, %15 ], [ %28, %19 ]
%31 = icmp slt i32 %1, %2
br i1 %31, label %32, label %102
32: ; preds = %29
%33 = sext i32 %2 to i64
%34 = sub nsw i64 %33, %6
%35 = xor i64 %6, -1
%36 = and i64 %34, 1
%37 = icmp eq i64 %36, 0
br i1 %37, label %49, label %38
38: ; preds = %32
%39 = add nsw i64 %6, 1
%40 = getelementptr inbounds float, float* %3, i64 %6
%41 = load float, float* %40
%42 = getelementptr inbounds float, float* %4, i64 %39
store float %41, float* %42
%43 = getelementptr inbounds float, float* %0, i64 %39
%44 = load float, float* %43
%45 = load float, float* %40
%46 = load float, float* %7
%47 = fneg float %44
%48 = tail call float @llvm.fmuladd.f32(float %47, float %45, float %46)
store float %48, float* %7
br label %49
49: ; preds = %38, %32
%50 = phi float [ undef, %32 ], [ %48, %38 ]
%51 = phi i64 [ %6, %32 ], [ %39, %38 ]
%52 = sub nsw i64 0, %33
%53 = icmp eq i64 %35, %52
br i1 %53, label %102, label %79
54: ; preds = %54, %13
%55 = phi i64 [ 0, %13 ], [ %76, %54 ]
%56 = phi i64 [ 0, %13 ], [ %77, %54 ]
%57 = getelementptr inbounds float, float* %3, i64 %55
%58 = load float, float* %57
%59 = getelementptr inbounds float, float* %4, i64 %55
store float %58, float* %59
%60 = getelementptr inbounds float, float* %0, i64 %55
%61 = load float, float* %60
%62 = load float, float* %57
%63 = load float, float* %7
%64 = fneg float %61
%65 = tail call float @llvm.fmuladd.f32(float %64, float %62, float %63)
store float %65, float* %7
%66 = or i64 %55, 1
%67 = getelementptr inbounds float, float* %3, i64 %66
%68 = load float, float* %67
%69 = getelementptr inbounds float, float* %4, i64 %66
store float %68, float* %69
%70 = getelementptr inbounds float, float* %0, i64 %66
%71 = load float, float* %70
%72 = load float, float* %67
%73 = load float, float* %7
%74 = fneg float %71
%75 = tail call float @llvm.fmuladd.f32(float %74, float %72, float %73)
store float %75, float* %7
%76 = add nuw nsw i64 %55, 2
%77 = add i64 %56, 2
%78 = icmp eq i64 %77, %14
br i1 %78, label %15, label %54
79: ; preds = %49, %79
%80 = phi i64 [ %91, %79 ], [ %51, %49 ]
%81 = add nsw i64 %80, 1
%82 = getelementptr inbounds float, float* %3, i64 %80
%83 = load float, float* %82
%84 = getelementptr inbounds float, float* %4, i64 %81
store float %83, float* %84
%85 = getelementptr inbounds float, float* %0, i64 %81
%86 = load float, float* %85
%87 = load float, float* %82
%88 = load float, float* %7
%89 = fneg float %86
%90 = tail call float @llvm.fmuladd.f32(float %89, float %87, float %88)
store float %90, float* %7
%91 = add nsw i64 %80, 2
%92 = getelementptr inbounds float, float* %3, i64 %81
%93 = load float, float* %92
%94 = getelementptr inbounds float, float* %4, i64 %91
store float %93, float* %94
%95 = getelementptr inbounds float, float* %0, i64 %91
%96 = load float, float* %95
%97 = load float, float* %92
%98 = load float, float* %7
%99 = fneg float %96
%100 = tail call float @llvm.fmuladd.f32(float %99, float %97, float %98)
store float %100, float* %7
%101 = icmp eq i64 %91, %33
br i1 %101, label %102, label %79
102: ; preds = %49, %79, %29
%103 = phi float [ %30, %29 ], [ %50, %49 ], [ %100, %79 ]
%104 = getelementptr inbounds float, float* %0, i64 %6
%105 = load float, float* %104
%106 = fdiv float %103, %105
store float %106, float* %7
ret void
}