#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 */
float sqrt(float);
int main() {
  int M, N;
  float **A;
  float *s;
  float *Rdiag;
  float *nrm;
  int i, j, k;
  float t;
  for (k = 0; k < N; k++) {
    nrm[k] = 0;
    for (i = k; i < M; i++)
      nrm[k] = sqrt(nrm[k] * nrm[k] + A[i][k] * A[i][k]);
    for (i = k; i < M; i++)
      A[i][k] = A[i][k] / nrm[k];
    A[k][k] = A[k][k] + 1;
    for (j = k + 1; j < N; j++) {
      s[j] = 0;
      for (i = k; i < M; i++)
        s[j] = s[j] + A[i][k] * A[i][j];
      s[j] = -s[j] / A[k][k];
      for (i = k; i < M; i++)
        A[i][j] = A[i][j] + s[j] * A[i][k];
    }
    Rdiag[k] = -nrm[k];
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13d2 <main+0x2c2>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11c0 <main+0xb0>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1030 <sqrt@plt>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1148 <main+0x38>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1217 <main+0x107>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11c6 <main+0xb6>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  0xdd1(%rip),%xmm0
addss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    139d <main+0x28d>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12da <main+0x1ca>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1274 <main+0x164>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    138a <main+0x27a>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    131c <main+0x20c>
jmp    138f <main+0x27f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1252 <main+0x142>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1126 <main+0x16>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
xor    %eax,%eax
ret

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

LLVM IR (-O2):
define i32 @main() {
ret i32 0
}