int valley_high_low(histogram, peak1, peak2, hi, low)
int peak1, peak2;
short *hi, *low;
unsigned long histogram[];
{
  int i, valley_point;
  unsigned long sum1 = 0, sum2 = 0;
  find_valley_point(histogram, peak1, peak2, &valley_point);
  for (i = 0; i < valley_point; i++)
    sum1 = sum1 + histogram[i];
  for (i = valley_point; i <= 255; i++)
    sum2 = sum2 + histogram[i];
  if (sum1 >= sum2) {
    *low = valley_point;
    *hi = 255;
  } else {
    *low = 0;
    *hi = valley_point;
  }
  return (1);
}


x86 assembly (clang, -O0):
<valley_high_low>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
lea    -0x28(%rbp),%rcx
mov    $0x0,%al
call   1030 <find_valley_point@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1184 <valley_high_low+0x74>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x24(%rbp),%rdx
add    (%rcx,%rdx,8),%rax
mov    %rax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1156 <valley_high_low+0x46>
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0xff,-0x24(%rbp)
jg     11b9 <valley_high_low+0xa9>
mov    -0x38(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x24(%rbp),%rdx
add    (%rcx,%rdx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    118a <valley_high_low+0x7a>
mov    -0x30(%rbp),%rax
cmp    -0x38(%rbp),%rax
jb     11e2 <valley_high_low+0xd2>
mov    -0x28(%rbp),%eax
mov    %ax,%cx
mov    -0x20(%rbp),%rax
mov    %cx,(%rax)
mov    -0x18(%rbp),%rax
movw   $0xff,(%rax)
jmp    11f8 <valley_high_low+0xe8>
mov    -0x20(%rbp),%rax
movw   $0x0,(%rax)
mov    -0x28(%rbp),%eax
mov    %ax,%cx
mov    -0x18(%rbp),%rax
mov    %cx,(%rax)
mov    $0x1,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<valley_high_low>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %r8,%r15
mov    %rcx,%r14
mov    %rdi,%r12
xor    %ebx,%ebx
lea    0x4(%rsp),%rcx
xor    %eax,%eax
call   1030 <find_valley_point@plt>
movslq 0x4(%rsp),%r8
mov    %r8d,%r10d
test   %r8,%r8
jle    126a <valley_high_low+0x15a>
cmp    $0x4,%r10d
jae    114f <valley_high_low+0x3f>
xor    %edx,%edx
xor    %ebx,%ebx
jmp    1250 <valley_high_low+0x140>
mov    %r10d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rax
jae    117b <valley_high_low+0x6b>
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
jmp    11f1 <valley_high_low+0xe1>
and    $0xfffffffffffffffc,%rdi
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu (%r12,%rcx,8),%xmm2
paddq  %xmm0,%xmm2
movdqu 0x10(%r12,%rcx,8),%xmm0
paddq  %xmm1,%xmm0
movdqu 0x20(%r12,%rcx,8),%xmm1
movdqu 0x30(%r12,%rcx,8),%xmm3
movdqu 0x40(%r12,%rcx,8),%xmm4
paddq  %xmm1,%xmm4
paddq  %xmm2,%xmm4
movdqu 0x50(%r12,%rcx,8),%xmm2
paddq  %xmm3,%xmm2
paddq  %xmm0,%xmm2
movdqu 0x60(%r12,%rcx,8),%xmm0
paddq  %xmm4,%xmm0
movdqu 0x70(%r12,%rcx,8),%xmm1
paddq  %xmm2,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1190 <valley_high_low+0x80>
test   %rsi,%rsi
je     122c <valley_high_low+0x11c>
lea    (%r12,%rcx,8),%rax
add    $0x10,%rax
shl    $0x5,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%rax,%rcx,1),%xmm2
paddq  %xmm2,%xmm0
movdqu (%rax,%rcx,1),%xmm2
paddq  %xmm2,%xmm1
add    $0x20,%rcx
cmp    %rcx,%rsi
jne    1210 <valley_high_low+0x100>
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%rbx
cmp    %r10,%rdx
je     125d <valley_high_low+0x14d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    (%r12,%rdx,8),%rbx
add    $0x1,%rdx
cmp    %rdx,%r10
jne    1250 <valley_high_low+0x140>
cmp    $0xff,%r8d
jg     139d <valley_high_low+0x28d>
mov    $0xff,%r9d
sub    %r8d,%r9d
cmp    $0x3,%r9d
jae    1283 <valley_high_low+0x173>
xor    %eax,%eax
mov    %r8,%rdx
jmp    1380 <valley_high_low+0x270>
add    $0x1,%r9
mov    %r9,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rax
jae    12b4 <valley_high_low+0x1a4>
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
jmp    1329 <valley_high_low+0x219>
and    $0xfffffffffffffffc,%rdi
lea    (%r12,%r8,8),%rax
add    $0x70,%rax
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu -0x70(%rax,%rcx,8),%xmm2
paddq  %xmm0,%xmm2
movdqu -0x60(%rax,%rcx,8),%xmm0
paddq  %xmm1,%xmm0
movdqu -0x50(%rax,%rcx,8),%xmm1
movdqu -0x40(%rax,%rcx,8),%xmm3
movdqu -0x30(%rax,%rcx,8),%xmm4
paddq  %xmm1,%xmm4
paddq  %xmm2,%xmm4
movdqu -0x20(%rax,%rcx,8),%xmm2
paddq  %xmm3,%xmm2
paddq  %xmm0,%xmm2
movdqu -0x10(%rax,%rcx,8),%xmm0
paddq  %xmm4,%xmm0
movdqu (%rax,%rcx,8),%xmm1
paddq  %xmm2,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdi
jne    12d0 <valley_high_low+0x1c0>
test   %rsi,%rsi
je     135c <valley_high_low+0x24c>
add    %r8,%rcx
lea    (%r12,%rcx,8),%rax
add    $0x10,%rax
shl    $0x5,%rsi
xor    %ecx,%ecx
nop
movdqu -0x10(%rax,%rcx,1),%xmm2
paddq  %xmm2,%xmm0
movdqu (%rax,%rcx,1),%xmm2
paddq  %xmm2,%xmm1
add    $0x20,%rcx
cmp    %rcx,%rsi
jne    1340 <valley_high_low+0x230>
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%rax
cmp    %rdx,%r9
je     1390 <valley_high_low+0x280>
add    %r8,%rdx
cs nopw 0x0(%rax,%rax,1)
add    (%r12,%rdx,8),%rax
add    $0x1,%rdx
cmp    $0x100,%edx
jne    1380 <valley_high_low+0x270>
cmp    %rax,%rbx
jae    139d <valley_high_low+0x28d>
movw   $0x0,(%r15)
jmp    13a6 <valley_high_low+0x296>
mov    %r8w,(%r15)
mov    $0xff,%r10w
mov    %r10w,(%r14)
mov    $0x1,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define i32 @valley_high_low(i64* %0, i32 %1, i32 %2, i16* nocapture writeonly %3, i16* nocapture writeonly %4) {
%6 = alloca i32
%7 = bitcast i32* %6 to i8*
%8 = call i32 (i64*, i32, i32, i32*, ...) bitcast (i32 (...)* @find_valley_point to i32 (i64*, i32, i32, i32*, ...)*)(i64* %0, i32 %1, i32 %2, i32* %6)
%9 = load i32, i32* %6
%10 = icmp sgt i32 %9, 0
br i1 %10, label %11, label %101
11: ; preds = %5
%12 = zext i32 %9 to i64
%13 = icmp ult i32 %9, 4
br i1 %13, label %95, label %14
14: ; preds = %11
%15 = and i64 %12, 4294967292
%16 = add nsw i64 %15, -4
%17 = lshr exact i64 %16, 2
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 3
%20 = icmp ult i64 %16, 12
br i1 %20, label %66, label %21
21: ; preds = %14
%22 = and i64 %18, 9223372036854775804
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %63, %23 ]
%25 = phi <2 x i64> [ zeroinitializer, %21 ], [ %61, %23 ]
%26 = phi <2 x i64> [ zeroinitializer, %21 ], [ %62, %23 ]
%27 = phi i64 [ 0, %21 ], [ %64, %23 ]
%28 = getelementptr inbounds i64, i64* %0, i64 %24
%29 = bitcast i64* %28 to <2 x i64>*
%30 = load <2 x i64>, <2 x i64>* %29
%31 = getelementptr inbounds i64, i64* %28, i64 2
%32 = bitcast i64* %31 to <2 x i64>*
%33 = load <2 x i64>, <2 x i64>* %32
%34 = add <2 x i64> %30, %25
%35 = add <2 x i64> %33, %26
%36 = or i64 %24, 4
%37 = getelementptr inbounds i64, i64* %0, i64 %36
%38 = bitcast i64* %37 to <2 x i64>*
%39 = load <2 x i64>, <2 x i64>* %38
%40 = getelementptr inbounds i64, i64* %37, i64 2
%41 = bitcast i64* %40 to <2 x i64>*
%42 = load <2 x i64>, <2 x i64>* %41
%43 = add <2 x i64> %39, %34
%44 = add <2 x i64> %42, %35
%45 = or i64 %24, 8
%46 = getelementptr inbounds i64, i64* %0, i64 %45
%47 = bitcast i64* %46 to <2 x i64>*
%48 = load <2 x i64>, <2 x i64>* %47
%49 = getelementptr inbounds i64, i64* %46, i64 2
%50 = bitcast i64* %49 to <2 x i64>*
%51 = load <2 x i64>, <2 x i64>* %50
%52 = add <2 x i64> %48, %43
%53 = add <2 x i64> %51, %44
%54 = or i64 %24, 12
%55 = getelementptr inbounds i64, i64* %0, i64 %54
%56 = bitcast i64* %55 to <2 x i64>*
%57 = load <2 x i64>, <2 x i64>* %56
%58 = getelementptr inbounds i64, i64* %55, i64 2
%59 = bitcast i64* %58 to <2 x i64>*
%60 = load <2 x i64>, <2 x i64>* %59
%61 = add <2 x i64> %57, %52
%62 = add <2 x i64> %60, %53
%63 = add nuw i64 %24, 16
%64 = add nuw i64 %27, 4
%65 = icmp eq i64 %64, %22
br i1 %65, label %66, label %23
66: ; preds = %23, %14
%67 = phi <2 x i64> [ undef, %14 ], [ %61, %23 ]
%68 = phi <2 x i64> [ undef, %14 ], [ %62, %23 ]
%69 = phi i64 [ 0, %14 ], [ %63, %23 ]
%70 = phi <2 x i64> [ zeroinitializer, %14 ], [ %61, %23 ]
%71 = phi <2 x i64> [ zeroinitializer, %14 ], [ %62, %23 ]
%72 = icmp eq i64 %19, 0
br i1 %72, label %89, label %73
73: ; preds = %66, %73
%74 = phi i64 [ %86, %73 ], [ %69, %66 ]
%75 = phi <2 x i64> [ %84, %73 ], [ %70, %66 ]
%76 = phi <2 x i64> [ %85, %73 ], [ %71, %66 ]
%77 = phi i64 [ %87, %73 ], [ 0, %66 ]
%78 = getelementptr inbounds i64, i64* %0, i64 %74
%79 = bitcast i64* %78 to <2 x i64>*
%80 = load <2 x i64>, <2 x i64>* %79
%81 = getelementptr inbounds i64, i64* %78, i64 2
%82 = bitcast i64* %81 to <2 x i64>*
%83 = load <2 x i64>, <2 x i64>* %82
%84 = add <2 x i64> %80, %75
%85 = add <2 x i64> %83, %76
%86 = add nuw i64 %74, 4
%87 = add i64 %77, 1
%88 = icmp eq i64 %87, %19
br i1 %88, label %89, label %73
89: ; preds = %73, %66
%90 = phi <2 x i64> [ %67, %66 ], [ %84, %73 ]
%91 = phi <2 x i64> [ %68, %66 ], [ %85, %73 ]
%92 = add <2 x i64> %91, %90
%93 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %92)
%94 = icmp eq i64 %15, %12
br i1 %94, label %98, label %95
95: ; preds = %11, %89
%96 = phi i64 [ 0, %11 ], [ %15, %89 ]
%97 = phi i64 [ 0, %11 ], [ %93, %89 ]
br label %198
98: ; preds = %198, %89
%99 = phi i64 [ %93, %89 ], [ %203, %198 ]
%100 = icmp slt i32 %9, 256
br i1 %100, label %101, label %218
101: ; preds = %5, %98
%102 = phi i64 [ %99, %98 ], [ 0, %5 ]
%103 = sext i32 %9 to i64
%104 = sub i32 255, %9
%105 = zext i32 %104 to i64
%106 = add nuw nsw i64 %105, 1
%107 = icmp ult i32 %104, 3
br i1 %107, label %195, label %108
108: ; preds = %101
%109 = and i64 %106, 8589934588
%110 = add nsw i64 %109, %103
%111 = add nsw i64 %109, -4
%112 = lshr exact i64 %111, 2
%113 = add nuw nsw i64 %112, 1
%114 = and i64 %113, 3
%115 = icmp ult i64 %111, 12
br i1 %115, label %165, label %116
116: ; preds = %108
%117 = and i64 %113, 9223372036854775804
br label %118
118: ; preds = %118, %116
%119 = phi i64 [ 0, %116 ], [ %162, %118 ]
%120 = phi <2 x i64> [ zeroinitializer, %116 ], [ %160, %118 ]
%121 = phi <2 x i64> [ zeroinitializer, %116 ], [ %161, %118 ]
%122 = phi i64 [ 0, %116 ], [ %163, %118 ]
%123 = add i64 %119, %103
%124 = getelementptr inbounds i64, i64* %0, i64 %123
%125 = bitcast i64* %124 to <2 x i64>*
%126 = load <2 x i64>, <2 x i64>* %125
%127 = getelementptr inbounds i64, i64* %124, i64 2
%128 = bitcast i64* %127 to <2 x i64>*
%129 = load <2 x i64>, <2 x i64>* %128
%130 = add <2 x i64> %126, %120
%131 = add <2 x i64> %129, %121
%132 = or i64 %119, 4
%133 = add i64 %132, %103
%134 = getelementptr inbounds i64, i64* %0, i64 %133
%135 = bitcast i64* %134 to <2 x i64>*
%136 = load <2 x i64>, <2 x i64>* %135
%137 = getelementptr inbounds i64, i64* %134, i64 2
%138 = bitcast i64* %137 to <2 x i64>*
%139 = load <2 x i64>, <2 x i64>* %138
%140 = add <2 x i64> %136, %130
%141 = add <2 x i64> %139, %131
%142 = or i64 %119, 8
%143 = add i64 %142, %103
%144 = getelementptr inbounds i64, i64* %0, i64 %143
%145 = bitcast i64* %144 to <2 x i64>*
%146 = load <2 x i64>, <2 x i64>* %145
%147 = getelementptr inbounds i64, i64* %144, i64 2
%148 = bitcast i64* %147 to <2 x i64>*
%149 = load <2 x i64>, <2 x i64>* %148
%150 = add <2 x i64> %146, %140
%151 = add <2 x i64> %149, %141
%152 = or i64 %119, 12
%153 = add i64 %152, %103
%154 = getelementptr inbounds i64, i64* %0, i64 %153
%155 = bitcast i64* %154 to <2 x i64>*
%156 = load <2 x i64>, <2 x i64>* %155
%157 = getelementptr inbounds i64, i64* %154, i64 2
%158 = bitcast i64* %157 to <2 x i64>*
%159 = load <2 x i64>, <2 x i64>* %158
%160 = add <2 x i64> %156, %150
%161 = add <2 x i64> %159, %151
%162 = add nuw i64 %119, 16
%163 = add nuw i64 %122, 4
%164 = icmp eq i64 %163, %117
br i1 %164, label %165, label %118
165: ; preds = %118, %108
%166 = phi <2 x i64> [ undef, %108 ], [ %160, %118 ]
%167 = phi <2 x i64> [ undef, %108 ], [ %161, %118 ]
%168 = phi i64 [ 0, %108 ], [ %162, %118 ]
%169 = phi <2 x i64> [ zeroinitializer, %108 ], [ %160, %118 ]
%170 = phi <2 x i64> [ zeroinitializer, %108 ], [ %161, %118 ]
%171 = icmp eq i64 %114, 0
br i1 %171, label %189, label %172
172: ; preds = %165, %172
%173 = phi i64 [ %186, %172 ], [ %168, %165 ]
%174 = phi <2 x i64> [ %184, %172 ], [ %169, %165 ]
%175 = phi <2 x i64> [ %185, %172 ], [ %170, %165 ]
%176 = phi i64 [ %187, %172 ], [ 0, %165 ]
%177 = add i64 %173, %103
%178 = getelementptr inbounds i64, i64* %0, i64 %177
%179 = bitcast i64* %178 to <2 x i64>*
%180 = load <2 x i64>, <2 x i64>* %179
%181 = getelementptr inbounds i64, i64* %178, i64 2
%182 = bitcast i64* %181 to <2 x i64>*
%183 = load <2 x i64>, <2 x i64>* %182
%184 = add <2 x i64> %180, %174
%185 = add <2 x i64> %183, %175
%186 = add nuw i64 %173, 4
%187 = add i64 %176, 1
%188 = icmp eq i64 %187, %114
br i1 %188, label %189, label %172
189: ; preds = %172, %165
%190 = phi <2 x i64> [ %166, %165 ], [ %184, %172 ]
%191 = phi <2 x i64> [ %167, %165 ], [ %185, %172 ]
%192 = add <2 x i64> %191, %190
%193 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %192)
%194 = icmp eq i64 %106, %109
br i1 %194, label %215, label %195
195: ; preds = %101, %189
%196 = phi i64 [ %103, %101 ], [ %110, %189 ]
%197 = phi i64 [ 0, %101 ], [ %193, %189 ]
br label %206
198: ; preds = %95, %198
%199 = phi i64 [ %204, %198 ], [ %96, %95 ]
%200 = phi i64 [ %203, %198 ], [ %97, %95 ]
%201 = getelementptr inbounds i64, i64* %0, i64 %199
%202 = load i64, i64* %201
%203 = add i64 %202, %200
%204 = add nuw nsw i64 %199, 1
%205 = icmp eq i64 %204, %12
br i1 %205, label %98, label %198
206: ; preds = %195, %206
%207 = phi i64 [ %212, %206 ], [ %196, %195 ]
%208 = phi i64 [ %211, %206 ], [ %197, %195 ]
%209 = getelementptr inbounds i64, i64* %0, i64 %207
%210 = load i64, i64* %209
%211 = add i64 %210, %208
%212 = add nsw i64 %207, 1
%213 = trunc i64 %212 to i32
%214 = icmp eq i32 %213, 256
br i1 %214, label %215, label %206
215: ; preds = %206, %189
%216 = phi i64 [ %193, %189 ], [ %211, %206 ]
%217 = icmp ult i64 %102, %216
br i1 %217, label %220, label %218
218: ; preds = %98, %215
%219 = trunc i32 %9 to i16
store i16 %219, i16* %4
br label %222
220: ; preds = %215
store i16 0, i16* %4
%221 = trunc i32 %9 to i16
br label %222
222: ; preds = %220, %218
%223 = phi i16 [ %221, %220 ], [ 255, %218 ]
store i16 %223, i16* %3
ret i32 1
}