#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 */
double median_(double *, int, int);
int smoothFilterRate(double *rate, int *rank, int index) {
  double medl = 0, medr = 0, val = rate[index - 5];
  int count = 0;
  if (index + 1 < 11)
    return 0;
  medl = median_(rate, index - 11 + 1, index - 5 - 1);
  medr = median_(rate, index - 5 + 1, index);
  if (((1.0 * val / medl > 1.10) && (1.0 * val / medr > 1.10)) ||
      ((1.0 * medl / val > 1.10) && (1.0 * medr / val > 1.10))) {
    int newrank = 0;
    double oldrate = rate[index - 5], newrate = 0;
    newrate = rate[index - 5] = (medl + medr) / 2.0;
    newrank = (newrate > oldrate) ? -0xFFFFFF : 0xFFFFFF;
    for (count = 0; count <= index; count++) {
      double r = rate[count];
      if (count == index - 5)
        continue;
      if (r > newrate && r < oldrate) {
        newrank = (newrank > rank[count]) ? rank[count] : newrank;
        rank[count]++;
      } else if (r > oldrate && r < newrate) {
        newrank = (newrank < rank[count]) ? rank[count] : newrank;
        rank[count]--;
      }
    }
    if (newrank != -0xFFFFFF && newrank != 0xFFFFFF)
      rank[index - 5] = newrank;
  }
  return 0;
}


x86 assembly (clang, -O0):
<smoothFilterRate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
cmp    $0xb,%eax
jge    116c <smoothFilterRate+0x5c>
movl   $0x0,-0x4(%rbp)
jmp    1408 <smoothFilterRate+0x2f8>
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
sub    $0xb,%esi
add    $0x1,%esi
mov    -0x1c(%rbp),%edx
sub    $0x5,%edx
sub    $0x1,%edx
call   1030 <median_@plt>
movsd  %xmm0,-0x28(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
sub    $0x5,%esi
add    $0x1,%esi
mov    -0x1c(%rbp),%edx
call   1030 <median_@plt>
movsd  %xmm0,-0x30(%rbp)
movsd  0xe5a(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  0xe40(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    11ee <smoothFilterRate+0xde>
movsd  0xe36(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
divsd  -0x30(%rbp),%xmm0
movsd  0xe1c(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1236 <smoothFilterRate+0x126>
movsd  0xe12(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  0xdf8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1401 <smoothFilterRate+0x2f1>
movsd  0xdee(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  0xdd4(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1401 <smoothFilterRate+0x2f1>
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x28(%rbp),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  0xda2(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mov    $0xffffff,%eax
mov    $0xff000001,%ecx
ucomisd %xmm1,%xmm0
cmova  %ecx,%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     13cf <smoothFilterRate+0x2bf>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x5,%ecx
cmp    %ecx,%eax
jne    12e2 <smoothFilterRate+0x1d2>
jmp    13c1 <smoothFilterRate+0x2b1>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    134f <smoothFilterRate+0x23f>
movsd  -0x58(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    134f <smoothFilterRate+0x23f>
mov    -0x40(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    132d <smoothFilterRate+0x21d>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
jmp    1333 <smoothFilterRate+0x223>
mov    -0x40(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    13bc <smoothFilterRate+0x2ac>
movsd  -0x58(%rbp),%xmm0
ucomisd -0x48(%rbp),%xmm0
jbe    13b7 <smoothFilterRate+0x2a7>
movsd  -0x58(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    13b7 <smoothFilterRate+0x2a7>
mov    -0x40(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    139a <smoothFilterRate+0x28a>
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
jmp    13a0 <smoothFilterRate+0x290>
mov    -0x40(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %edx,(%rax,%rcx,4)
jmp    13bc <smoothFilterRate+0x2ac>
jmp    13c1 <smoothFilterRate+0x2b1>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ae <smoothFilterRate+0x19e>
cmpl   $0xff000001,-0x40(%rbp)
je     13fc <smoothFilterRate+0x2ec>
cmpl   $0xffffff,-0x40(%rbp)
je     13fc <smoothFilterRate+0x2ec>
mov    -0x40(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x5,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1401 <smoothFilterRate+0x2f1>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<smoothFilterRate>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x28,%rsp
cmp    $0xa,%edx
jl     123c <smoothFilterRate+0x12c>
mov    %edx,%ebx
mov    %rsi,%r14
mov    %rdi,%r15
lea    -0x5(%rbx),%eax
movslq %eax,%r12
lea    -0xa(%rbx),%esi
lea    -0x6(%rbx),%edx
movsd  (%rdi,%r12,8),%xmm0
movapd %xmm0,0x10(%rsp)
call   1030 <median_@plt>
movapd %xmm0,(%rsp)
lea    -0x4(%rbx),%esi
mov    %r15,%rdi
mov    %ebx,%edx
call   1030 <median_@plt>
movapd 0x10(%rsp),%xmm6
movapd (%rsp),%xmm5
unpcklpd %xmm6,%xmm6
movapd %xmm0,%xmm1
unpcklpd %xmm5,%xmm1
movapd %xmm6,%xmm3
divpd  %xmm1,%xmm3
movapd 0xe7e(%rip),%xmm2
movapd %xmm2,%xmm4
cmpltpd %xmm3,%xmm4
movmskpd %xmm4,%eax
cmp    $0x3,%al
je     11a8 <smoothFilterRate+0x98>
divpd  %xmm6,%xmm1
cmpltpd %xmm1,%xmm2
movmskpd %xmm2,%eax
cmp    $0x3,%al
jne    123c <smoothFilterRate+0x12c>
addsd  %xmm0,%xmm5
mulsd  0xe5c(%rip),%xmm5
movsd  (%r15,%r12,8),%xmm0
ucomisd %xmm0,%xmm5
mov    $0xff000001,%ecx
mov    $0xffffff,%eax
cmova  %ecx,%eax
movsd  %xmm5,(%r15,%r12,8)
mov    %r12d,%ecx
add    $0x1,%ebx
xor    %edx,%edx
jmp    11f9 <smoothFilterRate+0xe9>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rdx,4),%esi
cmp    %esi,%eax
cmovg  %esi,%eax
add    $0x1,%esi
mov    %esi,(%r14,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rbx
je     122a <smoothFilterRate+0x11a>
cmp    %rdx,%rcx
je     11f0 <smoothFilterRate+0xe0>
movsd  (%r15,%rdx,8),%xmm1
ucomisd %xmm5,%xmm1
jbe    1210 <smoothFilterRate+0x100>
ucomisd %xmm1,%xmm0
ja     11e0 <smoothFilterRate+0xd0>
ucomisd %xmm0,%xmm1
jbe    11f0 <smoothFilterRate+0xe0>
ucomisd %xmm1,%xmm5
jbe    11f0 <smoothFilterRate+0xe0>
mov    (%r14,%rdx,4),%esi
cmp    %esi,%eax
cmovl  %esi,%eax
add    $0xffffffff,%esi
jmp    11ec <smoothFilterRate+0xdc>
cmp    $0xff000001,%eax
je     123c <smoothFilterRate+0x12c>
cmp    $0xffffff,%eax
je     123c <smoothFilterRate+0x12c>
mov    %eax,(%r14,%r12,4)
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define i32 @smoothFilterRate(double* %0, i32* nocapture %1, i32 %2) {
%4 = add nsw i32 %2, -5
%5 = sext i32 %4 to i64
%6 = getelementptr inbounds double, double* %0, i64 %5
%7 = icmp slt i32 %2, 10
br i1 %7, label %72, label %8
8: ; preds = %3
%9 = load double, double* %6
%10 = add nsw i32 %2, -10
%11 = add nsw i32 %2, -6
%12 = tail call double @median_(double* %0, i32 %10, i32 %11)
%13 = add nsw i32 %2, -4
%14 = tail call double @median_(double* %0, i32 %13, i32 %2)
%15 = insertelement <2 x double> poison, double %9, i64 0
%16 = shufflevector <2 x double> %15, <2 x double> poison, <2 x i32> zeroinitializer
%17 = insertelement <2 x double> poison, double %14, i64 0
%18 = insertelement <2 x double> %17, double %12, i64 1
%19 = fdiv <2 x double> %16, %18
%20 = fcmp ogt <2 x double> %19, <double 1.100000e+00, double 1.100000e+00>
%21 = extractelement <2 x i1> %20, i64 0
%22 = extractelement <2 x i1> %20, i64 1
%23 = select i1 %22, i1 %21, i1 false
br i1 %23, label %30, label %24
24: ; preds = %8
%25 = fdiv <2 x double> %18, %16
%26 = fcmp ogt <2 x double> %25, <double 1.100000e+00, double 1.100000e+00>
%27 = extractelement <2 x i1> %26, i64 0
%28 = extractelement <2 x i1> %26, i64 1
%29 = select i1 %28, i1 %27, i1 false
br i1 %29, label %30, label %72
30: ; preds = %8, %24
%31 = load double, double* %6
%32 = fadd double %12, %14
%33 = fmul double %32, 5.000000e-01
store double %33, double* %6
%34 = fcmp ogt double %33, %31
%35 = select i1 %34, i32 -16777215, i32 16777215
%36 = zext i32 %4 to i64
%37 = add nuw i32 %2, 1
%38 = zext i32 %37 to i64
br label %39
39: ; preds = %30, %65
%40 = phi i64 [ 0, %30 ], [ %67, %65 ]
%41 = phi i32 [ %35, %30 ], [ %66, %65 ]
%42 = getelementptr inbounds double, double* %0, i64 %40
%43 = load double, double* %42
%44 = icmp eq i64 %40, %36
br i1 %44, label %65, label %45
45: ; preds = %39
%46 = fcmp ogt double %43, %33
%47 = fcmp olt double %43, %31
%48 = select i1 %46, i1 %47, i1 false
br i1 %48, label %49, label %55
49: ; preds = %45
%50 = getelementptr inbounds i32, i32* %1, i64 %40
%51 = load i32, i32* %50
%52 = icmp sgt i32 %41, %51
%53 = select i1 %52, i32 %51, i32 %41
%54 = add nsw i32 %51, 1
store i32 %54, i32* %50
br label %65
55: ; preds = %45
%56 = fcmp ogt double %43, %31
%57 = fcmp olt double %43, %33
%58 = select i1 %56, i1 %57, i1 false
br i1 %58, label %59, label %65
59: ; preds = %55
%60 = getelementptr inbounds i32, i32* %1, i64 %40
%61 = load i32, i32* %60
%62 = icmp slt i32 %41, %61
%63 = select i1 %62, i32 %61, i32 %41
%64 = add nsw i32 %61, -1
store i32 %64, i32* %60
br label %65
65: ; preds = %49, %59, %55, %39
%66 = phi i32 [ %41, %39 ], [ %53, %49 ], [ %63, %59 ], [ %41, %55 ]
%67 = add nuw nsw i64 %40, 1
%68 = icmp eq i64 %67, %38
br i1 %68, label %69, label %39
69: ; preds = %65
switch i32 %66, label %70 [
i32 -16777215, label %72
i32 16777215, label %72
]
70: ; preds = %69
%71 = getelementptr inbounds i32, i32* %1, i64 %5
store i32 %66, i32* %71
br label %72
72: ; preds = %24, %69, %69, %70, %3
ret i32 0
}