#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 random();
int MatGen(int n, double **S, double range) {
  int i, j;
  double temp;
  for (i = 0; i < n; ++i) {
    for (j = 0; j < n; ++j) {
      temp = (double)(random() % (int)(100.0 * range)) / 100.0;
      if (random() % 2)
        temp *= -1;
      S[i][j] = temp;
    }
  }
  for (i = 0; i < n; ++i) {
    temp = 0;
    for (j = 0; j < n; ++j)
      if (S[i][i] * S[i][j] > 0)
        temp += S[i][j];
      else
        temp -= S[i][j];
    S[i][i] += temp / n * 10;
  }
  return 0;
}


x86 assembly (clang, -O0):
<MatGen>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11df <MatGen+0xcf>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11cc <MatGen+0xbc>
mov    $0x0,%al
call   1030 <random@plt>
movsd  0xeaf(%rip),%xmm0
mulsd  -0x18(%rbp),%xmm0
cvttsd2si %xmm0,%ecx
cltd
idiv   %ecx
cvtsi2sd %edx,%xmm0
movsd  0xe97(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
mov    $0x0,%al
call   1030 <random@plt>
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     11a4 <MatGen+0x94>
movsd  0xe76(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113e <MatGen+0x2e>
jmp    11d1 <MatGen+0xc1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112b <MatGen+0x1b>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12e4 <MatGen+0x1d4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    129e <MatGen+0x18e>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1268 <MatGen+0x158>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    128b <MatGen+0x17b>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
jmp    1290 <MatGen+0x180>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1201 <MatGen+0xf1>
movsd  -0x28(%rbp),%xmm0
cvtsi2sdl -0x4(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xd37(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11e6 <MatGen+0xd6>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MatGen>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
test   %edi,%edi
jle    12c7 <MatGen+0x1b7>
mov    %rsi,%r15
mov    %edi,%r14d
mulsd  0xecc(%rip),%xmm0
cvttsd2si %xmm0,%r13d
mov    %edi,%r12d
xor    %ebp,%ebp
jmp    1149 <MatGen+0x39>
add    $0x1,%rbp
cmp    %r12,%rbp
je     11a0 <MatGen+0x90>
xor    %ebx,%ebx
jmp    116f <MatGen+0x5f>
nopl   (%rax)
movapd (%rsp),%xmm0
xorpd  0xeb3(%rip),%xmm0
mov    (%r15,%rbp,8),%rax
movsd  %xmm0,(%rax,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r12
je     1140 <MatGen+0x30>
xor    %eax,%eax
call   1030 <random@plt>
cltd
idiv   %r13d
xorps  %xmm0,%xmm0
cvtsi2sd %edx,%xmm0
divsd  0xe77(%rip),%xmm0
movapd %xmm0,(%rsp)
xor    %eax,%eax
call   1030 <random@plt>
test   $0x1,%al
jne    1150 <MatGen+0x40>
movapd (%rsp),%xmm0
jmp    115d <MatGen+0x4d>
test   %r14d,%r14d
jle    12c7 <MatGen+0x1b7>
xorps  %xmm0,%xmm0
cvtsi2sd %r14d,%xmm0
mov    %r12d,%eax
and    $0xfffffffe,%eax
xor    %ecx,%ecx
movsd  0xe46(%rip),%xmm8
movapd 0xe46(%rip),%xmm2
jmp    11ef <MatGen+0xdf>
nopl   0x0(%rax)
divsd  %xmm0,%xmm4
mulsd  %xmm8,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rdx,%rcx,8)
add    $0x1,%rcx
cmp    %r12,%rcx
je     12c7 <MatGen+0x1b7>
mov    (%r15,%rcx,8),%rdx
movsd  (%rdx,%rcx,8),%xmm3
cmp    $0x1,%r14d
jne    1210 <MatGen+0x100>
xor    %esi,%esi
xorpd  %xmm4,%xmm4
jmp    1286 <MatGen+0x176>
nopl   0x0(%rax)
xorpd  %xmm4,%xmm4
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm5
movsd  0x8(%rdx,%rsi,8),%xmm6
movapd %xmm3,%xmm7
mulsd  %xmm5,%xmm7
xorpd  %xmm1,%xmm1
cmpltsd %xmm7,%xmm1
movapd %xmm1,%xmm7
andpd  %xmm5,%xmm7
xorpd  %xmm2,%xmm5
andnpd %xmm5,%xmm1
orpd   %xmm7,%xmm1
addsd  %xmm4,%xmm1
movapd %xmm3,%xmm5
mulsd  %xmm6,%xmm5
xorpd  %xmm4,%xmm4
cmpltsd %xmm5,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm6,%xmm5
xorpd  %xmm2,%xmm6
andnpd %xmm6,%xmm4
orpd   %xmm5,%xmm4
addsd  %xmm1,%xmm4
add    $0x2,%rsi
cmp    %rsi,%rax
jne    1220 <MatGen+0x110>
test   $0x1,%r12b
je     11d0 <MatGen+0xc0>
movsd  (%rdx,%rsi,8),%xmm1
movapd %xmm3,%xmm5
mulsd  %xmm1,%xmm5
xorpd  %xmm6,%xmm6
cmpltsd %xmm5,%xmm6
movapd %xmm6,%xmm5
andpd  %xmm1,%xmm5
xorpd  0xd5a(%rip),%xmm1
andnpd %xmm1,%xmm6
orpd   %xmm5,%xmm6
addsd  %xmm6,%xmm4
jmp    11d0 <MatGen+0xc0>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @MatGen(i32 %0, double** %1, double %2) {
%4 = alloca i32
%5 = alloca double**
%6 = alloca double
%7 = alloca i32
%8 = alloca i32
%9 = alloca double
store i32 %0, i32* %4
store double** %1, double*** %5
store double %2, double* %6
store i32 0, i32* %7
br label %10
10: ; preds = %47, %3
%11 = load i32, i32* %7
%12 = load i32, i32* %4
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %50
14: ; preds = %10
store i32 0, i32* %8
br label %15
15: ; preds = %43, %14
%16 = load i32, i32* %8
%17 = load i32, i32* %4
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %46
19: ; preds = %15
%20 = call i32 (...) @random()
%21 = load double, double* %6
%22 = fmul double 1.000000e+02, %21
%23 = fptosi double %22 to i32
%24 = srem i32 %20, %23
%25 = sitofp i32 %24 to double
%26 = fdiv double %25, 1.000000e+02
store double %26, double* %9
%27 = call i32 (...) @random()
%28 = srem i32 %27, 2
%29 = icmp ne i32 %28, 0
br i1 %29, label %30, label %33
30: ; preds = %19
%31 = load double, double* %9
%32 = fmul double %31, -1.000000e+00
store double %32, double* %9
br label %33
33: ; preds = %30, %19
%34 = load double, double* %9
%35 = load double**, double*** %5
%36 = load i32, i32* %7
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds double*, double** %35, i64 %37
%39 = load double*, double** %38
%40 = load i32, i32* %8
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds double, double* %39, i64 %41
store double %34, double* %42
br label %43
43: ; preds = %33
%44 = load i32, i32* %8
%45 = add nsw i32 %44, 1
store i32 %45, i32* %8
br label %15
46: ; preds = %15
br label %47
47: ; preds = %46
%48 = load i32, i32* %7
%49 = add nsw i32 %48, 1
store i32 %49, i32* %7
br label %10
50: ; preds = %10
store i32 0, i32* %7
br label %51
51: ; preds = %124, %50
%52 = load i32, i32* %7
%53 = load i32, i32* %4
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %127
55: ; preds = %51
store double 0.000000e+00, double* %9
store i32 0, i32* %8
br label %56
56: ; preds = %106, %55
%57 = load i32, i32* %8
%58 = load i32, i32* %4
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %109
60: ; preds = %56
%61 = load double**, double*** %5
%62 = load i32, i32* %7
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds double*, double** %61, i64 %63
%65 = load double*, double** %64
%66 = load i32, i32* %7
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %65, i64 %67
%69 = load double, double* %68
%70 = load double**, double*** %5
%71 = load i32, i32* %7
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double*, double** %70, i64 %72
%74 = load double*, double** %73
%75 = load i32, i32* %8
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds double, double* %74, i64 %76
%78 = load double, double* %77
%79 = fmul double %69, %78
%80 = fcmp ogt double %79, 0.000000e+00
br i1 %80, label %81, label %93
81: ; preds = %60
%82 = load double**, double*** %5
%83 = load i32, i32* %7
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds double*, double** %82, i64 %84
%86 = load double*, double** %85
%87 = load i32, i32* %8
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds double, double* %86, i64 %88
%90 = load double, double* %89
%91 = load double, double* %9
%92 = fadd double %91, %90
store double %92, double* %9
br label %105
93: ; preds = %60
%94 = load double**, double*** %5
%95 = load i32, i32* %7
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double*, double** %94, i64 %96
%98 = load double*, double** %97
%99 = load i32, i32* %8
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %98, i64 %100
%102 = load double, double* %101
%103 = load double, double* %9
%104 = fsub double %103, %102
store double %104, double* %9
br label %105
105: ; preds = %93, %81
br label %106
106: ; preds = %105
%107 = load i32, i32* %8
%108 = add nsw i32 %107, 1
store i32 %108, i32* %8
br label %56
109: ; preds = %56
%110 = load double, double* %9
%111 = load i32, i32* %4
%112 = sitofp i32 %111 to double
%113 = fdiv double %110, %112
%114 = load double**, double*** %5
%115 = load i32, i32* %7
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds double*, double** %114, i64 %116
%118 = load double*, double** %117
%119 = load i32, i32* %7
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
%122 = load double, double* %121
%123 = call double @llvm.fmuladd.f64(double %113, double 1.000000e+01, double %122)
store double %123, double* %121
br label %124
124: ; preds = %109
%125 = load i32, i32* %7
%126 = add nsw i32 %125, 1
store i32 %126, i32* %7
br label %51
127: ; preds = %51
ret i32 0
}

LLVM IR (-O2):
define i32 @MatGen(i32 %0, double** nocapture %1, double %2) {
%4 = icmp sgt i32 %0, 0
br i1 %4, label %5, label %85
5: ; preds = %3
%6 = fmul double %2, 1.000000e+02
%7 = fptosi double %6 to i32
%8 = zext i32 %0 to i64
br label %9
9: ; preds = %35, %5
%10 = phi i64 [ 0, %5 ], [ %36, %35 ]
%11 = getelementptr inbounds double*, double** %1, i64 %10
br label %20
12: ; preds = %35
br i1 %4, label %13, label %85
13: ; preds = %12
%14 = sitofp i32 %0 to double
%15 = zext i32 %0 to i64
%16 = and i64 %8, 1
%17 = icmp eq i32 %0, 1
%18 = and i64 %8, 4294967294
%19 = icmp eq i64 %16, 0
br label %38
20: ; preds = %9, %20
%21 = phi i64 [ 0, %9 ], [ %33, %20 ]
%22 = tail call i32 (...) @random()
%23 = srem i32 %22, %7
%24 = sitofp i32 %23 to double
%25 = fdiv double %24, 1.000000e+02
%26 = tail call i32 (...) @random()
%27 = and i32 %26, 1
%28 = icmp eq i32 %27, 0
%29 = fneg double %25
%30 = select i1 %28, double %25, double %29
%31 = load double*, double** %11
%32 = getelementptr inbounds double, double* %31, i64 %21
store double %30, double* %32
%33 = add nuw nsw i64 %21, 1
%34 = icmp eq i64 %33, %8
br i1 %34, label %35, label %20
35: ; preds = %20
%36 = add nuw nsw i64 %10, 1
%37 = icmp eq i64 %36, %8
br i1 %37, label %12, label %9
38: ; preds = %78, %13
%39 = phi i64 [ 0, %13 ], [ %83, %78 ]
%40 = getelementptr inbounds double*, double** %1, i64 %39
%41 = load double*, double** %40
%42 = getelementptr inbounds double, double* %41, i64 %39
%43 = load double, double* %42
br i1 %17, label %66, label %44
44: ; preds = %38, %44
%45 = phi i64 [ %63, %44 ], [ 0, %38 ]
%46 = phi double [ %62, %44 ], [ 0.000000e+00, %38 ]
%47 = phi i64 [ %64, %44 ], [ 0, %38 ]
%48 = getelementptr inbounds double, double* %41, i64 %45
%49 = load double, double* %48
%50 = fmul double %43, %49
%51 = fcmp ogt double %50, 0.000000e+00
%52 = fneg double %49
%53 = select i1 %51, double %49, double %52
%54 = fadd double %46, %53
%55 = or i64 %45, 1
%56 = getelementptr inbounds double, double* %41, i64 %55
%57 = load double, double* %56
%58 = fmul double %43, %57
%59 = fcmp ogt double %58, 0.000000e+00
%60 = fneg double %57
%61 = select i1 %59, double %57, double %60
%62 = fadd double %54, %61
%63 = add nuw nsw i64 %45, 2
%64 = add i64 %47, 2
%65 = icmp eq i64 %64, %18
br i1 %65, label %66, label %44
66: ; preds = %44, %38
%67 = phi double [ undef, %38 ], [ %62, %44 ]
%68 = phi i64 [ 0, %38 ], [ %63, %44 ]
%69 = phi double [ 0.000000e+00, %38 ], [ %62, %44 ]
br i1 %19, label %78, label %70
70: ; preds = %66
%71 = getelementptr inbounds double, double* %41, i64 %68
%72 = load double, double* %71
%73 = fmul double %43, %72
%74 = fcmp ogt double %73, 0.000000e+00
%75 = fneg double %72
%76 = select i1 %74, double %72, double %75
%77 = fadd double %69, %76
br label %78
78: ; preds = %66, %70
%79 = phi double [ %67, %66 ], [ %77, %70 ]
%80 = fdiv double %79, %14
%81 = getelementptr inbounds double, double* %41, i64 %39
%82 = tail call double @llvm.fmuladd.f64(double %80, double 1.000000e+01, double %43)
store double %82, double* %81
%83 = add nuw nsw i64 %39, 1
%84 = icmp eq i64 %83, %15
br i1 %84, label %85, label %38
85: ; preds = %78, %3, %12
ret i32 0
}