void generateTPMatrix(double **matrix, int n) {
  for (int i = 0; i < n; i++) {
    int count = 0;
    for (int l = 0; l < n; l++) {
      if (matrix[i][l] != 0.0)
        ++count;
    }
    for (int l = 0; l < n; l++) {
      if (count == 0)
        matrix[i][l] = 1.0 / (double)n;
      else
        matrix[i][l] /= count;
    }
  }
  return;
}


x86 assembly (clang, -O0):
<generateTPMatrix>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1212 <generateTPMatrix+0x112>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1181 <generateTPMatrix+0x81>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1165 <generateTPMatrix+0x65>
jp     1165 <generateTPMatrix+0x65>
jmp    116e <generateTPMatrix+0x6e>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1173 <generateTPMatrix+0x73>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    112c <generateTPMatrix+0x2c>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11ff <generateTPMatrix+0xff>
cmpl   $0x0,-0x14(%rbp)
jne    11c9 <generateTPMatrix+0xc9>
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  0xe55(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    11ec <generateTPMatrix+0xec>
cvtsi2sdl -0x14(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    11f1 <generateTPMatrix+0xf1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1188 <generateTPMatrix+0x88>
jmp    1204 <generateTPMatrix+0x104>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1112 <generateTPMatrix+0x12>
pop    %rbp
ret

x86 assembly (clang, -O2):
<generateTPMatrix>:
push   %rbp
push   %r15
push   %r14
push   %rbx
test   %esi,%esi
jle    12fe <generateTPMatrix+0x1fe>
cvtsi2sd %esi,%xmm1
movsd  0xee6(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    %esi,%eax
mov    %eax,%r11d
and    $0xfffffffc,%r11d
lea    -0x4(%r11),%r8
mov    %r8,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %r10,%r9
and    $0xfffffffffffffffe,%r9
mov    %eax,%r15d
and    $0xfffffffe,%r15d
xor    %r14d,%r14d
xorpd  %xmm8,%xmm8
xorpd  %xmm2,%xmm2
jmp    1172 <generateTPMatrix+0x72>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm4,(%rcx,%rbx,8)
add    $0x1,%r14
cmp    %rax,%r14
je     12fe <generateTPMatrix+0x1fe>
mov    (%rdi,%r14,8),%rbx
cmp    $0x4,%esi
jae    1190 <generateTPMatrix+0x90>
xor    %ecx,%ecx
xor    %ebp,%ebp
jmp    1250 <generateTPMatrix+0x150>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
pxor   %xmm3,%xmm3
test   %r8,%r8
je     12e9 <generateTPMatrix+0x1e9>
mov    %r9,%rcx
xor    %ebp,%ebp
pxor   %xmm4,%xmm4
cs nopw 0x0(%rax,%rax,1)
movupd (%rbx,%rbp,8),%xmm5
movupd 0x10(%rbx,%rbp,8),%xmm6
movupd 0x20(%rbx,%rbp,8),%xmm7
movupd 0x30(%rbx,%rbp,8),%xmm1
cmpneqpd %xmm2,%xmm5
shufps $0xe8,%xmm5,%xmm5
psubd  %xmm5,%xmm3
cmpneqpd %xmm2,%xmm6
shufps $0xe8,%xmm6,%xmm6
psubd  %xmm6,%xmm4
cmpneqpd %xmm2,%xmm7
shufps $0xe8,%xmm7,%xmm7
psubd  %xmm7,%xmm3
cmpneqpd %xmm2,%xmm1
shufps $0xe8,%xmm1,%xmm1
psubd  %xmm1,%xmm4
add    $0x8,%rbp
add    $0xfffffffffffffffe,%rcx
jne    11b0 <generateTPMatrix+0xb0>
test   $0x1,%r10b
je     1230 <generateTPMatrix+0x130>
movupd (%rbx,%rbp,8),%xmm1
movupd 0x10(%rbx,%rbp,8),%xmm5
cmpneqpd %xmm2,%xmm1
shufps $0xe8,%xmm1,%xmm1
psubd  %xmm1,%xmm3
cmpneqpd %xmm2,%xmm5
shufps $0xe8,%xmm5,%xmm5
psubd  %xmm5,%xmm4
paddd  %xmm4,%xmm3
pshufd $0x55,%xmm3,%xmm1
paddd  %xmm3,%xmm1
movd   %xmm1,%ebp
mov    %r11,%rcx
cmp    %rax,%r11
je     126b <generateTPMatrix+0x16b>
nopl   0x0(%rax)
movsd  (%rbx,%rcx,8),%xmm1
cmpneqsd %xmm8,%xmm1
movq   %xmm1,%rdx
sub    %edx,%ebp
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1250 <generateTPMatrix+0x150>
xorps  %xmm3,%xmm3
cvtsi2sd %ebp,%xmm3
cmp    $0x1,%esi
jne    12a0 <generateTPMatrix+0x1a0>
xor    %ebx,%ebx
test   $0x1,%al
je     1165 <generateTPMatrix+0x65>
mov    (%rdi,%r14,8),%rcx
movapd %xmm0,%xmm4
test   %ebp,%ebp
je     1160 <generateTPMatrix+0x60>
movsd  (%rcx,%rbx,8),%xmm4
divsd  %xmm3,%xmm4
jmp    1160 <generateTPMatrix+0x60>
nop
mov    (%rdi,%r14,8),%rcx
xor    %ebx,%ebx
jmp    12bf <generateTPMatrix+0x1bf>
nopl   0x0(%rax,%rax,1)
movsd  %xmm4,0x8(%rcx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r15
je     1279 <generateTPMatrix+0x179>
movapd %xmm0,%xmm4
test   %ebp,%ebp
je     12d0 <generateTPMatrix+0x1d0>
movsd  (%rcx,%rbx,8),%xmm4
divsd  %xmm3,%xmm4
movsd  %xmm4,(%rcx,%rbx,8)
movapd %xmm0,%xmm4
test   %ebp,%ebp
je     12b0 <generateTPMatrix+0x1b0>
movsd  0x8(%rcx,%rbx,8),%xmm4
divsd  %xmm3,%xmm4
jmp    12b0 <generateTPMatrix+0x1b0>
xor    %ebp,%ebp
pxor   %xmm4,%xmm4
test   $0x1,%r10b
jne    120b <generateTPMatrix+0x10b>
jmp    1230 <generateTPMatrix+0x130>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @generateTPMatrix(double** %0, i32 %1) {
%3 = alloca double**
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store double** %0, double*** %3
store i32 %1, i32* %4
store i32 0, i32* %5
br label %9
9: ; preds = %74, %2
%10 = load i32, i32* %5
%11 = load i32, i32* %4
%12 = icmp slt i32 %10, %11
br i1 %12, label %13, label %77
13: ; preds = %9
store i32 0, i32* %6
store i32 0, i32* %7
br label %14
14: ; preds = %33, %13
%15 = load i32, i32* %7
%16 = load i32, i32* %4
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %36
18: ; preds = %14
%19 = load double**, double*** %3
%20 = load i32, i32* %5
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds double*, double** %19, i64 %21
%23 = load double*, double** %22
%24 = load i32, i32* %7
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds double, double* %23, i64 %25
%27 = load double, double* %26
%28 = fcmp une double %27, 0.000000e+00
br i1 %28, label %29, label %32
29: ; preds = %18
%30 = load i32, i32* %6
%31 = add nsw i32 %30, 1
store i32 %31, i32* %6
br label %32
32: ; preds = %29, %18
br label %33
33: ; preds = %32
%34 = load i32, i32* %7
%35 = add nsw i32 %34, 1
store i32 %35, i32* %7
br label %14
36: ; preds = %14
store i32 0, i32* %8
br label %37
37: ; preds = %70, %36
%38 = load i32, i32* %8
%39 = load i32, i32* %4
%40 = icmp slt i32 %38, %39
br i1 %40, label %41, label %73
41: ; preds = %37
%42 = load i32, i32* %6
%43 = icmp eq i32 %42, 0
br i1 %43, label %44, label %56
44: ; preds = %41
%45 = load i32, i32* %4
%46 = sitofp i32 %45 to double
%47 = fdiv double 1.000000e+00, %46
%48 = load double**, double*** %3
%49 = load i32, i32* %5
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds double*, double** %48, i64 %50
%52 = load double*, double** %51
%53 = load i32, i32* %8
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
store double %47, double* %55
br label %69
56: ; preds = %41
%57 = load i32, i32* %6
%58 = sitofp i32 %57 to double
%59 = load double**, double*** %3
%60 = load i32, i32* %5
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double*, double** %59, i64 %61
%63 = load double*, double** %62
%64 = load i32, i32* %8
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double, double* %63, i64 %65
%67 = load double, double* %66
%68 = fdiv double %67, %58
store double %68, double* %66
br label %69
69: ; preds = %56, %44
br label %70
70: ; preds = %69
%71 = load i32, i32* %8
%72 = add nsw i32 %71, 1
store i32 %72, i32* %8
br label %37
73: ; preds = %37
br label %74
74: ; preds = %73
%75 = load i32, i32* %5
%76 = add nsw i32 %75, 1
store i32 %76, i32* %5
br label %9
77: ; preds = %9
ret void
}

LLVM IR (-O2):
define void @generateTPMatrix(double** nocapture %0, i32 %1) {
%3 = icmp sgt i32 %1, 0
br i1 %3, label %4, label %88
4: ; preds = %2
%5 = sitofp i32 %1 to double
%6 = fdiv double 1.000000e+00, %5
%7 = zext i32 %1 to i64
%8 = and i64 %7, 4294967292
%9 = add nsw i64 %8, -4
%10 = lshr exact i64 %9, 2
%11 = add nuw nsw i64 %10, 1
%12 = icmp ult i32 %1, 4
%13 = and i64 %7, 4294967292
%14 = and i64 %11, 1
%15 = icmp eq i64 %9, 0
%16 = and i64 %11, 9223372036854775806
%17 = icmp eq i64 %14, 0
%18 = icmp eq i64 %13, %7
%19 = and i64 %7, 1
%20 = icmp eq i32 %1, 1
%21 = and i64 %7, 4294967294
%22 = icmp eq i64 %19, 0
br label %23
23: ; preds = %117, %4
%24 = phi i64 [ 0, %4 ], [ %118, %117 ]
%25 = getelementptr inbounds double*, double** %0, i64 %24
%26 = load double*, double** %25
br i1 %12, label %85, label %27
27: ; preds = %23
br i1 %15, label %61, label %28
28: ; preds = %27, %28
%29 = phi i64 [ %58, %28 ], [ 0, %27 ]
%30 = phi <2 x i32> [ %56, %28 ], [ zeroinitializer, %27 ]
%31 = phi <2 x i32> [ %57, %28 ], [ zeroinitializer, %27 ]
%32 = phi i64 [ %59, %28 ], [ 0, %27 ]
%33 = getelementptr inbounds double, double* %26, i64 %29
%34 = bitcast double* %33 to <2 x double>*
%35 = load <2 x double>, <2 x double>* %34
%36 = getelementptr inbounds double, double* %33, i64 2
%37 = bitcast double* %36 to <2 x double>*
%38 = load <2 x double>, <2 x double>* %37
%39 = fcmp une <2 x double> %35, zeroinitializer
%40 = fcmp une <2 x double> %38, zeroinitializer
%41 = zext <2 x i1> %39 to <2 x i32>
%42 = zext <2 x i1> %40 to <2 x i32>
%43 = add <2 x i32> %30, %41
%44 = add <2 x i32> %31, %42
%45 = or i64 %29, 4
%46 = getelementptr inbounds double, double* %26, i64 %45
%47 = bitcast double* %46 to <2 x double>*
%48 = load <2 x double>, <2 x double>* %47
%49 = getelementptr inbounds double, double* %46, i64 2
%50 = bitcast double* %49 to <2 x double>*
%51 = load <2 x double>, <2 x double>* %50
%52 = fcmp une <2 x double> %48, zeroinitializer
%53 = fcmp une <2 x double> %51, zeroinitializer
%54 = zext <2 x i1> %52 to <2 x i32>
%55 = zext <2 x i1> %53 to <2 x i32>
%56 = add <2 x i32> %43, %54
%57 = add <2 x i32> %44, %55
%58 = add nuw i64 %29, 8
%59 = add i64 %32, 2
%60 = icmp eq i64 %59, %16
br i1 %60, label %61, label %28
61: ; preds = %28, %27
%62 = phi <2 x i32> [ undef, %27 ], [ %56, %28 ]
%63 = phi <2 x i32> [ undef, %27 ], [ %57, %28 ]
%64 = phi i64 [ 0, %27 ], [ %58, %28 ]
%65 = phi <2 x i32> [ zeroinitializer, %27 ], [ %56, %28 ]
%66 = phi <2 x i32> [ zeroinitializer, %27 ], [ %57, %28 ]
br i1 %17, label %80, label %67
67: ; preds = %61
%68 = getelementptr inbounds double, double* %26, i64 %64
%69 = bitcast double* %68 to <2 x double>*
%70 = load <2 x double>, <2 x double>* %69
%71 = getelementptr inbounds double, double* %68, i64 2
%72 = bitcast double* %71 to <2 x double>*
%73 = load <2 x double>, <2 x double>* %72
%74 = fcmp une <2 x double> %70, zeroinitializer
%75 = fcmp une <2 x double> %73, zeroinitializer
%76 = zext <2 x i1> %74 to <2 x i32>
%77 = zext <2 x i1> %75 to <2 x i32>
%78 = add <2 x i32> %65, %76
%79 = add <2 x i32> %66, %77
br label %80
80: ; preds = %61, %67
%81 = phi <2 x i32> [ %62, %61 ], [ %78, %67 ]
%82 = phi <2 x i32> [ %63, %61 ], [ %79, %67 ]
%83 = add <2 x i32> %82, %81
%84 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %83)
br i1 %18, label %89, label %85
85: ; preds = %23, %80
%86 = phi i64 [ 0, %23 ], [ %13, %80 ]
%87 = phi i32 [ 0, %23 ], [ %84, %80 ]
br label %97
88: ; preds = %117, %2
ret void
89: ; preds = %97, %80
%90 = phi i32 [ %84, %80 ], [ %104, %97 ]
%91 = icmp eq i32 %90, 0
%92 = sitofp i32 %90 to double
%93 = getelementptr inbounds double*, double** %0, i64 %24
br i1 %20, label %107, label %94
94: ; preds = %89
%95 = load double*, double** %93
%96 = load double*, double** %93
br label %120
97: ; preds = %85, %97
%98 = phi i64 [ %105, %97 ], [ %86, %85 ]
%99 = phi i32 [ %104, %97 ], [ %87, %85 ]
%100 = getelementptr inbounds double, double* %26, i64 %98
%101 = load double, double* %100
%102 = fcmp une double %101, 0.000000e+00
%103 = zext i1 %102 to i32
%104 = add nuw nsw i32 %99, %103
%105 = add nuw nsw i64 %98, 1
%106 = icmp eq i64 %105, %7
br i1 %106, label %89, label %97
107: ; preds = %134, %89
%108 = phi i64 [ 0, %89 ], [ %136, %134 ]
br i1 %22, label %117, label %109
109: ; preds = %107
%110 = load double*, double** %93
%111 = getelementptr inbounds double, double* %110, i64 %108
br i1 %91, label %115, label %112
112: ; preds = %109
%113 = load double, double* %111
%114 = fdiv double %113, %92
br label %115
115: ; preds = %112, %109
%116 = phi double [ %114, %112 ], [ %6, %109 ]
store double %116, double* %111
br label %117
117: ; preds = %107, %115
%118 = add nuw nsw i64 %24, 1
%119 = icmp eq i64 %118, %7
br i1 %119, label %88, label %23
120: ; preds = %134, %94
%121 = phi i64 [ 0, %94 ], [ %136, %134 ]
%122 = phi i64 [ 0, %94 ], [ %137, %134 ]
%123 = getelementptr inbounds double, double* %95, i64 %121
br i1 %91, label %127, label %124
124: ; preds = %120
%125 = load double, double* %123
%126 = fdiv double %125, %92
br label %127
127: ; preds = %120, %124
%128 = phi double [ %126, %124 ], [ %6, %120 ]
store double %128, double* %123
%129 = or i64 %121, 1
%130 = getelementptr inbounds double, double* %96, i64 %129
br i1 %91, label %134, label %131
131: ; preds = %127
%132 = load double, double* %130
%133 = fdiv double %132, %92
br label %134
134: ; preds = %131, %127
%135 = phi double [ %133, %131 ], [ %6, %127 ]
store double %135, double* %130
%136 = add nuw nsw i64 %121, 2
%137 = add i64 %122, 2
%138 = icmp eq i64 %137, %21
br i1 %138, label %107, label %120
}