#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 */
scalar_t__ malloc(int);
int candy(int *ratings, int ratingsSize) {
  if (ratingsSize <= 0)
    return 0;
  int *f = (int *)malloc(sizeof(int) * ratingsSize);
  f[0] = 1;
  for (int i = 1; i < ratingsSize; ++i)
    if (ratings[i] > ratings[i - 1])
      f[i] = f[i - 1] + 1;
    else
      f[i] = 1;
  for (int i = ratingsSize - 2; i >= 0; --i)
    if (ratings[i] > ratings[i + 1] && f[i] <= f[i + 1])
      f[i] = f[i + 1] + 1;
  int result = 0;
  for (int i = 0; i < ratingsSize; ++i)
    result += f[i];
  return result;
}


x86 assembly (clang, -O0):
<candy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jg     1135 <candy+0x25>
movl   $0x0,-0x4(%rbp)
jmp    1290 <candy+0x180>
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x1,(%rax)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11cb <candy+0xbb>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    11a9 <candy+0x99>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11b8 <candy+0xa8>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    11bd <candy+0xad>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1159 <candy+0x49>
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1251 <candy+0x141>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    123e <candy+0x12e>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     123e <candy+0x12e>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1243 <candy+0x133>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    11d4 <candy+0xc4>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    128a <candy+0x17a>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    125f <candy+0x14f>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<candy>:
push   %r15
push   %r14
push   %rbx
xor    %ebx,%ebx
test   %esi,%esi
jle    132c <candy+0x21c>
mov    %esi,%r14d
mov    %rdi,%r15
lea    0x0(,%r14,4),%edi
call   1030 <malloc@plt>
movl   $0x1,(%rax)
mov    %r14d,%r9d
cmp    $0x1,%r14d
je     121c <candy+0x10c>
lea    -0x1(%r9),%r8
cmp    $0x2,%r14d
jne    1161 <candy+0x51>
mov    $0x1,%esi
mov    $0x2,%edi
test   $0x1,%r8b
jne    11c2 <candy+0xb2>
jmp    11d6 <candy+0xc6>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%esi
mov    $0x1,%r10d
mov    $0x1,%edi
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rsi,4),%ecx
add    $0x1,%edi
cmp    -0x4(%r15,%rsi,4),%ecx
cmovle %r10d,%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r15,%rsi,4),%ecx
add    $0x1,%edi
cmp    (%r15,%rsi,4),%ecx
cmovle %r10d,%edi
mov    %edi,0x4(%rax,%rsi,4)
lea    (%rdx,%rsi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rsi
cmp    $0x1,%rcx
jne    1180 <candy+0x70>
add    $0x1,%edi
test   $0x1,%r8b
je     11d6 <candy+0xc6>
mov    (%r15,%rsi,4),%ecx
cmp    -0x4(%r15,%rsi,4),%ecx
mov    $0x1,%ecx
cmovg  %edi,%ecx
mov    %ecx,(%rax,%rsi,4)
cmp    $0x2,%r14d
jl     1213 <candy+0x103>
lea    -0x2(%r14),%ecx
add    $0x1,%rcx
jmp    11f6 <candy+0xe6>
cs nopw 0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rcx
jle    1213 <candy+0x103>
mov    -0x4(%r15,%rcx,4),%edx
cmp    (%r15,%rcx,4),%edx
jle    11f0 <candy+0xe0>
mov    (%rax,%rcx,4),%edx
cmp    %edx,-0x4(%rax,%rcx,4)
jg     11f0 <candy+0xe0>
add    $0x1,%edx
mov    %edx,-0x4(%rax,%rcx,4)
jmp    11f0 <candy+0xe0>
test   %r14d,%r14d
jle    132c <candy+0x21c>
cmp    $0x8,%r14d
jae    122b <candy+0x11b>
xor    %edx,%edx
xor    %ebx,%ebx
jmp    1320 <candy+0x210>
mov    %r9d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rcx
jae    1257 <candy+0x147>
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
jmp    12c9 <candy+0x1b9>
and    $0xfffffffffffffffc,%rsi
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%rax,%rdi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rax,%rdi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rax,%rdi,4),%xmm1
movdqu 0x30(%rax,%rdi,4),%xmm3
movdqu 0x40(%rax,%rdi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rax,%rdi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rax,%rdi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rax,%rdi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1270 <candy+0x160>
test   %rbx,%rbx
je     12fc <candy+0x1ec>
lea    (%rax,%rdi,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rbx
xor    %esi,%esi
nopl   0x0(%rax)
movdqu -0x10(%rcx,%rsi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rcx,%rsi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rsi
cmp    %rsi,%rbx
jne    12e0 <candy+0x1d0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebx
cmp    %r9,%rdx
je     132c <candy+0x21c>
nopl   0x0(%rax,%rax,1)
add    (%rax,%rdx,4),%ebx
add    $0x1,%rdx
cmp    %rdx,%r9
jne    1320 <candy+0x210>
mov    %ebx,%eax
pop    %rbx
pop    %r14
pop    %r15
ret

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

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