#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*/ vectorFPAtan2(double *, double *, double *, int);
int /*<<< orphan*/ vectorFPBexp(double *, double *, double *, int);
int /*<<< orphan*/ vectorFPCosine(double *, double *, double *, int);
int /*<<< orphan*/ vectorFPDivide(double *, double *, double *, int);
int /*<<< orphan*/ vectorFPMultiply(double *, double *, double *, int);
int /*<<< orphan*/ vectorFPNop(double *, double *, double *, int);
int /*<<< orphan*/ vectorFPSincos(double *, double *, double *, int);
int /*<<< orphan*/ vectorFPSqrt(double *, double *, double *, int);
int /*<<< orphan*/ vectorFPSum(double *, double *, double *, int);
int /*<<< orphan*/ vectorFPYlogx(double *, double *, double *, int);
int vectorOps(void *a, void *b, void *c, int nsize, int niters, int nmode) {
  int j;
  switch (nmode) {
  case 0:
    for (j = niters; j > 0; j--)
      vectorFPNop((double *)a, (double *)b, (double *)c, nsize);
    break;
  case 1:
    for (j = niters; j > 0; j--)
      vectorFPSum((double *)a, (double *)b, (double *)c, nsize);
    break;
  case 2:
    for (j = niters; j > 0; j--)
      vectorFPMultiply((double *)a, (double *)b, (double *)c, nsize);
    break;
  case 3:
    for (j = niters; j > 0; j--)
      vectorFPDivide((double *)a, (double *)b, (double *)c, nsize);
    break;
  case 5:
    for (j = niters; j > 0; j--)
      vectorFPSqrt((double *)a, (double *)b, (double *)c, nsize);
    break;
  case 4:
    for (j = niters; j > 0; j--)
      vectorFPCosine((double *)a, (double *)b, (double *)c, nsize);
    break;
  case 6:
    for (j = niters; j > 0; j--)
      vectorFPAtan2((double *)a, (double *)b, (double *)c, nsize);
    break;
  case 7:
    for (j = niters; j > 0; j--)
      vectorFPYlogx((double *)a, (double *)b, (double *)c, nsize);
    break;
  case 8:
    for (j = niters; j > 0; j--)
      vectorFPSincos((double *)a, (double *)b, (double *)c, nsize);
    break;
  case 9:
    for (j = niters; j > 0; j--)
      vectorFPBexp((double *)a, (double *)b, (double *)c, nsize);
    break;
  default:
    return 0;
  }
  return niters;
}


x86 assembly (clang, -O0):
<vectorOps>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %rax,-0x38(%rbp)
sub    $0x9,%rax
ja     140a <vectorOps+0x26a>
mov    -0x38(%rbp),%rax
lea    0xe25(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    1216 <vectorOps+0x76>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   10a0 <vectorFPNop@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    11ea <vectorOps+0x4a>
jmp    1416 <vectorOps+0x276>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    124d <vectorOps+0xad>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1070 <vectorFPSum@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1221 <vectorOps+0x81>
jmp    1416 <vectorOps+0x276>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    1284 <vectorOps+0xe4>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1060 <vectorFPMultiply@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1258 <vectorOps+0xb8>
jmp    1416 <vectorOps+0x276>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    12bb <vectorOps+0x11b>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   10b0 <vectorFPDivide@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    128f <vectorOps+0xef>
jmp    1416 <vectorOps+0x276>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    12f2 <vectorOps+0x152>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1040 <vectorFPSqrt@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    12c6 <vectorOps+0x126>
jmp    1416 <vectorOps+0x276>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    1329 <vectorOps+0x189>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   10c0 <vectorFPCosine@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    12fd <vectorOps+0x15d>
jmp    1416 <vectorOps+0x276>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    1360 <vectorOps+0x1c0>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1080 <vectorFPAtan2@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1334 <vectorOps+0x194>
jmp    1416 <vectorOps+0x276>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    1397 <vectorOps+0x1f7>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1050 <vectorFPYlogx@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    136b <vectorOps+0x1cb>
jmp    1416 <vectorOps+0x276>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    13ce <vectorOps+0x22e>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1030 <vectorFPSincos@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    13a2 <vectorOps+0x202>
jmp    1416 <vectorOps+0x276>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    1405 <vectorOps+0x265>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    -0x24(%rbp),%ecx
call   1090 <vectorFPBexp@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    13d9 <vectorOps+0x239>
jmp    1416 <vectorOps+0x276>
movl   $0x0,-0x4(%rbp)
jmp    141c <vectorOps+0x27c>
mov    -0x28(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vectorOps>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
cmp    $0x9,%r9d
ja     11fe <vectorOps+0x5e>
mov    %r8d,%r14d
mov    %ecx,%r15d
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%rbx
mov    %r9d,%eax
lea    0xe36(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   10a0 <vectorFPNop@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     11e0 <vectorOps+0x40>
jmp    13b9 <vectorOps+0x219>
xor    %r14d,%r14d
jmp    13b9 <vectorOps+0x219>
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   1070 <vectorFPSum@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1220 <vectorOps+0x80>
jmp    13b9 <vectorOps+0x219>
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   1060 <vectorFPMultiply@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1250 <vectorOps+0xb0>
jmp    13b9 <vectorOps+0x219>
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   10b0 <vectorFPDivide@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1280 <vectorOps+0xe0>
jmp    13b9 <vectorOps+0x219>
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   10c0 <vectorFPCosine@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     12b0 <vectorOps+0x110>
jmp    13b9 <vectorOps+0x219>
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   1040 <vectorFPSqrt@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     12e0 <vectorOps+0x140>
jmp    13b9 <vectorOps+0x219>
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   1080 <vectorFPAtan2@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1310 <vectorOps+0x170>
jmp    13b9 <vectorOps+0x219>
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
nopl   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   1050 <vectorFPYlogx@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1340 <vectorOps+0x1a0>
jmp    13b9 <vectorOps+0x219>
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   1030 <vectorFPSincos@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     1370 <vectorOps+0x1d0>
jmp    13b9 <vectorOps+0x219>
test   %r14d,%r14d
jle    13b9 <vectorOps+0x219>
lea    0x1(%r14),%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
call   1090 <vectorFPBexp@plt>
add    $0xffffffff,%ebp
cmp    $0x1,%ebp
ja     13a0 <vectorOps+0x200>
mov    %r14d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @vectorOps(i8* %0, i8* %1, i8* %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
store i8* %0, i8** %8
store i8* %1, i8** %9
store i8* %2, i8** %10
store i32 %3, i32* %11
store i32 %4, i32* %12
store i32 %5, i32* %13
%15 = load i32, i32* %13
switch i32 %15, label %196 [
i32 0, label %16
i32 1, label %34
i32 2, label %52
i32 3, label %70
i32 5, label %88
i32 4, label %106
i32 6, label %124
i32 7, label %142
i32 8, label %160
i32 9, label %178
]
16: ; preds = %6
%17 = load i32, i32* %12
store i32 %17, i32* %14
br label %18
18: ; preds = %30, %16
%19 = load i32, i32* %14
%20 = icmp sgt i32 %19, 0
br i1 %20, label %21, label %33
21: ; preds = %18
%22 = load i8*, i8** %8
%23 = bitcast i8* %22 to double*
%24 = load i8*, i8** %9
%25 = bitcast i8* %24 to double*
%26 = load i8*, i8** %10
%27 = bitcast i8* %26 to double*
%28 = load i32, i32* %11
%29 = call i32 @vectorFPNop(double* %23, double* %25, double* %27, i32 %28)
br label %30
30: ; preds = %21
%31 = load i32, i32* %14
%32 = add nsw i32 %31, -1
store i32 %32, i32* %14
br label %18
33: ; preds = %18
br label %197
34: ; preds = %6
%35 = load i32, i32* %12
store i32 %35, i32* %14
br label %36
36: ; preds = %48, %34
%37 = load i32, i32* %14
%38 = icmp sgt i32 %37, 0
br i1 %38, label %39, label %51
39: ; preds = %36
%40 = load i8*, i8** %8
%41 = bitcast i8* %40 to double*
%42 = load i8*, i8** %9
%43 = bitcast i8* %42 to double*
%44 = load i8*, i8** %10
%45 = bitcast i8* %44 to double*
%46 = load i32, i32* %11
%47 = call i32 @vectorFPSum(double* %41, double* %43, double* %45, i32 %46)
br label %48
48: ; preds = %39
%49 = load i32, i32* %14
%50 = add nsw i32 %49, -1
store i32 %50, i32* %14
br label %36
51: ; preds = %36
br label %197
52: ; preds = %6
%53 = load i32, i32* %12
store i32 %53, i32* %14
br label %54
54: ; preds = %66, %52
%55 = load i32, i32* %14
%56 = icmp sgt i32 %55, 0
br i1 %56, label %57, label %69
57: ; preds = %54
%58 = load i8*, i8** %8
%59 = bitcast i8* %58 to double*
%60 = load i8*, i8** %9
%61 = bitcast i8* %60 to double*
%62 = load i8*, i8** %10
%63 = bitcast i8* %62 to double*
%64 = load i32, i32* %11
%65 = call i32 @vectorFPMultiply(double* %59, double* %61, double* %63, i32 %64)
br label %66
66: ; preds = %57
%67 = load i32, i32* %14
%68 = add nsw i32 %67, -1
store i32 %68, i32* %14
br label %54
69: ; preds = %54
br label %197
70: ; preds = %6
%71 = load i32, i32* %12
store i32 %71, i32* %14
br label %72
72: ; preds = %84, %70
%73 = load i32, i32* %14
%74 = icmp sgt i32 %73, 0
br i1 %74, label %75, label %87
75: ; preds = %72
%76 = load i8*, i8** %8
%77 = bitcast i8* %76 to double*
%78 = load i8*, i8** %9
%79 = bitcast i8* %78 to double*
%80 = load i8*, i8** %10
%81 = bitcast i8* %80 to double*
%82 = load i32, i32* %11
%83 = call i32 @vectorFPDivide(double* %77, double* %79, double* %81, i32 %82)
br label %84
84: ; preds = %75
%85 = load i32, i32* %14
%86 = add nsw i32 %85, -1
store i32 %86, i32* %14
br label %72
87: ; preds = %72
br label %197
88: ; preds = %6
%89 = load i32, i32* %12
store i32 %89, i32* %14
br label %90
90: ; preds = %102, %88
%91 = load i32, i32* %14
%92 = icmp sgt i32 %91, 0
br i1 %92, label %93, label %105
93: ; preds = %90
%94 = load i8*, i8** %8
%95 = bitcast i8* %94 to double*
%96 = load i8*, i8** %9
%97 = bitcast i8* %96 to double*
%98 = load i8*, i8** %10
%99 = bitcast i8* %98 to double*
%100 = load i32, i32* %11
%101 = call i32 @vectorFPSqrt(double* %95, double* %97, double* %99, i32 %100)
br label %102
102: ; preds = %93
%103 = load i32, i32* %14
%104 = add nsw i32 %103, -1
store i32 %104, i32* %14
br label %90
105: ; preds = %90
br label %197
106: ; preds = %6
%107 = load i32, i32* %12
store i32 %107, i32* %14
br label %108
108: ; preds = %120, %106
%109 = load i32, i32* %14
%110 = icmp sgt i32 %109, 0
br i1 %110, label %111, label %123
111: ; preds = %108
%112 = load i8*, i8** %8
%113 = bitcast i8* %112 to double*
%114 = load i8*, i8** %9
%115 = bitcast i8* %114 to double*
%116 = load i8*, i8** %10
%117 = bitcast i8* %116 to double*
%118 = load i32, i32* %11
%119 = call i32 @vectorFPCosine(double* %113, double* %115, double* %117, i32 %118)
br label %120
120: ; preds = %111
%121 = load i32, i32* %14
%122 = add nsw i32 %121, -1
store i32 %122, i32* %14
br label %108
123: ; preds = %108
br label %197
124: ; preds = %6
%125 = load i32, i32* %12
store i32 %125, i32* %14
br label %126
126: ; preds = %138, %124
%127 = load i32, i32* %14
%128 = icmp sgt i32 %127, 0
br i1 %128, label %129, label %141
129: ; preds = %126
%130 = load i8*, i8** %8
%131 = bitcast i8* %130 to double*
%132 = load i8*, i8** %9
%133 = bitcast i8* %132 to double*
%134 = load i8*, i8** %10
%135 = bitcast i8* %134 to double*
%136 = load i32, i32* %11
%137 = call i32 @vectorFPAtan2(double* %131, double* %133, double* %135, i32 %136)
br label %138
138: ; preds = %129
%139 = load i32, i32* %14
%140 = add nsw i32 %139, -1
store i32 %140, i32* %14
br label %126
141: ; preds = %126
br label %197
142: ; preds = %6
%143 = load i32, i32* %12
store i32 %143, i32* %14
br label %144
144: ; preds = %156, %142
%145 = load i32, i32* %14
%146 = icmp sgt i32 %145, 0
br i1 %146, label %147, label %159
147: ; preds = %144
%148 = load i8*, i8** %8
%149 = bitcast i8* %148 to double*
%150 = load i8*, i8** %9
%151 = bitcast i8* %150 to double*
%152 = load i8*, i8** %10
%153 = bitcast i8* %152 to double*
%154 = load i32, i32* %11
%155 = call i32 @vectorFPYlogx(double* %149, double* %151, double* %153, i32 %154)
br label %156
156: ; preds = %147
%157 = load i32, i32* %14
%158 = add nsw i32 %157, -1
store i32 %158, i32* %14
br label %144
159: ; preds = %144
br label %197
160: ; preds = %6
%161 = load i32, i32* %12
store i32 %161, i32* %14
br label %162
162: ; preds = %174, %160
%163 = load i32, i32* %14
%164 = icmp sgt i32 %163, 0
br i1 %164, label %165, label %177
165: ; preds = %162
%166 = load i8*, i8** %8
%167 = bitcast i8* %166 to double*
%168 = load i8*, i8** %9
%169 = bitcast i8* %168 to double*
%170 = load i8*, i8** %10
%171 = bitcast i8* %170 to double*
%172 = load i32, i32* %11
%173 = call i32 @vectorFPSincos(double* %167, double* %169, double* %171, i32 %172)
br label %174
174: ; preds = %165
%175 = load i32, i32* %14
%176 = add nsw i32 %175, -1
store i32 %176, i32* %14
br label %162
177: ; preds = %162
br label %197
178: ; preds = %6
%179 = load i32, i32* %12
store i32 %179, i32* %14
br label %180
180: ; preds = %192, %178
%181 = load i32, i32* %14
%182 = icmp sgt i32 %181, 0
br i1 %182, label %183, label %195
183: ; preds = %180
%184 = load i8*, i8** %8
%185 = bitcast i8* %184 to double*
%186 = load i8*, i8** %9
%187 = bitcast i8* %186 to double*
%188 = load i8*, i8** %10
%189 = bitcast i8* %188 to double*
%190 = load i32, i32* %11
%191 = call i32 @vectorFPBexp(double* %185, double* %187, double* %189, i32 %190)
br label %192
192: ; preds = %183
%193 = load i32, i32* %14
%194 = add nsw i32 %193, -1
store i32 %194, i32* %14
br label %180
195: ; preds = %180
br label %197
196: ; preds = %6
store i32 0, i32* %7
br label %199
197: ; preds = %195, %177, %159, %141, %123, %105, %87, %69, %51, %33
%198 = load i32, i32* %12
store i32 %198, i32* %7
br label %199
199: ; preds = %197, %196
%200 = load i32, i32* %7
ret i32 %200
}

LLVM IR (-O2):
define i32 @vectorOps(i8* %0, i8* %1, i8* %2, i32 %3, i32 %4, i32 %5) {
switch i32 %5, label %117 [
i32 0, label %61
i32 1, label %55
i32 2, label %49
i32 3, label %43
i32 5, label %37
i32 4, label %31
i32 6, label %25
i32 7, label %19
i32 8, label %13
i32 9, label %7
]
7: ; preds = %6
%8 = icmp sgt i32 %4, 0
br i1 %8, label %9, label %117
9: ; preds = %7
%10 = bitcast i8* %0 to double*
%11 = bitcast i8* %1 to double*
%12 = bitcast i8* %2 to double*
br label %112
13: ; preds = %6
%14 = icmp sgt i32 %4, 0
br i1 %14, label %15, label %117
15: ; preds = %13
%16 = bitcast i8* %0 to double*
%17 = bitcast i8* %1 to double*
%18 = bitcast i8* %2 to double*
br label %107
19: ; preds = %6
%20 = icmp sgt i32 %4, 0
br i1 %20, label %21, label %117
21: ; preds = %19
%22 = bitcast i8* %0 to double*
%23 = bitcast i8* %1 to double*
%24 = bitcast i8* %2 to double*
br label %102
25: ; preds = %6
%26 = icmp sgt i32 %4, 0
br i1 %26, label %27, label %117
27: ; preds = %25
%28 = bitcast i8* %0 to double*
%29 = bitcast i8* %1 to double*
%30 = bitcast i8* %2 to double*
br label %97
31: ; preds = %6
%32 = icmp sgt i32 %4, 0
br i1 %32, label %33, label %117
33: ; preds = %31
%34 = bitcast i8* %0 to double*
%35 = bitcast i8* %1 to double*
%36 = bitcast i8* %2 to double*
br label %92
37: ; preds = %6
%38 = icmp sgt i32 %4, 0
br i1 %38, label %39, label %117
39: ; preds = %37
%40 = bitcast i8* %0 to double*
%41 = bitcast i8* %1 to double*
%42 = bitcast i8* %2 to double*
br label %87
43: ; preds = %6
%44 = icmp sgt i32 %4, 0
br i1 %44, label %45, label %117
45: ; preds = %43
%46 = bitcast i8* %0 to double*
%47 = bitcast i8* %1 to double*
%48 = bitcast i8* %2 to double*
br label %82
49: ; preds = %6
%50 = icmp sgt i32 %4, 0
br i1 %50, label %51, label %117
51: ; preds = %49
%52 = bitcast i8* %0 to double*
%53 = bitcast i8* %1 to double*
%54 = bitcast i8* %2 to double*
br label %77
55: ; preds = %6
%56 = icmp sgt i32 %4, 0
br i1 %56, label %57, label %117
57: ; preds = %55
%58 = bitcast i8* %0 to double*
%59 = bitcast i8* %1 to double*
%60 = bitcast i8* %2 to double*
br label %72
61: ; preds = %6
%62 = icmp sgt i32 %4, 0
br i1 %62, label %63, label %117
63: ; preds = %61
%64 = bitcast i8* %0 to double*
%65 = bitcast i8* %1 to double*
%66 = bitcast i8* %2 to double*
br label %67
67: ; preds = %63, %67
%68 = phi i32 [ %4, %63 ], [ %70, %67 ]
%69 = tail call i32 @vectorFPNop(double* %64, double* %65, double* %66, i32 %3)
%70 = add nsw i32 %68, -1
%71 = icmp ugt i32 %68, 1
br i1 %71, label %67, label %117
72: ; preds = %57, %72
%73 = phi i32 [ %4, %57 ], [ %75, %72 ]
%74 = tail call i32 @vectorFPSum(double* %58, double* %59, double* %60, i32 %3)
%75 = add nsw i32 %73, -1
%76 = icmp ugt i32 %73, 1
br i1 %76, label %72, label %117
77: ; preds = %51, %77
%78 = phi i32 [ %4, %51 ], [ %80, %77 ]
%79 = tail call i32 @vectorFPMultiply(double* %52, double* %53, double* %54, i32 %3)
%80 = add nsw i32 %78, -1
%81 = icmp ugt i32 %78, 1
br i1 %81, label %77, label %117
82: ; preds = %45, %82
%83 = phi i32 [ %4, %45 ], [ %85, %82 ]
%84 = tail call i32 @vectorFPDivide(double* %46, double* %47, double* %48, i32 %3)
%85 = add nsw i32 %83, -1
%86 = icmp ugt i32 %83, 1
br i1 %86, label %82, label %117
87: ; preds = %39, %87
%88 = phi i32 [ %4, %39 ], [ %90, %87 ]
%89 = tail call i32 @vectorFPSqrt(double* %40, double* %41, double* %42, i32 %3)
%90 = add nsw i32 %88, -1
%91 = icmp ugt i32 %88, 1
br i1 %91, label %87, label %117
92: ; preds = %33, %92
%93 = phi i32 [ %4, %33 ], [ %95, %92 ]
%94 = tail call i32 @vectorFPCosine(double* %34, double* %35, double* %36, i32 %3)
%95 = add nsw i32 %93, -1
%96 = icmp ugt i32 %93, 1
br i1 %96, label %92, label %117
97: ; preds = %27, %97
%98 = phi i32 [ %4, %27 ], [ %100, %97 ]
%99 = tail call i32 @vectorFPAtan2(double* %28, double* %29, double* %30, i32 %3)
%100 = add nsw i32 %98, -1
%101 = icmp ugt i32 %98, 1
br i1 %101, label %97, label %117
102: ; preds = %21, %102
%103 = phi i32 [ %4, %21 ], [ %105, %102 ]
%104 = tail call i32 @vectorFPYlogx(double* %22, double* %23, double* %24, i32 %3)
%105 = add nsw i32 %103, -1
%106 = icmp ugt i32 %103, 1
br i1 %106, label %102, label %117
107: ; preds = %15, %107
%108 = phi i32 [ %4, %15 ], [ %110, %107 ]
%109 = tail call i32 @vectorFPSincos(double* %16, double* %17, double* %18, i32 %3)
%110 = add nsw i32 %108, -1
%111 = icmp ugt i32 %108, 1
br i1 %111, label %107, label %117
112: ; preds = %9, %112
%113 = phi i32 [ %4, %9 ], [ %115, %112 ]
%114 = tail call i32 @vectorFPBexp(double* %10, double* %11, double* %12, i32 %3)
%115 = add nsw i32 %113, -1
%116 = icmp ugt i32 %113, 1
br i1 %116, label %112, label %117
117: ; preds = %112, %107, %102, %97, %92, %87, %82, %77, %72, %67, %7, %13, %19, %25, %31, %37, %43, %49, %55, %61, %6
%118 = phi i32 [ 0, %6 ], [ %4, %61 ], [ %4, %55 ], [ %4, %49 ], [ %4, %43 ], [ %4, %37 ], [ %4, %31 ], [ %4, %25 ], [ %4, %19 ], [ %4, %13 ], [ %4, %7 ], [ %4, %67 ], [ %4, %72 ], [ %4, %77 ], [ %4, %82 ], [ %4, %87 ], [ %4, %92 ], [ %4, %97 ], [ %4, %102 ], [ %4, %107 ], [ %4, %112 ]
ret i32 %118
}