#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*/ phase_matrix_symmetry2(int, int, double **, double **,
                                          double **, double **, double);
void r_t_matrix_symmetry(int n_quad, int n_stokes, double **A11, double **A12,
                         double **A21, double **A22, double f) {
  int i;
  int j;
  int n;
  n = n_quad * n_stokes;
  if (n_stokes <= 2) {
    for (i = 0; i < n; ++i) {
      for (j = 0; j < n; ++j) {
        A21[i][j] = f * A12[i][j];
        A22[i][j] = f * A11[i][j];
      }
    }
  } else
    phase_matrix_symmetry2(n_quad, n_stokes, A11, A12, A22, A21, f);
}


x86 assembly (clang, -O0):
<r_t_matrix_symmetry>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    -0x4(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x2,-0x8(%rbp)
jg     11f1 <r_t_matrix_symmetry+0xe1>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    11ec <r_t_matrix_symmetry+0xdc>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    11d9 <r_t_matrix_symmetry+0xc9>
movsd  -0x30(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1161 <r_t_matrix_symmetry+0x51>
jmp    11de <r_t_matrix_symmetry+0xce>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    114e <r_t_matrix_symmetry+0x3e>
jmp    1211 <r_t_matrix_symmetry+0x101>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x20(%rbp),%r9
movsd  -0x30(%rbp),%xmm0
call   1030 <phase_matrix_symmetry2@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<r_t_matrix_symmetry>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %r8,%r15
cmp    $0x2,%esi
jg     147c <r_t_matrix_symmetry+0x36c>
imul   %edi,%esi
test   %esi,%esi
jle    1491 <r_t_matrix_symmetry+0x381>
mov    %esi,%r8d
mov    %r8d,%eax
and    $0xfffffffc,%eax
mov    %rax,-0x10(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x18(%rsp)
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %rdi,%rax
mov    %rdi,-0x20(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,-0x28(%rsp)
mov    %r8,%rax
neg    %rax
mov    %rax,-0x8(%rsp)
xor    %r13d,%r13d
mov    %r15,-0x40(%rsp)
mov    %r9,-0x48(%rsp)
mov    %rcx,-0x30(%rsp)
mov    %rdx,-0x50(%rsp)
mov    %esi,-0x34(%rsp)
jmp    11ad <r_t_matrix_symmetry+0x9d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r13
cmp    %r8,%r13
je     1491 <r_t_matrix_symmetry+0x381>
mov    (%rcx,%r13,8),%rax
mov    (%r15,%r13,8),%rbx
mov    (%rdx,%r13,8),%rbp
mov    (%r9,%r13,8),%r14
cmp    $0x4,%esi
jae    1260 <r_t_matrix_symmetry+0x150>
xor    %r10d,%r10d
mov    %r10,%rdi
test   $0x1,%r8b
je     11fa <r_t_matrix_symmetry+0xea>
movsd  (%rax,%r10,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rbx,%r10,8)
movsd  0x0(%rbp,%r10,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%r14,%r10,8)
mov    %r10,%rdi
or     $0x1,%rdi
not    %r10
cmp    -0x8(%rsp),%r10
je     11a0 <r_t_matrix_symmetry+0x90>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%rbx,%rdi,8)
movsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,(%r14,%rdi,8)
movsd  0x8(%rax,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rbx,%rdi,8)
movsd  0x8(%rbp,%rdi,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%r14,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r8
jne    1210 <r_t_matrix_symmetry+0x100>
jmp    11a0 <r_t_matrix_symmetry+0x90>
nopl   (%rax)
lea    (%rbx,%r8,8),%rcx
lea    (%r14,%r8,8),%rdx
lea    (%rax,%r8,8),%rdi
lea    0x0(,%r8,8),%r9
add    %rbp,%r9
cmp    %rdx,%rbx
setb   -0x51(%rsp)
cmp    %rcx,%r14
setb   %sil
cmp    %rdi,%rbx
setb   %r10b
cmp    %rcx,%rax
setb   %r12b
cmp    %r9,%rbx
setb   %r11b
cmp    %rcx,%rbp
setb   %cl
cmp    %rdi,%r14
setb   %r15b
cmp    %rdx,%rax
setb   -0x52(%rsp)
cmp    %r9,%r14
setb   %dil
cmp    %rdx,%rbp
setb   %dl
test   %sil,-0x51(%rsp)
jne    145c <r_t_matrix_symmetry+0x34c>
and    %r12b,%r10b
mov    -0x34(%rsp),%esi
jne    1440 <r_t_matrix_symmetry+0x330>
and    %cl,%r11b
jne    1440 <r_t_matrix_symmetry+0x330>
and    -0x52(%rsp),%r15b
mov    -0x30(%rsp),%rcx
jne    1429 <r_t_matrix_symmetry+0x319>
mov    $0x0,%r10d
and    %dl,%dil
mov    -0x40(%rsp),%r15
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%rdx
jne    11c9 <r_t_matrix_symmetry+0xb9>
cmpq   $0x0,-0x18(%rsp)
je     141d <r_t_matrix_symmetry+0x30d>
mov    -0x28(%rsp),%r11
xor    %r10d,%r10d
movupd (%rax,%r10,8),%xmm2
movupd 0x10(%rax,%r10,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rbx,%r10,8)
movupd %xmm3,0x10(%rbx,%r10,8)
movupd 0x0(%rbp,%r10,8),%xmm2
movupd 0x10(%rbp,%r10,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r14,%r10,8)
movupd %xmm3,0x10(%r14,%r10,8)
movupd 0x20(%rax,%r10,8),%xmm2
movupd 0x30(%rax,%r10,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%rbx,%r10,8)
movupd %xmm3,0x30(%rbx,%r10,8)
movupd 0x20(%rbp,%r10,8),%xmm2
movupd 0x30(%rbp,%r10,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x20(%r14,%r10,8)
movupd %xmm3,0x30(%r14,%r10,8)
add    $0x8,%r10
add    $0xfffffffffffffffe,%r11
jne    1320 <r_t_matrix_symmetry+0x210>
testb  $0x1,-0x20(%rsp)
je     1407 <r_t_matrix_symmetry+0x2f7>
movupd (%rax,%r10,8),%xmm2
movupd 0x10(%rax,%r10,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%rbx,%r10,8)
movupd %xmm3,0x10(%rbx,%r10,8)
movupd 0x0(%rbp,%r10,8),%xmm2
movupd 0x10(%rbp,%r10,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r14,%r10,8)
movupd %xmm3,0x10(%r14,%r10,8)
mov    -0x10(%rsp),%rdi
mov    %rdi,%r10
cmp    %r8,%rdi
je     11a0 <r_t_matrix_symmetry+0x90>
jmp    11c9 <r_t_matrix_symmetry+0xb9>
xor    %r10d,%r10d
testb  $0x1,-0x20(%rsp)
jne    13c2 <r_t_matrix_symmetry+0x2b2>
jmp    1407 <r_t_matrix_symmetry+0x2f7>
xor    %r10d,%r10d
mov    -0x40(%rsp),%r15
mov    -0x48(%rsp),%r9
mov    -0x50(%rsp),%rdx
jmp    11c9 <r_t_matrix_symmetry+0xb9>
xor    %r10d,%r10d
mov    -0x40(%rsp),%r15
mov    -0x48(%rsp),%r9
mov    -0x30(%rsp),%rcx
mov    -0x50(%rsp),%rdx
jmp    11c9 <r_t_matrix_symmetry+0xb9>
xor    %r10d,%r10d
mov    -0x40(%rsp),%r15
mov    -0x48(%rsp),%r9
mov    -0x30(%rsp),%rcx
mov    -0x50(%rsp),%rdx
mov    -0x34(%rsp),%esi
jmp    11c9 <r_t_matrix_symmetry+0xb9>
mov    %r9,%r8
mov    %r15,%r9
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <phase_matrix_symmetry2@plt>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @r_t_matrix_symmetry(i32 %0, i32 %1, double** %2, double** %3, double** %4, double** %5, double %6) {
%8 = mul i32 %1, %0
%9 = icmp slt i32 %1, 3
br i1 %9, label %10, label %190
10: ; preds = %7
%11 = icmp sgt i32 %8, 0
br i1 %11, label %12, label %192
12: ; preds = %10
%13 = zext i32 %8 to i64
%14 = and i64 %13, 4294967292
%15 = add nsw i64 %14, -4
%16 = lshr exact i64 %15, 2
%17 = add nuw nsw i64 %16, 1
%18 = icmp ult i32 %8, 4
%19 = and i64 %13, 4294967292
%20 = insertelement <2 x double> poison, double %6, i64 0
%21 = shufflevector <2 x double> %20, <2 x double> poison, <2 x i32> zeroinitializer
%22 = insertelement <2 x double> poison, double %6, i64 0
%23 = shufflevector <2 x double> %22, <2 x double> poison, <2 x i32> zeroinitializer
%24 = and i64 %17, 1
%25 = icmp eq i64 %15, 0
%26 = and i64 %17, 9223372036854775806
%27 = icmp eq i64 %24, 0
%28 = icmp eq i64 %19, %13
%29 = and i64 %13, 1
%30 = icmp eq i64 %29, 0
%31 = sub nsw i64 0, %13
br label %32
32: ; preds = %187, %12
%33 = phi i64 [ 0, %12 ], [ %188, %187 ]
%34 = getelementptr inbounds double*, double** %3, i64 %33
%35 = load double*, double** %34
%36 = getelementptr inbounds double*, double** %4, i64 %33
%37 = load double*, double** %36
%38 = getelementptr inbounds double*, double** %2, i64 %33
%39 = load double*, double** %38
%40 = getelementptr inbounds double*, double** %5, i64 %33
%41 = load double*, double** %40
br i1 %18, label %150, label %42
42: ; preds = %32
%43 = getelementptr double, double* %37, i64 %13
%44 = getelementptr double, double* %41, i64 %13
%45 = getelementptr double, double* %35, i64 %13
%46 = getelementptr double, double* %39, i64 %13
%47 = icmp ult double* %37, %44
%48 = icmp ult double* %41, %43
%49 = and i1 %47, %48
%50 = icmp ult double* %37, %45
%51 = icmp ult double* %35, %43
%52 = and i1 %50, %51
%53 = or i1 %49, %52
%54 = icmp ult double* %37, %46
%55 = icmp ult double* %39, %43
%56 = and i1 %54, %55
%57 = or i1 %53, %56
%58 = icmp ult double* %41, %45
%59 = icmp ult double* %35, %44
%60 = and i1 %58, %59
%61 = or i1 %57, %60
%62 = icmp ult double* %41, %46
%63 = icmp ult double* %39, %44
%64 = and i1 %62, %63
%65 = or i1 %61, %64
br i1 %65, label %150, label %66
66: ; preds = %42
br i1 %25, label %122, label %67
67: ; preds = %66, %67
%68 = phi i64 [ %119, %67 ], [ 0, %66 ]
%69 = phi i64 [ %120, %67 ], [ 0, %66 ]
%70 = getelementptr inbounds double, double* %35, i64 %68
%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 = fmul <2 x double> %72, %21
%77 = fmul <2 x double> %75, %23
%78 = getelementptr inbounds double, double* %37, i64 %68
%79 = bitcast double* %78 to <2 x double>*
store <2 x double> %76, <2 x double>* %79
%80 = getelementptr inbounds double, double* %78, i64 2
%81 = bitcast double* %80 to <2 x double>*
store <2 x double> %77, <2 x double>* %81
%82 = getelementptr inbounds double, double* %39, i64 %68
%83 = bitcast double* %82 to <2 x double>*
%84 = load <2 x double>, <2 x double>* %83
%85 = getelementptr inbounds double, double* %82, i64 2
%86 = bitcast double* %85 to <2 x double>*
%87 = load <2 x double>, <2 x double>* %86
%88 = fmul <2 x double> %84, %21
%89 = fmul <2 x double> %87, %23
%90 = getelementptr inbounds double, double* %41, i64 %68
%91 = bitcast double* %90 to <2 x double>*
store <2 x double> %88, <2 x double>* %91
%92 = getelementptr inbounds double, double* %90, i64 2
%93 = bitcast double* %92 to <2 x double>*
store <2 x double> %89, <2 x double>* %93
%94 = or i64 %68, 4
%95 = getelementptr inbounds double, double* %35, i64 %94
%96 = bitcast double* %95 to <2 x double>*
%97 = load <2 x double>, <2 x double>* %96
%98 = getelementptr inbounds double, double* %95, i64 2
%99 = bitcast double* %98 to <2 x double>*
%100 = load <2 x double>, <2 x double>* %99
%101 = fmul <2 x double> %97, %21
%102 = fmul <2 x double> %100, %23
%103 = getelementptr inbounds double, double* %37, i64 %94
%104 = bitcast double* %103 to <2 x double>*
store <2 x double> %101, <2 x double>* %104
%105 = getelementptr inbounds double, double* %103, i64 2
%106 = bitcast double* %105 to <2 x double>*
store <2 x double> %102, <2 x double>* %106
%107 = getelementptr inbounds double, double* %39, i64 %94
%108 = bitcast double* %107 to <2 x double>*
%109 = load <2 x double>, <2 x double>* %108
%110 = getelementptr inbounds double, double* %107, i64 2
%111 = bitcast double* %110 to <2 x double>*
%112 = load <2 x double>, <2 x double>* %111
%113 = fmul <2 x double> %109, %21
%114 = fmul <2 x double> %112, %23
%115 = getelementptr inbounds double, double* %41, i64 %94
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> %113, <2 x double>* %116
%117 = getelementptr inbounds double, double* %115, i64 2
%118 = bitcast double* %117 to <2 x double>*
store <2 x double> %114, <2 x double>* %118
%119 = add nuw i64 %68, 8
%120 = add i64 %69, 2
%121 = icmp eq i64 %120, %26
br i1 %121, label %122, label %67
122: ; preds = %67, %66
%123 = phi i64 [ 0, %66 ], [ %119, %67 ]
br i1 %27, label %149, label %124
124: ; preds = %122
%125 = getelementptr inbounds double, double* %35, i64 %123
%126 = bitcast double* %125 to <2 x double>*
%127 = load <2 x double>, <2 x double>* %126
%128 = getelementptr inbounds double, double* %125, i64 2
%129 = bitcast double* %128 to <2 x double>*
%130 = load <2 x double>, <2 x double>* %129
%131 = fmul <2 x double> %127, %21
%132 = fmul <2 x double> %130, %23
%133 = getelementptr inbounds double, double* %37, i64 %123
%134 = bitcast double* %133 to <2 x double>*
store <2 x double> %131, <2 x double>* %134
%135 = getelementptr inbounds double, double* %133, i64 2
%136 = bitcast double* %135 to <2 x double>*
store <2 x double> %132, <2 x double>* %136
%137 = getelementptr inbounds double, double* %39, i64 %123
%138 = bitcast double* %137 to <2 x double>*
%139 = load <2 x double>, <2 x double>* %138
%140 = getelementptr inbounds double, double* %137, i64 2
%141 = bitcast double* %140 to <2 x double>*
%142 = load <2 x double>, <2 x double>* %141
%143 = fmul <2 x double> %139, %21
%144 = fmul <2 x double> %142, %23
%145 = getelementptr inbounds double, double* %41, i64 %123
%146 = bitcast double* %145 to <2 x double>*
store <2 x double> %143, <2 x double>* %146
%147 = getelementptr inbounds double, double* %145, i64 2
%148 = bitcast double* %147 to <2 x double>*
store <2 x double> %144, <2 x double>* %148
br label %149
149: ; preds = %122, %124
br i1 %28, label %187, label %150
150: ; preds = %42, %32, %149
%151 = phi i64 [ 0, %42 ], [ 0, %32 ], [ %19, %149 ]
%152 = xor i64 %151, -1
br i1 %30, label %163, label %153
153: ; preds = %150
%154 = getelementptr inbounds double, double* %35, i64 %151
%155 = load double, double* %154
%156 = fmul double %155, %6
%157 = getelementptr inbounds double, double* %37, i64 %151
store double %156, double* %157
%158 = getelementptr inbounds double, double* %39, i64 %151
%159 = load double, double* %158
%160 = fmul double %159, %6
%161 = getelementptr inbounds double, double* %41, i64 %151
store double %160, double* %161
%162 = or i64 %151, 1
br label %163
163: ; preds = %153, %150
%164 = phi i64 [ %151, %150 ], [ %162, %153 ]
%165 = icmp eq i64 %152, %31
br i1 %165, label %187, label %166
166: ; preds = %163, %166
%167 = phi i64 [ %185, %166 ], [ %164, %163 ]
%168 = getelementptr inbounds double, double* %35, i64 %167
%169 = load double, double* %168
%170 = fmul double %169, %6
%171 = getelementptr inbounds double, double* %37, i64 %167
store double %170, double* %171
%172 = getelementptr inbounds double, double* %39, i64 %167
%173 = load double, double* %172
%174 = fmul double %173, %6
%175 = getelementptr inbounds double, double* %41, i64 %167
store double %174, double* %175
%176 = add nuw nsw i64 %167, 1
%177 = getelementptr inbounds double, double* %35, i64 %176
%178 = load double, double* %177
%179 = fmul double %178, %6
%180 = getelementptr inbounds double, double* %37, i64 %176
store double %179, double* %180
%181 = getelementptr inbounds double, double* %39, i64 %176
%182 = load double, double* %181
%183 = fmul double %182, %6
%184 = getelementptr inbounds double, double* %41, i64 %176
store double %183, double* %184
%185 = add nuw nsw i64 %167, 2
%186 = icmp eq i64 %185, %13
br i1 %186, label %187, label %166
187: ; preds = %163, %166, %149
%188 = add nuw nsw i64 %33, 1
%189 = icmp eq i64 %188, %13
br i1 %189, label %192, label %32
190: ; preds = %7
%191 = tail call i32 @phase_matrix_symmetry2(i32 %0, i32 %1, double** %2, double** %3, double** %5, double** %4, double %6)
br label %192
192: ; preds = %187, %10, %190
ret void
}