#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*/ Shellsort_int(int *, int);
int getStopFreq(int fs, int stop_freq) {
  int result, i;
  int *v_stop_freq = NULL;
  int k1_min;
  int v_dstop[13];
  int v_stop_freq_32[14] = {32, 34, 36, 38, 40, 42, 44,
                            46, 49, 52, 55, 58, 61, 64};
  int v_stop_freq_44[14] = {23, 25, 27, 29, 32, 34, 37,
                            40, 43, 47, 51, 55, 59, 64};
  int v_stop_freq_48[14] = {21, 23, 25, 27, 30, 32, 35,
                            38, 42, 45, 49, 54, 59, 64};
  ;
  ;
  ;
  switch (fs) {
  case 32000:;
    k1_min = 32;
    ;
    v_stop_freq = v_stop_freq_32;
    break;
  case 44100:;
    k1_min = 23;
    ;
    v_stop_freq = v_stop_freq_44;
    break;
  case 48000:;
    k1_min = 21;
    ;
    v_stop_freq = v_stop_freq_48;
    break;
  default:;
    k1_min = 21;
  };
  ;
  for (i = 0; i <= 12; i++) {
    ;
    ;
    v_dstop[i] = v_stop_freq[i + 1] - v_stop_freq[i];
  };
  Shellsort_int(v_dstop, 13);
  ;
  result = k1_min;
  ;
  ;
  for (i = 0; i < stop_freq; i++) {
    ;
    result = result + v_dstop[i];
  };
  return result;
}


x86 assembly (clang, -O0):
<getStopFreq>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movq   $0x0,-0x18(%rbp)
mov    0xf00(%rip),%rax
mov    %rax,-0x60(%rbp)
movaps 0xee5(%rip),%xmm0
movaps %xmm0,-0x70(%rbp)
movaps 0xeca(%rip),%xmm0
movaps %xmm0,-0x80(%rbp)
movaps 0xeaf(%rip),%xmm0
movaps %xmm0,-0x90(%rbp)
mov    0xf11(%rip),%rax
mov    %rax,-0xa0(%rbp)
movaps 0xef3(%rip),%xmm0
movaps %xmm0,-0xb0(%rbp)
movaps 0xed5(%rip),%xmm0
movaps %xmm0,-0xc0(%rbp)
movaps 0xeb7(%rip),%xmm0
movaps %xmm0,-0xd0(%rbp)
mov    0xf19(%rip),%rax
mov    %rax,-0xe0(%rbp)
movaps 0xefb(%rip),%xmm0
movaps %xmm0,-0xf0(%rbp)
movaps 0xedd(%rip),%xmm0
movaps %xmm0,-0x100(%rbp)
movaps 0xebf(%rip),%xmm0
movaps %xmm0,-0x110(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x114(%rbp)
sub    $0x7d00,%eax
je     120d <getStopFreq+0xfd>
jmp    11e1 <getStopFreq+0xd1>
mov    -0x114(%rbp),%eax
sub    $0xac44,%eax
je     1224 <getStopFreq+0x114>
jmp    11f7 <getStopFreq+0xe7>
mov    -0x114(%rbp),%eax
sub    $0xbb80,%eax
je     123b <getStopFreq+0x12b>
jmp    1252 <getStopFreq+0x142>
movl   $0x20,-0x1c(%rbp)
lea    -0x90(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1259 <getStopFreq+0x149>
movl   $0x17,-0x1c(%rbp)
lea    -0xd0(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1259 <getStopFreq+0x149>
movl   $0x15,-0x1c(%rbp)
lea    -0x110(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1259 <getStopFreq+0x149>
movl   $0x15,-0x1c(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0xc,-0x10(%rbp)
jg     129b <getStopFreq+0x18b>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x18(%rbp),%rax
movslq -0x10(%rbp),%rdx
sub    (%rax,%rdx,4),%ecx
movslq -0x10(%rbp),%rax
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1260 <getStopFreq+0x150>
lea    -0x50(%rbp),%rdi
mov    $0xd,%esi
call   1030 <Shellsort_int@plt>
mov    -0x1c(%rbp),%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12de <getStopFreq+0x1ce>
mov    -0xc(%rbp),%eax
movslq -0x10(%rbp),%rcx
add    -0x50(%rbp,%rcx,4),%eax
mov    %eax,-0xc(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12b6 <getStopFreq+0x1a6>
mov    -0xc(%rbp),%eax
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getStopFreq>:
push   %rbp
push   %rbx
sub    $0xf8,%rsp
mov    %esi,%ebp
mov    0xf0e(%rip),%rax
mov    %rax,0xf0(%rsp)
movaps 0xeef(%rip),%xmm0
movaps %xmm0,0xe0(%rsp)
movaps 0xed0(%rip),%xmm0
movaps %xmm0,0xd0(%rsp)
movaps 0xeb1(%rip),%xmm0
movaps %xmm0,0xc0(%rsp)
mov    0xf12(%rip),%rax
mov    %rax,0xb0(%rsp)
movaps 0xef3(%rip),%xmm0
movaps %xmm0,0xa0(%rsp)
movaps 0xed4(%rip),%xmm0
movaps %xmm0,0x90(%rsp)
movaps 0xeb5(%rip),%xmm0
movaps %xmm0,0x80(%rsp)
mov    0xf16(%rip),%rax
mov    %rax,0x70(%rsp)
movaps 0xefa(%rip),%xmm0
movaps %xmm0,0x60(%rsp)
movaps 0xede(%rip),%xmm0
movaps %xmm0,0x50(%rsp)
movaps 0xec2(%rip),%xmm0
movaps %xmm0,0x40(%rsp)
cmp    $0x7d00,%edi
je     11df <getStopFreq+0xcf>
cmp    $0xbb80,%edi
jne    11ee <getStopFreq+0xde>
mov    $0x15,%ebx
lea    0x40(%rsp),%rax
jmp    11fb <getStopFreq+0xeb>
mov    $0x20,%ebx
lea    0xc0(%rsp),%rax
jmp    11fb <getStopFreq+0xeb>
mov    $0x17,%ebx
lea    0x80(%rsp),%rax
movups 0x4(%rax),%xmm0
movss  (%rax),%xmm1
movlhps %xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
pshufd $0xff,%xmm0,%xmm2
psubd  %xmm1,%xmm0
movdqa %xmm0,(%rsp)
mov    0x14(%rax),%ecx
movd   %xmm2,%edx
movd   %ecx,%xmm0
sub    %edx,%ecx
mov    %ecx,0x10(%rsp)
movdqu 0x18(%rax),%xmm1
punpcklqdq %xmm1,%xmm0
shufps $0x98,%xmm1,%xmm0
movdqa %xmm1,%xmm2
psubd  %xmm0,%xmm2
movdqu %xmm2,0x14(%rsp)
movups 0x28(%rax),%xmm0
shufps $0x3,%xmm0,%xmm1
shufps $0x98,%xmm0,%xmm1
psubd  %xmm1,%xmm0
movdqu %xmm0,0x24(%rsp)
mov    %rsp,%rdi
mov    $0xd,%esi
call   1030 <Shellsort_int@plt>
test   %ebp,%ebp
jle    135c <getStopFreq+0x24c>
mov    %ebp,%eax
cmp    $0x8,%ebp
jae    127d <getStopFreq+0x16d>
xor    %ecx,%ecx
jmp    1350 <getStopFreq+0x240>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
movd   %ebx,%xmm0
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    12a8 <getStopFreq+0x198>
pxor   %xmm1,%xmm1
xor    %esi,%esi
jmp    12f9 <getStopFreq+0x1e9>
and    $0xfffffffffffffffc,%rdi
pxor   %xmm1,%xmm1
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
paddd  (%rsp,%rsi,4),%xmm0
paddd  0x10(%rsp,%rsi,4),%xmm1
paddd  0x20(%rsp,%rsi,4),%xmm0
paddd  0x30(%rsp,%rsi,4),%xmm1
paddd  0x40(%rsp,%rsi,4),%xmm0
paddd  0x50(%rsp,%rsi,4),%xmm1
paddd  0x60(%rsp,%rsi,4),%xmm0
paddd  0x70(%rsp,%rsi,4),%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    12c0 <getStopFreq+0x1b0>
test   %rdx,%rdx
je     1324 <getStopFreq+0x214>
lea    (%rsp,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
paddd  -0x10(%rsi,%rdi,1),%xmm0
paddd  (%rsi,%rdi,1),%xmm1
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1310 <getStopFreq+0x200>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
cmp    %rax,%rcx
je     135c <getStopFreq+0x24c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    (%rsp,%rcx,4),%ebx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1350 <getStopFreq+0x240>
mov    %ebx,%eax
add    $0xf8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
@__const.getStopFreq.v_stop_freq_32 = [14 x i32] [i32 32, i32 34, i32 36, i32 38, i32 40, i32 42, i32 44, i32 46, i32 49, i32 52, i32 55, i32 58, i32 61, i32 64]
@__const.getStopFreq.v_stop_freq_44 = [14 x i32] [i32 23, i32 25, i32 27, i32 29, i32 32, i32 34, i32 37, i32 40, i32 43, i32 47, i32 51, i32 55, i32 59, i32 64]
@__const.getStopFreq.v_stop_freq_48 = [14 x i32] [i32 21, i32 23, i32 25, i32 27, i32 30, i32 32, i32 35, i32 38, i32 42, i32 45, i32 49, i32 54, i32 59, i32 64]
define i32 @getStopFreq(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32
%9 = alloca [13 x i32]
%10 = alloca [14 x i32]
%11 = alloca [14 x i32]
%12 = alloca [14 x i32]
store i32 %0, i32* %3
store i32 %1, i32* %4
store i32* null, i32** %7
%13 = bitcast [14 x i32]* %10 to i8*
%14 = bitcast [14 x i32]* %11 to i8*
%15 = bitcast [14 x i32]* %12 to i8*
%16 = load i32, i32* %3
switch i32 %16, label %23 [
i32 32000, label %17
i32 44100, label %19
i32 48000, label %21
]
17: ; preds = %2
store i32 32, i32* %8
%18 = getelementptr inbounds [14 x i32], [14 x i32]* %10, i64 0, i64 0
store i32* %18, i32** %7
br label %24
19: ; preds = %2
store i32 23, i32* %8
%20 = getelementptr inbounds [14 x i32], [14 x i32]* %11, i64 0, i64 0
store i32* %20, i32** %7
br label %24
21: ; preds = %2
store i32 21, i32* %8
%22 = getelementptr inbounds [14 x i32], [14 x i32]* %12, i64 0, i64 0
store i32* %22, i32** %7
br label %24
23: ; preds = %2
store i32 21, i32* %8
br label %24
24: ; preds = %23, %21, %19, %17
store i32 0, i32* %6
br label %25
25: ; preds = %44, %24
%26 = load i32, i32* %6
%27 = icmp sle i32 %26, 12
br i1 %27, label %28, label %47
28: ; preds = %25
%29 = load i32*, i32** %7
%30 = load i32, i32* %6
%31 = add nsw i32 %30, 1
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i32, i32* %29, i64 %32
%34 = load i32, i32* %33
%35 = load i32*, i32** %7
%36 = load i32, i32* %6
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i32, i32* %35, i64 %37
%39 = load i32, i32* %38
%40 = sub nsw i32 %34, %39
%41 = load i32, i32* %6
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [13 x i32], [13 x i32]* %9, i64 0, i64 %42
store i32 %40, i32* %43
br label %44
44: ; preds = %28
%45 = load i32, i32* %6
%46 = add nsw i32 %45, 1
store i32 %46, i32* %6
br label %25
47: ; preds = %25
%48 = getelementptr inbounds [13 x i32], [13 x i32]* %9, i64 0, i64 0
%49 = call i32 @Shellsort_int(i32* %48, i32 13)
%50 = load i32, i32* %8
store i32 %50, i32* %5
store i32 0, i32* %6
br label %51
51: ; preds = %62, %47
%52 = load i32, i32* %6
%53 = load i32, i32* %4
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %65
55: ; preds = %51
%56 = load i32, i32* %5
%57 = load i32, i32* %6
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [13 x i32], [13 x i32]* %9, i64 0, i64 %58
%60 = load i32, i32* %59
%61 = add nsw i32 %56, %60
store i32 %61, i32* %5
br label %62
62: ; preds = %55
%63 = load i32, i32* %6
%64 = add nsw i32 %63, 1
store i32 %64, i32* %6
br label %51
65: ; preds = %51
%66 = load i32, i32* %5
ret i32 %66
}

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