int G_math_complex_mult(double *v1[2], int size1, double *v2[2], int size2,
                        double *v3[2], int size3) {
  int i, n;
  n = (size1 < size2 ? size1 : size2);
  for (i = 0; i < n; i++) {
    *(v3[0] + i) = *(v1[0] + i) * *(v2[0] + i) - *(v1[1] + i) * *(v2[1] + i);
    *(v3[1] + i) = *(v1[0] + i) * *(v2[1] + i) + *(v2[0] + i) * *(v1[1] + i);
  }
  if (size1 != size2)
    for (i = n; i < size3; i++) {
      *(v3[0] + i) = 0.0;
      *(v3[1] + i) = 0.0;
    }
  return 0;
}


x86 assembly (clang, -O0):
<G_math_complex_mult>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1131 <G_math_complex_mult+0x31>
mov    -0xc(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1137 <G_math_complex_mult+0x37>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    122a <G_math_complex_mult+0x12a>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1144 <G_math_complex_mult+0x44>
mov    -0xc(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1282 <G_math_complex_mult+0x182>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    127d <G_math_complex_mult+0x17d>
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    123c <G_math_complex_mult+0x13c>
jmp    1282 <G_math_complex_mult+0x182>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<G_math_complex_mult>:
push   %r15
push   %r14
push   %r12
push   %rbx
cmp    %ecx,%esi
mov    %ecx,%r10d
cmovl  %esi,%r10d
test   %r10d,%r10d
jle    1177 <G_math_complex_mult+0x77>
mov    (%rdi),%r12
mov    0x8(%rdi),%rdi
mov    (%rdx),%rbx
mov    0x8(%rdx),%rdx
mov    (%r8),%r11
mov    0x8(%r8),%r14
mov    %r10d,%r15d
xor    %eax,%eax
nop
movsd  (%r12,%rax,8),%xmm0
movsd  (%rdx,%rax,8),%xmm1
mulsd  (%rdi,%rax,8),%xmm1
mulsd  (%rbx,%rax,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%rax,8)
movsd  (%r12,%rax,8),%xmm0
movsd  (%rbx,%rax,8),%xmm1
mulsd  (%rdi,%rax,8),%xmm1
mulsd  (%rdx,%rax,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1130 <G_math_complex_mult+0x30>
cmp    %ecx,%esi
je     134f <G_math_complex_mult+0x24f>
cmp    %r9d,%r10d
jge    134f <G_math_complex_mult+0x24f>
mov    (%r8),%rax
mov    0x8(%r8),%rcx
movslq %r10d,%rdx
movslq %r9d,%r14
mov    %r14,%r10
sub    %rdx,%r10
cmp    $0x4,%r10
jb     12cb <G_math_complex_mult+0x1cb>
lea    (%rax,%rdx,8),%rsi
lea    (%rcx,%r14,8),%rdi
cmp    %rdi,%rsi
jae    11c3 <G_math_complex_mult+0xc3>
lea    (%rax,%r14,8),%rsi
lea    (%rcx,%rdx,8),%rdi
cmp    %rsi,%rdi
jb     12cb <G_math_complex_mult+0x1cb>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rsi
mov    %rsi,%r15
shr    $0x2,%r15
add    $0x1,%r15
mov    %r15d,%r11d
and    $0x3,%r11d
cmp    $0xc,%rsi
jae    11ed <G_math_complex_mult+0xed>
xor    %ebx,%ebx
jmp    1278 <G_math_complex_mult+0x178>
and    $0xfffffffffffffffc,%r15
lea    (%rcx,%rdx,8),%rsi
add    $0x70,%rsi
lea    (%rax,%rdx,8),%rdi
add    $0x70,%rdi
xor    %ebx,%ebx
xorpd  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movupd %xmm0,-0x70(%rdi,%rbx,8)
movupd %xmm0,-0x60(%rdi,%rbx,8)
movupd %xmm0,-0x70(%rsi,%rbx,8)
movupd %xmm0,-0x60(%rsi,%rbx,8)
movupd %xmm0,-0x50(%rdi,%rbx,8)
movupd %xmm0,-0x40(%rdi,%rbx,8)
movupd %xmm0,-0x50(%rsi,%rbx,8)
movupd %xmm0,-0x40(%rsi,%rbx,8)
movupd %xmm0,-0x30(%rdi,%rbx,8)
movupd %xmm0,-0x20(%rdi,%rbx,8)
movupd %xmm0,-0x30(%rsi,%rbx,8)
movupd %xmm0,-0x20(%rsi,%rbx,8)
movupd %xmm0,-0x10(%rdi,%rbx,8)
movupd %xmm0,(%rdi,%rbx,8)
movupd %xmm0,-0x10(%rsi,%rbx,8)
movupd %xmm0,(%rsi,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%r15
jne    1210 <G_math_complex_mult+0x110>
test   %r11,%r11
je     12bf <G_math_complex_mult+0x1bf>
add    %rdx,%rbx
lea    (%rcx,%rbx,8),%rsi
add    $0x10,%rsi
lea    (%rax,%rbx,8),%rdi
add    $0x10,%rdi
shl    $0x5,%r11
xor    %ebx,%ebx
xorpd  %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movupd %xmm0,-0x10(%rdi,%rbx,1)
movupd %xmm0,(%rdi,%rbx,1)
movupd %xmm0,-0x10(%rsi,%rbx,1)
movupd %xmm0,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r11
jne    12a0 <G_math_complex_mult+0x1a0>
cmp    %r8,%r10
je     134f <G_math_complex_mult+0x24f>
add    %r8,%rdx
sub    %edx,%r9d
mov    %rdx,%rsi
not    %rsi
add    %r14,%rsi
and    $0x3,%r9
je     12fa <G_math_complex_mult+0x1fa>
nopl   (%rax)
movq   $0x0,(%rax,%rdx,8)
movq   $0x0,(%rcx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%r9
jne    12e0 <G_math_complex_mult+0x1e0>
cmp    $0x3,%rsi
jb     134f <G_math_complex_mult+0x24f>
movq   $0x0,(%rax,%rdx,8)
movq   $0x0,(%rcx,%rdx,8)
movq   $0x0,0x8(%rax,%rdx,8)
movq   $0x0,0x8(%rcx,%rdx,8)
movq   $0x0,0x10(%rax,%rdx,8)
movq   $0x0,0x10(%rcx,%rdx,8)
movq   $0x0,0x18(%rax,%rdx,8)
movq   $0x0,0x18(%rcx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%r14
jne    1300 <G_math_complex_mult+0x200>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

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